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