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

   1 #!/usr/bin/env python
   2
   3 from __future__ import with_statement
   4 from __future__ import division
   5
   6 import re
   7 import logging
   8
   9 from PyQt4 import QtGui
  10 from PyQt4 import QtCore
  11
  12 from util import qtpie
  13 from util import qui_utils
  14 from util import misc as misc_utils
  15
  16 import backends.null_backend as null_backend
  17 import backends.file_backend as file_backend
  18
  19
  20 _moduleLogger = logging.getLogger(__name__)
  21
  22
  23 class Dialpad(object):
  24
  25         def __init__(self, app, session, errorLog):
  26                 self._app = app
  27                 self._session = session
  28                 self._errorLog = errorLog
  29
  30                 self._plus = self._generate_key_button("+", "")
  31                 self._entry = QtGui.QLineEdit()
  32
  33                 backAction = QtGui.QAction(None)
  34                 backAction.setText("Back")
  35                 backAction.triggered.connect(self._on_backspace)
  36                 backPieItem = qtpie.QActionPieItem(backAction)
  37                 clearAction = QtGui.QAction(None)
  38                 clearAction.setText("Clear")
  39                 clearAction.triggered.connect(self._on_clear_text)
  40                 clearPieItem = qtpie.QActionPieItem(clearAction)
  41                 self._back = qtpie.QPieButton(backPieItem)
  42                 self._back.set_center(backPieItem)
  43                 self._back.insertItem(qtpie.PieFiling.NULL_CENTER)
  44                 self._back.insertItem(clearPieItem)
  45                 self._back.insertItem(qtpie.PieFiling.NULL_CENTER)
  46                 self._back.insertItem(qtpie.PieFiling.NULL_CENTER)
  47
  48                 self._entryLayout = QtGui.QHBoxLayout()
  49                 self._entryLayout.addWidget(self._plus, 0, QtCore.Qt.AlignCenter)
  50                 self._entryLayout.addWidget(self._entry, 10)
  51                 self._entryLayout.addWidget(self._back, 0, QtCore.Qt.AlignCenter)
  52
  53                 self._smsButton = QtGui.QPushButton("SMS")
  54                 self._smsButton.clicked.connect(self._on_sms_clicked)
  55                 self._callButton = QtGui.QPushButton("Call")
  56                 self._callButton.clicked.connect(self._on_call_clicked)
  57
  58                 self._padLayout = QtGui.QGridLayout()
  59                 rows = [0, 0, 0, 1, 1, 1, 2, 2, 2]
  60                 columns = [0, 1, 2] * 3
  61                 keys = [
  62                         ("1", ""),
  63                         ("2", "ABC"),
  64                         ("3", "DEF"),
  65                         ("4", "GHI"),
  66                         ("5", "JKL"),
  67                         ("6", "MNO"),
  68                         ("7", "PQRS"),
  69                         ("8", "TUV"),
  70                         ("9", "WXYZ"),
  71                 ]
  72                 for (num, letters), (row, column) in zip(keys, zip(rows, columns)):
  73                         self._padLayout.addWidget(
  74                                 self._generate_key_button(num, letters), row, column, QtCore.Qt.AlignCenter
  75                         )
  76                 self._padLayout.addWidget(self._smsButton, 3, 0)
  77                 self._padLayout.addWidget(
  78                         self._generate_key_button("0", ""), 3, 1, QtCore.Qt.AlignCenter
  79                 )
  80                 self._padLayout.addWidget(self._callButton, 3, 2)
  81
  82                 self._layout = QtGui.QVBoxLayout()
  83                 self._layout.addLayout(self._entryLayout)
  84                 self._layout.addLayout(self._padLayout)
  85                 self._widget = QtGui.QWidget()
  86                 self._widget.setLayout(self._layout)
  87
  88         @property
  89         def toplevel(self):
  90                 return self._widget
  91
  92         def enable(self):
  93                 self._smsButton.setEnabled(True)
  94                 self._callButton.setEnabled(True)
  95
  96         def disable(self):
  97                 self._smsButton.setEnabled(False)
  98                 self._callButton.setEnabled(False)
  99
 100         def clear(self):
 101                 pass
 102
 103         def refresh(self, force = True):
 104                 pass
 105
 106         def _generate_key_button(self, center, letters):
 107                 centerPieItem = self._generate_button_slice(center)
 108                 button = qtpie.QPieButton(centerPieItem)
 109                 button.set_center(centerPieItem)
 110
 111                 if len(letters) == 0:
 112                         for i in xrange(8):
 113                                 pieItem = qtpie.PieFiling.NULL_CENTER
 114                                 button.insertItem(pieItem)
 115                 elif len(letters) in [3, 4]:
 116                         for i in xrange(6 - len(letters)):
 117                                 pieItem = qtpie.PieFiling.NULL_CENTER
 118                                 button.insertItem(pieItem)
 119
 120                         for letter in letters:
 121                                 pieItem = self._generate_button_slice(letter)
 122                                 button.insertItem(pieItem)
 123
 124                         for i in xrange(2):
 125                                 pieItem = qtpie.PieFiling.NULL_CENTER
 126                                 button.insertItem(pieItem)
 127                 else:
 128                         raise NotImplementedError("Cannot handle %r" % letters)
 129                 return button
 130
 131         def _generate_button_slice(self, letter):
 132                 action = QtGui.QAction(None)
 133                 action.setText(letter)
 134                 action.triggered.connect(lambda: self._on_keypress(letter))
 135                 pieItem = qtpie.QActionPieItem(action)
 136                 return pieItem
 137
 138         @misc_utils.log_exception(_moduleLogger)
 139         def _on_keypress(self, key):
 140                 self._entry.insert(key)
 141
 142         @misc_utils.log_exception(_moduleLogger)
 143         def _on_backspace(self, toggled = False):
 144                 self._entry.backspace()
 145
 146         @misc_utils.log_exception(_moduleLogger)
 147         def _on_clear_text(self, toggled = False):
 148                 self._entry.clear()
 149
 150         @QtCore.pyqtSlot()
 151         @QtCore.pyqtSlot(bool)
 152         @misc_utils.log_exception(_moduleLogger)
 153         def _on_sms_clicked(self, checked = False):
 154                 number = str(self._entry.text())
 155                 self._entry.clear()
 156
 157                 contactId = number
 158                 title = number
 159                 description = number
 160                 numbersWithDescriptions = [(number, "")]
 161                 self._session.draft.add_contact(contactId, title, description, numbersWithDescriptions)
 162
 163         @QtCore.pyqtSlot()
 164         @QtCore.pyqtSlot(bool)
 165         @misc_utils.log_exception(_moduleLogger)
 166         def _on_call_clicked(self, checked = False):
 167                 number = str(self._entry.text())
 168                 self._entry.clear()
 169
 170                 contactId = number
 171                 title = number
 172                 description = number
 173                 numbersWithDescriptions = [(number, "")]
 174                 self._session.draft.clear()
 175                 self._session.draft.add_contact(contactId, title, description, numbersWithDescriptions)
 176                 self._session.draft.call()
 177
 178
 179 class History(object):
 180
 181         DATE_IDX = 0
 182         ACTION_IDX = 1
 183         NUMBER_IDX = 2
 184         FROM_IDX = 3
 185         MAX_IDX = 4
 186
 187         HISTORY_ITEM_TYPES = ["Received", "Missed", "Placed", "All"]
 188         HISTORY_COLUMNS = ["When", "What", "Number", "From"]
 189         assert len(HISTORY_COLUMNS) == MAX_IDX
 190
 191         def __init__(self, app, session, errorLog):
 192                 self._selectedFilter = self.HISTORY_ITEM_TYPES[-1]
 193                 self._app = app
 194                 self._session = session
 195                 self._session.historyUpdated.connect(self._on_history_updated)
 196                 self._errorLog = errorLog
 197
 198                 self._typeSelection = QtGui.QComboBox()
 199                 self._typeSelection.addItems(self.HISTORY_ITEM_TYPES)
 200                 self._typeSelection.setCurrentIndex(
 201                         self.HISTORY_ITEM_TYPES.index(self._selectedFilter)
 202                 )
 203                 self._typeSelection.currentIndexChanged[str].connect(self._on_filter_changed)
 204
 205                 self._itemStore = QtGui.QStandardItemModel()
 206                 self._itemStore.setHorizontalHeaderLabels(self.HISTORY_COLUMNS)
 207
 208                 self._itemView = QtGui.QTreeView()
 209                 self._itemView.setModel(self._itemStore)
 210                 self._itemView.setUniformRowHeights(True)
 211                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 212                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 213                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 214                 self._itemView.setHeaderHidden(True)
 215                 self._itemView.activated.connect(self._on_row_activated)
 216
 217                 self._layout = QtGui.QVBoxLayout()
 218                 self._layout.addWidget(self._typeSelection)
 219                 self._layout.addWidget(self._itemView)
 220                 self._widget = QtGui.QWidget()
 221                 self._widget.setLayout(self._layout)
 222
 223                 self._populate_items()
 224
 225         @property
 226         def toplevel(self):
 227                 return self._widget
 228
 229         def enable(self):
 230                 self._itemView.setEnabled(True)
 231
 232         def disable(self):
 233                 self._itemView.setEnabled(False)
 234
 235         def clear(self):
 236                 self._itemView.clear()
 237
 238         def refresh(self, force=True):
 239                 self._session.update_history(force)
 240
 241         def _populate_items(self):
 242                 self._itemStore.clear()
 243                 history = self._session.get_history()
 244                 history.sort(key=lambda item: item["time"], reverse=True)
 245                 for event in history:
 246                         if self._selectedFilter in [self.HISTORY_ITEM_TYPES[-1], event["action"]]:
 247                                 relTime = abbrev_relative_date(event["relTime"])
 248                                 action = event["action"]
 249                                 number = event["number"]
 250                                 prettyNumber = make_pretty(number)
 251                                 name = event["name"]
 252                                 if not name or name == number:
 253                                         name = event["location"]
 254                                 if not name:
 255                                         name = "Unknown"
 256
 257                                 timeItem = QtGui.QStandardItem(relTime)
 258                                 actionItem = QtGui.QStandardItem(action)
 259                                 numberItem = QtGui.QStandardItem(prettyNumber)
 260                                 nameItem = QtGui.QStandardItem(name)
 261                                 row = timeItem, actionItem, numberItem, nameItem
 262                                 for item in row:
 263                                         item.setEditable(False)
 264                                         item.setCheckable(False)
 265                                         if item is not nameItem:
 266                                                 itemFont = item.font()
 267                                                 itemFont.setPointSize(max(itemFont.pointSize() - 3, 5))
 268                                                 item.setFont(itemFont)
 269                                 numberItem.setData(event)
 270                                 self._itemStore.appendRow(row)
 271
 272         @QtCore.pyqtSlot(str)
 273         @misc_utils.log_exception(_moduleLogger)
 274         def _on_filter_changed(self, newItem):
 275                 self._selectedFilter = str(newItem)
 276                 self._populate_items()
 277
 278         @QtCore.pyqtSlot()
 279         @misc_utils.log_exception(_moduleLogger)
 280         def _on_history_updated(self):
 281                 self._populate_items()
 282
 283         @QtCore.pyqtSlot(QtCore.QModelIndex)
 284         @misc_utils.log_exception(_moduleLogger)
 285         def _on_row_activated(self, index):
 286                 rowIndex = index.row()
 287                 item = self._itemStore.item(rowIndex, self.NUMBER_IDX)
 288                 contactDetails = item.data().toPyObject()
 289
 290                 title = str(self._itemStore.item(rowIndex, self.FROM_IDX).text())
 291                 number = str(contactDetails[QtCore.QString("number")])
 292                 contactId = number # ids don't seem too unique so using numbers
 293
 294                 descriptionRows = []
 295                 # @bug doesn't seem to print multiple entries
 296                 for i in xrange(self._itemStore.rowCount()):
 297                         iItem = self._itemStore.item(i, self.NUMBER_IDX)
 298                         iContactDetails = iItem.data().toPyObject()
 299                         iNumber = str(iContactDetails[QtCore.QString("number")])
 300                         if number != iNumber:
 301                                 continue
 302                         relTime = abbrev_relative_date(iContactDetails[QtCore.QString("relTime")])
 303                         action = str(iContactDetails[QtCore.QString("action")])
 304                         number = str(iContactDetails[QtCore.QString("number")])
 305                         prettyNumber = make_pretty(number)
 306                         rowItems = relTime, action, prettyNumber
 307                         descriptionRows.append("<tr><td>%s</td></tr>" % "</td><td>".join(rowItems))
 308                 description = "<table>%s</table>" % "".join(descriptionRows)
 309                 numbersWithDescriptions = [(str(contactDetails[QtCore.QString("number")]), "")]
 310                 self._session.draft.add_contact(contactId, title, description, numbersWithDescriptions)
 311
 312
 313 class Messages(object):
 314
 315         NO_MESSAGES = "None"
 316         VOICEMAIL_MESSAGES = "Voicemail"
 317         TEXT_MESSAGES = "SMS"
 318         ALL_TYPES = "All Messages"
 319         MESSAGE_TYPES = [NO_MESSAGES, VOICEMAIL_MESSAGES, TEXT_MESSAGES, ALL_TYPES]
 320
 321         UNREAD_STATUS = "Unread"
 322         UNARCHIVED_STATUS = "Inbox"
 323         ALL_STATUS = "Any"
 324         MESSAGE_STATUSES = [UNREAD_STATUS, UNARCHIVED_STATUS, ALL_STATUS]
 325
 326         _MIN_MESSAGES_SHOWN = 4
 327
 328         def __init__(self, app, session, errorLog):
 329                 self._selectedTypeFilter = self.ALL_TYPES
 330                 self._selectedStatusFilter = self.ALL_STATUS
 331                 self._app = app
 332                 self._session = session
 333                 self._session.messagesUpdated.connect(self._on_messages_updated)
 334                 self._errorLog = errorLog
 335
 336                 self._typeSelection = QtGui.QComboBox()
 337                 self._typeSelection.addItems(self.MESSAGE_TYPES)
 338                 self._typeSelection.setCurrentIndex(
 339                         self.MESSAGE_TYPES.index(self._selectedTypeFilter)
 340                 )
 341                 self._typeSelection.currentIndexChanged[str].connect(self._on_type_filter_changed)
 342
 343                 self._statusSelection = QtGui.QComboBox()
 344                 self._statusSelection.addItems(self.MESSAGE_STATUSES)
 345                 self._statusSelection.setCurrentIndex(
 346                         self.MESSAGE_STATUSES.index(self._selectedStatusFilter)
 347                 )
 348                 self._statusSelection.currentIndexChanged[str].connect(self._on_status_filter_changed)
 349
 350                 self._selectionLayout = QtGui.QHBoxLayout()
 351                 self._selectionLayout.addWidget(self._typeSelection)
 352                 self._selectionLayout.addWidget(self._statusSelection)
 353
 354                 self._itemStore = QtGui.QStandardItemModel()
 355                 self._itemStore.setHorizontalHeaderLabels(["Messages"])
 356
 357                 self._htmlDelegate = qui_utils.QHtmlDelegate()
 358                 self._itemView = QtGui.QTreeView()
 359                 self._itemView.setModel(self._itemStore)
 360                 self._itemView.setUniformRowHeights(False)
 361                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 362                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 363                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 364                 self._itemView.setHeaderHidden(True)
 365                 self._itemView.setItemDelegate(self._htmlDelegate)
 366                 self._itemView.activated.connect(self._on_row_activated)
 367
 368                 self._layout = QtGui.QVBoxLayout()
 369                 self._layout.addLayout(self._selectionLayout)
 370                 self._layout.addWidget(self._itemView)
 371                 self._widget = QtGui.QWidget()
 372                 self._widget.setLayout(self._layout)
 373
 374                 self._populate_items()
 375
 376         @property
 377         def toplevel(self):
 378                 return self._widget
 379
 380         def enable(self):
 381                 self._itemView.setEnabled(True)
 382
 383         def disable(self):
 384                 self._itemView.setEnabled(False)
 385
 386         def clear(self):
 387                 self._itemView.clear()
 388
 389         def refresh(self, force=True):
 390                 self._session.update_messages(force)
 391
 392         def _populate_items(self):
 393                 self._itemStore.clear()
 394                 rawMessages = self._session.get_messages()
 395                 rawMessages.sort(key=lambda item: item["time"], reverse=True)
 396                 for item in rawMessages:
 397                         isUnarchived = not item["isArchived"]
 398                         isUnread = not item["isRead"]
 399                         visibleStatus = {
 400                                 self.UNREAD_STATUS: isUnarchived and isUnread,
 401                                 self.UNARCHIVED_STATUS: isUnarchived,
 402                                 self.ALL_STATUS: True,
 403                         }[self._selectedStatusFilter]
 404
 405                         visibleType = self._selectedTypeFilter in [item["type"], self.ALL_TYPES]
 406                         if visibleType and visibleStatus:
 407                                 relTime = abbrev_relative_date(item["relTime"])
 408                                 number = item["number"]
 409                                 prettyNumber = make_pretty(number)
 410                                 name = item["name"]
 411                                 if not name or name == number:
 412                                         name = item["location"]
 413                                 if not name:
 414                                         name = "Unknown"
 415
 416                                 messageParts = list(item["messageParts"])
 417                                 if len(messageParts) == 0:
 418                                         messages = ("No Transcription", )
 419                                 elif len(messageParts) == 1:
 420                                         if messageParts[0][1]:
 421                                                 messages = (messageParts[0][1], )
 422                                         else:
 423                                                 messages = ("No Transcription", )
 424                                 else:
 425                                         messages = [
 426                                                 "<b>%s</b>: %s" % (messagePart[0], messagePart[1])
 427                                                 for messagePart in messageParts
 428                                         ]
 429
 430                                 firstMessage = "<b>%s - %s</b> <i>(%s)</i>" % (name, prettyNumber, relTime)
 431
 432                                 expandedMessages = [firstMessage]
 433                                 expandedMessages.extend(messages)
 434                                 if (self._MIN_MESSAGES_SHOWN + 1) < len(messages):
 435                                         secondMessage = "<i>%d Messages Hidden...</i>" % (len(messages) - self._MIN_MESSAGES_SHOWN, )
 436                                         collapsedMessages = [firstMessage, secondMessage]
 437                                         collapsedMessages.extend(messages[-(self._MIN_MESSAGES_SHOWN+0):])
 438                                 else:
 439                                         collapsedMessages = expandedMessages
 440
 441                                 item = dict(item.iteritems())
 442                                 item["collapsedMessages"] = "<br/>\n".join(collapsedMessages)
 443                                 item["expandedMessages"] = "<br/>\n".join(expandedMessages)
 444
 445                                 messageItem = QtGui.QStandardItem(item["collapsedMessages"])
 446                                 # @bug Not showing all of a message
 447                                 messageItem.setData(item)
 448                                 messageItem.setEditable(False)
 449                                 messageItem.setCheckable(False)
 450                                 row = (messageItem, )
 451                                 self._itemStore.appendRow(row)
 452
 453         @QtCore.pyqtSlot(str)
 454         @misc_utils.log_exception(_moduleLogger)
 455         def _on_type_filter_changed(self, newItem):
 456                 self._selectedTypeFilter = str(newItem)
 457                 self._populate_items()
 458
 459         @QtCore.pyqtSlot(str)
 460         @misc_utils.log_exception(_moduleLogger)
 461         def _on_status_filter_changed(self, newItem):
 462                 self._selectedStatusFilter = str(newItem)
 463                 self._populate_items()
 464
 465         @QtCore.pyqtSlot()
 466         @misc_utils.log_exception(_moduleLogger)
 467         def _on_messages_updated(self):
 468                 self._populate_items()
 469
 470         @QtCore.pyqtSlot(QtCore.QModelIndex)
 471         @misc_utils.log_exception(_moduleLogger)
 472         def _on_row_activated(self, index):
 473                 rowIndex = index.row()
 474                 item = self._itemStore.item(rowIndex, 0)
 475                 contactDetails = item.data().toPyObject()
 476
 477                 name = str(contactDetails[QtCore.QString("name")])
 478                 number = str(contactDetails[QtCore.QString("number")])
 479                 if not name or name == number:
 480                         name = str(contactDetails[QtCore.QString("location")])
 481                 if not name:
 482                         name = "Unknown"
 483
 484                 contactId = str(contactDetails[QtCore.QString("id")])
 485                 title = name
 486                 description = str(contactDetails[QtCore.QString("expandedMessages")])
 487                 numbersWithDescriptions = [(number, "")]
 488                 self._session.draft.add_contact(contactId, title, description, numbersWithDescriptions)
 489
 490
 491 class Contacts(object):
 492
 493         def __init__(self, app, session, errorLog):
 494                 self._app = app
 495                 self._session = session
 496                 self._session.contactsUpdated.connect(self._on_contacts_updated)
 497                 self._errorLog = errorLog
 498                 self._addressBookFactories = [
 499                         null_backend.NullAddressBookFactory(),
 500                         file_backend.FilesystemAddressBookFactory(app.fsContactsPath),
 501                 ]
 502                 self._addressBooks = []
 503
 504                 self._listSelection = QtGui.QComboBox()
 505                 self._listSelection.addItems([])
 506                 self._listSelection.currentIndexChanged[str].connect(self._on_filter_changed)
 507
 508                 self._itemStore = QtGui.QStandardItemModel()
 509                 self._itemStore.setHorizontalHeaderLabels(["Contacts"])
 510
 511                 self._itemView = QtGui.QTreeView()
 512                 self._itemView.setModel(self._itemStore)
 513                 self._itemView.setUniformRowHeights(True)
 514                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 515                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 516                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 517                 self._itemView.setHeaderHidden(True)
 518                 self._itemView.activated.connect(self._on_row_activated)
 519
 520                 self._layout = QtGui.QVBoxLayout()
 521                 self._layout.addWidget(self._listSelection)
 522                 self._layout.addWidget(self._itemView)
 523                 self._widget = QtGui.QWidget()
 524                 self._widget.setLayout(self._layout)
 525
 526                 self.update_addressbooks()
 527                 self._populate_items()
 528
 529         @property
 530         def toplevel(self):
 531                 return self._widget
 532
 533         def enable(self):
 534                 self._itemView.setEnabled(True)
 535
 536         def disable(self):
 537                 self._itemView.setEnabled(False)
 538
 539         def clear(self):
 540                 self._itemView.clear()
 541
 542         def refresh(self, force=True):
 543                 self._backend.update_contacts(force)
 544
 545         @property
 546         def _backend(self):
 547                 return self._addressBooks[self._listSelection.currentIndex()]["book"]
 548
 549         def update_addressbooks(self):
 550                 self._addressBooks = [
 551                         {"book": book, "name": book.name}
 552                         for factory in self._addressBookFactories
 553                         for book in factory.get_addressbooks()
 554                 ]
 555                 self._addressBooks.append(
 556                         {
 557                                 "book": self._session,
 558                                 "name": "Google Voice",
 559                         }
 560                 )
 561
 562                 currentItem = str(self._listSelection.currentText())
 563                 if currentItem == "":
 564                         # Not loaded yet
 565                         currentItem = "None"
 566                 while 0 < self._listSelection.count():
 567                         self._listSelection.removeItem(0)
 568                 bookNames = [book["name"] for book in self._addressBooks]
 569                 try:
 570                         newIndex = bookNames.index(currentItem)
 571                 except ValueError:
 572                         # Switch over to None for the user
 573                         newIndex = 0
 574                         self._itemStore.clear()
 575                         _moduleLogger.info("Addressbook %r doesn't exist anymore, switching to None" % currentItem)
 576                 self._listSelection.addItems(bookNames)
 577                 self._listSelection.setCurrentIndex(newIndex)
 578
 579         def _populate_items(self):
 580                 self._itemStore.clear()
 581
 582                 contacts = list(self._backend.get_contacts().itervalues())
 583                 contacts.sort(key=lambda contact: contact["name"].lower())
 584                 for item in contacts:
 585                         name = item["name"]
 586                         numbers = item["numbers"]
 587                         nameItem = QtGui.QStandardItem(name)
 588                         nameItem.setEditable(False)
 589                         nameItem.setCheckable(False)
 590                         nameItem.setData(item)
 591                         row = (nameItem, )
 592                         self._itemStore.appendRow(row)
 593
 594         @QtCore.pyqtSlot(str)
 595         @misc_utils.log_exception(_moduleLogger)
 596         def _on_filter_changed(self, newItem):
 597                 self._populate_items()
 598
 599         @QtCore.pyqtSlot()
 600         @misc_utils.log_exception(_moduleLogger)
 601         def _on_contacts_updated(self):
 602                 self._populate_items()
 603
 604         @QtCore.pyqtSlot(QtCore.QModelIndex)
 605         @misc_utils.log_exception(_moduleLogger)
 606         def _on_row_activated(self, index):
 607                 rowIndex = index.row()
 608                 item = self._itemStore.item(rowIndex, 0)
 609                 contactDetails = item.data().toPyObject()
 610
 611                 name = str(contactDetails[QtCore.QString("name")])
 612                 if not name:
 613                         name = str(contactDetails[QtCore.QString("location")])
 614                 if not name:
 615                         name = "Unknown"
 616
 617                 contactId = str(contactDetails[QtCore.QString("contactId")])
 618                 numbers = contactDetails[QtCore.QString("numbers")]
 619                 numbers = [
 620                         dict(
 621                                 (str(k), str(v))
 622                                 for (k, v) in number.iteritems()
 623                         )
 624                         for number in numbers
 625                 ]
 626                 numbersWithDescriptions = [
 627                         (
 628                                 number["phoneNumber"],
 629                                 self._choose_phonetype(number),
 630                         )
 631                         for number in numbers
 632                 ]
 633                 title = name
 634                 description = name
 635                 self._session.draft.add_contact(contactId, title, description, numbersWithDescriptions)
 636
 637         @staticmethod
 638         def _choose_phonetype(numberDetails):
 639                 if "phoneTypeName" in numberDetails:
 640                         return numberDetails["phoneTypeName"]
 641                 elif "phoneType" in numberDetails:
 642                         return numberDetails["phoneType"]
 643                 else:
 644                         return ""
 645
 646
 647 def make_ugly(prettynumber):
 648         """
 649         function to take a phone number and strip out all non-numeric
 650         characters
 651
 652         >>> make_ugly("+012-(345)-678-90")
 653         '+01234567890'
 654         """
 655         return normalize_number(prettynumber)
 656
 657
 658 def normalize_number(prettynumber):
 659         """
 660         function to take a phone number and strip out all non-numeric
 661         characters
 662
 663         >>> normalize_number("+012-(345)-678-90")
 664         '+01234567890'
 665         >>> normalize_number("1-(345)-678-9000")
 666         '+13456789000'
 667         >>> normalize_number("+1-(345)-678-9000")
 668         '+13456789000'
 669         """
 670         uglynumber = re.sub('[^0-9+]', '', prettynumber)
 671
 672         if uglynumber.startswith("+"):
 673                 pass
 674         elif uglynumber.startswith("1"):
 675                 uglynumber = "+"+uglynumber
 676         elif 10 <= len(uglynumber):
 677                 assert uglynumber[0] not in ("+", "1")
 678                 uglynumber = "+1"+uglynumber
 679         else:
 680                 pass
 681
 682         return uglynumber
 683
 684
 685 def _make_pretty_with_areacode(phonenumber):
 686         prettynumber = "(%s)" % (phonenumber[0:3], )
 687         if 3 < len(phonenumber):
 688                 prettynumber += " %s" % (phonenumber[3:6], )
 689                 if 6 < len(phonenumber):
 690                         prettynumber += "-%s" % (phonenumber[6:], )
 691         return prettynumber
 692
 693
 694 def _make_pretty_local(phonenumber):
 695         prettynumber = "%s" % (phonenumber[0:3], )
 696         if 3 < len(phonenumber):
 697                 prettynumber += "-%s" % (phonenumber[3:], )
 698         return prettynumber
 699
 700
 701 def _make_pretty_international(phonenumber):
 702         prettynumber = phonenumber
 703         if phonenumber.startswith("1"):
 704                 prettynumber = "1 "
 705                 prettynumber += _make_pretty_with_areacode(phonenumber[1:])
 706         return prettynumber
 707
 708
 709 def make_pretty(phonenumber):
 710         """
 711         Function to take a phone number and return the pretty version
 712         pretty numbers:
 713                 if phonenumber begins with 0:
 714                         ...-(...)-...-....
 715                 if phonenumber begins with 1: ( for gizmo callback numbers )
 716                         1 (...)-...-....
 717                 if phonenumber is 13 digits:
 718                         (...)-...-....
 719                 if phonenumber is 10 digits:
 720                         ...-....
 721         >>> make_pretty("12")
 722         '12'
 723         >>> make_pretty("1234567")
 724         '123-4567'
 725         >>> make_pretty("2345678901")
 726         '+1 (234) 567-8901'
 727         >>> make_pretty("12345678901")
 728         '+1 (234) 567-8901'
 729         >>> make_pretty("01234567890")
 730         '+012 (345) 678-90'
 731         >>> make_pretty("+01234567890")
 732         '+012 (345) 678-90'
 733         >>> make_pretty("+12")
 734         '+1 (2)'
 735         >>> make_pretty("+123")
 736         '+1 (23)'
 737         >>> make_pretty("+1234")
 738         '+1 (234)'
 739         """
 740         if phonenumber is None or phonenumber is "":
 741                 return ""
 742
 743         phonenumber = normalize_number(phonenumber)
 744
 745         if phonenumber[0] == "+":
 746                 prettynumber = _make_pretty_international(phonenumber[1:])
 747                 if not prettynumber.startswith("+"):
 748                         prettynumber = "+"+prettynumber
 749         elif 8 < len(phonenumber) and phonenumber[0] in ("1", ):
 750                 prettynumber = _make_pretty_international(phonenumber)
 751         elif 7 < len(phonenumber):
 752                 prettynumber = _make_pretty_with_areacode(phonenumber)
 753         elif 3 < len(phonenumber):
 754                 prettynumber = _make_pretty_local(phonenumber)
 755         else:
 756                 prettynumber = phonenumber
 757         return prettynumber.strip()
 758
 759
 760 def abbrev_relative_date(date):
 761         """
 762         >>> abbrev_relative_date("42 hours ago")
 763         '42 h'
 764         >>> abbrev_relative_date("2 days ago")
 765         '2 d'
 766         >>> abbrev_relative_date("4 weeks ago")
 767         '4 w'
 768         """
 769         parts = date.split(" ")
 770         return "%s %s" % (parts[0], parts[1][0])