3 from __future__ import with_statement
20 def get_screen_orientation():
21 width, height = gtk.gdk.get_default_root_window().get_size()
23 return gtk.ORIENTATION_VERTICAL
25 return gtk.ORIENTATION_HORIZONTAL
28 def orientation_change_connect(handler, *args):
30 @param handler(orientation, *args) -> None(?)
32 initialScreenOrientation = get_screen_orientation()
33 orientationAndArgs = list(itertools.chain((initialScreenOrientation, ), args))
35 def _on_screen_size_changed(screen):
36 newScreenOrientation = get_screen_orientation()
37 if newScreenOrientation != orientationAndArgs[0]:
38 orientationAndArgs[0] = newScreenOrientation
39 handler(*orientationAndArgs)
41 rootScreen = gtk.gdk.get_default_root_window()
42 return gtk.connect(rootScreen, "size-changed", _on_screen_size_changed)
45 @contextlib.contextmanager
46 def flock(path, timeout=-1):
53 while timeSpent <= timeout or timeout == WAIT_FOREVER:
55 fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_RDWR)
59 if e.errno != errno.EEXIST:
64 assert acquired, "Failed to grab file-lock %s within timeout %d" % (path, timeout)
72 @contextlib.contextmanager
74 gtk.gdk.threads_enter()
78 gtk.gdk.threads_leave()
81 def find_parent_window(widget):
83 parent = widget.get_parent()
84 if isinstance(parent, gtk.Window):
91 Decorator that makes a generator-function into a function that will continue execution on next call
95 @functools.wraps(func)
96 def decorated_func(*args, **kwds):
98 a.append(func(*args, **kwds))
102 except StopIteration:
106 return decorated_func
109 def asynchronous_gtk_message(original_func):
111 @note Idea came from http://www.aclevername.com/articles/python-webgui/
114 def execute(allArgs):
115 args, kwargs = allArgs
117 original_func(*args, **kwargs)
120 @functools.wraps(original_func)
121 def delayed_func(*args, **kwargs):
122 gobject.idle_add(execute, (args, kwargs))
127 def synchronous_gtk_message(original_func):
129 @note Idea came from http://www.aclevername.com/articles/python-webgui/
132 @functools.wraps(original_func)
133 def immediate_func(*args, **kwargs):
135 return original_func(*args, **kwargs)
137 return immediate_func
143 ... def grep_sink(pattern):
144 ... print "Looking for %s" % pattern
147 ... if pattern in line:
149 >>> g = grep_sink("python")
151 >>> g.send("Yeah but no but yeah but no")
152 >>> g.send("A series of tubes")
153 >>> g.send("python generators rock!")
154 python generators rock!
158 @functools.wraps(func)
159 def start(*args, **kwargs):
160 cr = func(*args, **kwargs)
168 def printer_sink(format = "%s"):
170 >>> pr = printer_sink("%r")
177 >>> p = printer_sink()
182 >>> # p.throw(RuntimeError, "Goodbye")
188 print format % (item, )
194 Good for uses like with cochain to pick up any slack
201 def comap(function, target):
203 >>> p = printer_sink()
204 >>> cm = comap(lambda x: x+1, p)
215 mappedItem = function(*item)
216 target.send(mappedItem)
218 logging.exception("Forwarding exception!")
219 target.throw(e.__class__, str(e))
222 def _flush_queue(queue):
223 while not queue.empty():
228 def queue_sink(queue):
230 >>> q = Queue.Queue()
231 >>> qs = queue_sink(q)
234 >>> qs.throw(RuntimeError, "Goodbye")
237 >>> print [i for i in _flush_queue(q)]
238 [(None, 'Hello'), (None, 'World'), (<type 'exceptions.RuntimeError'>, 'Goodbye'), (None, 'Meh'), (<type 'exceptions.GeneratorExit'>, None)]
243 queue.put((None, item))
245 queue.put((e.__class__, str(e)))
246 except GeneratorExit:
247 queue.put((GeneratorExit, None))
251 def decode_item(item, target):
255 elif item[0] is GeneratorExit:
259 target.throw(item[0], item[1])
263 def nonqueue_source(queue, target):
267 isDone = decode_item(item, target)
268 while not queue.empty():
272 def threaded_stage(target, thread_factory = threading.Thread):
273 messages = Queue.Queue()
275 run_source = functools.partial(nonqueue_source, messages, target)
276 thread = thread_factory(target=run_source)
277 thread.setDaemon(True)
280 # Sink running in current thread
281 return queue_sink(messages)
284 class LoginWindow(object):
286 def __init__(self, widgetTree):
288 @note Thread agnostic
290 self._dialog = widgetTree.get_widget("loginDialog")
291 self._parentWindow = widgetTree.get_widget("mainWindow")
292 self._serviceCombo = widgetTree.get_widget("serviceCombo")
293 self._usernameEntry = widgetTree.get_widget("usernameentry")
294 self._passwordEntry = widgetTree.get_widget("passwordentry")
296 self._serviceList = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING)
297 self._serviceCombo.set_model(self._serviceList)
298 cell = gtk.CellRendererText()
299 self._serviceCombo.pack_start(cell, True)
300 self._serviceCombo.add_attribute(cell, 'text', 1)
301 self._serviceCombo.set_active(0)
303 widgetTree.get_widget("loginbutton").connect("clicked", self._on_loginbutton_clicked)
304 widgetTree.get_widget("logins_close_button").connect("clicked", self._on_loginclose_clicked)
306 def request_credentials(self,
308 defaultCredentials = ("", "")
313 if parentWindow is None:
314 parentWindow = self._parentWindow
316 self._serviceCombo.hide()
317 self._serviceList.clear()
319 self._usernameEntry.set_text(defaultCredentials[0])
320 self._passwordEntry.set_text(defaultCredentials[1])
323 self._dialog.set_transient_for(parentWindow)
324 self._dialog.set_default_response(gtk.RESPONSE_OK)
325 response = self._dialog.run()
326 if response != gtk.RESPONSE_OK:
327 raise RuntimeError("Login Cancelled")
329 username = self._usernameEntry.get_text()
330 password = self._passwordEntry.get_text()
331 self._passwordEntry.set_text("")
335 return username, password
337 def request_credentials_from(self,
340 defaultCredentials = ("", "")
345 if parentWindow is None:
346 parentWindow = self._parentWindow
348 self._serviceList.clear()
349 for serviceIdserviceName in services:
350 self._serviceList.append(serviceIdserviceName)
351 self._serviceCombo.set_active(0)
352 self._serviceCombo.show()
354 self._usernameEntry.set_text(defaultCredentials[0])
355 self._passwordEntry.set_text(defaultCredentials[1])
358 self._dialog.set_transient_for(parentWindow)
359 self._dialog.set_default_response(gtk.RESPONSE_OK)
360 response = self._dialog.run()
361 if response != gtk.RESPONSE_OK:
362 raise RuntimeError("Login Cancelled")
364 username = self._usernameEntry.get_text()
365 password = self._passwordEntry.get_text()
369 itr = self._serviceCombo.get_active_iter()
370 serviceId = int(self._serviceList.get_value(itr, 0))
371 self._serviceList.clear()
372 return serviceId, username, password
374 def _on_loginbutton_clicked(self, *args):
375 self._dialog.response(gtk.RESPONSE_OK)
377 def _on_loginclose_clicked(self, *args):
378 self._dialog.response(gtk.RESPONSE_CANCEL)
381 def safecall(f, errorDisplay=None, default=None, exception=Exception):
383 Returns modified f. When the modified f is called and throws an
384 exception, the default value is returned
386 def _safecall(*args, **argv):
388 return f(*args,**argv)
390 if errorDisplay is not None:
391 errorDisplay.push_exception(e)
396 class ErrorDisplay(object):
398 def __init__(self, widgetTree):
399 super(ErrorDisplay, self).__init__()
400 self.__errorBox = widgetTree.get_widget("errorEventBox")
401 self.__errorDescription = widgetTree.get_widget("errorDescription")
402 self.__errorClose = widgetTree.get_widget("errorClose")
403 self.__parentBox = self.__errorBox.get_parent()
405 self.__errorBox.connect("button_release_event", self._on_close)
408 self.__parentBox.remove(self.__errorBox)
410 def push_message_with_lock(self, message):
412 self.push_message(message)
414 def push_message(self, message):
415 self.__messages.append(message)
416 if 1 == len(self.__messages):
417 self.__show_message(message)
419 def push_exception_with_lock(self):
421 self.push_exception()
423 def push_exception(self):
424 userMessage = str(sys.exc_info()[1])
425 self.push_message(userMessage)
426 logging.exception(userMessage)
428 def pop_message(self):
429 del self.__messages[0]
430 if 0 == len(self.__messages):
431 self.__hide_message()
433 self.__errorDescription.set_text(self.__messages[0])
435 def _on_close(self, *args):
438 def __show_message(self, message):
439 self.__errorDescription.set_text(message)
440 self.__parentBox.pack_start(self.__errorBox, False, False)
441 self.__parentBox.reorder_child(self.__errorBox, 1)
443 def __hide_message(self):
444 self.__errorDescription.set_text("")
445 self.__parentBox.remove(self.__errorBox)
448 class DummyErrorDisplay(object):
451 super(DummyErrorDisplay, self).__init__()
455 def push_message_with_lock(self, message):
456 self.push_message(message)
458 def push_message(self, message):
459 if 0 < len(self.__messages):
460 self.__messages.append(message)
462 self.__show_message(message)
464 def push_exception(self, exception = None):
465 userMessage = str(sys.exc_value)
466 logging.exception(userMessage)
468 def pop_message(self):
469 if 0 < len(self.__messages):
470 self.__show_message(self.__messages[0])
471 del self.__messages[0]
473 def __show_message(self, message):
474 logging.debug(message)
477 class MessageBox(gtk.MessageDialog):
479 def __init__(self, message):
481 gtk.MessageDialog.__init__(
484 gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
489 self.set_default_response(gtk.RESPONSE_OK)
490 self.connect('response', self._handle_clicked)
492 def _handle_clicked(self, *args):
496 class MessageBox2(gtk.MessageDialog):
498 def __init__(self, message):
500 gtk.MessageDialog.__init__(
503 gtk.DIALOG_DESTROY_WITH_PARENT,
508 self.set_default_response(gtk.RESPONSE_OK)
509 self.connect('response', self._handle_clicked)
511 def _handle_clicked(self, *args):
515 class PopupCalendar(object):
517 def __init__(self, parent, displayDate, title = ""):
518 self._displayDate = displayDate
520 self._calendar = gtk.Calendar()
521 self._calendar.select_month(self._displayDate.month, self._displayDate.year)
522 self._calendar.select_day(self._displayDate.day)
523 self._calendar.set_display_options(
524 gtk.CALENDAR_SHOW_HEADING |
525 gtk.CALENDAR_SHOW_DAY_NAMES |
526 gtk.CALENDAR_NO_MONTH_CHANGE |
529 self._calendar.connect("day-selected", self._on_day_selected)
531 self._popupWindow = gtk.Window()
532 self._popupWindow.set_title(title)
533 self._popupWindow.add(self._calendar)
534 self._popupWindow.set_transient_for(parent)
535 self._popupWindow.set_modal(True)
536 self._popupWindow.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
537 self._popupWindow.set_skip_pager_hint(True)
538 self._popupWindow.set_skip_taskbar_hint(True)
541 self._popupWindow.show_all()
543 def _on_day_selected(self, *args):
545 self._calendar.select_month(self._displayDate.month, self._displayDate.year)
546 self._calendar.select_day(self._displayDate.day)
551 class QuickAddView(object):
553 def __init__(self, widgetTree, errorDisplay, signalSink, prefix):
554 self._errorDisplay = errorDisplay
556 self._signalSink = signalSink
558 self._clipboard = gtk.clipboard_get()
560 self._taskNameEntry = widgetTree.get_widget(prefix+"-nameEntry")
561 self._addTaskButton = widgetTree.get_widget(prefix+"-addButton")
562 self._pasteTaskNameButton = widgetTree.get_widget(prefix+"-pasteNameButton")
563 self._clearTaskNameButton = widgetTree.get_widget(prefix+"-clearNameButton")
565 self._onAddClickedId = None
566 self._onAddReleasedId = None
567 self._addToEditTimerId = None
568 self._onClearId = None
569 self._onPasteId = None
571 def enable(self, manager):
572 self._manager = manager
574 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
575 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
576 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
577 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
578 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
583 self._addTaskButton.disconnect(self._onAddId)
584 self._addTaskButton.disconnect(self._onAddClickedId)
585 self._addTaskButton.disconnect(self._onAddReleasedId)
586 self._pasteTaskNameButton.disconnect(self._onPasteId)
587 self._clearTaskNameButton.disconnect(self._onClearId)
589 def set_addability(self, addability):
590 self._addTaskButton.set_sensitive(addability)
592 def _on_add(self, *args):
594 name = self._taskNameEntry.get_text()
595 self._taskNameEntry.set_text("")
597 self._signalSink.stage.send(("add", name))
599 self._errorDisplay.push_exception()
601 def _on_add_edit(self, *args):
603 name = self._taskNameEntry.get_text()
604 self._taskNameEntry.set_text("")
606 self._signalSink.stage.send(("add-edit", name))
608 self._errorDisplay.push_exception()
610 def _on_add_pressed(self, widget):
612 self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
614 self._errorDisplay.push_exception()
616 def _on_add_released(self, widget):
618 if self._addToEditTimerId is not None:
619 gobject.source_remove(self._addToEditTimerId)
620 self._addToEditTimerId = None
622 self._errorDisplay.push_exception()
624 def _on_paste(self, *args):
626 entry = self._taskNameEntry.get_text()
627 addedText = self._clipboard.wait_for_text()
630 self._taskNameEntry.set_text(entry)
632 self._errorDisplay.push_exception()
634 def _on_clear(self, *args):
636 self._taskNameEntry.set_text("")
638 self._errorDisplay.push_exception()
641 class TapOrHold(object):
643 def __init__(self, widget):
644 self._widget = widget
646 self._isPointerInside = True
647 self._holdTimeoutId = None
648 self._tapTimeoutId = None
657 self._bpeId = self._widget.connect("button-press-event", self._on_button_press)
658 self._breId = self._widget.connect("button-release-event", self._on_button_release)
659 self._eneId = self._widget.connect("enter-notify-event", self._on_enter)
660 self._lneId = self._widget.connect("leave-notify-event", self._on_leave)
663 self._widget.disconnect(self._bpeId)
664 self._widget.disconnect(self._breId)
665 self._widget.disconnect(self._eneId)
666 self._widget.disconnect(self._lneId)
668 def on_tap(self, taps):
671 def on_hold(self, taps):
674 def on_holding(self):
680 def _on_button_press(self, *args):
681 # Hack to handle weird notebook behavior
682 self._isPointerInside = True
685 if self._tapTimeoutId is not None:
686 gobject.source_remove(self._tapTimeoutId)
687 self._tapTimeoutId = None
690 if self._holdTimeoutId is None:
691 self._tapTimeoutId = None
694 self._holdTimeoutId = gobject.timeout_add(1000, self._on_hold_timeout)
698 def _on_button_release(self, *args):
699 assert self._tapTimeoutId is None
700 # Handle release after timeout if user hasn't double-clicked
701 self._tapTimeoutId = gobject.timeout_add(100, self._on_tap_timeout)
703 def _on_actual_press(self, *args):
704 if self._holdTimeoutId is not None:
705 gobject.source_remove(self._holdTimeoutId)
706 self._holdTimeoutId = None
708 if self._isPointerInside:
710 self.on_tap(self._taps)
712 self.on_hold(self._taps)
716 def _on_tap_timeout(self, *args):
717 self._tapTimeoutId = None
718 self._on_actual_press()
721 def _on_hold_timeout(self, *args):
722 self._holdTimeoutId = None
727 def _on_enter(self, *args):
728 self._isPointerInside = True
730 def _on_leave(self, *args):
731 self._isPointerInside = False
734 if __name__ == "__main__":
737 cal = PopupCalendar(None, datetime.datetime.now())
738 cal._popupWindow.connect("destroy", lambda w: gtk.main_quit())