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