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