git.maemo.org Git - gc-dialer/blob - src/gtk_toolbox.py

   1 #!/usr/bin/python
   2
   3 from __future__ import with_statement
   4
   5 import sys
   6 import traceback
   7 import functools
   8 import contextlib
   9 import warnings
  10 import threading
  11 import Queue
  12
  13 import gobject
  14 import gtk
  15
  16
  17 @contextlib.contextmanager
  18 def gtk_lock():
  19         gtk.gdk.threads_enter()
  20         try:
  21                 yield
  22         finally:
  23                 gtk.gdk.threads_leave()
  24
  25
  26 def find_parent_window(widget):
  27         while True:
  28                 parent = widget.get_parent()
  29                 if isinstance(parent, gtk.Window):
  30                         return parent
  31                 widget = parent
  32
  33
  34 def make_idler(func):
  35         """
  36         Decorator that makes a generator-function into a function that will continue execution on next call
  37         """
  38         a = []
  39
  40         @functools.wraps(func)
  41         def decorated_func(*args, **kwds):
  42                 if not a:
  43                         a.append(func(*args, **kwds))
  44                 try:
  45                         a[0].next()
  46                         return True
  47                 except StopIteration:
  48                         del a[:]
  49                         return False
  50
  51         return decorated_func
  52
  53
  54 def asynchronous_gtk_message(original_func):
  55         """
  56         @note Idea came from http://www.aclevername.com/articles/python-webgui/
  57         """
  58
  59         def execute(allArgs):
  60                 args, kwargs = allArgs
  61                 with gtk_lock():
  62                         original_func(*args, **kwargs)
  63                 return False
  64
  65         @functools.wraps(original_func)
  66         def delayed_func(*args, **kwargs):
  67                 gobject.idle_add(execute, (args, kwargs))
  68
  69         return delayed_func
  70
  71
  72 def synchronous_gtk_message(original_func):
  73         """
  74         @note Idea came from http://www.aclevername.com/articles/python-webgui/
  75         """
  76
  77         @functools.wraps(original_func)
  78         def immediate_func(*args, **kwargs):
  79                 with gtk_lock():
  80                         return original_func(*args, **kwargs)
  81
  82         return immediate_func
  83
  84
  85 def autostart(func):
  86         """
  87         >>> @autostart
  88         ... def grep_sink(pattern):
  89         ...     print "Looking for %s" % pattern
  90         ...     while True:
  91         ...             line = yield
  92         ...             if pattern in line:
  93         ...                     print line,
  94         >>> g = grep_sink("python")
  95         Looking for python
  96         >>> g.send("Yeah but no but yeah but no")
  97         >>> g.send("A series of tubes")
  98         >>> g.send("python generators rock!")
  99         python generators rock!
 100         >>> g.close()
 101         """
 102
 103         @functools.wraps(func)
 104         def start(*args, **kwargs):
 105                 cr = func(*args, **kwargs)
 106                 cr.next()
 107                 return cr
 108
 109         return start
 110
 111
 112 @autostart
 113 def null_sink():
 114         """
 115         Good for uses like with cochain to pick up any slack
 116         """
 117         while True:
 118                 item = yield
 119
 120
 121 @autostart
 122 def comap(function, target):
 123         """
 124         >>> p = printer_sink()
 125         >>> cm = comap(lambda x: x+1, p)
 126         >>> cm.send(0)
 127         1
 128         >>> cm.send(1.0)
 129         2.0
 130         >>> cm.send(-2)
 131         -1
 132         >>> # cm.throw(RuntimeError, "Goodbye")
 133         >>> # cm.send(0)
 134         >>> # cm.send(1.0)
 135         >>> # cm.close()
 136         """
 137         while True:
 138                 try:
 139                         item = yield
 140                         mappedItem = function(*item)
 141                         target.send(mappedItem)
 142                 except StandardError, e:
 143                         target.throw(e.__class__, e.message)
 144
 145
 146 @autostart
 147 def queue_sink(queue):
 148         """
 149         >>> q = Queue.Queue()
 150         >>> qs = queue_sink(q)
 151         >>> qs.send("Hello")
 152         >>> qs.send("World")
 153         >>> qs.throw(RuntimeError, "Goodbye")
 154         >>> qs.send("Meh")
 155         >>> qs.close()
 156         >>> print [i for i in _flush_queue(q)]
 157         [(None, 'Hello'), (None, 'World'), (<type 'exceptions.RuntimeError'>, 'Goodbye'), (None, 'Meh'), (<type 'exceptions.GeneratorExit'>, None)]
 158         """
 159         while True:
 160                 try:
 161                         item = yield
 162                         queue.put((None, item))
 163                 except StandardError, e:
 164                         queue.put((e.__class__, e.message))
 165                 except GeneratorExit:
 166                         queue.put((GeneratorExit, None))
 167                         raise
 168
 169
 170 def decode_item(item, target):
 171         if item[0] is None:
 172                 target.send(item[1])
 173                 return False
 174         elif item[0] is GeneratorExit:
 175                 target.close()
 176                 return True
 177         else:
 178                 target.throw(item[0], item[1])
 179                 return False
 180
 181
 182 def nonqueue_source(queue, target):
 183         """
 184         >>> q = Queue.Queue()
 185         >>> for i in [
 186         ...     (None, 'Hello'),
 187         ...     (None, 'World'),
 188         ...     (GeneratorExit, None),
 189         ...     ]:
 190         ...     q.put(i)
 191         >>> qs = queue_source(q, printer_sink())
 192         Hello
 193         """
 194         isDone = False
 195         while not isDone:
 196                 item = queue.get()
 197                 isDone = decode_item(item, target)
 198                 while not queue.empty():
 199                         queue.get_nowait()
 200
 201
 202 def threaded_stage(target, thread_factory = threading.Thread):
 203         messages = Queue.Queue()
 204
 205         run_source = functools.partial(nonqueue_source, messages, target)
 206         thread = thread_factory(target=run_source)
 207         thread.setDaemon(True)
 208         thread.start()
 209
 210         # Sink running in current thread
 211         return queue_sink(messages)
 212
 213
 214 class LoginWindow(object):
 215
 216         def __init__(self, widgetTree):
 217                 """
 218                 @note Thread agnostic
 219                 """
 220                 self._dialog = widgetTree.get_widget("loginDialog")
 221                 self._parentWindow = widgetTree.get_widget("mainWindow")
 222                 self._serviceCombo = widgetTree.get_widget("serviceCombo")
 223                 self._usernameEntry = widgetTree.get_widget("usernameentry")
 224                 self._passwordEntry = widgetTree.get_widget("passwordentry")
 225
 226                 self._serviceList = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING)
 227                 self._serviceCombo.set_model(self._serviceList)
 228                 cell = gtk.CellRendererText()
 229                 self._serviceCombo.pack_start(cell, True)
 230                 self._serviceCombo.add_attribute(cell, 'text', 1)
 231                 self._serviceCombo.set_active(0)
 232
 233                 callbackMapping = {
 234                         "on_loginbutton_clicked": self._on_loginbutton_clicked,
 235                         "on_loginclose_clicked": self._on_loginclose_clicked,
 236                 }
 237                 widgetTree.signal_autoconnect(callbackMapping)
 238
 239         def request_credentials(self, parentWindow = None):
 240                 """
 241                 @note UI Thread
 242                 """
 243                 if parentWindow is None:
 244                         parentWindow = self._parentWindow
 245
 246                 self._serviceCombo.hide()
 247                 self._serviceList.clear()
 248
 249                 try:
 250                         self._dialog.set_transient_for(parentWindow)
 251                         self._dialog.set_default_response(gtk.RESPONSE_OK)
 252                         response = self._dialog.run()
 253                         if response != gtk.RESPONSE_OK:
 254                                 raise RuntimeError("Login Cancelled")
 255
 256                         username = self._usernameEntry.get_text()
 257                         password = self._passwordEntry.get_text()
 258                         self._passwordEntry.set_text("")
 259                 finally:
 260                         self._dialog.hide()
 261
 262                 return username, password
 263
 264         def request_credentials_from(self,
 265                 services,
 266                 parentWindow = None,
 267                 defaultCredentials = ("", "")
 268         ):
 269                 """
 270                 @note UI Thread
 271                 """
 272                 if parentWindow is None:
 273                         parentWindow = self._parentWindow
 274
 275                 self._serviceList.clear()
 276                 for serviceIdserviceName in services:
 277                         self._serviceList.append(serviceIdserviceName)
 278                 self._serviceCombo.set_active(0)
 279                 self._serviceCombo.show()
 280
 281                 self._usernameEntry.set_text(defaultCredentials[0])
 282                 self._passwordEntry.set_text(defaultCredentials[1])
 283
 284                 try:
 285                         self._dialog.set_transient_for(parentWindow)
 286                         self._dialog.set_default_response(gtk.RESPONSE_OK)
 287                         response = self._dialog.run()
 288                         if response != gtk.RESPONSE_OK:
 289                                 raise RuntimeError("Login Cancelled")
 290
 291                         username = self._usernameEntry.get_text()
 292                         password = self._passwordEntry.get_text()
 293                 finally:
 294                         self._dialog.hide()
 295
 296                 itr = self._serviceCombo.get_active_iter()
 297                 serviceId = int(self._serviceList.get_value(itr, 0))
 298                 self._serviceList.clear()
 299                 return serviceId, username, password
 300
 301         def _on_loginbutton_clicked(self, *args):
 302                 self._dialog.response(gtk.RESPONSE_OK)
 303
 304         def _on_loginclose_clicked(self, *args):
 305                 self._dialog.response(gtk.RESPONSE_CANCEL)
 306
 307
 308 def safecall(f, errorDisplay=None, default=None, exception=Exception):
 309         '''
 310         Returns modified f. When the modified f is called and throws an
 311         exception, the default value is returned
 312         '''
 313         def _safecall(*args, **argv):
 314                 try:
 315                         return f(*args,**argv)
 316                 except exception, e:
 317                         if errorDisplay is not None:
 318                                 errorDisplay.push_exception(e)
 319                         return default
 320         return _safecall
 321
 322
 323 class ErrorDisplay(object):
 324
 325         def __init__(self, widgetTree):
 326                 super(ErrorDisplay, self).__init__()
 327                 self.__errorBox = widgetTree.get_widget("errorEventBox")
 328                 self.__errorDescription = widgetTree.get_widget("errorDescription")
 329                 self.__errorClose = widgetTree.get_widget("errorClose")
 330                 self.__parentBox = self.__errorBox.get_parent()
 331
 332                 self.__errorBox.connect("button_release_event", self._on_close)
 333
 334                 self.__messages = []
 335                 self.__parentBox.remove(self.__errorBox)
 336
 337         def push_message_with_lock(self, message):
 338                 with gtk_lock():
 339                         self.push_message(message)
 340
 341         def push_message(self, message):
 342                 if 0 < len(self.__messages):
 343                         self.__messages.append(message)
 344                 else:
 345                         self.__show_message(message)
 346
 347         def push_exception_with_lock(self, exception = None):
 348                 with gtk_lock():
 349                         self.push_exception(exception)
 350
 351         def push_exception(self, exception = None):
 352                 if exception is None:
 353                         userMessage = str(sys.exc_value)
 354                         warningMessage = str(traceback.format_exc())
 355                 else:
 356                         userMessage = str(exception)
 357                         warningMessage = str(exception)
 358                 self.push_message(userMessage)
 359                 warnings.warn(warningMessage, stacklevel=2)
 360
 361         def pop_message(self):
 362                 if 0 < len(self.__messages):
 363                         self.__show_message(self.__messages[0])
 364                         del self.__messages[0]
 365                 else:
 366                         self.__hide_message()
 367
 368         def _on_close(self, *args):
 369                 self.pop_message()
 370
 371         def __show_message(self, message):
 372                 self.__errorDescription.set_text(message)
 373                 self.__parentBox.pack_start(self.__errorBox, False, False)
 374                 self.__parentBox.reorder_child(self.__errorBox, 1)
 375
 376         def __hide_message(self):
 377                 self.__errorDescription.set_text("")
 378                 self.__parentBox.remove(self.__errorBox)
 379
 380
 381 class DummyErrorDisplay(object):
 382
 383         def __init__(self):
 384                 super(DummyErrorDisplay, self).__init__()
 385
 386                 self.__messages = []
 387
 388         def push_message_with_lock(self, message):
 389                 self.push_message(message)
 390
 391         def push_message(self, message):
 392                 if 0 < len(self.__messages):
 393                         self.__messages.append(message)
 394                 else:
 395                         self.__show_message(message)
 396
 397         def push_exception(self, exception = None):
 398                 if exception is None:
 399                         warningMessage = traceback.format_exc()
 400                 else:
 401                         warningMessage = exception
 402                 warnings.warn(warningMessage, stacklevel=3)
 403
 404         def pop_message(self):
 405                 if 0 < len(self.__messages):
 406                         self.__show_message(self.__messages[0])
 407                         del self.__messages[0]
 408
 409         def __show_message(self, message):
 410                 warnings.warn(message, stacklevel=2)
 411
 412
 413 class MessageBox(gtk.MessageDialog):
 414
 415         def __init__(self, message):
 416                 parent = None
 417                 gtk.MessageDialog.__init__(
 418                         self,
 419                         parent,
 420                         gtk.DIALOG_MODAL|gtk.DIALOG_DESTROY_WITH_PARENT,
 421                         gtk.MESSAGE_ERROR,
 422                         gtk.BUTTONS_OK,
 423                         message,
 424                 )
 425                 self.set_default_response(gtk.RESPONSE_OK)
 426                 self.connect('response', self._handle_clicked)
 427
 428         def _handle_clicked(self, *args):
 429                 self.destroy()
 430
 431
 432 class MessageBox2(gtk.MessageDialog):
 433
 434         def __init__(self, message):
 435                 parent = None
 436                 gtk.MessageDialog.__init__(
 437                         self,
 438                         parent,
 439                         gtk.DIALOG_DESTROY_WITH_PARENT,
 440                         gtk.MESSAGE_ERROR,
 441                         gtk.BUTTONS_OK,
 442                         message,
 443                 )
 444                 self.set_default_response(gtk.RESPONSE_OK)
 445                 self.connect('response', self._handle_clicked)
 446
 447         def _handle_clicked(self, *args):
 448                 self.destroy()
 449
 450
 451 class PopupCalendar(object):
 452
 453         def __init__(self, parent, displayDate, title = ""):
 454                 self._displayDate = displayDate
 455
 456                 self._calendar = gtk.Calendar()
 457                 self._calendar.select_month(self._displayDate.month, self._displayDate.year)
 458                 self._calendar.select_day(self._displayDate.day)
 459                 self._calendar.set_display_options(
 460                         gtk.CALENDAR_SHOW_HEADING |
 461                         gtk.CALENDAR_SHOW_DAY_NAMES |
 462                         gtk.CALENDAR_NO_MONTH_CHANGE |
 463                         0
 464                 )
 465                 self._calendar.connect("day-selected", self._on_day_selected)
 466
 467                 self._popupWindow = gtk.Window()
 468                 self._popupWindow.set_title(title)
 469                 self._popupWindow.add(self._calendar)
 470                 self._popupWindow.set_transient_for(parent)
 471                 self._popupWindow.set_modal(True)
 472                 self._popupWindow.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
 473                 self._popupWindow.set_skip_pager_hint(True)
 474                 self._popupWindow.set_skip_taskbar_hint(True)
 475
 476         def run(self):
 477                 self._popupWindow.show_all()
 478
 479         def _on_day_selected(self, *args):
 480                 try:
 481                         self._calendar.select_month(self._displayDate.month, self._displayDate.year)
 482                         self._calendar.select_day(self._displayDate.day)
 483                 except StandardError, e:
 484                         warnings.warn(e.message)
 485
 486
 487 class QuickAddView(object):
 488
 489         def __init__(self, widgetTree, errorDisplay, signalSink, prefix):
 490                 self._errorDisplay = errorDisplay
 491                 self._manager = None
 492                 self._signalSink = signalSink
 493
 494                 self._clipboard = gtk.clipboard_get()
 495
 496                 self._taskNameEntry = widgetTree.get_widget(prefix+"-nameEntry")
 497                 self._addTaskButton = widgetTree.get_widget(prefix+"-addButton")
 498                 self._pasteTaskNameButton = widgetTree.get_widget(prefix+"-pasteNameButton")
 499                 self._clearTaskNameButton = widgetTree.get_widget(prefix+"-clearNameButton")
 500                 self._onAddId = None
 501                 self._onAddClickedId = None
 502                 self._onAddReleasedId = None
 503                 self._addToEditTimerId = None
 504                 self._onClearId = None
 505                 self._onPasteId = None
 506
 507         def enable(self, manager):
 508                 self._manager = manager
 509
 510                 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
 511                 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
 512                 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
 513                 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
 514                 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
 515
 516         def disable(self):
 517                 self._manager = None
 518
 519                 self._addTaskButton.disconnect(self._onAddId)
 520                 self._addTaskButton.disconnect(self._onAddClickedId)
 521                 self._addTaskButton.disconnect(self._onAddReleasedId)
 522                 self._pasteTaskNameButton.disconnect(self._onPasteId)
 523                 self._clearTaskNameButton.disconnect(self._onClearId)
 524
 525         def set_addability(self, addability):
 526                 self._addTaskButton.set_sensitive(addability)
 527
 528         def _on_add(self, *args):
 529                 try:
 530                         name = self._taskNameEntry.get_text()
 531                         self._taskNameEntry.set_text("")
 532
 533                         self._signalSink.stage.send(("add", name))
 534                 except StandardError, e:
 535                         self._errorDisplay.push_exception()
 536
 537         def _on_add_edit(self, *args):
 538                 try:
 539                         name = self._taskNameEntry.get_text()
 540                         self._taskNameEntry.set_text("")
 541
 542                         self._signalSink.stage.send(("add-edit", name))
 543                 except StandardError, e:
 544                         self._errorDisplay.push_exception()
 545
 546         def _on_add_pressed(self, widget):
 547                 try:
 548                         self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
 549                 except StandardError, e:
 550                         self._errorDisplay.push_exception()
 551
 552         def _on_add_released(self, widget):
 553                 try:
 554                         if self._addToEditTimerId is not None:
 555                                 gobject.source_remove(self._addToEditTimerId)
 556                         self._addToEditTimerId = None
 557                 except StandardError, e:
 558                         self._errorDisplay.push_exception()
 559
 560         def _on_paste(self, *args):
 561                 try:
 562                         entry = self._taskNameEntry.get_text()
 563                         addedText = self._clipboard.wait_for_text()
 564                         if addedText:
 565                                 entry += addedText
 566                         self._taskNameEntry.set_text(entry)
 567                 except StandardError, e:
 568                         self._errorDisplay.push_exception()
 569
 570         def _on_clear(self, *args):
 571                 try:
 572                         self._taskNameEntry.set_text("")
 573                 except StandardError, e:
 574                         self._errorDisplay.push_exception()
 575
 576
 577 class TapOrHold(object):
 578
 579         def __init__(self, widget):
 580                 self._widget = widget
 581                 self._isTap = True
 582                 self._isPointerInside = True
 583                 self._holdTimeoutId = None
 584                 self._tapTimeoutId = None
 585                 self._taps = 0
 586
 587                 self._bpeId = None
 588                 self._breId = None
 589                 self._eneId = None
 590                 self._lneId = None
 591
 592         def enable(self):
 593                 self._bpeId = self._widget.connect("button-press-event", self._on_button_press)
 594                 self._breId = self._widget.connect("button-release-event", self._on_button_release)
 595                 self._eneId = self._widget.connect("enter-notify-event", self._on_enter)
 596                 self._lneId = self._widget.connect("leave-notify-event", self._on_leave)
 597
 598         def disable(self):
 599                 self._widget.disconnect(self._bpeId)
 600                 self._widget.disconnect(self._breId)
 601                 self._widget.disconnect(self._eneId)
 602                 self._widget.disconnect(self._lneId)
 603
 604         def on_tap(self, taps):
 605                 print "TAP", taps
 606
 607         def on_hold(self, taps):
 608                 print "HOLD", taps
 609
 610         def on_holding(self):
 611                 print "HOLDING"
 612
 613         def on_cancel(self):
 614                 print "CANCEL"
 615
 616         def _on_button_press(self, *args):
 617                 # Hack to handle weird notebook behavior
 618                 self._isPointerInside = True
 619
 620                 if self._tapTimeoutId is not None:
 621                         gobject.source_remove(self._tapTimeoutId)
 622                         self._tapTimeoutId = None
 623
 624                 # Handle double taps
 625                 if self._holdTimeoutId is None:
 626                         self._tapTimeoutId = None
 627
 628                         self._taps = 1
 629                         self._holdTimeoutId = gobject.timeout_add(1000, self._on_hold_timeout)
 630                 else:
 631                         self._taps = 2
 632
 633         def _on_button_release(self, *args):
 634                 assert self._tapTimeoutId is None
 635                 # Handle release after timeout if user hasn't double-clicked
 636                 self._tapTimeoutId = gobject.timeout_add(100, self._on_tap_timeout)
 637
 638         def _on_actual_press(self, *args):
 639                 if self._holdTimeoutId is not None:
 640                         gobject.source_remove(self._holdTimeoutId)
 641                 self._holdTimeoutId = None
 642
 643                 if self._isPointerInside:
 644                         if self._isTap:
 645                                 self.on_tap(self._taps)
 646                         else:
 647                                 self.on_hold(self._taps)
 648                 else:
 649                         self.on_cancel()
 650
 651         def _on_tap_timeout(self, *args):
 652                 self._tapTimeoutId = None
 653                 self._on_actual_press()
 654                 return False
 655
 656         def _on_hold_timeout(self, *args):
 657                 self._holdTimeoutId = None
 658                 self._isTap = False
 659                 self.on_holding()
 660                 return False
 661
 662         def _on_enter(self, *args):
 663                 self._isPointerInside = True
 664
 665         def _on_leave(self, *args):
 666                 self._isPointerInside = False
 667
 668
 669 if __name__ == "__main__":
 670         if False:
 671                 import datetime
 672                 cal = PopupCalendar(None, datetime.datetime.now())
 673                 cal._popupWindow.connect("destroy", lambda w: gtk.main_quit())
 674                 cal.run()
 675
 676         gtk.main()