Thread: SF.net SVN: fclient: [13] trunk/fclient/fclient_lib
Status: Pre-Alpha
Brought to you by:
jurner
From: <jU...@us...> - 2007-10-27 16:57:37
|
Revision: 13 http://fclient.svn.sourceforge.net/fclient/?rev=13&view=rev Author: jUrner Date: 2007-10-27 09:57:28 -0700 (Sat, 27 Oct 2007) Log Message: ----------- added python extensions module Added Paths: ----------- trunk/fclient/fclient_lib/pyex/ trunk/fclient/fclient_lib/pyex/__init__.py trunk/fclient/fclient_lib/pyex/__init__.pyc trunk/fclient/fclient_lib/pyex/events.py trunk/fclient/fclient_lib/pyex/events.pyc trunk/fclient/fclient_lib/pyex/namespace.py trunk/fclient/fclient_lib/pyex/numbers.py trunk/fclient/fclient_lib/pyex/numbers.pyc trunk/fclient/fclient_lib/pyex/omapping.py Added: trunk/fclient/fclient_lib/pyex/__init__.py =================================================================== --- trunk/fclient/fclient_lib/pyex/__init__.py (rev 0) +++ trunk/fclient/fclient_lib/pyex/__init__.py 2007-10-27 16:57:28 UTC (rev 13) @@ -0,0 +1 @@ +"""Pytrhon extension modules""" Added: trunk/fclient/fclient_lib/pyex/__init__.pyc =================================================================== (Binary files differ) Property changes on: trunk/fclient/fclient_lib/pyex/__init__.pyc ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: trunk/fclient/fclient_lib/pyex/events.py =================================================================== --- trunk/fclient/fclient_lib/pyex/events.py (rev 0) +++ trunk/fclient/fclient_lib/pyex/events.py 2007-10-27 16:57:28 UTC (rev 13) @@ -0,0 +1,125 @@ +"""Signals and events""" + +#*********************************************************************** +# +# event handler. Mostly taken from +#http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/410686 +# +#*********************************************************************** +class EventMeta(type): + """Metaclass for events""" + + class Event(object): + """Event handler""" + + def __init__(self, name): + """ + @param name: name of the event + @attr name: name of the event + @attr observers: list of observers of the event + """ + self.name = name + self.observers = [] + + def __call__(self, *args, **kwargs): + """Dispatches the event and additional parameters to all observers registerd""" + for o in self.observers: + o(self, *args, **kwargs) + + def __iadd__(self, observer): + """Adds an observer to the event + @note: the observer will be called with the event as first paraeter, + followed by any number of *args or **kwargs passed by the caller of an event + """ + self.observers.append(observer) + return self + + def __isub__(self, observer): + """Removes the first occurence of an observer from the event""" + self.observers.remove(observer) + return self + + def __new__(clss, name, bases, kws): + events = kws.get('_events_', None) + if events is None: + raise ValueError('Event classes must implement an "_event_" attribute') + for event_name in events: + kws[event_name] = clss.Event(event_name) + return type.__new__(clss, name, bases, kws) + + +class Events(object): + """Base class for events + + Derrived classes should list events they support in the "_events_" tuple. + Each event name is automagically set as attribute of the event + class. + + Listeners may register to receiving events by calling __iadd__, + unregister by calling __isub__ on these attributes. Callback are + always called with the event as first argument, followed by additional + arguments, depending on the event. + + Events have the following methods: + + 'name': name of the event + 'observers': list of observers listening to the event + + + Note: + Always make shure to disconnnect when event notification is no longer desired + + + >>> class MyEvents(Events): + ... _events_ = ('FooEvent', 'BarEvent') + ... + >>> events = MyEvents() + >>> def cb(event): + ... print 'Received: %s' % event.name + + >>> events.FooEvent += cb + >>> events.FooEvent() + Received: FooEvent + + >>> events.FooEvent -= cb + >>> events.FooEvent() + + >>> events += ( (events.FooEvent, cb), (events.BarEvent, cb) ) + >>> events.FooEvent() + Received: FooEvent + >>> events.BarEvent() + Received: BarEvent + + >>> events -= ( (events.FooEvent, cb), (events.BarEvent, cb) ) + >>> events.FooEvent() + + >>> events.BarEvent() + + """ + __metaclass__ = EventMeta + _events_ = () + + def __iadd__(self, events): + """Adds one or more events / observers at once + @param events: tuple( (event, observer), (event, observer), ...) + """ + for event, observer in events: + event += observer + return self + + def __isub__(self, events): + """Removes one or more events / observers at once + @param events: tuple( (event, observer), (event, observer), ...) + """ + for event, observer in events: + event -= observer + return self + + +#********************************************************************* +# +#********************************************************************* +if __name__ == '__main__': + import doctest + doctest.testmod() + Added: trunk/fclient/fclient_lib/pyex/events.pyc =================================================================== (Binary files differ) Property changes on: trunk/fclient/fclient_lib/pyex/events.pyc ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: trunk/fclient/fclient_lib/pyex/namespace.py =================================================================== --- trunk/fclient/fclient_lib/pyex/namespace.py (rev 0) +++ trunk/fclient/fclient_lib/pyex/namespace.py 2007-10-27 16:57:28 UTC (rev 13) @@ -0,0 +1,115 @@ +"""Namespace handling""" + +import os +import re +#********************************************************************* +# +#********************************************************************* +def unique_filename(fpath, prefix='', names=None): + """Creates a filepath with a unique (human readable) filename + @param: fpath: filepath to patch + @param prefix: prefix to add to the filename or '' + @param names: list of filenames to patch agaunst or None to check files in the directory + of filepath + + @return: a filepath with one of these 'MyFile (1).txt' patched filenames + + >>> names = ['foo.txt', 'foo (1).txt'] + >>> unique_filename('foo.txt', names=names) + 'foo (2).txt' + + >>> names = ['foo.txt', 'foo (2).txt'] + >>> unique_filename('foo.txt', names=names) + 'foo (1).txt' + + >>> names = ['foo.txt', ] + >>> result = unique_filename(os.path.join('myDir', 'foo.txt'), names=names) + >>> expected = os.path.join('myDir', 'foo (1).txt') + >>> result == expected + True + + >>> names = ['foo.txt', ] + >>> unique_filename('foo.txt', names=names, prefix="Copy Of") + 'Copy Of foo.txt' + + >>> names = ['foo.txt', 'Copy Of foo.txt'] + >>> unique_filename('foo.txt', names=names, prefix="Copy Of") + 'Copy Of foo (1).txt' + + """ + filename = os.path.basename(fpath) + dirname = os.path.dirname(fpath) + if not filename: + raise ValueError("No filename found: %s" % fpath) + + n = 0 + tmp_filename = filename + while True: + if names is not None: + if tmp_filename not in names: break + else: + if not os.path.exists(os.path.join(dirname, tmp_filename)): break + + n += 1 + tmp_filename, tmp_ext = os.path.splitext(filename) + if prefix: + if n == 1: + tmp_filename = '%s %s' % (prefix, tmp_filename) + else: + tmp_filename = '%s %s (%s)' % (prefix, tmp_filename, n -1) + else: + tmp_filename = '%s (%s)' % (tmp_filename, n) + tmp_filename = tmp_filename + tmp_ext + + return os.path.join(dirname, tmp_filename) + + +#********************************************************************* +# +#********************************************************************* +def unquote_uri(uri, slash='-'): + """Unquotes an uri so it can be used as a name in the filesystem + @param uri: (str) uri to unquote + @param slasch: (str) substitution string shlashes to use or None to keep slashes + @return: (str) uri + + >>> unquote_uri('foo/bar') + 'foo-bar' + >>> unquote_uri('foo/b%20ar') + 'foo-b ar' + >>> unquote_uri('foo/b%34ar') + 'foo-b%34ar' + >>> unquote_uri('foo/bar', slash='77') + 'foo77bar' + >>> unquote_uri('foo/bar', slash=None) + 'foo/bar' + + """ + + # impossible to handle all the dos and donts on oses. So do minimum + # to enshure user readability + if slash is not None: + uri = uri.replace('/', slash) + uri = uri.replace('%20', ' ') + uri = uri.replace('%28', '(') + uri = uri.replace('%29', ')') + return uri + + +#********************************************************************* +# +#********************************************************************* +if __name__ == '__main__': + import doctest + doctest.testmod() + +#TODO: handle fpath='myFolder/foo (1).txt' ? +#a = 'foo (123)' +#p = re.compile('\A(.*)\(([0-9]+)\)\Z') + + + + + + + Added: trunk/fclient/fclient_lib/pyex/numbers.py =================================================================== --- trunk/fclient/fclient_lib/pyex/numbers.py (rev 0) +++ trunk/fclient/fclient_lib/pyex/numbers.py 2007-10-27 16:57:28 UTC (rev 13) @@ -0,0 +1,143 @@ +"""Number crunching and others + +""" + +#*************************************************************** +# +#*************************************************************** +def format_num_bytes(num, short=True, conform=True): + """Formats a number representing a number of bytes to a human readable string + @param num: (int) number to fomat + @param short: use short names + @param conform: if True factor is 1000, else factor is 1024 + @return: (str) formated number + + >>> format_num_bytes(100) + '100 b' + + >>> format_num_bytes(1000) + '1.00 kb' + + >>> format_num_bytes(1024, conform=False) + '1.00 kb' + + >>> format_num_bytes(1000, short=False) + '1.00 Kilobyte' + + """ + + if short: + names = ('b', 'kb', 'mb', 'gb', 'tb', 'pb', 'eb', 'zb', 'yb') + else: + names = ('Byte', + 'Kilobyte', + 'Megabyte', + 'Gigabyte', + 'Terabyte', + 'Petabyte', + 'Exabyte', + 'Zettabyte', + 'Yottabyte' + ) + if conform: + factor = 1000 + else: + factor = 1024 + + num = float(num) + name = names[0] + if num >= factor: + for tmp_name in names[1: ]: + num /= factor + name = tmp_name + if num < factor: + break + else: + return '%i %s' % (num, name) + + + + return '%01.2f %s' % (num, name) +#*************************************************************** +# +#*************************************************************** +TimeDurationNames = { + 'seconds': 's', + 'minutes': 'm', + 'hours': 'h', + 'days': 'd', + 'years': 'y' + } +def format_time_delta(t1, t2, names=None): + """Pretty prints a time delta + @arg t1: duration starting time + @arg t2: duration ending time + @arg names: (optional) dict mapping names to names as they should be + to be printed (see TimeDurationNames) + + >>> import time + >>> t0 = time.time() + + >>> format_time_delta(t0, t0 +1) + '1s' + + >>> format_time_delta(t0, t0) + '0s' + + >>> format_time_delta(t0, t0 +1.4) + '1.4s' + + >>> format_time_delta(t0, t0 +60) + '1m' + + >>> format_time_delta(t0, t0 +12345) + '3.4h' + + >>> format_time_delta(t0, t0 +1234567890) + '39.1y' + + >>> format_time_delta(t0, t0 +1234567890, names={'years': 'leapers', 'seconds': 's', 'minutes': 'm', 'hours': 'h', 'days': 'd'}) + '39.1leapers' + + """ + mapping = ( + ('years', 1), + ('days', 365), + ('hours', 24), + ('minutes', 60), + ('seconds', 60), + ) + if names is None: + names = TimeDurationNames + + delta = t2 - t1 + if delta < 0: + t = n = 0 + name = 'seconds' + else: + start = (60 * 60 * 24 * 365) + for name, fac in mapping: + start = start / fac + t = delta / start + t = round(t, 1) + n = int(t) + if n: + break + + name = names[name] + if t > n: + return '%s%s' % (t, name) + else: + return '%s%s' % (n, name) + + +#***************************************************************** +# +#**************************************************************** +if __name__ == '__main__': + import doctest + doctest.testmod() + + + + Added: trunk/fclient/fclient_lib/pyex/numbers.pyc =================================================================== (Binary files differ) Property changes on: trunk/fclient/fclient_lib/pyex/numbers.pyc ___________________________________________________________________ Name: svn:mime-type + application/octet-stream Added: trunk/fclient/fclient_lib/pyex/omapping.py =================================================================== --- trunk/fclient/fclient_lib/pyex/omapping.py (rev 0) +++ trunk/fclient/fclient_lib/pyex/omapping.py 2007-10-27 16:57:28 UTC (rev 13) @@ -0,0 +1,345 @@ +"""Ordered mappings""" + +#****************************************************************************** +# +#****************************************************************************** +class StableMapping(dict): + """Stable mapping wich keeps insertion order of items (neither complete nor whatever) + + >>> StableMapping() + {} + >>> o = StableMapping( ((1, 1), (2, 2)) ) + >>> for i in o: i + (1, 1) + (2, 2) + + >>> enum = o.__iter__() + >>> enum.next() + (1, 1) + + >>> o.popitem(-1) + (2, 2) + + >>> for i in o: i + (1, 1) + + >>> o['a'] = 'aa' + >>> for i in o: i + (1, 1) + ('a', 'aa') + + >>> o['a'] = 'bb' + >>> for i in o: i + (1, 1) + ('a', 'bb') + + >>> o.getitem(-1) + ('a', 'bb') + + >>> del o['a'] + >>> for i in o: i + (1, 1) + + + >>> o.item_order + [1] + + >>> o.remove(1) + >>> for i in o: i + + + """ + + def __init__(self, items=None): + self.item_order = [] + if items is None: + dict.__init__(self) + else: + dict.__init__(self, items) + self.item_order = [i[0] for i in items] + + def __delitem__(self, name): + dict.__delitem__(self, name) + self.item_order.remove(name) + + def __iter__(self): + for i in self.item_order: + yield (i, self[i]) + + def __setitem__(self, name, value): + isnew = name not in self + dict.__setitem__(self, name, value) + if isnew: + self.item_order.append(name) + + def pop(self, name): + item = dict.pop(self, name) + self.item_order.remove(name) + return item + + def popitem(self, i=-1): + item = self.item_order.pop(i) + return (item, dict.pop(self, item)) + + def getitem(self, i): + item = self.item_order[i] + return (item, self[item]) + + def index(self, item): + return self.item_order.index(item) + + def remove(self, item): + del self[item] + +#****************************************************************************** +# +#****************************************************************************** +class MappedPriorityQueue(object): + """Sorted queue supporting priorities and dictionary lookup of items + + >>> PriorityHigh = 2 + >>> PriorityMiddle = 1 + >>> PriorityLow = 0 + + >>> m = MappedPriorityQueue() + >>> for i in range(4): m.push(str(i), 'MyItem-%s' % i, PriorityLow) + >>> len(m) + 4 + >>> [name for (priority, name, item) in m.iter_items()] + ['0', '1', '2', '3'] + + >>> m.set_priority('3', PriorityHigh) + >>> [name for (priority, name, item) in m.iter_items()] + ['3', '0', '1', '2'] + + >>> m.set_priority('2', PriorityMiddle) + >>> [name for (priority, name, item) in m.iter_items()] + ['3', '2', '0', '1'] + + # iterate over all items with PriorityMiddle + >>> for item in m.iter_items(PriorityMiddle, PriorityMiddle): item + (1, '2', 'MyItem-2') + + # pop all items with PriorityMiddle and below + >>> for item in m.pop_items(PriorityMiddle): item + (1, '2', 'MyItem-2') + (0, '0', 'MyItem-0') + (0, '1', 'MyItem-1') + + >>> [name for (priority, name, item) in m.iter_items()] + ['3'] + + + # items can be popped by name aswell + >>> m.push('MyName', 'MyItem', PriorityLow) + >>> [name for (priority, name, item) in m.iter_items()] + ['3', 'MyName'] + + >>> m.pop('MyName') + (0, 'MyName', 'MyItem') + >>> [name for (priority, name, item) in m.iter_items()] + ['3'] + + + # dictionary lookup + >>> m['3'] + 'MyItem-3' + + + # check if queue is empty + >>> bool(m) + True + + >>> m.clear() + >>> bool(m) + False + + """ + + + class QueueItem(object): + + __slots__ = ('item', 'priority', 'name') + + def __init__(self, priority, name, item): + self.item = item + self.priority = priority + self.name = name + + def __cmp__(self,other): + if isinstance(other, self.__class__): + return cmp(self.priority, other.priority) + return cmp(self.priority, other) + + + def __init__(self): + """ + @attr queue: (list) [QueueItem, ...] + @attr mapping: (dict) name --> QueueItem + @note: both mappings should be considered read only + """ + self.queue = [] + self.mapping = {} + + + def __contains__(self, name): + """Returns True if an item 'name' exists in the queue, False otherwise""" + return name in self.mapping + + def __getitem__(self, name): + """Returns an item from the queue given its name""" + return self.mapping[name].item + + def __setitem__(self, name, item): + """Sets the item associated to name""" + self.mapping[name].item = item + + + def __len__(self): + """Retuns the number of items in the queue""" + return len(self.queue) + + def __nonzero__(self): + """Returns False if the queue is empty, True otherwise""" + return bool(self.queue) + + + def clear(self): + """Removes all items from the queue""" + self.queue = [] + self.mapping = {} + + + def get(self, name, default=None): + """Returns an item from the queue given its name or default + @return: tuple(priority, item) + """ + queue_item = self.mapping.get(name, None) + if queue_item is None: + return default + return (queue_item.priority, queue_item.item) + + + def index(self, name): + """Returns the first index of an item in the queue""" + queue_item = self.mapping[name] + return self.queue.index(queue_item) + + + def iter_items(self, priority_start=None, priority_stop=None): + """Iterates over all items in the queue + @param priority_start: minimu priority to start iterating at + or None to start at the first item + @param priority_stop: priority to stop iterating at. If None + all items below priority_start are returned + @return: tuple(priority, name, item) for the next item in turn + """ + for queue_item in self.queue: + if priority_stop is not None: + if queue_item < priority_stop: + raise StopIteration + + if priority_start is not None: + if queue_item > priority_start: + continue + yield (queue_item.priority, queue_item.name, queue_item.item) + + + + def peak(self, index): + """Returns an item from a specified index + @return: tuple(priority, name, item) + """ + queue_item = self.queue[index] + return (queue_item.priority, queue_item.name, queue_item.item) + + + def pop(self, name=None): + """Pops an item from the queue + @param name: name of the item to pop. If None, the item with the highest priority is popped + @return: tuple(priority, name, item) + """ + if name: + queue_item = self.mapping[name] + else: + queue_item = self.queue[0] + self.queue.remove(queue_item) + self.mapping.pop(name) + return (queue_item.priority, queue_item.name, queue_item.item) + + + def pop_items(self, priority_start=None, priority_stop=None): + """Sequentially pops a number of items from the queue + @param priority_start: minimu priority to start popping at + @param priority_stop: priority to stop popping at. If None + all items below priority_start are popped + @return: tuple(name, item) for the next item in turn + """ + i = 0 + while len(self.queue) > i: + queue_item = self.queue[i] + if priority_stop is not None: + if queue_item < priority_stop: + raise StopIteration + + if priority_start is None: + del self.queue[i] + del self.mapping[queue_item.name] + yield (queue_item.name, queue_item.item) + + elif queue_item <= priority_start: + del self.queue[i] + del self.mapping[queue_item.name] + yield (queue_item.priority, queue_item.name, queue_item.item) + + else: + i += 1 + + + def push(self, name, item, priority, sort=True): + """Pushes an item into the queue + @param item: any desired item + @param priority: (int) priority of the item + @param sort: if True the queue is sorted right away, if False, use sort() + to trigger sorting manually + """ + if name in self.mapping: + raise KeyError('Item already exists: %r' % name) + + queue_item = self.QueueItem(priority, name, item) + self.queue.append(queue_item) + self.mapping[name] = queue_item + if sort: + self.sort() + + + def get_priority(self, name): + """Returns the priority of item name""" + return self.mapping[name].priority + + + def set_priority(self, name, priority, sort=True): + """Adjusts the priority of an item + @param name: name of the item to adjust priority for + @param priority: (int) new priority of the item + @param sort: if True the queue is sorted right away, if False, use sort() + to trigger sorting manually + """ + self.mapping[name].priority = priority + if sort: + self.sort() + + + def sort(self): + """Sorts the queue""" + self.queue.sort(reverse=True) + + +#*************************************************************** +# +#*************************************************************** +if __name__ == '__main__': + import doctest + doctest.testmod() + + This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |
From: <jU...@us...> - 2007-11-05 12:50:37
|
Revision: 47 http://fclient.svn.sourceforge.net/fclient/?rev=47&view=rev Author: jUrner Date: 2007-11-05 04:50:42 -0800 (Mon, 05 Nov 2007) Log Message: ----------- svn fix Added Paths: ----------- trunk/fclient/fclient_lib/qt4ex/ trunk/fclient/fclient_lib/qt4ex/LICENCE.MIT trunk/fclient/fclient_lib/qt4ex/README trunk/fclient/fclient_lib/qt4ex/__init__.py trunk/fclient/fclient_lib/qt4ex/assistant.py trunk/fclient/fclient_lib/qt4ex/ctrls/ trunk/fclient/fclient_lib/qt4ex/ctrls/__init__.py trunk/fclient/fclient_lib/qt4ex/ctrls/areatips.py trunk/fclient/fclient_lib/qt4ex/ctrls/checkarraywrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/colorbutton.py trunk/fclient/fclient_lib/qt4ex/ctrls/compactpatwrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/dragtool.py trunk/fclient/fclient_lib/qt4ex/ctrls/editboxwrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/labelwrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/mrumenu.py trunk/fclient/fclient_lib/qt4ex/ctrls/progressbarwrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/tablewidget.py trunk/fclient/fclient_lib/qt4ex/ctrls/toolbarwrap.py trunk/fclient/fclient_lib/qt4ex/ctrls/treewidgetwrap.py trunk/fclient/fclient_lib/qt4ex/dlgs/ trunk/fclient/fclient_lib/qt4ex/dlgs/__init__.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgabout/ trunk/fclient/fclient_lib/qt4ex/dlgs/dlgabout/DlgAbout.ui trunk/fclient/fclient_lib/qt4ex/dlgs/dlgabout/Ui_DlgAbout.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgabout/__init__.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgfindreplace/ trunk/fclient/fclient_lib/qt4ex/dlgs/dlgfindreplace/DlgFindReplace.ui trunk/fclient/fclient_lib/qt4ex/dlgs/dlgfindreplace/Ui_DlgFindReplace.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgfindreplace/__init__.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgpreferences/ trunk/fclient/fclient_lib/qt4ex/dlgs/dlgpreferences/DlgPreferencesTree.ui trunk/fclient/fclient_lib/qt4ex/dlgs/dlgpreferences/Ui_DlgPreferencesTree.py trunk/fclient/fclient_lib/qt4ex/dlgs/dlgpreferences/__init__.py trunk/fclient/fclient_lib/qt4ex/lang/ trunk/fclient/fclient_lib/qt4ex/lang/qt4ex_de.ts trunk/fclient/fclient_lib/qt4ex/lang/qt4ex_en.ts trunk/fclient/fclient_lib/qt4ex/language.py trunk/fclient/fclient_lib/qt4ex/qt4ex.pro trunk/fclient/fclient_lib/qt4ex/qtools.py trunk/fclient/fclient_lib/qt4ex/res/ trunk/fclient/fclient_lib/qt4ex/res/language/ trunk/fclient/fclient_lib/qt4ex/res/language/LangCodes-ISO 639-1.txt trunk/fclient/fclient_lib/qt4ex/resources.py trunk/fclient/fclient_lib/qt4ex/scripts/ trunk/fclient/fclient_lib/qt4ex/scripts/__init__.py trunk/fclient/fclient_lib/qt4ex/scripts/manifest.py trunk/fclient/fclient_lib/qt4ex/scripts/pylupdate.py trunk/fclient/fclient_lib/qt4ex/scripts/qtpro.py trunk/fclient/fclient_lib/qt4ex/settingsbase.py Added: trunk/fclient/fclient_lib/qt4ex/LICENCE.MIT =================================================================== --- trunk/fclient/fclient_lib/qt4ex/LICENCE.MIT (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/LICENCE.MIT 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,21 @@ + +qt4ex -- Qt5 / PyQt4 extensions + +Copyright (c) 2007 J\xFCrgen Urner + + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software +and associated documentation files (the "Software"), to deal in the Software without restriction, +including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, +INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT +OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file Added: trunk/fclient/fclient_lib/qt4ex/README =================================================================== --- trunk/fclient/fclient_lib/qt4ex/README (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/README 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,23 @@ + qt4ex -- Qt5 / PyQt4 extensions + + + +Version history: + +******************************************************************* +0.1.0 +******************************************************************* +news: + x. initial release + +bugfixes: + x. + + + + + + + + + Added: trunk/fclient/fclient_lib/qt4ex/__init__.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/__init__.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/__init__.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,11 @@ +"""Qt4 extensions + +""" + +__version__ = '0.1.0' +__author__ = 'Juergen Urner' +__emeil__ = 'jU...@ar...' +__licence__ = 'Mit' +__copyright__ = '(c) 2007 Juergen Urner' + + Added: trunk/fclient/fclient_lib/qt4ex/assistant.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/assistant.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/assistant.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,130 @@ + +import os +from PyQt4 import QtCore, QtGui + +__version__ = '0.0.1' +#***************************************************************** +# +#***************************************************************** +class Assistant(QtCore.QObject): + """Class to tame QAssistant a bit + + Usage: + + * Feed a profile and a dict of pages to the class + * call showPage() with the widget and the name of a page to show as params + * call close() with the widget as param the page is shown for when the widget is closed + + An internal refcount is kept to enshure QAssistant is not closed any sooner + than as when the last widget refering to it is closed. And as a bonus closing + a page for a widget will switch back to the page opend by the previous widget + + @note: currently only one open page / widget is supported + """ + def __init__(self, parent, profile, pages): + """ + @param profile: (absolute) path of the profile file to dfeed to assistant + @param pages: a dict{name-of-page: fpath-page} of pages + """ + QtCore.QObject.__init__(self, parent) + + self._referers = [[], []] # [widgets, page-names] + self._isInited = False + + self.qtAssistant = None + self.pages = pages + self.parent = parent + self.profile = profile + + if self.pages is None: + self.pages = {} + + + ################################################ + ## slots + ################################################ + def onAssistantClosed(self): + self._referers = [[], []] + + ################################################ + ## methods + ################################################ + def close(self, parent): + """Closes assistant if open and no other widget currently has a page open + """ + if self.qtAssistant is not None: + widgets, pages = self._referers + if parent in widgets: + i = widgets.index(parent) + del widgets[i] + del pages[i] + if widgets: + self.showPage(widgets[-1], pages[-1], register=False) + else: + if self.qtAssistant.isOpen(): + self.qtAssistant.closeAssistant() + return True + return False + + + def error(self, msg): + QtGui.QMessageBox.critical(self.parent, self.trUtf8('Qt assistant error'), msg) + return False + + + def initAssistant(self, parent): + """Inits QAssistant client if not already done""" + if self._isInited: + return + else: + self._isInited = True + + try: + from PyQt4 import QtAssistant + except ImportError: + pass + else: + self.qtAssistant = QtAssistant.QAssistantClient('', parent) + self.qtAssistant.connect( + self.qtAssistant, + QtCore.SIGNAL('error(const QSting&)'), + self.error + ) + self.qtAssistant.connect( + self.qtAssistant, + QtCore.SIGNAL('assistantClosed()'), + self.onAssistantClosed + ) + + L = QtCore.QStringList('-profile' ) << self.profile + self.qtAssistant.setArguments(L) + + + def showPage(self, parent, name, register=True): + """Shows a page + @param widget: widget to show the page for + @param name: name of the page + @param register: if True the widget will be registerd in the stack of open pages + """ + self.initAssistant(parent) + if self.qtAssistant is None: + return self.error(self.trUtf8('Can not display help. Assistant is not installed')) + + fpath = self.pages.get(name, None) + if fpath is None: + return self.error(self.trUtf8('Can not display help. No such page: ') + name) + if not os.path.isfile(fpath): + return self.error(self.trUtf8('Can not display help. Page not found: ') + '\n' + fpath) + if register and parent not in self._referers[0]: + self._referers[0].append(parent) + self._referers[1].append(name) + self.qtAssistant.showPage(fpath) + return True + + + + + + + + \ No newline at end of file Added: trunk/fclient/fclient_lib/qt4ex/ctrls/__init__.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/__init__.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/__init__.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1 @@ + Added: trunk/fclient/fclient_lib/qt4ex/ctrls/areatips.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/areatips.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/areatips.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,465 @@ +# -*- coding: utf-8 -*- + +"""Customized tooltips +""" + +# TODO: +# +# x. fix ComboBoxEditTip to act as promised +# x. add classes to handle temTips for editBoxes (...) +# +# x. ComboBox trouble. +# +# XXX jopefuly fixed by adding an event.type().Leave handler to cancel toolTip display XXX +# +# y. The dropdown of a combobox does not seem to eat up events +# An itemView underneath the dropdown still receives mouseMove events +# and may pop up an itemTip. No idea what todo. +# +# y. there is a glitch with comboBoxes. When an itemTip is popped up +# and the user clicks on it, the dropDown is closed, but the itemTip +# not. For some reason the itemView eats the mouse message and +# the itemTip never gets notified. +# +# x. there is a possible glitch aswell in itemTips when an itemView gets +# disabled / hidden while an itemTip is scheduled for display. No way to +# cancel the itemTip currently +# +# +import os +from PyQt4 import QtCore, QtGui + +__version__ = '0.0.1' +#*************************************************************************** +# +#*************************************************************************** +DEFAULT_SHOW_DELAY = 400 + +#*************************************************************************** +# +#*************************************************************************** +#code for the toolTip is taken from QToolTip.cpp + +class AreaTip(QtGui.QLabel): + """ + Customized tooltip class to show tooltips for a specified area + under the mouse cursor. + + """ + + def __init__(self, parent, showDelay=DEFAULT_SHOW_DELAY): + """constructor + + @param parent parent of the tooltip + @showDelay delay in milliseconds before the tootliptp is shown + """ + + + QtGui.QLabel.__init__(self, parent, QtCore.Qt.ToolTip) + self.hide() + + + self._currentAreaTipData = None + self._showTimer = QtCore.QTimer(self) + self._showDelay = showDelay + + self.connect( + self._showTimer, + QtCore.SIGNAL("timeout()"), + self.onShowTip) + + + + self.ensurePolished() + frameW = self.style().pixelMetric( + QtGui.QStyle.PM_ToolTipLabelFrameWidth, + None, + self + ) + self.setMargin( 1 + frameW) + self.setFrameStyle(QtGui.QFrame.NoFrame) + self.setAlignment(QtCore.Qt.AlignLeft) + self.setIndent(1) + + self.installEventFilter(self) + + opacity = self.style().styleHint( + QtGui.QStyle.SH_ToolTipLabel_Opacity, + None, + self + ) + self.setWindowOpacity( opacity / 255.0) + self.setPalette(QtGui.QToolTip.palette()) + + + + def showDelay(self): + """returns the current show delay""" + return self._showDelay + + def setShowDelay(self, n): + """adjusts the show delay + @param n milliseconds to delay the popup of the tooltip + """ + self._showDelay = n + + + def paintEvent(self, event): + """overwritten QWidget.paintEvent""" + p = QtGui.QStylePainter(self) + + opt = QtGui.QStyleOptionFrame() + opt.init(self) + p.drawPrimitive(QtGui.QStyle.PE_PanelTipLabel, opt) + p.end() + + QtGui.QLabel.paintEvent(self, event) + + + + def eventFilter(self, obj, event): + """event filter for the tooltip""" + + type_ = event.type() + if type_ == event.KeyPress or type == event.KeyRelease: + key = event.key() + modifiers = event.modifiers() + if modifiers & QtCore.Qt.KeyboardModifierMask or \ + key == QtCore.Qt.Key_Shift or \ + key == QtCore.Qt.Key_Control or \ + key == QtCore.Qt.Key_Alt or \ + key == QtCore.Qt.Key_Meta: + return False + + # TODO: delegate mouseactions to the window underneath the cursor + elif type_ in ( + event.Leave, + event.WindowActivate, + event.WindowDeactivate, + event.MouseButtonPress, + event.MouseButtonRelease, + event.MouseButtonDblClick, + event.FocusIn, + event.FocusOut, + event.Wheel, + ): + self.hideTip() + + return False + + + def onShowTip(self): + """called when the tooltip is about to be displayed""" + + if self._currentAreaTipData: + pt, text, rc = self._currentAreaTipData + pos = QtGui.QCursor().pos() + if not rc.contains(pos): + return + + desktop = QtGui.QApplication.desktop() + if desktop.isVirtualDesktop(): + scr = desktop.screenNumber(pt) + else: + scr = desktop.screenNumber(self.parent()) + + if os.name == "mac": + screen = desktop.availableGeometry(scr) + else: + screen = desktop.screenGeometry(scr) + + self.setText(text) + fm = QtGui.QFontMetrics(self.font()) + extra = QtCore.QSize(1, 0) + # Make it look good with the default ToolTip font on Mac, + # which has a small descent. + if fm.descent() == 2 and fm.ascent() >= 11: + extra.setHeight(extra.height() + 1) + + self.resize(self.sizeHint() + extra) + + self.setWordWrap(QtCore.Qt.mightBeRichText(text)) + self.move(pt) + self.show() + + + def cancel(self): + if self._showTimer.isActive(): + self._showTimer.stop() + + + def hideTip(self): + """hides the tooltip""" + self.cancel() + self.hide() + + + def showText(self, pt, text, rc): + """shows the tooltip + + @param pt: (global coordinates) point to show the tooltip at (left/top) + @param text: text to show (if emtpty string the tooltip is not shown) + @param rc: (global coordinates) bounding rect the tooltip is assigned to + + """ + self._currentAreaTipData = (pt, text, rc) + self.hideTip() + if not text.isEmpty(): + self._showTimer.start(self._showDelay) + + + def showItemTip(self, itemView, index): + """Shows an item tip for item views (QTreeView, QListView ....) + for the specified index if necessary. + + @param itemView: item view to display the tip for + @param index: QModelIndex of the item to display the tip for + + Note: the tolltip will only be displayed if the text of the item is truncated + or the item is not entirely visible. + """ + rc = self.getTruncatedItemRect(itemView, index) + if rc is not None: + text = index.data().toString() + if not text.isEmpty() and itemView.hasFocus(): + self.showText(rc.topLeft(), text, rc) + + + def getTruncatedItemRect(self, itemView, index): + """Helper method. Returns the rect of a truncted item in an item view + @param itemView: QAbstractItemView + @param index: index of the item + @return: (global coordinates QRect) if the item is truncated, None otherwise + @note: this method is callled by showItemTip() to determine wether to + display a toolTip for an item or not. Overwrite to customize + """ + viewport = itemView.viewport() + rcCli = viewport.contentsRect() + rcActual = itemView.visualRect(index) + rcDesired = QtCore.QRect( + rcActual.topLeft(), + itemView.sizeHintForIndex(index) + ) + if not rcActual.contains(rcDesired, False) or \ + not rcCli.contains(rcDesired, False): + + rcActual.moveTo( viewport.mapToGlobal(rcActual.topLeft()) ) + return rcActual + + +#**************************************************************************** +# +#**************************************************************************** +class ItemTips(QtCore.QObject): + """Equips an itemView (QTreeView, QListView ....) with tooltips for truncated items (item tips) + """ + + def __init__(self, itemView, showDelay=DEFAULT_SHOW_DELAY): + """ + @param itemView: itemView to equip with item tips + param showDelay: delay in (miliseconds) after wich to show a tooltip for an item + """ + QtCore.QObject.__init__(self, itemView) + + self.areaTip = AreaTip(itemView, showDelay=showDelay) + self.itemView = itemView + + itemView.setMouseTracking(True) # enshure we get mouseMove messages + itemView.viewport().installEventFilter(self) + + + def eventFilter(self, obj, event): + """Event filter for the itemTip""" + if event.type() == event.MouseMove: + if self.areaTip.isHidden(): + + # hope this check fixes a glitch with comboBoxes. Sometimes am itemTip + # did pop up when the combos dropdown was closed. + if not self.itemView.isHidden() and self.itemView.isEnabled() and self.itemView.underMouse(): + index = self.itemView.indexAt(event.pos()) + if index.isValid(): + self.areaTip.showItemTip(self.itemView, index) + if event.type() == event.Leave: + self.areaTip.cancel() + + return False + + + def setEnabled(self, flag): + self.areaTip.setEnabled(flag) + pass + + def isEnabled(self): + self.areaTip.isEnabled() + + def getShowDelay(self): + """returns the current show delay""" + return self.areaTip.getShowDelay() + + def setShowDelay(self, n): + """adjusts the show delay + @param n milliseconds to delay the popup of the tooltip + """ + return self.areaTip.setShowDelay(delay) + +#**************************************************************************** +# +#**************************************************************************** +class ComboBoxEditTips(QtCore.QObject): + """Equips a QComboBox with a toolTip popping up when the text in its edit box is truncated + + @note: this class does currently not quite what it is supposed todo. A normal toolTip is + sisplayed instead of a toolTip that covers the editBox. This may change in future versions. + """ + + def __init__(self, comboBox, showDelay=DEFAULT_SHOW_DELAY): + QtCore.QObject.__init__(self, comboBox) + + self.connect( + comboBox, + QtCore.SIGNAL('currentIndexChanged(const QString &)'), + self._adjustToolTip + ) + + comboBox.installEventFilter(self) + self.comboBox = comboBox + + + def eventFilter(self, obj, event): + if event.type() == event.Resize: + self._adjustToolTip(self.comboBox.currentText()) + return False + + def _adjustToolTip(self, text): + fm = self.comboBox.fontMetrics() + style = self.comboBox.style() + rc = self.comboBox.contentsRect() + rc2 = style.subControlRect( + style.CC_ComboBox, + QtGui.QStyleOptionComboBox(), + style.SC_ComboBoxEditField, + ) + + cx = rc.width() + rc2.width() + w = fm.width(text) + if w > cx -2: + self.comboBox.setToolTip(text) + else: + self.comboBox.setToolTip('') + + + + +#******************************************************************************************** +# some test guis +#******************************************************************************************** +def _testItemModel(): + """Tests itemTips for a QTableView""" + + import sys + + + class TestModel(QtCore.QAbstractTableModel): + + + def __init__(self, table): + QtCore.QAbstractTableModel.__init__(self, table) + + self.__table = table + self.__columns = ('foo', "foo") + self.__rows = ['foo'*10 for i in range(10)] + + self.areaTip = AreaTip(table) + + + def hasIndex(self, row, column): + """QAbstractTableModel.hasIndex() implementation""" + if -1 < column <= len(self.__columns): + if -1 < row < len(self.__rows): + return True + return False + + def rowCount(self, parent): + """QAbstractTableModel.rowCount() implementation""" + return len(self.__rows) + + + def columnCount(self, parent): + """QAbstractTableModel.columnCount() implementation""" + return len(self.__columns) + + + def headerData(self, section, orientation, role): + """QAbstractTableModel.headerData() implementation""" + if role == QtCore.Qt.DisplayRole and orientation == QtCore.Qt.Horizontal: + return QtCore.QVariant(self.__columns[section]) + return QtCore.QVariant() + + + def data(self, index, role): + """QAbstractTableModel.data() implementation""" + + if self.hasIndex(index.row(), index.column()): + if role == QtCore.Qt.DisplayRole: + return QtCore.QVariant(self.__rows[index.column()]) + + # display tooltip if text does not fit column width + # or item is not entirely visible + elif role == QtCore.Qt.ToolTipRole: + self.areaTip.showItemTip(self.__table, index) + + + return QtCore.QVariant() + + app = QtGui.QApplication(sys.argv) + dlg = QtGui.QWidget() + + grid = QtGui.QHBoxLayout(dlg) + + tv = QtGui.QTableView(dlg) + grid.addWidget(tv) + + tv.setModel(TestModel(tv)) + + dlg.show() + res = app.exec_() + sys.exit(res) + + + +def _testComboBox(): + """Tests itemTips for a QCombobox""" + + + import sys + + app = QtGui.QApplication(sys.argv) + w = QtGui.QWidget() + + b = QtGui.QGridLayout(w) + c = QtGui.QComboBox(w) + c.setMinimumContentsLength(5) + b.addWidget(c) + + itemTips = ItemTips(c.view()) + + + for i in range(10): + c.addItem('loooooooooooooooooooooooooooooong-itemText-%s' % i) + + w.show() + res = app.exec_() + sys.exit(res) + + + +#*********************************************************************** +# +#*********************************************************************** +if __name__ == "__main__": + pass + #_testItemModel() + #_testComboBox() + + + Added: trunk/fclient/fclient_lib/qt4ex/ctrls/checkarraywrap.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/checkarraywrap.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/checkarraywrap.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,93 @@ +"""wrapper class for handling checkboxes (...) as bit array + + +CONST_1 = 1 +CONST_2 = 2 +CONST_3 = 4 + +checks = { + CONST_1: ckeckbox1, + CONST_2: checkbox2, + CONST_3: cjeckbox3, + + } + + +flags = CheckArray(checks, initvalue=CONST_1 | CONST_2) + +flags |= CONST_3 # check 3rd checkbox +flags.showChecks(CONST_1 | CONST_2) # hide 3rd checkbox + +""" + +from PyQt4 import QtCore +#******************************************************* +# +#******************************************************* +class CheckArrayWrap(QtCore.QObject): + + def __init__(self, parent, checks, value=None): + QtCore.QObject.__init__(self, parent) + self._checks = checks + + if value is not None: + self.setChecks(value) + + ###################################### + ## public methods + ###################################### + def getValue(self): + value = 0 + for const, ck in self._checks.items(): + if ck.isChecked(): + value |= const + return value + + + def setChecks(self, flags): + for const, ck in self._checks.items(): + if flags & const: + ck.setCheckState(QtCore.Qt.Checked) + else: + ck.setCheckState(QtCore.Qt.Unchecked) + flags &= ~const + if not flags: + break + + + def showChecks(self, flags): + for const, ck in self._checks.items(): + if flags & const: + check.control.setEnabled(True) + check.control.show() + else: + check.control.setEnabled(False) + check.control.hide() + flags &= ~const + if not flags: + break + + + def __or__(self, n): + value = self.getValue() | n + self.setChecks(value) + return self + def __ior__(self, n): return self.__or__(n) + def __ror__(self, n): return self.__or__(n) + + def __and__(self, n): + value = self.getValue() & n + self.setChecks(value) + return self + def __iand__(self, n): return self.__and__(n) + def __rand__(self, n): return self.__and__(n) + + def __xor__(self, n): + value = self.getValue() ^ n + self.setChecks(value) + return self + def __ixor__(self, n): return self.__xor__(n) + def __rxor__(self, n): return self.__xor__(n) + + + Added: trunk/fclient/fclient_lib/qt4ex/ctrls/colorbutton.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/colorbutton.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/colorbutton.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,238 @@ +"""pyQt4 ColorButton with drag and drop support + +mostly taken from +[http://api.kde.org/4.0-api/kdelibs-apidocs/kdeui/html/classKColorButton.html] +with some minor adjustements +""" + +import sys, os + +#--> rel import hack +d = os.path.dirname(os.path.dirname(__file__)) +sys.path.insert(0, d) + +import qtools + +sys.path.pop(0) +del d +#<-- rel import hack + + +from PyQt4 import QtCore, QtGui + +__author__ = 'Juergen Urner' +__email__ = 'jU...@ar...' +__version__ = '0.1.0' +#************************************************************************ +# +#************************************************************************ +class ColorButtonWrap(QtCore.QObject): + """Event filter to transform a QPushButton into a color button + + The button will popup a color selection dialog when hit ++ the button supports + drag / drop of colors. + + @signal colorChanged(const QColor*): emited when the user changes the color of + the button via color dialog or color drop. + """ + + def __init__(self, button, color=None, fitColor=True): + """ + @param button: button to wrap + @param color: initial color. If None, initial color is black + @fitColor: if True the color shown is adjusted to fit the contents of the button + """ + QtCore.QObject.__init__(self, button) + + self.button = button + self._color = color or QtGui.QColor('black') + self.fitColor = fitColor + + button.setAcceptDrops(True) + button.installEventFilter(self) + self.connect(button, QtCore.SIGNAL('clicked()'), self.chooseColor) + + + def _initStyleOption(self, opt): + opt.initFrom(self.button) + opt.text.clear() + opt.icon = QtGui.QIcon() + opt.features = QtGui.QStyleOptionButton.None + + + def eventFilter(self, obj, event): + """Event filter for the button wrapped""" + + eventType = event.type() + + if eventType == event.Paint: + painter = QtGui.QPainter(self.button) + + # draw bevel + opt = QtGui.QStyleOptionButton() + self._initStyleOption(opt) + self.button.style().drawControl(QtGui.QStyle.CE_PushButtonBevel, opt, painter, self.button) + + # draw color box + #First, sort out where it goes + labelRect = self.button.style().subElementRect(QtGui.QStyle.SE_PushButtonContents, opt, self.button) + shift = self.button.style().pixelMetric(QtGui.QStyle.PM_ButtonMargin) + labelRect.adjust(shift, shift, -shift, -shift); + x, y, w, h = labelRect.getRect() + + if self.button.isChecked() or self.button.isDown(): + x += self.button.style().pixelMetric(QtGui.QStyle.PM_ButtonShiftHorizontal) + y += self.button.style().pixelMetric(QtGui.QStyle.PM_ButtonShiftVertical) + if self.button.isEnabled(): + fillCol = self.getColor() + else: + fillCol = self.button.palette().color(self.button.backgroundRole()) + + QtGui.qDrawShadePanel(painter, x, y, w, h, self.button.palette(), True, 1, None) + if fillCol.isValid(): + painter.fillRect( x+1, y+1, w-2, h-2, fillCol) + + if self.button.hasFocus(): + focusRect = self.button.style().subElementRect(QtGui.QStyle.SE_PushButtonFocusRect, opt, self.button) + focusOpt = QtGui.QStyleOptionFocusRect() + focusOpt.initFrom(self.button) + focusOpt.rect = focusRect + focusOpt.backgroundColor = self.button.palette().background().color() + self.button.style().drawPrimitive(QtGui.QStyle.PE_FrameFocusRect, focusOpt, painter, self.button) + return True + + elif eventType == event.MouseMove: + if not self._mouse_pressed: + return False + + if event.buttons() & QtCore.Qt.LeftButton: + if (self._mousepress_pos - event.pos()).manhattanLength() > QtGui.QApplication.startDragDistance(): + self._mouse_pressed = False + self.button.setDown(False) + drag = QtGui.QDrag(self.button) + data = QtCore.QMimeData() + data.setColorData(QtCore.QVariant(self._color)) + drag.setMimeData(data) + drag.start(QtCore.Qt.CopyAction) + return True + + elif eventType == event.MouseButtonPress: + self._mousepress_pos = QtCore.QPoint(event.pos()) + self._mouse_pressed = True + return False + + elif eventType == event.MouseButtonRelease: + self._mouse_pressed = False + return False + + elif eventType == event.DragEnter: + if event.mimeData().hasColor(): + event.accept() + else: + event.ignore() + return True + + elif eventType == event.DragMove: + if event.mimeData().hasColor(): + event.accept() + else: + Event.ignore() + return True + + elif eventType == event.Drop: + if event.mimeData().hasColor(): + v = event.mimeData().colorData() + self.setColor( QtGui.QColor(v.toString() ) ) + else: + event.ignore() + return True + + + # TODO: copy & paste + if eventType == event.KeyPress: + + if qtools.isStandardKeyEvent(event, QtGui.QKeySequence.Copy): + mimeData = QtCore.QMimeData() + mimeData.setColorData(QtCore.QVariant(self.getColor() ) ) + QtGui.QApplication.clipboard().setMimeData(mimeData, QtGui.QClipboard.Clipboard) + elif qtools.isStandardKeyEvent(event, QtGui.QKeySequence.Paste): + mimeData = QtGui.QApplication.clipboard().mimeData(QtGui.QClipboard.Clipboard) + if mimeData.hasColor(): + v = mimeData.colorData() + self.setColor( QtGui.QColor(v.toString() ) ) + + + + + + """ + void KColorButton::keyPressEvent( QKeyEvent *e ) + { + int key = e->key() | e->modifiers(); + + if ( KStandardShortcut::copy().contains( key ) ) { + QMimeData *mime=new QMimeData; + KColorMimeData::populateMimeData(mime,color()); + QApplication::clipboard()->setMimeData( mime, QClipboard::Clipboard ); + } + else if ( KStandardShortcut::paste().contains( key ) ) { + QColor color=KColorMimeData::fromMimeData( QApplication::clipboard()->mimeData( QClipboard::Clipboard )); + setColor( color ); + } + else + QPushButton::keyPressEvent( e ); + } + """ + + return False + + + ############################################# + ## methods + ############################################# + def chooseColor(self): + """Pops up a color selection dialog to adjust the color of the button""" + color = QtGui.QColorDialog.getColor(self._color, self.button) + if color.isValid(): + self.setColor(color) + self.emit(QtCore.SIGNAL('colorChanged(const QColor*)'), color) + + def getColor(self): + """Returns the color of the button + @return: QColor + """ + return self._color + + def setColor(self, color): + """Sets the color of the button + @param color: QColor + """ + self._color = color + self.button.update() + self.emit(QtCore.SIGNAL('colorChanged(const QColor*)'), color) + + +#******************************************************************** +# +#******************************************************************** +if __name__ == '__main__': + import sys + + app = QtGui.QApplication(sys.argv) + w = QtGui.QWidget(None) + box = QtGui.QVBoxLayout(w) + colors = ('yellow', 'red', 'green', 'blue') + for color in colors: + bt = QtGui.QPushButton(w) + wrap = ColorButtonWrap(bt, QtGui.QColor(color)) + box.addWidget(bt) + + + + w.show() + res = app.exec_() + sys.exit(res) + + + + \ No newline at end of file Added: trunk/fclient/fclient_lib/qt4ex/ctrls/compactpatwrap.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/compactpatwrap.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/compactpatwrap.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,576 @@ + +"""module to handles compacting of filepaths and urls + + @author Juergen Urner + """ + +import operator +import os +import re + +import ntpath +import posixpath +import macpath + +from PyQt4 import QtCore, QtGui + +# TODO: +# +# x. builtin type() is shaddowed in some methods +# x. rename DEFAULT to DEFAULT_TYPE + +#******************************************************************************* +# compacts a filepath to fit into a desired width +# As measuring function any function may be passed that returns True if a path +# is short enough, False otherwise. Default is len() +# +# +# IDEA: +# +# weight path components by priority, 0 is lowest. +# +# 2 0 1 3 +# mypath = "aaa/bb/ccc/ddd" +# +# genearte a sort matrix [[nPriority0, indexComponent0, component0], [...]] +# so we only have to flip the matrix to either get the priority order of the +# components and eat components from martx[0] to matrix[N] or the restore +# the original component order +# +# matrix = [[2, 0, "aaa"], [0, 1, "bbb"], [1, 2, "ccc"], [3, 3, "ddd"]] +# matrix.sort() +# matrix = [[0, 1, "bbb"], [1, 2, "ccc"], [2, 0, "aaa"], [3, 3, "ddd"]] +# +# I am shure that so. with better algo skills than me can come up with a nicer +# solution to the problem. I would like to see that. +# +#********************************************************************************** + +#************************************************************************************** +# helpers +#************************************************************************************** +_drive_pat = re.compile(r'([a-zA-Z]\:)(?=/|\\|\Z)') +def is_drive(fpath): + return bool(_drive_pat.match(fpath)) + +_host_pat = re.compile(r'([^:/?#]+:[^/]*///?)') +def is_host(fpath): + return bool(_host_pat.match(fpath)) + +def is_root(fpath): + return fpath.startswith("/") + +def is_mac_root(fpath): + if fpath: + return ':' in fpath and fpath[0] != ':' + return False + +if os.path.__name__.startswith("nt"): + DEFAULT = "nt" +elif os.path.__name__.startswith("mac"): + DEFAULT = "mac" +elif os.path.__name__.startswith("posix"): + DEFAULT = "posix" +else: + DEFAULT = os.path.__name__ + +PATH_MODULES = { # modules to handle path actions for path types + 'nt': ntpath, + 'posix': posixpath, + 'mac': macpath, + 'url': posixpath, + DEFAULT: os.path, + } + +#************************************************************************************** +# +#************************************************************************************** +class PathCompacter(object): + """ + implementation of the compact path algorithm. + + The class is available as compactPath() function in the module. + For a description of parameters see PathCompacter.__call__() + + @note: you do not have to use this class directly. On the module level + its functionality is available as function compactPath() + """ + + ELLIPSIS = "..." + PARDIR = ".." + DOT = "." + + def __init__(self): + """ + constructor + """ + self.root = "" + self.path_module = None + + + def chewComponent(self, cpn, fromLeft=True): + """ + shorten a single path component by one char + + @param cpn the component to to be shortened + @keyparam fromLeft if True the component is shortened on the left side, + if False on the right + """ + if fromLeft: + while True: + cpn = cpn[3: ] + if not cpn: + yield self.PARDIR + break + + cpn = self.PARDIR + cpn + yield cpn + + else: + while True: + cpn = cpn[ :-3] + if not cpn: + yield self.PARDIR + break + cpn = cpn + self.PARDIR + yield cpn + + + def getMatrix(self, n): + """ + generates a sort matrix of lenght (n) + """ + if n == 0: + return [] + + # ...enshure last item in range is last item in the matrix + if n % 2: + rng = range(n) + else: + rng = range(n -1) + + start = len(rng) / 2 + out = [] + for i in rng: + if i == start: + out.append([0, ]) + elif i < start: + out.append([ (start - i) *2 - 1, ]) + else: + out.append([ (i - start) *2, ]) + + if not n % 2: + out.append([len(out)]) + return out + + + def matrixToPath(self, matrix): + """ + private method to generate a filepath from a sort matrix + """ + getter = operator.itemgetter + out = [] + + matrix.sort(key=getter(1)) + for i in matrix: + out.append(i[2]) + + matrix.sort() + + if self.type == "url": + return self.root + "/".join(out) + elif self.type == "nt": + return self.path_module.join(self.root, *out) + elif self.type == "posix": + return self.path_module.join(self.root, *out) + elif self.type == "mac": + return self.path_module.join(self.root, *out) + return self.path_module.join(*out) + + + def matrixFromPath(self, fpath): + """ + private method to convert a filepath into a sort matrix + """ + arrPath = self._path_to_list(fpath) + if not arrPath: + return [] + + self.root = "" + if self.type == "nt": + if is_drive(arrPath[0]): + self.root = arrPath[0] + arrPath.pop(0) + elif self.type == "posix": + if is_root(arrPath[0]): + self.root = arrPath[0] + arrPath.pop(0) + elif self.type == "mac": + if is_mac_root(arrPath[0]): + self.root = arrPath[0] + arrPath.pop(0) + elif self.type == "url": + host = arrPath[0] + "//" + if is_host(host): + self.root = host + arrPath.pop(0) + + matrix = self.getMatrix(len(arrPath)) + i = 0 + for item in matrix: + item.append(i) + item.append(arrPath[i]) + i += 1 + + return matrix + + + def _path_to_list(self, fpath): + head = fpath + out = [] + # taken from: http://www.jorendorff.com/articles/python/path/ + while head != self.path_module.curdir and head != self.path_module.pardir: + prev = head + head, tail = self.path_module.split(head) + if head == prev: break + out.append(tail) + if head: + out.append(head) + out.reverse() + return out + + + def __call__(self, fpath, w, measure=len, max_pardirs=2, type=DEFAULT): + """ + compacts a filepath or url to fit into the desired width + + @param fpath the filepath to be compacted + @param w the desired width the filepath should fit into + @keyparam measure function to measure the length of the filepath. + Default is len() but may be any other function that takes a filepath as + argument and returns its length as undigned int. + @keyparam max_pardirs maximum number of compacted parent dirs ("../") allowed + in the compacted path. Must be > 0. + @keyparam type use this explicitely specify the type of path passed. + Can be "posix", "nt", "mac" or "url" or DEFAULT. DEFAULT processes the + path with whatever os.path currently is. + + """ + if max_pardirs < 1: + raise PathError("max_pardirs < 1 is not allowed") + + if not fpath: + return "" + if measure(fpath) < w: + return fpath + + self.type, self.path_module = type, PATH_MODULES[type] + matrix = self.matrixFromPath(fpath) + if not matrix: + return "" # error here, the pattern does not match anything + matrix.sort() + + # process our sort matrix + i = 0 + while True: + + if len(matrix) > 2: + # ...chew next component till it's exhausted + item = matrix[i] + for cpn in self.chewComponent(item[2], fromLeft=False): + item[2] = cpn + path = self.matrixToPath(matrix) + if measure(path) < w: + return path + + if cpn == self.PARDIR: + i += 1 + break + + # ...pop 1 pardir if necessary + if i > max_pardirs or i >= len(matrix) -1: + matrix.pop(0) + matrix[0][2] = self.ELLIPSIS + i -= 1 + path = self.matrixToPath(matrix) + if measure(path) < w: + return path + + else: + # finalize + # 1. chew root away + if self.root: + for cpn in self.chewComponent(self.root, fromLeft=True): + self.root = cpn + if self.root == self.PARDIR: + if not matrix: + if measure(self.PARDIR) < w: + return self.PARDIR + if measure(self.DOT) < w: + return self.DOT + return "" + self.root = "" + break + path = self.matrixToPath(matrix) + if measure(path) < w: + return path + + path = self.matrixToPath(matrix) + if measure(path) < w: + return path + + # 2. chew filename away + if len(matrix) == 2: + component = matrix[0][2] + matrix[1][2] + if measure(component) < w: + return component + else: + component = matrix[0][2] + + for cpn in self.chewComponent(component, fromLeft=True): + if measure(cpn) < w: + return cpn + + if cpn == self.PARDIR: + if measure(self.DOT) < w: + return self.DOT + break + + # done it + break + + return "" + + +#******************************************** +# init PathCompacter() as function +#******************************************** +compactPath = PathCompacter() +#******************************************************************************** +# lightweight wrapper class for QLabels to display a compactable filepath or url +# the class is designed as a wrapper not a derrived class so it does not get in the +# way with QtDesigner +# +# problem to tackle is that every setText() triggers a resize of the whole layout +# so the filepath can't be adjusted in resizeEvent() (recursive). We handle +# paintEvent() instead and draw the label from scratch. +# +# similar wrappers can be easily implemented for QMenuItem() and QListView() +# header controls (...). +# +# Usage hint: +# if used on statusbars you should adjust the stretch factor, otherwise +# the label might appear invisible, 'cos it may not get resized. +# +# The label has a minimum size of 0 by default. To force a minimum +# size set any initial text to the label wrapped. Effect is 1. the text will not be +# displayed ++ the label will not get resized any smaller than this text. +# +#******************************************************************************* +class PathLabelWrap(object): + """ + class wrapping a QLabel to display a filepath or url that is compacted on + resizing of the label + """ + + def __init__(self, label, fpath="", prefix="", max_pardirs=1, type=DEFAULT): + """ + constructor + + @param label an initialized QLabel to wrap compactPath functionality around + @param fpath the filepath or url the label should display + @keyparam prefix: chars to be used as fixed prefix of the path like: "file: my/path/here" + @keyparam max_pardirs maximum number of compacted parent dirs ("../") allowed + in the compacted path. Must be > 0. + @keyparam type: use this to explicitely specify the type of path specified. + Can be "nt", "posix", "mac", "url" or DEFAULT to use whatever type of path + os.path currently handles. + + Note: currently the wrapper does not know how to display text for disabled state. + So disabling the underlaying QLabel will not result in the desired effect. + """ + self.label = label + self.fpath = fpath + self.prefix = prefix + self.max_pardirs= max_pardirs + self.type = type + + self.label.paintEvent = self.onPaint # overwrite + # for testing: + #self.label.setPaletteBackgroundColor(qt.QColor(10, 255, 22)) + + + def onPaint(self, event): + """ + overwritten method to handle painting of the filepath + """ + + # draw the label from scratch + # TODO: check if there is an easier processing via QStyle.drawControl() + fm = self.label.fontMetrics() + rc = self.label.rect() + frameW = self.label.frameWidth() + indent = self.label.indent() + if indent < 0: # see Qt docs: label.indent() + if frameW > 0: + indent = fm.width("x") /2 + else: + indent = 0 + rc.adjust(frameW + indent, frameW , -(frameW + indent), -frameW) + + w = rc.width() + if self.prefix: + w -= fm.width(self.prefix) + + fpath = compactPath( + self.fpath, + w, + measure=fm.width, + max_pardirs=self.max_pardirs, + type=self.type + ) + + painter = QtGui.QPainter(self.label) + painter.eraseRect(self.label.rect()) + self.label.drawFrame(painter) + # TODO: draw enabled/disabled text + # textColor is already ok but I haven't found a way to draw disabled text + # embossed + # if self.label.isEnabled(): + # else: + if self.prefix: + painter.drawText(rc, self.label.alignment(), '%s%s' % (self.prefix, fpath)) + else: + painter.drawText(rc, self.label.alignment(), fpath) + + + def setPath(self, fpath, prefix=None, max_pardirs=None, type=None): + """ + sets the filepath or url to be displayed + + If any of the keyword params is not None, the according property is adjusted to the specified value + """ + if prefix is not None: + self.prefix = prefix + if max_pardirs is not None: + self.max_pardirs = max_pardirs + if type is not None: + self.type = type + self.fpath = fpath + self.label.update() + + def getPath(self): + """ + retrieves the (uncompacted) filepath or url + """ + return self.fpath + +#****************************************************************************** +# tests +#****************************************************************************** +if __name__ == "__main__": + + def testGui(): + + CAPTION = "compactPath - [%s]" + PATHS = ( + ('posix', "/my/very/long/path/containing/many/compoponents/here.txt"), + ('nt', "c:\\my\\very\\long\\path\\containing\\many\\compoponents\\here.txt"), + ('mac', "my:very:long:path:containing:many:compoponents:here.txt"), + ('url', "http://my/very/long/path/containing/many/compoponents/here.txt"), + ) + BLINDTEXT = "xxxxxxxxxx" # this is set as text to the labels to force a minimum size. Adjust to your needs + + class TestGui(QtGui.QMainWindow): + """test gui""" + + def __init__(self): + QtGui.QMainWindow.__init__(self) + + self.mainWidget = QtGui.QWidget(self) + self.setCentralWidget(self.mainWidget) + + # NOTE: all the sep="" params are only thrown in for test purposes. + # + # Too bad, the label in the caption bar seems not to be available in Qt. So there is no way + # to adjust it dynamically. So init to some fixed width. Note that the width of the caption + # bar label has no effect on the GUIs width. + # + pathType, fpath = PATHS[0] + fpath = compactPath(fpath, 50 - len(CAPTION), type=pathType) + self.setWindowTitle(CAPTION % fpath) + + # throw labels into the Gui + layout = QtGui.QVBoxLayout(self.centralWidget()) + frameStyle = QtGui.QLabel.Sunken | QtGui.QLabel.Box + self.pathLabels = [] + for pathType, fpath in PATHS: + label = QtGui.QLabel(BLINDTEXT, self.mainWidget) + w = PathLabelWrap(label, fpath=fpath, prefix=pathType + ': ', type=pathType) + label.setFrameStyle(frameStyle) + layout.addWidget(label) + + # just a test label to see if our owner drawn labels are ok + self.labelTest = QtGui.QLabel("just a test", self.mainWidget) + self.labelTest.setFrameStyle(frameStyle) + layout.addWidget(self.labelTest) + + layout.addItem(QtGui.QSpacerItem(0, 0, QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Expanding)) + + # add another one on the statusbar + self.status = self.statusBar() + self.statusLabelPosix = PathLabelWrap(QtGui.QLabel(BLINDTEXT, self.status), fpath=fpath) + self.status.addWidget(QtGui.QLabel('status::', self.status)) + self.status.addWidget(self.statusLabelPosix.label, 10) + self.status.addWidget(QtGui.QLabel('foo-bar', self.status)) + + def styleChange(self, oldStyle): + """styleChange handler""" + self.update() + + import sys + a = QtGui.QApplication(sys.argv) + QtCore.QObject.connect(a,QtCore.SIGNAL("lastWindowClosed()"),a,QtCore.SLOT("quit()")) + w = TestGui() + w.show() + a.exec_() + + ## + testGui() + + + + def test(): + """ + test compactPath() + """ + + def compact(path, start, stop, type=DEFAULT): + for i in range(start +1, stop, -1): + p = compactPath(path, i, max_pardirs=1, type=type) + print i, len(p), repr(p) + + def test1(): + path = "a:\\eeeeee\\fff\\foobarbaz\\ddd" + compact(path, len(path), 0, type="nt") + test1() + + def test2(): + path = "/home/eeeeee/fff/foobarbaz/ddd" + compact(path, len(path), 0, type="posix") + test2() + + def test3(): + path = "home:eeeeee:fff:foobarbaz:ddd" + compact(path, len(path), 0, type="mac") + test3() + + def test4(): + path = "home://eeeeee/fff/foobarbaz/ddd" + compact(path, len(path), 0, type="url") + test4() + + ## + #test() + + Added: trunk/fclient/fclient_lib/qt4ex/ctrls/dragtool.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/dragtool.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/dragtool.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,205 @@ +"""DraggableTool widget""" + + +from PyQt4 import QtCore, QtGui + +__version__ = '0.0.4' +#********************************************************************** +# +#********************************************************************** +class DragToolEventFilter(QtCore.QObject): + """helper widget to handle draging of bitmaps as cursor + + @note: the widget has to be visible and at least 1x1 in size, otherwise Qt refuses to + pass the mouse capture over to the widget + """ + + + def __init__(self, button, cursor=None, releaseOnClick=False): + """constructor + + @arg parent: parent of the grabber widget + @arg cursor: QCursor + @arg grab_cursor: if 'grab_cursor' is True the user may drag the pixmap around + without holding the left mouse button. If False the cursor is released as soon as + the user releases the the left mouse button. In both cases dragging can be endet + by hitting the escape key. In "grab_cursor" mode dragging may be endet aswell by + hitting the right mouse button. + + """ + QtGui.QWidget.__init__(self, button) + + self._isDraging = False + self._releaseOnClick = releaseOnClick + + self.button = button + self.cursor = None + + self.setCursor(cursor) + self.button.installEventFilter(self) + button.connect(button, QtCore.SIGNAL('clicked()'), self.startDrag) + + + def getReleaseOnClick(self): + return self._releaseOnClick + + def setReleaseOnClick(self, flag): + self._releaseOnClick = flag + + + def isDraging(self): + """Checks if the drag tool is currently about to be draged""" + return self._isDraging + + + def startDrag(self): + """Starts dragging the cursor around""" + + if self.cursor is None: + raise ValueError('No cursor set') + + if not self.isDraging(): + self._isDraging = True + #self.button.grabKeyboard() + self.button.grabMouse(self.cursor) + self.button.setMouseTracking(True) + pt = QtGui.QCursor().pos() + self.emit(QtCore.SIGNAL('startDrag(int, int)'), pt.x(), pt.y()) + + + def getCursor(self): + """Returns the dragg cursor + @return: QCursor + """ + return self.cursor + + + def setCursor(self, cursor): + """Sets the pixmap to be dragged around + @arg cursor: QCursor + """ + self.cursor = cursor + + + def setGrabCursor(self, flag): + self.grab_cursor = flag + + def getGrabCursor(self, flag): + return self.grab_cursor + + + def endDrag(self, x=0, y=0, canceled=False): + if self.isDraging(): + self._isDraging = False + #self.button.releaseKeyboard() + self.button.releaseMouse() + self.button.setMouseTracking(False) + if canceled: + self.emit(QtCore.SIGNAL('dragCanceled()')) + else: + self.emit(QtCore.SIGNAL('draged(int, int)'), x, y) + self.emit(QtCore.SIGNAL('dragEnd()')) + + + def eventFilter(self, obj, event): + + # TODO: grabKeyboard() will eat all keyboard input for a Gui but events never arrive here + #if event.type() == event.KeyRelease: + # if event.key() == QtCore.Qt.Key_Escape: + # self.endDrag(canceled=True) + # return True + + if event.type() == event.MouseButtonPress: + if event.button()== QtCore.Qt.LeftButton: + if self.isDraging(): + if self._releaseOnClick: + self.endDrag(event.globalX(), event.globalY(), canceled=False) + return True + + elif event.type() == event.MouseButtonRelease: + if event.button()== QtCore.Qt.LeftButton: + if self.isDraging(): + if not self._releaseOnClick: + self.emit(QtCore.SIGNAL('draged(int, int)'), event.globalX(), event.globalY()) + return True + elif event.button()== QtCore.Qt.RightButton: + if self.isDraging(): + self.endDrag(canceled=True) + return True + + elif event.type() == event.MouseMove: + if self._isDraging: + try: + self.emit( + QtCore.SIGNAL('draging(int, int)'), + event.globalPos().x(), + event.globalPos().y() + ) + except Exception, d: # just in case + self.endDrag(canceled=True) + return True + + return False + +#****************************************************************************** +# +#****************************************************************************** +if __name__ == '__main__': + import sys + + # test tool. Click on the green square to take it up, anpther click + # will release it again + class TestTool(DragTool): + + def __init__(self, parent, px, releaseOnClick=True): + DragTool.__init__(self, parent, px, releaseOnClick=releaseOnClick) + self.connect( + self, + QtCore.SIGNAL('draging(int, int)'), + self.on_draging + ) + self.connect( + self, + QtCore.SIGNAL('draged(int, int)'), + self.on_draged + ) + + def on_draging(self, x, y): + print "moving: %s, %s" % (x, y) + + def on_draged(self, x, y): + print "dragged: %s, %s" % (x, y) + + + + app = QtGui.QApplication(sys.argv) + + w = QtGui.QWidget(None) + w.setGeometry(50, 50, 200, 200) + + # setup pixmap + px = QtGui.QPixmap(QtCore.QSize(32, 32)) + px.fill(QtCore.Qt.green) + + # setup dragg tool and button + dragTool = TestTool( + w, + QtGui.QCursor(px, 0, 0), + #releaseOnClick=False + ) + dragTool.setGeometry(-1, -1, 1, 12) + + bt = QtGui.QToolButton(w) + bt.setIcon(QtGui.QIcon(px)) + w.connect( + bt, + QtCore.SIGNAL('clicked()'), + dragTool.startDrag + ) + + + w.show() + res = app.exec_() + sys.exit(res) + + Added: trunk/fclient/fclient_lib/qt4ex/ctrls/editboxwrap.py =================================================================== --- trunk/fclient/fclient_lib/qt4ex/ctrls/editboxwrap.py (rev 0) +++ trunk/fclient/fclient_lib/qt4ex/ctrls/editboxwrap.py 2007-11-05 12:50:42 UTC (rev 47) @@ -0,0 +1,201 @@ +"""Wrappers and tools for QLineEdit and QTextEdit""" + +from PyQt4 import QtCore, QtGui +#*********************************************************************** +# +#*********************************************************************** +class EditBoxContextMenuWrap(QtCore.QObject): + """Wrapper class for to handle custom context menus for editboxes + + @note: make shure to always keep a reference to the wrapper + """ + + def __init__(self, edit): + """ + @param edit: QTextEdit or QLineEdit + @attr edit: editbox + @attr actions: dict containing default actions for the editbox. Available actions are: + "Copy", "Cut", "Paste", "Redo", "SelectAll", "Undo". Caution: the dict is considered + to be read only! + @signal: 'customizeContextMenu(QObject* EditContextMenuWrap, QMenu* contextMenu)'. + This signal is emitted when the context menu for the editbox is requested. Use this signal + to customize the menu. + @signal: 'contextMenuActionSelected(QAction* action, bool isStandardAction)'. + Emitted when the user selected an action from the context menu. The flag indicates wether + a standard action or a custom action was selected + + """ + QtCore.QObject.__init__(self, edit) + + self.edit = edit + self.actions = {} + + edit.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) + self.connect( + edit, + QtCore.SIGNAL('customContextMenuRequested(const QPoint &)'), + self.__call__ + ) + + def __call__(self, pt): + + # create custom LineEdit context menu + self.actions = {} + m = QtGui.QMenu(self.edit) + + # add default QLineEdit actions + actions = ( + ( + 'Undo', + self.edit.trUtf8("&Undo"), + QtGui.QKeySequence.Undo, + self.trUtf8('Undos the last ation'), + self.edit.undo, + ), + ( + 'Redo', + self.edit.trUtf8("&Redo"), + QtGui.QKeySequence.Redo, + self.trUtf8('Redos the last ation'), + self.edit.redo, + ), + ( + 'Cut', + self.edit.trUtf8("Cu&t"), + QtGui.QKeySequence.Cut, + self.trUtf8('Cuts the currently selected text'), + self.edit.cut, + ), + ( + 'Copy', + self.edit.trUtf8("&Copy"), + QtGui.QKeySequence.Copy, + self.trUtf8('Copies the currently selected text'), + self.edit.copy, + ), + ( + 'Paste', + self.edit.trUtf8("&Paste"), + QtGui.QKeySequence.Paste, + self.trUtf8('Pastes text from the clipboard'), + self.edit.paste, + ), + ( + 'SelectAll', + self.edit.trUtf8("Select All"), + QtGui.QKeySequence.SelectAll, + self.trUtf8('Selects all text'), + self.edit.selectAll, + ), + #TODO: Delete + #d->actions[QLineEditPrivate::ClearAct] = new QAction(QLineEdit::tr("Delete"), this); + #QObject::connect(d->actions[QLineEditPrivate::ClearAct], SIGNAL(triggered()), this, SLOT(_q_deleteSelected())); + ) + + # setup actions + for name, text, shortcut, tip, trigger in actions: + act = QtGui.QAction(text, None) + act.setObjectName(name) + act.setStatusTip(tip) + if shortcut.__class__.__name__ == 'StandardKey': + # BUG: in PyQt4.3 - already reported + # initializing QKeySequence() with a Qt.StandardKey gives segfault + act.setShortcut(shortcut) + else: + act.setShortcut(QtGui.QKeySequence(shortcut) ) + self.connect(act, QtCore.SIGNAL('triggered()'), trigger) + m.addAction(act) + self.actions[name] = act + + # adjust actions + # NOTE: disabling "SelectAll" is somewhat unnecessary, so leave it out + if isinstance(self.edit, QtGui.QLineEdit): + canPaste = not QtGui.QApplication.clipboard().text().isEmpty() + canRedo = self.edit.isRedoAvailable() + canUndo = self.edit.isUndoAvailable() + hasSelection = self.edit.hasSelectedText() + isReadOnly = self.edit.isReadOnly() + else: + canPaste = self.edit.canPaste() + canRedo = self.edit.document().isRedoAvailable() + canUndo = self.edit.document().isUndoAvailable() + hasSelection = self.edit.textCursor().hasSelection() + isReadOnly = self.edit.isReadOnly() + + self.actions['Undo'].setEnabled(canUndo) + self.actions['Redo'].setEnabled(canRedo) + self.actions['Cut'].setEnabled(not isReadOnly and hasSelection) + self.actions['Copy'].setEnabled(hasSelection) + self.actions['Paste'].setEnabled(not isReadOnly and canPaste) + self.actions['SelectAll'].setEnabled(True) + + # TODO: control chars submenu not yet implemented + # one problem is that one can not remove a menu from a menu + #~ ControlCharacters = ( + #~ (QT_TRANSLATE_NOOP("QUnicodeControlCharacterMenu", "LRM Left-to-right mark"), 0x200e), + #~ (QT_TRANSLATE_NOOP("QUnicodeControlCharacterMenu", "RLM Right-to-left mark"), 0x200f), + #~ (QT_TRANSLATE_NOOP("QUnicodeControlCharacterMenu", "ZWJ Zero width joiner"), 0x200d), + #~ (QT_TRANSLATE_NOOP("QUnicodeControlCharacterMenu", "ZWNJ Zero width non-joiner"), 0x200c), + ... [truncated message content] |