Les fichiers binaires gdevilspie-0.5/gDevilspie/__init__.pyc et gdevilspie-0.5.jrd/gDevilspie/__init__.pyc sont différents. Les fichiers binaires gdevilspie-0.5/gDevilspie/filler.pyc et gdevilspie-0.5.jrd/gDevilspie/filler.pyc sont différents. Les fichiers binaires gdevilspie-0.5/gDevilspie/reader.pyc et gdevilspie-0.5.jrd/gDevilspie/reader.pyc sont différents. Les fichiers binaires gdevilspie-0.5/gDevilspie/sparser.pyc et gdevilspie-0.5.jrd/gDevilspie/sparser.pyc sont différents. diff -ruN gdevilspie-0.5/gdevilspie gdevilspie-0.5.jrd/gdevilspie --- gdevilspie-0.5/gdevilspie 2010-06-12 03:41:19.000000000 +0200 +++ gdevilspie-0.5.jrd/gdevilspie 2010-12-12 23:11:24.547869582 +0100 @@ -26,6 +26,7 @@ import string import gDevilspie.reader as reader import tempfile +from odict import odict try: import gobject import pygtk @@ -172,37 +173,37 @@ # Dictionary of the actions for each of which we store a dictionary of help text and widgets -actions_dict={ -"geometry" : {"description" : _("Set position and size of window"), "widget" : None, "type" : "Text" , "input" : { "xposition" : None, "yposition" : None, "width" : None, "height" : None } }, -"fullscreen" : {"description" : _("Make the window fullscreen"), "widget" : None}, -"focus": {"description" : _("Focus the window"), "widget" : None}, -"center": {"description" : _("Center the position of the window"), "widget" : None}, -"maximize": {"description" : _("Maximize the window"), "widget" : None}, -"maximize_vertically": {"description" : _("Maximize the window vertically only"), "widget" : None}, -"maximize_horizontally": {"description" : _("Maximize the window horizontally only"), "widget" : None}, -"unmaximize": {"description" : _("Unmaximize the window"), "widget" : None}, -"minimize": {"description" : _("Minimize the window"), "widget" : None}, -"unminimize": {"description" : _("Unminimize the window"), "widget" : None}, -"shade": {"description" : _("Roll up the window"), "widget" : None}, -"unshade": {"description" : _("Roll down the window"), "widget" : None}, -"close": {"description" : _("Close the window"), "widget" : None}, -"pin": {"description" : _("Pin the window to all workspaces"), "widget" : None}, -"unpin": {"description" : _("Unpin the window from all workspaces"), "widget" : None}, -"stick": {"description" : _("Stick the window to all viewports"), "widget" : None}, -"unstick": {"description" : _("Unstick the window from all viewports"), "widget" : None}, -"set_workspace": {"description" : _("Move the window to a specific workspace number"), "widget" : None, "type" : "Spin" , "input" : { "workspace" : None } }, -"set_viewport": {"description" : _("Move the window to a specific viewport number"), "widget" : None, "type" : "Spin" , "input" : { "viewport" : None } }, -"skip_pager": {"description" : _("Remove the window from the pager"), "widget" : None}, -"skip_tasklist": {"description" : _("Remove the window from the window list"), "widget" : None}, -"above": {"description" : _("Set the current window to be above all normal windows"), "widget" : None}, -"below": {"description" : _("Set the current window to be below all normal windows"), "widget" : None}, -"decorate": {"description" : _("Add the window manager decorations to the window"), "widget" : None}, -"undecorate": {"description" : _("Remove the window manager decorations from the window"), "widget" : None}, -"wintype": {"description" : _("Set the window type of the window"), "widget" : None, "type" : "Combo" , "Choices" : ["normal", "dialog", "menu", "toolbar", "splash-screen", "utility", "dock", "desktop"] , "input" : { "wintype" : None } }, -"opacity": {"description" : _("Change the opacity level of the widnow"), "widget" : None, "type" : "Spin" , "input" : { "opacity" : None } }, -"spawn_async": {"description" : _("Execute a command in the background"), "widget" : None, "type" : "Text" , "input" : { "command" : None } }, -"spawn_sync": {"description" : _("Execute a command in the foreground"), "widget" : None, "type" : "Text" , "input" : { "command" : None } } -} +actions_dict=odict([ +("geometry", {"description" : _("Set position and size of window"), "widget" : None, "type" : "Text" , "input" : { "xposition" : None, "yposition" : None, "width" : None, "height" : None } }), +("fullscreen", {"description" : _("Make the window fullscreen"), "widget" : None}), +("focus", {"description" : _("Focus the window"), "widget" : None}), +("center", {"description" : _("Center the position of the window"), "widget" : None}), +("maximize", {"description" : _("Maximize the window"), "widget" : None}), +("maximize_vertically", {"description" : _("Maximize the window vertically only"), "widget" : None}), +("maximize_horizontally", {"description" : _("Maximize the window horizontally only"), "widget" : None}), +("unmaximize", {"description" : _("Unmaximize the window"), "widget" : None}), +("minimize", {"description" : _("Minimize the window"), "widget" : None}), +("unminimize", {"description" : _("Unminimize the window"), "widget" : None}), +("shade", {"description" : _("Roll up the window"), "widget" : None}), +("unshade", {"description" : _("Roll down the window"), "widget" : None}), +("close", {"description" : _("Close the window"), "widget" : None}), +("pin", {"description" : _("Pin the window to all workspaces"), "widget" : None}), +("unpin", {"description" : _("Unpin the window from all workspaces"), "widget" : None}), +("stick", {"description" : _("Stick the window to all viewports"), "widget" : None}), +("unstick", {"description" : _("Unstick the window from all viewports"), "widget" : None}), +("set_workspace", {"description" : _("Move the window to a specific workspace number"), "widget" : None, "type" : "Spin" , "input" : { "workspace" : None } }), +("set_viewport", {"description" : _("Move the window to a specific viewport number"), "widget" : None, "type" : "Spin" , "input" : { "viewport" : None } }), +("skip_pager", {"description" : _("Remove the window from the pager"), "widget" : None}), +("skip_tasklist", {"description" : _("Remove the window from the window list"), "widget" : None}), +("above", {"description" : _("Set the current window to be above all normal windows"), "widget" : None}), +("below", {"description" : _("Set the current window to be below all normal windows"), "widget" : None}), +("decorate", {"description" : _("Add the window manager decorations to the window"), "widget" : None}), +("undecorate", {"description" : _("Remove the window manager decorations from the window"), "widget" : None}), +("wintype", {"description" : _("Set the window type of the window"), "widget" : None, "type" : "Combo" , "Choices" : ["normal", "dialog", "menu", "toolbar", "splash-screen", "utility", "dock", "desktop"] , "input" : { "wintype" : None } }), +("opacity", {"description" : _("Change the opacity level of the widnow"), "widget" : None, "type" : "Spin" , "input" : { "opacity" : None } }), +("spawn_async", {"description" : _("Execute a command in the background"), "widget" : None, "type" : "Text" , "input" : { "command" : None } }), +("spawn_sync", {"description" : _("Execute a command in the foreground"), "widget" : None, "type" : "Text" , "input" : { "command" : None } }) +]) def create_action_parameters_page(action_name): vbox = gtk.VBox() diff -ruN gdevilspie-0.5/odict.py gdevilspie-0.5.jrd/odict.py --- gdevilspie-0.5/odict.py 1970-01-01 01:00:00.000000000 +0100 +++ gdevilspie-0.5.jrd/odict.py 2010-12-12 23:07:13.705867276 +0100 @@ -0,0 +1,328 @@ +# -*- coding: utf-8 -*- +""" + odict + ~~~~~ + + This module is an example implementation of an ordered dict for the + collections module. It's not written for performance (it actually + performs pretty bad) but to show how the API works. + + + Questions and Answers + ===================== + + Why would anyone need ordered dicts? + + Dicts in python are unordered which means that the order of items when + iterating over dicts is undefined. As a matter of fact it is most of + the time useless and differs from implementation to implementation. + + Many developers stumble upon that problem sooner or later when + comparing the output of doctests which often does not match the order + the developer thought it would. + + Also XML systems such as Genshi have their problems with unordered + dicts as the input and output ordering of tag attributes is often + mixed up because the ordering is lost when converting the data into + a dict. Switching to lists is often not possible because the + complexity of a lookup is too high. + + Another very common case is metaprogramming. The default namespace + of a class in python is a dict. With Python 3 it becomes possible + to replace it with a different object which could be an ordered dict. + Django is already doing something similar with a hack that assigns + numbers to some descriptors initialized in the class body of a + specific subclass to restore the ordering after class creation. + + When porting code from programming languages such as PHP and Ruby + where the item-order in a dict is guaranteed it's also a great help + to have an equivalent data structure in Python to ease the transition. + + Where are new keys added? + + At the end. This behavior is consistent with Ruby 1.9 Hashmaps + and PHP Arrays. It also matches what common ordered dict + implementations do currently. + + What happens if an existing key is reassigned? + + The key is *not* moved. This is consitent with existing + implementations and can be changed by a subclass very easily:: + + class movingodict(odict): + def __setitem__(self, key, value): + self.pop(key, None) + odict.__setitem__(self, key, value) + + Moving keys to the end of a ordered dict on reassignment is not + very useful for most applications. + + Does it mean the dict keys are sorted by a sort expression? + + That's not the case. The odict only guarantees that there is an order + and that newly inserted keys are inserted at the end of the dict. If + you want to sort it you can do so, but newly added keys are again added + at the end of the dict. + + I initializes the odict with a dict literal but the keys are not + ordered like they should! + + Dict literals in Python generate dict objects and as such the order of + their items is not guaranteed. Before they are passed to the odict + constructor they are already unordered. + + What happens if keys appear multiple times in the list passed to the + constructor? + + The same as for the dict. The latter item overrides the former. This + has the side-effect that the position of the first key is used because + the key is actually overwritten: + + >>> odict([('a', 1), ('b', 2), ('a', 3)]) + odict.odict([('a', 3), ('b', 2)]) + + This behavor is consistent with existing implementation in Python + and the PHP array and the hashmap in Ruby 1.9. + + This odict doesn't scale! + + Yes it doesn't. The delitem operation is O(n). This is file is a + mockup of a real odict that could be implemented for collections + based on an linked list. + + Why is there no .insert()? + + There are few situations where you really want to insert a key at + an specified index. To now make the API too complex the proposed + solution for this situation is creating a list of items, manipulating + that and converting it back into an odict: + + >>> d = odict([('a', 42), ('b', 23), ('c', 19)]) + >>> l = d.items() + >>> l.insert(1, ('x', 0)) + >>> odict(l) + odict.odict([('a', 42), ('x', 0), ('b', 23), ('c', 19)]) + + :copyright: (c) 2008 by Armin Ronacher and PEP 273 authors. + :license: modified BSD license. +""" +from itertools import izip, imap +from copy import deepcopy + +missing = object() + + +class odict(dict): + """ + Ordered dict example implementation. + + This is the proposed interface for a an ordered dict as proposed on the + Python mailinglist (proposal_). + + It's a dict subclass and provides some list functions. The implementation + of this class is inspired by the implementation of Babel but incorporates + some ideas from the `ordereddict`_ and Django's ordered dict. + + The constructor and `update()` both accept iterables of tuples as well as + mappings: + + >>> d = odict([('a', 'b'), ('c', 'd')]) + >>> d.update({'foo': 'bar'}) + >>> d + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar')]) + + Keep in mind that when updating from dict-literals the order is not + preserved as these dicts are unsorted! + + You can copy an odict like a dict by using the constructor, `copy.copy` + or the `copy` method and make deep copies with `copy.deepcopy`: + + >>> from copy import copy, deepcopy + >>> copy(d) + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar')]) + >>> d.copy() + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar')]) + >>> odict(d) + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar')]) + >>> d['spam'] = [] + >>> d2 = deepcopy(d) + >>> d2['spam'].append('eggs') + >>> d + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar'), ('spam', [])]) + >>> d2 + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar'), ('spam', ['eggs'])]) + + All iteration methods as well as `keys`, `values` and `items` return + the values ordered by the the time the key-value pair is inserted: + + >>> d.keys() + ['a', 'c', 'foo', 'spam'] + >>> d.values() + ['b', 'd', 'bar', []] + >>> d.items() + [('a', 'b'), ('c', 'd'), ('foo', 'bar'), ('spam', [])] + >>> list(d.iterkeys()) + ['a', 'c', 'foo', 'spam'] + >>> list(d.itervalues()) + ['b', 'd', 'bar', []] + >>> list(d.iteritems()) + [('a', 'b'), ('c', 'd'), ('foo', 'bar'), ('spam', [])] + + Index based lookup is supported too by `byindex` which returns the + key/value pair for an index: + + >>> d.byindex(2) + ('foo', 'bar') + + You can reverse the odict as well: + + >>> d.reverse() + >>> d + odict.odict([('spam', []), ('foo', 'bar'), ('c', 'd'), ('a', 'b')]) + + And sort it like a list: + + >>> d.sort(key=lambda x: x[0].lower()) + >>> d + odict.odict([('a', 'b'), ('c', 'd'), ('foo', 'bar'), ('spam', [])]) + + .. _proposal: http://thread.gmane.org/gmane.comp.python.devel/95316 + .. _ordereddict: http://www.xs4all.nl/~anthon/Python/ordereddict/ + """ + + def __init__(self, *args, **kwargs): + dict.__init__(self) + self._keys = [] + self.update(*args, **kwargs) + + def __delitem__(self, key): + dict.__delitem__(self, key) + self._keys.remove(key) + + def __setitem__(self, key, item): + if key not in self: + self._keys.append(key) + dict.__setitem__(self, key, item) + + def __deepcopy__(self, memo=None): + if memo is None: + memo = {} + d = memo.get(id(self), missing) + if d is not missing: + return d + memo[id(self)] = d = self.__class__() + dict.__init__(d, deepcopy(self.items(), memo)) + d._keys = self._keys[:] + return d + + def __getstate__(self): + return {'items': dict(self), 'keys': self._keys} + + def __setstate__(self, d): + self._keys = d['keys'] + dict.update(d['items']) + + def __reversed__(self): + return reversed(self._keys) + + def __eq__(self, other): + if isinstance(other, odict): + if not dict.__eq__(self, other): + return False + return self.items() == other.items() + return dict.__eq__(self, other) + + def __ne__(self, other): + return not self.__eq__(other) + + def __cmp__(self, other): + if isinstance(other, odict): + return cmp(self.items(), other.items()) + elif isinstance(other, dict): + return dict.__cmp__(self, other) + return NotImplemented + + @classmethod + def fromkeys(cls, iterable, default=None): + return cls((key, default) for key in iterable) + + def clear(self): + del self._keys[:] + dict.clear(self) + + def copy(self): + return self.__class__(self) + + def items(self): + return zip(self._keys, self.values()) + + def iteritems(self): + return izip(self._keys, self.itervalues()) + + def keys(self): + return self._keys[:] + + def iterkeys(self): + return iter(self._keys) + + def pop(self, key, default=missing): + if default is missing: + return dict.pop(self, key) + elif key not in self: + return default + self._keys.remove(key) + return dict.pop(self, key, default) + + def popitem(self, key): + self._keys.remove(key) + return dict.popitem(key) + + def setdefault(self, key, default=None): + if key not in self: + self._keys.append(key) + dict.setdefault(self, key, default) + + def update(self, *args, **kwargs): + sources = [] + if len(args) == 1: + if hasattr(args[0], 'iteritems'): + sources.append(args[0].iteritems()) + else: + sources.append(iter(args[0])) + elif args: + raise TypeError('expected at most one positional argument') + if kwargs: + sources.append(kwargs.iteritems()) + for iterable in sources: + for key, val in iterable: + self[key] = val + + def values(self): + return map(self.get, self._keys) + + def itervalues(self): + return imap(self.get, self._keys) + + def index(self, item): + return self._keys.index(item) + + def byindex(self, item): + key = self._keys[item] + return (key, dict.__getitem__(self, key)) + + def reverse(self): + self._keys.reverse() + + def sort(self, *args, **kwargs): + self._keys.sort(*args, **kwargs) + + def __repr__(self): + return 'odict.odict(%r)' % self.items() + + __copy__ = copy + __iter__ = iterkeys + + +if __name__ == '__main__': + import doctest + doctest.testmod()