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

   1 #!/usr/bin/python2.5
   2
   3 # DialCentral - Front end for Google's Grand Central service.
   4 # Copyright (C) 2008  Mark Bergman bergman AT merctech DOT com
   5 #
   6 # This library is free software; you can redistribute it and/or
   7 # modify it under the terms of the GNU Lesser General Public
   8 # License as published by the Free Software Foundation; either
   9 # version 2.1 of the License, or (at your option) any later version.
  10 #
  11 # This library is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # Lesser General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU Lesser General Public
  17 # License along with this library; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19
  20 import threading
  21 import time
  22 import warnings
  23
  24 import gobject
  25 import gtk
  26
  27
  28 def make_ugly(prettynumber):
  29         """
  30         function to take a phone number and strip out all non-numeric
  31         characters
  32
  33         >>> make_ugly("+012-(345)-678-90")
  34         '01234567890'
  35         """
  36         import re
  37         uglynumber = re.sub('\D', '', prettynumber)
  38         return uglynumber
  39
  40
  41 def make_pretty(phonenumber):
  42         """
  43         Function to take a phone number and return the pretty version
  44         pretty numbers:
  45                 if phonenumber begins with 0:
  46                         ...-(...)-...-....
  47                 if phonenumber begins with 1: ( for gizmo callback numbers )
  48                         1 (...)-...-....
  49                 if phonenumber is 13 digits:
  50                         (...)-...-....
  51                 if phonenumber is 10 digits:
  52                         ...-....
  53         >>> make_pretty("12")
  54         '12'
  55         >>> make_pretty("1234567")
  56         '123-4567'
  57         >>> make_pretty("2345678901")
  58         '(234)-567-8901'
  59         >>> make_pretty("12345678901")
  60         '1 (234)-567-8901'
  61         >>> make_pretty("01234567890")
  62         '+012-(345)-678-90'
  63         """
  64         if phonenumber is None or phonenumber is "":
  65                 return ""
  66
  67         if len(phonenumber) < 3:
  68                 return phonenumber
  69
  70         if phonenumber[0] == "0":
  71                 prettynumber = ""
  72                 prettynumber += "+%s" % phonenumber[0:3]
  73                 if 3 < len(phonenumber):
  74                         prettynumber += "-(%s)" % phonenumber[3:6]
  75                         if 6 < len(phonenumber):
  76                                 prettynumber += "-%s" % phonenumber[6:9]
  77                                 if 9 < len(phonenumber):
  78                                         prettynumber += "-%s" % phonenumber[9:]
  79                 return prettynumber
  80         elif len(phonenumber) <= 7:
  81                 prettynumber = "%s-%s" % (phonenumber[0:3], phonenumber[3:])
  82         elif len(phonenumber) > 8 and phonenumber[0] == "1":
  83                 prettynumber = "1 (%s)-%s-%s" % (phonenumber[1:4], phonenumber[4:7], phonenumber[7:])
  84         elif len(phonenumber) > 7:
  85                 prettynumber = "(%s)-%s-%s" % (phonenumber[0:3], phonenumber[3:6], phonenumber[6:])
  86         return prettynumber
  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         def decorated_func(*args, **kwds):
  96                 if not a:
  97                         a.append(func(*args, **kwds))
  98                 try:
  99                         a[0].next()
 100                         return True
 101                 except StopIteration:
 102                         del a[:]
 103                         return False
 104
 105         decorated_func.__name__ = func.__name__
 106         decorated_func.__doc__ = func.__doc__
 107         decorated_func.__dict__.update(func.__dict__)
 108
 109         return decorated_func
 110
 111
 112 class DummyAddressBook(object):
 113         """
 114         Minimal example of both an addressbook factory and an addressbook
 115         """
 116
 117         def clear_caches(self):
 118                 pass
 119
 120         def get_addressbooks(self):
 121                 """
 122                 @returns Iterable of (Address Book Factory, Book Id, Book Name)
 123                 """
 124                 yield self, "", "None"
 125
 126         def open_addressbook(self, bookId):
 127                 return self
 128
 129         @staticmethod
 130         def contact_source_short_name(contactId):
 131                 return ""
 132
 133         @staticmethod
 134         def factory_name():
 135                 return ""
 136
 137         @staticmethod
 138         def get_contacts():
 139                 """
 140                 @returns Iterable of (contact id, contact name)
 141                 """
 142                 return []
 143
 144         @staticmethod
 145         def get_contact_details(contactId):
 146                 """
 147                 @returns Iterable of (Phone Type, Phone Number)
 148                 """
 149                 return []
 150
 151
 152 class MergedAddressBook(object):
 153         """
 154         Merger of all addressbooks
 155         """
 156
 157         def __init__(self, addressbookFactories, sorter = None):
 158                 self.__addressbookFactories = addressbookFactories
 159                 self.__addressbooks = None
 160                 self.__sort_contacts = sorter if sorter is not None else self.null_sorter
 161
 162         def clear_caches(self):
 163                 self.__addressbooks = None
 164                 for factory in self.__addressbookFactories:
 165                         factory.clear_caches()
 166
 167         def get_addressbooks(self):
 168                 """
 169                 @returns Iterable of (Address Book Factory, Book Id, Book Name)
 170                 """
 171                 yield self, "", ""
 172
 173         def open_addressbook(self, bookId):
 174                 return self
 175
 176         def contact_source_short_name(self, contactId):
 177                 if self.__addressbooks is None:
 178                         return ""
 179                 bookIndex, originalId = contactId.split("-", 1)
 180                 return self.__addressbooks[int(bookIndex)].contact_source_short_name(originalId)
 181
 182         @staticmethod
 183         def factory_name():
 184                 return "All Contacts"
 185
 186         def get_contacts(self):
 187                 """
 188                 @returns Iterable of (contact id, contact name)
 189                 """
 190                 if self.__addressbooks is None:
 191                         self.__addressbooks = list(
 192                                 factory.open_addressbook(id)
 193                                 for factory in self.__addressbookFactories
 194                                 for (f, id, name) in factory.get_addressbooks()
 195                         )
 196                 contacts = (
 197                         ("-".join([str(bookIndex), contactId]), contactName)
 198                                 for (bookIndex, addressbook) in enumerate(self.__addressbooks)
 199                                         for (contactId, contactName) in addressbook.get_contacts()
 200                 )
 201                 sortedContacts = self.__sort_contacts(contacts)
 202                 return sortedContacts
 203
 204         def get_contact_details(self, contactId):
 205                 """
 206                 @returns Iterable of (Phone Type, Phone Number)
 207                 """
 208                 if self.__addressbooks is None:
 209                         return []
 210                 bookIndex, originalId = contactId.split("-", 1)
 211                 return self.__addressbooks[int(bookIndex)].get_contact_details(originalId)
 212
 213         @staticmethod
 214         def null_sorter(contacts):
 215                 """
 216                 Good for speed/low memory
 217                 """
 218                 return contacts
 219
 220         @staticmethod
 221         def basic_firtname_sorter(contacts):
 222                 """
 223                 Expects names in "First Last" format
 224                 """
 225                 contactsWithKey = [
 226                         (contactName.rsplit(" ", 1)[0], (contactId, contactName))
 227                                 for (contactId, contactName) in contacts
 228                 ]
 229                 contactsWithKey.sort()
 230                 return (contactData for (lastName, contactData) in contactsWithKey)
 231
 232         @staticmethod
 233         def basic_lastname_sorter(contacts):
 234                 """
 235                 Expects names in "First Last" format
 236                 """
 237                 contactsWithKey = [
 238                         (contactName.rsplit(" ", 1)[-1], (contactId, contactName))
 239                                 for (contactId, contactName) in contacts
 240                 ]
 241                 contactsWithKey.sort()
 242                 return (contactData for (lastName, contactData) in contactsWithKey)
 243
 244         @staticmethod
 245         def reversed_firtname_sorter(contacts):
 246                 """
 247                 Expects names in "Last, First" format
 248                 """
 249                 contactsWithKey = [
 250                         (contactName.split(", ", 1)[-1], (contactId, contactName))
 251                                 for (contactId, contactName) in contacts
 252                 ]
 253                 contactsWithKey.sort()
 254                 return (contactData for (lastName, contactData) in contactsWithKey)
 255
 256         @staticmethod
 257         def reversed_lastname_sorter(contacts):
 258                 """
 259                 Expects names in "Last, First" format
 260                 """
 261                 contactsWithKey = [
 262                         (contactName.split(", ", 1)[0], (contactId, contactName))
 263                                 for (contactId, contactName) in contacts
 264                 ]
 265                 contactsWithKey.sort()
 266                 return (contactData for (lastName, contactData) in contactsWithKey)
 267
 268         @staticmethod
 269         def guess_firstname(name):
 270                 if ", " in name:
 271                         return name.split(", ", 1)[-1]
 272                 else:
 273                         return name.rsplit(" ", 1)[0]
 274
 275         @staticmethod
 276         def guess_lastname(name):
 277                 if ", " in name:
 278                         return name.split(", ", 1)[0]
 279                 else:
 280                         return name.rsplit(" ", 1)[-1]
 281
 282         @classmethod
 283         def advanced_firtname_sorter(cls, contacts):
 284                 contactsWithKey = [
 285                         (cls.guess_firstname(contactName), (contactId, contactName))
 286                                 for (contactId, contactName) in contacts
 287                 ]
 288                 contactsWithKey.sort()
 289                 return (contactData for (lastName, contactData) in contactsWithKey)
 290
 291         @classmethod
 292         def advanced_lastname_sorter(cls, contacts):
 293                 contactsWithKey = [
 294                         (cls.guess_lastname(contactName), (contactId, contactName))
 295                                 for (contactId, contactName) in contacts
 296                 ]
 297                 contactsWithKey.sort()
 298                 return (contactData for (lastName, contactData) in contactsWithKey)
 299
 300
 301 class PhoneTypeSelector(object):
 302
 303         def __init__(self, widgetTree, gcBackend):
 304                 self._gcBackend = gcBackend
 305                 self._widgetTree = widgetTree
 306                 self._dialog = self._widgetTree.get_widget("phonetype_dialog")
 307
 308                 self._selectButton = self._widgetTree.get_widget("select_button")
 309                 self._selectButton.connect("clicked", self._on_phonetype_select)
 310
 311                 self._cancelButton = self._widgetTree.get_widget("cancel_button")
 312                 self._cancelButton.connect("clicked", self._on_phonetype_cancel)
 313
 314                 self._typemodel = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
 315                 self._typeviewselection = None
 316
 317                 typeview = self._widgetTree.get_widget("phonetypes")
 318                 typeview.connect("row-activated", self._on_phonetype_select)
 319                 typeview.set_model(self._typemodel)
 320                 textrenderer = gtk.CellRendererText()
 321
 322                 # Add the column to the treeview
 323                 column = gtk.TreeViewColumn("Phone Numbers", textrenderer, text=1)
 324                 column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 325
 326                 typeview.append_column(column)
 327
 328                 self._typeviewselection = typeview.get_selection()
 329                 self._typeviewselection.set_mode(gtk.SELECTION_SINGLE)
 330
 331         def run(self, contactDetails):
 332                 self._typemodel.clear()
 333
 334                 for phoneType, phoneNumber in contactDetails:
 335                         self._typemodel.append((phoneNumber, "%s - %s" % (make_pretty(phoneNumber), phoneType)))
 336
 337                 userResponse = self._dialog.run()
 338
 339                 if userResponse == gtk.RESPONSE_OK:
 340                         model, itr = self._typeviewselection.get_selected()
 341                         if itr:
 342                                 phoneNumber = self._typemodel.get_value(itr, 0)
 343                 else:
 344                         phoneNumber = ""
 345
 346                 self._typeviewselection.unselect_all()
 347                 self._dialog.hide()
 348                 return phoneNumber
 349
 350         def _on_phonetype_select(self, *args):
 351                 self._dialog.response(gtk.RESPONSE_OK)
 352
 353         def _on_phonetype_cancel(self, *args):
 354                 self._dialog.response(gtk.RESPONSE_CANCEL)
 355
 356
 357 class Dialpad(object):
 358
 359         def __init__(self, widgetTree, errorDisplay):
 360                 self._errorDisplay = errorDisplay
 361                 self._numberdisplay = widgetTree.get_widget("numberdisplay")
 362                 self._dialButton = widgetTree.get_widget("dial")
 363                 self._phonenumber = ""
 364                 self._prettynumber = ""
 365                 self._clearall_id = None
 366
 367                 callbackMapping = {
 368                         "on_dial_clicked": self._on_dial_clicked,
 369                         "on_digit_clicked": self._on_digit_clicked,
 370                         "on_clear_number": self._on_clear_number,
 371                         "on_back_clicked": self._on_backspace,
 372                         "on_back_pressed": self._on_back_pressed,
 373                         "on_back_released": self._on_back_released,
 374                 }
 375                 widgetTree.signal_autoconnect(callbackMapping)
 376
 377         def enable(self):
 378                 self._dialButton.grab_focus()
 379
 380         def disable(self):
 381                 pass
 382
 383         def dial(self, number):
 384                 """
 385                 @note Actual dial function is patched in later
 386                 """
 387                 raise NotImplementedError
 388
 389         def get_number(self):
 390                 return self._phonenumber
 391
 392         def set_number(self, number):
 393                 """
 394                 Set the callback phonenumber
 395                 """
 396                 try:
 397                         self._phonenumber = make_ugly(number)
 398                         self._prettynumber = make_pretty(self._phonenumber)
 399                         self._numberdisplay.set_label("<span size='30000' weight='bold'>%s</span>" % (self._prettynumber))
 400                 except TypeError, e:
 401                         self._errorDisplay.push_message(e.message)
 402
 403         def clear(self):
 404                 self.set_number("")
 405
 406         def _on_dial_clicked(self, widget):
 407                 self.dial(self.get_number())
 408
 409         def _on_clear_number(self, *args):
 410                 self.clear()
 411
 412         def _on_digit_clicked(self, widget):
 413                 self.set_number(self._phonenumber + widget.get_name()[-1])
 414
 415         def _on_backspace(self, widget):
 416                 self.set_number(self._phonenumber[:-1])
 417
 418         def _on_clearall(self):
 419                 self.clear()
 420                 return False
 421
 422         def _on_back_pressed(self, widget):
 423                 self._clearall_id = gobject.timeout_add(1000, self._on_clearall)
 424
 425         def _on_back_released(self, widget):
 426                 if self._clearall_id is not None:
 427                         gobject.source_remove(self._clearall_id)
 428                 self._clearall_id = None
 429
 430
 431 class AccountInfo(object):
 432
 433         def __init__(self, widgetTree, backend, errorDisplay):
 434                 self._errorDisplay = errorDisplay
 435                 self._backend = backend
 436
 437                 self._callbackList = gtk.ListStore(gobject.TYPE_STRING)
 438                 self._accountViewNumberDisplay = widgetTree.get_widget("gcnumber_display")
 439                 self._callbackCombo = widgetTree.get_widget("callbackcombo")
 440
 441         def enable(self):
 442                 assert self._backend.is_authed()
 443                 self._accountViewNumberDisplay.set_use_markup(True)
 444                 self.set_account_number("")
 445                 self._callbackList.clear()
 446                 self.update()
 447                 self._callbackCombo.get_child().connect("changed", self._on_callbackentry_changed)
 448
 449         def disable(self):
 450                 self._callbackCombo.get_child().disconnect("changed", self._on_callbackentry_changed)
 451                 self.clear()
 452                 self._callbackList.clear()
 453
 454         def get_selected_callback_number(self):
 455                 return make_ugly(self._callbackCombo.get_child().get_text())
 456
 457         def set_account_number(self, number):
 458                 """
 459                 Displays current account number
 460                 """
 461                 self._accountViewNumberDisplay.set_label("<span size='23000' weight='bold'>%s</span>" % (number))
 462
 463         def update(self):
 464                 self.populate_callback_combo()
 465                 self.set_account_number(self._backend.get_account_number())
 466
 467         def clear(self):
 468                 self._callbackCombo.get_child().set_text("")
 469                 self.set_account_number("")
 470
 471         def populate_callback_combo(self):
 472                 self._callbackList.clear()
 473                 try:
 474                         callbackNumbers = self._backend.get_callback_numbers()
 475                 except RuntimeError, e:
 476                         self._errorDisplay.push_message(e.message)
 477                         return
 478
 479                 for number, description in callbackNumbers.iteritems():
 480                         self._callbackList.append((make_pretty(number),))
 481
 482                 self._callbackCombo.set_model(self._callbackList)
 483                 self._callbackCombo.set_text_column(0)
 484                 try:
 485                         callbackNumber = self._backend.get_callback_number()
 486                 except RuntimeError, e:
 487                         self._errorDisplay.push_message(e.message)
 488                         return
 489                 self._callbackCombo.get_child().set_text(make_pretty(callbackNumber))
 490
 491         def _on_callbackentry_changed(self, *args):
 492                 """
 493                 @todo Potential blocking on web access, maybe we should defer this or put up a dialog?
 494                 """
 495                 try:
 496                         text = self.get_selected_callback_number()
 497                         if not self._backend.is_valid_syntax(text):
 498                                 self._errorDisplay.push_message("%s is not a valid callback number" % text)
 499                         elif text == self._backend.get_callback_number():
 500                                 warnings.warn("Callback number already is %s" % self._backend.get_callback_number(), UserWarning, 2)
 501                         else:
 502                                 self._backend.set_callback_number(text)
 503                 except RuntimeError, e:
 504                         self._errorDisplay.push_message(e.message)
 505
 506
 507 class RecentCallsView(object):
 508
 509         def __init__(self, widgetTree, backend, errorDisplay):
 510                 self._errorDisplay = errorDisplay
 511                 self._backend = backend
 512
 513                 self._recenttime = 0.0
 514                 self._recentmodel = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
 515                 self._recentview = widgetTree.get_widget("recentview")
 516                 self._recentviewselection = None
 517
 518                 textrenderer = gtk.CellRendererText()
 519                 self._recentviewColumn = gtk.TreeViewColumn("Calls", textrenderer, text=1)
 520                 self._recentviewColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 521
 522         def enable(self):
 523                 assert self._backend.is_authed()
 524                 self._recentview.set_model(self._recentmodel)
 525
 526                 self._recentview.append_column(self._recentviewColumn)
 527                 self._recentviewselection = self._recentview.get_selection()
 528                 self._recentviewselection.set_mode(gtk.SELECTION_SINGLE)
 529
 530                 self._recentview.connect("row-activated", self._on_recentview_row_activated)
 531
 532         def disable(self):
 533                 self._recentview.disconnect("row-activated", self._on_recentview_row_activated)
 534                 self._recentview.remove_column(self._recentviewColumn)
 535                 self._recentview.set_model(None)
 536
 537         def number_selected(self, number):
 538                 """
 539                 @note Actual dial function is patched in later
 540                 """
 541                 raise NotImplementedError
 542
 543         def update(self):
 544                 if (time.time() - self._recenttime) < 300:
 545                         return
 546                 backgroundPopulate = threading.Thread(target=self._idly_populate_recentview)
 547                 backgroundPopulate.setDaemon(True)
 548                 backgroundPopulate.start()
 549
 550         def clear(self):
 551                 self._recenttime = 0.0
 552                 self._recentmodel.clear()
 553
 554         def _idly_populate_recentview(self):
 555                 self._recenttime = time.time()
 556                 self._recentmodel.clear()
 557
 558                 try:
 559                         recentItems = self._backend.get_recent()
 560                 except RuntimeError, e:
 561                         gtk.gdk.threads_enter()
 562                         try:
 563                                 self._errorDisplay.push_message(e.message)
 564                         finally:
 565                                 gtk.gdk.threads_leave()
 566                         self._recenttime = 0.0
 567                         recentItems = []
 568                 for personsName, phoneNumber, date, action in recentItems:
 569                         description = "%s on %s from/to %s - %s" % (action.capitalize(), date, personsName, phoneNumber)
 570                         item = (phoneNumber, description)
 571                         gtk.gdk.threads_enter()
 572                         try:
 573                                 self._recentmodel.append(item)
 574                         finally:
 575                                 gtk.gdk.threads_leave()
 576
 577                 return False
 578
 579         def _on_recentview_row_activated(self, treeview, path, view_column):
 580                 model, itr = self._recentviewselection.get_selected()
 581                 if not itr:
 582                         return
 583
 584                 self.number_selected(self._recentmodel.get_value(itr, 0))
 585                 self._recentviewselection.unselect_all()
 586
 587
 588 class ContactsView(object):
 589
 590         def __init__(self, widgetTree, backend, errorDisplay):
 591                 self._errorDisplay = errorDisplay
 592                 self._backend = backend
 593
 594                 self._addressBook = None
 595                 self._addressBookFactories = [DummyAddressBook()]
 596
 597                 self._booksList = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
 598                 self._booksSelectionBox = widgetTree.get_widget("addressbook_combo")
 599
 600                 self._contactstime = 0.0
 601                 self._contactsmodel = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
 602                 self._contactsviewselection = None
 603                 self._contactsview = widgetTree.get_widget("contactsview")
 604
 605                 self._contactColumn = gtk.TreeViewColumn("Contact")
 606                 displayContactSource = True
 607                 if displayContactSource:
 608                         textrenderer = gtk.CellRendererText()
 609                         self._contactColumn.pack_start(textrenderer, expand=False)
 610                         self._contactColumn.add_attribute(textrenderer, 'text', 0)
 611                 textrenderer = gtk.CellRendererText()
 612                 self._contactColumn.pack_start(textrenderer, expand=True)
 613                 self._contactColumn.add_attribute(textrenderer, 'text', 1)
 614                 textrenderer = gtk.CellRendererText()
 615                 self._contactColumn.pack_start(textrenderer, expand=True)
 616                 self._contactColumn.add_attribute(textrenderer, 'text', 4)
 617                 self._contactColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
 618                 self._contactColumn.set_sort_column_id(1)
 619                 self._contactColumn.set_visible(True)
 620
 621                 self._phoneTypeSelector = PhoneTypeSelector(widgetTree, self._backend)
 622
 623         def enable(self):
 624                 assert self._backend.is_authed()
 625
 626                 self._contactsview.set_model(self._contactsmodel)
 627                 self._contactsview.append_column(self._contactColumn)
 628                 self._contactsviewselection = self._contactsview.get_selection()
 629                 self._contactsviewselection.set_mode(gtk.SELECTION_SINGLE)
 630
 631                 self._booksList.clear()
 632                 for (factoryId, bookId), (factoryName, bookName) in self.get_addressbooks():
 633                         if factoryName and bookName:
 634                                 entryName = "%s: %s" % (factoryName, bookName)
 635                         elif factoryName:
 636                                 entryName = factoryName
 637                         elif bookName:
 638                                 entryName = bookName
 639                         else:
 640                                 entryName = "Bad name (%d)" % factoryId
 641                         row = (str(factoryId), bookId, entryName)
 642                         self._booksList.append(row)
 643
 644                 self._booksSelectionBox.set_model(self._booksList)
 645                 cell = gtk.CellRendererText()
 646                 self._booksSelectionBox.pack_start(cell, True)
 647                 self._booksSelectionBox.add_attribute(cell, 'text', 2)
 648                 self._booksSelectionBox.set_active(0)
 649
 650                 self._contactsview.connect("row-activated", self._on_contactsview_row_activated)
 651                 self._booksSelectionBox.connect("changed", self._on_addressbook_combo_changed)
 652
 653         def disable(self):
 654                 self._booksSelectionBox.set_model(None)
 655                 self._contactsview.set_model(None)
 656                 self._contactsview.remove_column(self._contactColumn)
 657                 self._contactsview.disconnect("row-activated", self._on_contactsview_row_activated)
 658                 self._booksSelectionBox.disconnect("changed", self._on_addressbook_combo_changed)
 659
 660         def number_selected(self, number):
 661                 """
 662                 @note Actual dial function is patched in later
 663                 """
 664                 raise NotImplementedError
 665
 666         def get_addressbooks(self):
 667                 """
 668                 @returns Iterable of ((Factory Id, Book Id), (Factory Name, Book Name))
 669                 """
 670                 for i, factory in enumerate(self._addressBookFactories):
 671                         for bookFactory, bookId, bookName in factory.get_addressbooks():
 672                                 yield (i, bookId), (factory.factory_name(), bookName)
 673
 674         def open_addressbook(self, bookFactoryId, bookId):
 675                 self._addressBook = self._addressBookFactories[bookFactoryId].open_addressbook(bookId)
 676                 self._contactstime = 0
 677                 backgroundPopulate = threading.Thread(target=self._idly_populate_contactsview)
 678                 backgroundPopulate.setDaemon(True)
 679                 backgroundPopulate.start()
 680
 681         def update(self):
 682                 if (time.time() - self._contactstime) < 300:
 683                         return
 684                 backgroundPopulate = threading.Thread(target=self._idly_populate_contactsview)
 685                 backgroundPopulate.setDaemon(True)
 686                 backgroundPopulate.start()
 687
 688         def clear(self):
 689                 self._contactstime = 0.0
 690                 self._contactsmodel.clear()
 691
 692         def clear_caches(self):
 693                 for factory in self._addressBookFactories:
 694                         factory.clear_caches()
 695                 self._addressBook.clear_caches()
 696
 697         def append(self, book):
 698                 self._addressBookFactories.append(book)
 699
 700         def extend(self, books):
 701                 self._addressBookFactories.extend(books)
 702
 703         def _idly_populate_contactsview(self):
 704                 #@todo Add a lock so only one code path can be in here at a time
 705                 self.clear()
 706
 707                 # completely disable updating the treeview while we populate the data
 708                 self._contactsview.freeze_child_notify()
 709                 self._contactsview.set_model(None)
 710
 711                 addressBook = self._addressBook
 712                 try:
 713                         contacts = addressBook.get_contacts()
 714                 except RuntimeError, e:
 715                         contacts = []
 716                         self._contactstime = 0.0
 717                         gtk.gdk.threads_enter()
 718                         try:
 719                                 self._errorDisplay.push_message(e.message)
 720                         finally:
 721                                 gtk.gdk.threads_leave()
 722                 for contactId, contactName in contacts:
 723                         contactType = (addressBook.contact_source_short_name(contactId),)
 724                         self._contactsmodel.append(contactType + (contactName, "", contactId) + ("",))
 725
 726                 # restart the treeview data rendering
 727                 self._contactsview.set_model(self._contactsmodel)
 728                 self._contactsview.thaw_child_notify()
 729                 return False
 730
 731         def _on_addressbook_combo_changed(self, *args, **kwds):
 732                 itr = self._booksSelectionBox.get_active_iter()
 733                 if itr is None:
 734                         return
 735                 factoryId = int(self._booksList.get_value(itr, 0))
 736                 bookId = self._booksList.get_value(itr, 1)
 737                 self.open_addressbook(factoryId, bookId)
 738
 739         def _on_contactsview_row_activated(self, treeview, path, view_column):
 740                 model, itr = self._contactsviewselection.get_selected()
 741                 if not itr:
 742                         return
 743
 744                 contactId = self._contactsmodel.get_value(itr, 3)
 745                 try:
 746                         contactDetails = self._addressBook.get_contact_details(contactId)
 747                 except RuntimeError, e:
 748                         contactDetails = []
 749                         self._contactstime = 0.0
 750                         self._errorDisplay.push_message(e.message)
 751                 contactDetails = [phoneNumber for phoneNumber in contactDetails]
 752
 753                 if len(contactDetails) == 0:
 754                         phoneNumber = ""
 755                 elif len(contactDetails) == 1:
 756                         phoneNumber = contactDetails[0][1]
 757                 else:
 758                         phoneNumber = self._phoneTypeSelector.run(contactDetails)
 759
 760                 if 0 < len(phoneNumber):
 761                         self.number_selected(phoneNumber)
 762
 763                 self._contactsviewselection.unselect_all()