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

   1 #!/usr/bin/env python
   2
   3 from __future__ import with_statement
   4 from __future__ import division
   5
   6 import datetime
   7 import string
   8 import itertools
   9 import logging
  10
  11 import util.qt_compat as qt_compat
  12 QtCore = qt_compat.QtCore
  13 QtGui = qt_compat.import_module("QtGui")
  14
  15 from util import qtpie
  16 from util import qui_utils
  17 from util import misc as misc_utils
  18
  19 import backends.null_backend as null_backend
  20 import backends.file_backend as file_backend
  21 import backends.qt_backend as qt_backend
  22
  23
  24 _moduleLogger = logging.getLogger(__name__)
  25
  26
  27 _SENTINEL_ICON = QtGui.QIcon()
  28
  29
  30 class Dialpad(object):
  31
  32         def __init__(self, app, session, errorLog):
  33                 self._app = app
  34                 self._session = session
  35                 self._errorLog = errorLog
  36
  37                 self._plus = QtGui.QPushButton("+")
  38                 self._plus.clicked.connect(lambda: self._on_keypress("+"))
  39                 self._entry = QtGui.QLineEdit()
  40
  41                 backAction = QtGui.QAction(None)
  42                 backAction.setText("Back")
  43                 backAction.triggered.connect(self._on_backspace)
  44                 backPieItem = qtpie.QActionPieItem(backAction)
  45                 clearAction = QtGui.QAction(None)
  46                 clearAction.setText("Clear")
  47                 clearAction.triggered.connect(self._on_clear_text)
  48                 clearPieItem = qtpie.QActionPieItem(clearAction)
  49                 backSlices = [
  50                         qtpie.PieFiling.NULL_CENTER,
  51                         clearPieItem,
  52                         qtpie.PieFiling.NULL_CENTER,
  53                         qtpie.PieFiling.NULL_CENTER,
  54                 ]
  55                 self._back = qtpie.QPieButton(backPieItem)
  56                 self._back.set_center(backPieItem)
  57                 for slice in backSlices:
  58                         self._back.insertItem(slice)
  59
  60                 self._entryLayout = QtGui.QHBoxLayout()
  61                 self._entryLayout.addWidget(self._plus, 1, QtCore.Qt.AlignCenter)
  62                 self._entryLayout.addWidget(self._entry, 1000)
  63                 self._entryLayout.addWidget(self._back, 1, QtCore.Qt.AlignCenter)
  64
  65                 smsIcon = self._app.get_icon("messages.png")
  66                 self._smsButton = QtGui.QPushButton(smsIcon, "SMS")
  67                 self._smsButton.clicked.connect(self._on_sms_clicked)
  68                 self._smsButton.setSizePolicy(QtGui.QSizePolicy(
  69                         QtGui.QSizePolicy.MinimumExpanding,
  70                         QtGui.QSizePolicy.MinimumExpanding,
  71                         QtGui.QSizePolicy.PushButton,
  72                 ))
  73                 callIcon = self._app.get_icon("dialpad.png")
  74                 self._callButton = QtGui.QPushButton(callIcon, "Call")
  75                 self._callButton.clicked.connect(self._on_call_clicked)
  76                 self._callButton.setSizePolicy(QtGui.QSizePolicy(
  77                         QtGui.QSizePolicy.MinimumExpanding,
  78                         QtGui.QSizePolicy.MinimumExpanding,
  79                         QtGui.QSizePolicy.PushButton,
  80                 ))
  81
  82                 self._padLayout = QtGui.QGridLayout()
  83                 rows = [0, 0, 0, 1, 1, 1, 2, 2, 2]
  84                 columns = [0, 1, 2] * 3
  85                 keys = [
  86                         ("1", ""),
  87                         ("2", "ABC"),
  88                         ("3", "DEF"),
  89                         ("4", "GHI"),
  90                         ("5", "JKL"),
  91                         ("6", "MNO"),
  92                         ("7", "PQRS"),
  93                         ("8", "TUV"),
  94                         ("9", "WXYZ"),
  95                 ]
  96                 for (num, letters), (row, column) in zip(keys, zip(rows, columns)):
  97                         self._padLayout.addWidget(self._generate_key_button(num, letters), row, column)
  98                 self._zerothButton = QtGui.QPushButton("0")
  99                 self._zerothButton.clicked.connect(lambda: self._on_keypress("0"))
 100                 self._zerothButton.setSizePolicy(QtGui.QSizePolicy(
 101                         QtGui.QSizePolicy.MinimumExpanding,
 102                         QtGui.QSizePolicy.MinimumExpanding,
 103                         QtGui.QSizePolicy.PushButton,
 104                 ))
 105                 self._padLayout.addWidget(self._smsButton, 3, 0)
 106                 self._padLayout.addWidget(self._zerothButton)
 107                 self._padLayout.addWidget(self._callButton, 3, 2)
 108
 109                 self._layout = QtGui.QVBoxLayout()
 110                 self._layout.addLayout(self._entryLayout, 0)
 111                 self._layout.addLayout(self._padLayout, 1000000)
 112                 self._widget = QtGui.QWidget()
 113                 self._widget.setLayout(self._layout)
 114
 115         @property
 116         def toplevel(self):
 117                 return self._widget
 118
 119         def enable(self):
 120                 self._smsButton.setEnabled(True)
 121                 self._callButton.setEnabled(True)
 122
 123         def disable(self):
 124                 self._smsButton.setEnabled(False)
 125                 self._callButton.setEnabled(False)
 126
 127         def get_settings(self):
 128                 return {}
 129
 130         def set_settings(self, settings):
 131                 pass
 132
 133         def clear(self):
 134                 pass
 135
 136         def refresh(self, force = True):
 137                 pass
 138
 139         def _generate_key_button(self, center, letters):
 140                 button = QtGui.QPushButton("%s\n%s" % (center, letters))
 141                 button.setSizePolicy(QtGui.QSizePolicy(
 142                         QtGui.QSizePolicy.MinimumExpanding,
 143                         QtGui.QSizePolicy.MinimumExpanding,
 144                         QtGui.QSizePolicy.PushButton,
 145                 ))
 146                 button.clicked.connect(lambda: self._on_keypress(center))
 147                 return button
 148
 149         @misc_utils.log_exception(_moduleLogger)
 150         def _on_keypress(self, key):
 151                 with qui_utils.notify_error(self._errorLog):
 152                         self._entry.insert(key)
 153
 154         @misc_utils.log_exception(_moduleLogger)
 155         def _on_backspace(self, toggled = False):
 156                 with qui_utils.notify_error(self._errorLog):
 157                         self._entry.backspace()
 158
 159         @misc_utils.log_exception(_moduleLogger)
 160         def _on_clear_text(self, toggled = False):
 161                 with qui_utils.notify_error(self._errorLog):
 162                         self._entry.clear()
 163
 164         @qt_compat.Slot()
 165         @qt_compat.Slot(bool)
 166         @misc_utils.log_exception(_moduleLogger)
 167         def _on_sms_clicked(self, checked = False):
 168                 with qui_utils.notify_error(self._errorLog):
 169                         number = misc_utils.make_ugly(str(self._entry.text()))
 170                         self._entry.clear()
 171
 172                         contactId = number
 173                         title = misc_utils.make_pretty(number)
 174                         description = misc_utils.make_pretty(number)
 175                         numbersWithDescriptions = [(number, "")]
 176                         self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
 177
 178         @qt_compat.Slot()
 179         @qt_compat.Slot(bool)
 180         @misc_utils.log_exception(_moduleLogger)
 181         def _on_call_clicked(self, checked = False):
 182                 with qui_utils.notify_error(self._errorLog):
 183                         number = misc_utils.make_ugly(str(self._entry.text()))
 184                         self._entry.clear()
 185
 186                         contactId = number
 187                         title = misc_utils.make_pretty(number)
 188                         description = misc_utils.make_pretty(number)
 189                         numbersWithDescriptions = [(number, "")]
 190                         self._session.draft.clear()
 191                         self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
 192                         self._session.draft.call()
 193
 194
 195 class TimeCategories(object):
 196
 197         _NOW_SECTION = 0
 198         _TODAY_SECTION = 1
 199         _WEEK_SECTION = 2
 200         _MONTH_SECTION = 3
 201         _REST_SECTION = 4
 202         _MAX_SECTIONS = 5
 203
 204         _NO_ELAPSED = datetime.timedelta(hours=1)
 205         _WEEK_ELAPSED = datetime.timedelta(weeks=1)
 206         _MONTH_ELAPSED = datetime.timedelta(days=30)
 207
 208         def __init__(self, parentItem):
 209                 self._timeItems = [
 210                         QtGui.QStandardItem(description)
 211                         for (i, description) in zip(
 212                                 xrange(self._MAX_SECTIONS),
 213                                 ["Now", "Today", "Week", "Month", "Past"],
 214                         )
 215                 ]
 216                 for item in self._timeItems:
 217                         item.setEditable(False)
 218                         item.setCheckable(False)
 219                         row = (item, )
 220                         parentItem.appendRow(row)
 221
 222                 self._today = datetime.datetime(1900, 1, 1)
 223
 224                 self.prepare_for_update(self._today)
 225
 226         def prepare_for_update(self, newToday):
 227                 self._today = newToday
 228                 for item in self._timeItems:
 229                         item.removeRows(0, item.rowCount())
 230                 try:
 231                         hour = self._today.strftime("%X")
 232                         day = self._today.strftime("%x")
 233                 except ValueError:
 234                         _moduleLogger.exception("Can't format times")
 235                         hour = "Now"
 236                         day = "Today"
 237                 self._timeItems[self._NOW_SECTION].setText(hour)
 238                 self._timeItems[self._TODAY_SECTION].setText(day)
 239
 240         def add_row(self, rowDate, row):
 241                 elapsedTime = self._today - rowDate
 242                 todayTuple = self._today.timetuple()
 243                 rowTuple = rowDate.timetuple()
 244                 if elapsedTime < self._NO_ELAPSED:
 245                         section = self._NOW_SECTION
 246                 elif todayTuple[0:3] == rowTuple[0:3]:
 247                         section = self._TODAY_SECTION
 248                 elif elapsedTime < self._WEEK_ELAPSED:
 249                         section = self._WEEK_SECTION
 250                 elif elapsedTime < self._MONTH_ELAPSED:
 251                         section = self._MONTH_SECTION
 252                 else:
 253                         section = self._REST_SECTION
 254                 self._timeItems[section].appendRow(row)
 255
 256         def get_item(self, timeIndex, rowIndex, column):
 257                 timeItem = self._timeItems[timeIndex]
 258                 item = timeItem.child(rowIndex, column)
 259                 return item
 260
 261
 262 class History(object):
 263
 264         DETAILS_IDX = 0
 265         FROM_IDX = 1
 266         MAX_IDX = 2
 267
 268         HISTORY_RECEIVED = "Received"
 269         HISTORY_MISSED = "Missed"
 270         HISTORY_PLACED = "Placed"
 271         HISTORY_ALL = "All"
 272
 273         HISTORY_ITEM_TYPES = [HISTORY_RECEIVED, HISTORY_MISSED, HISTORY_PLACED, HISTORY_ALL]
 274         HISTORY_COLUMNS = ["", "From"]
 275         assert len(HISTORY_COLUMNS) == MAX_IDX
 276
 277         def __init__(self, app, session, errorLog):
 278                 self._selectedFilter = self.HISTORY_ITEM_TYPES[-1]
 279                 self._app = app
 280                 self._session = session
 281                 self._session.historyUpdated.connect(self._on_history_updated)
 282                 self._errorLog = errorLog
 283
 284                 self._typeSelection = QtGui.QComboBox()
 285                 self._typeSelection.addItems(self.HISTORY_ITEM_TYPES)
 286                 self._typeSelection.setCurrentIndex(
 287                         self.HISTORY_ITEM_TYPES.index(self._selectedFilter)
 288                 )
 289                 self._typeSelection.currentIndexChanged[str].connect(self._on_filter_changed)
 290                 refreshIcon = qui_utils.get_theme_icon(
 291                         ("view-refresh", "general_refresh", "gtk-refresh", ),
 292                         _SENTINEL_ICON
 293                 )
 294                 if refreshIcon is not _SENTINEL_ICON:
 295                         self._refreshButton = QtGui.QPushButton(refreshIcon, "")
 296                 else:
 297                         self._refreshButton = QtGui.QPushButton("Refresh")
 298                 self._refreshButton.clicked.connect(self._on_refresh_clicked)
 299                 self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
 300                         QtGui.QSizePolicy.Minimum,
 301                         QtGui.QSizePolicy.Minimum,
 302                         QtGui.QSizePolicy.PushButton,
 303                 ))
 304                 self._managerLayout = QtGui.QHBoxLayout()
 305                 self._managerLayout.addWidget(self._typeSelection, 1000)
 306                 self._managerLayout.addWidget(self._refreshButton, 0)
 307
 308                 self._itemStore = QtGui.QStandardItemModel()
 309                 self._itemStore.setHorizontalHeaderLabels(self.HISTORY_COLUMNS)
 310                 self._categoryManager = TimeCategories(self._itemStore)
 311
 312                 self._itemView = QtGui.QTreeView()
 313                 self._itemView.setModel(self._itemStore)
 314                 self._itemView.setUniformRowHeights(True)
 315                 self._itemView.setRootIsDecorated(False)
 316                 self._itemView.setIndentation(0)
 317                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 318                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 319                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 320                 self._itemView.setHeaderHidden(True)
 321                 self._itemView.setItemsExpandable(False)
 322                 self._itemView.header().setResizeMode(QtGui.QHeaderView.ResizeToContents)
 323                 self._itemView.activated.connect(self._on_row_activated)
 324
 325                 self._layout = QtGui.QVBoxLayout()
 326                 self._layout.addLayout(self._managerLayout)
 327                 self._layout.addWidget(self._itemView)
 328                 self._widget = QtGui.QWidget()
 329                 self._widget.setLayout(self._layout)
 330
 331                 self._actionIcon = {
 332                         "Placed": self._app.get_icon("placed.png"),
 333                         "Missed": self._app.get_icon("missed.png"),
 334                         "Received": self._app.get_icon("received.png"),
 335                 }
 336
 337                 self._populate_items()
 338
 339         @property
 340         def toplevel(self):
 341                 return self._widget
 342
 343         def enable(self):
 344                 self._itemView.setEnabled(True)
 345
 346         def disable(self):
 347                 self._itemView.setEnabled(False)
 348
 349         def get_settings(self):
 350                 return {
 351                         "filter": self._selectedFilter,
 352                 }
 353
 354         def set_settings(self, settings):
 355                 selectedFilter = settings.get("filter", self.HISTORY_ITEM_TYPES[-1])
 356                 if selectedFilter in self.HISTORY_ITEM_TYPES:
 357                         self._selectedFilter = selectedFilter
 358                         self._typeSelection.setCurrentIndex(
 359                                 self.HISTORY_ITEM_TYPES.index(selectedFilter)
 360                         )
 361
 362         def clear(self):
 363                 self._itemView.clear()
 364
 365         def refresh(self, force=True):
 366                 self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
 367
 368                 if self._selectedFilter == self.HISTORY_RECEIVED:
 369                         self._session.update_history(self._session.HISTORY_RECEIVED, force)
 370                 elif self._selectedFilter == self.HISTORY_MISSED:
 371                         self._session.update_history(self._session.HISTORY_MISSED, force)
 372                 elif self._selectedFilter == self.HISTORY_PLACED:
 373                         self._session.update_history(self._session.HISTORY_PLACED, force)
 374                 elif self._selectedFilter == self.HISTORY_ALL:
 375                         self._session.update_history(self._session.HISTORY_ALL, force)
 376                 else:
 377                         assert False, "How did we get here?"
 378
 379                 if self._app.notifyOnMissed and self._app.alarmHandler.alarmType != self._app.alarmHandler.ALARM_NONE:
 380                         self._app.ledHandler.off()
 381
 382         def _populate_items(self):
 383                 self._categoryManager.prepare_for_update(self._session.get_when_history_updated())
 384
 385                 history = self._session.get_history()
 386                 history.sort(key=lambda item: item["time"], reverse=True)
 387                 for event in history:
 388                         if self._selectedFilter not in [self.HISTORY_ITEM_TYPES[-1], event["action"]]:
 389                                 continue
 390
 391                         relTime = event["relTime"]
 392                         action = event["action"]
 393                         number = event["number"]
 394                         prettyNumber = misc_utils.make_pretty(number)
 395                         if prettyNumber.startswith("+1 "):
 396                                 prettyNumber = prettyNumber[len("+1 "):]
 397                         name = event["name"]
 398                         if not name or name == number:
 399                                 name = event["location"]
 400                         if not name:
 401                                 name = "Unknown"
 402
 403                         detailsItem = QtGui.QStandardItem(self._actionIcon[action], "%s\n%s" % (prettyNumber, relTime))
 404                         detailsFont = detailsItem.font()
 405                         detailsFont.setPointSize(max(detailsFont.pointSize() - 6, 5))
 406                         detailsItem.setFont(detailsFont)
 407                         nameItem = QtGui.QStandardItem(name)
 408                         nameFont = nameItem.font()
 409                         nameFont.setPointSize(nameFont.pointSize() + 4)
 410                         nameItem.setFont(nameFont)
 411                         row = detailsItem, nameItem
 412                         for item in row:
 413                                 item.setEditable(False)
 414                                 item.setCheckable(False)
 415                         row[self.DETAILS_IDX].setData(event)
 416                         self._categoryManager.add_row(event["time"], row)
 417                 self._itemView.expandAll()
 418
 419         @qt_compat.Slot(str)
 420         @misc_utils.log_exception(_moduleLogger)
 421         def _on_filter_changed(self, newItem):
 422                 with qui_utils.notify_error(self._errorLog):
 423                         self._selectedFilter = str(newItem)
 424                         self._populate_items()
 425
 426         @qt_compat.Slot()
 427         @misc_utils.log_exception(_moduleLogger)
 428         def _on_history_updated(self):
 429                 with qui_utils.notify_error(self._errorLog):
 430                         self._populate_items()
 431
 432         @qt_compat.Slot()
 433         @misc_utils.log_exception(_moduleLogger)
 434         def _on_refresh_clicked(self, arg = None):
 435                 with qui_utils.notify_error(self._errorLog):
 436                         self.refresh(force=True)
 437
 438         @qt_compat.Slot(QtCore.QModelIndex)
 439         @misc_utils.log_exception(_moduleLogger)
 440         def _on_row_activated(self, index):
 441                 with qui_utils.notify_error(self._errorLog):
 442                         timeIndex = index.parent()
 443                         if not timeIndex.isValid():
 444                                 return
 445                         timeRow = timeIndex.row()
 446                         row = index.row()
 447                         detailsItem = self._categoryManager.get_item(timeRow, row, self.DETAILS_IDX)
 448                         fromItem = self._categoryManager.get_item(timeRow, row, self.FROM_IDX)
 449                         contactDetails = detailsItem.data()
 450
 451                         title = unicode(fromItem.text())
 452                         number = str(contactDetails["number"])
 453                         contactId = number # ids don't seem too unique so using numbers
 454
 455                         descriptionRows = []
 456                         for t in xrange(self._itemStore.rowCount()):
 457                                 randomTimeItem = self._itemStore.item(t, 0)
 458                                 for i in xrange(randomTimeItem.rowCount()):
 459                                         iItem = randomTimeItem.child(i, 0)
 460                                         iContactDetails = iItem.data()
 461                                         iNumber = str(iContactDetails["number"])
 462                                         if number != iNumber:
 463                                                 continue
 464                                         relTime = misc_utils.abbrev_relative_date(iContactDetails["relTime"])
 465                                         action = str(iContactDetails["action"])
 466                                         number = str(iContactDetails["number"])
 467                                         prettyNumber = misc_utils.make_pretty(number)
 468                                         rowItems = relTime, action, prettyNumber
 469                                         descriptionRows.append("<tr><td>%s</td></tr>" % "</td><td>".join(rowItems))
 470                         description = "<table>%s</table>" % "".join(descriptionRows)
 471                         numbersWithDescriptions = [(str(contactDetails["number"]), "")]
 472                         self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
 473
 474
 475 class Messages(object):
 476
 477         NO_MESSAGES = "None"
 478         VOICEMAIL_MESSAGES = "Voicemail"
 479         TEXT_MESSAGES = "SMS"
 480         ALL_TYPES = "All Messages"
 481         MESSAGE_TYPES = [NO_MESSAGES, VOICEMAIL_MESSAGES, TEXT_MESSAGES, ALL_TYPES]
 482
 483         UNREAD_STATUS = "Unread"
 484         UNARCHIVED_STATUS = "Inbox"
 485         ALL_STATUS = "Any"
 486         MESSAGE_STATUSES = [UNREAD_STATUS, UNARCHIVED_STATUS, ALL_STATUS]
 487
 488         _MIN_MESSAGES_SHOWN = 1
 489
 490         def __init__(self, app, session, errorLog):
 491                 self._selectedTypeFilter = self.ALL_TYPES
 492                 self._selectedStatusFilter = self.ALL_STATUS
 493                 self._app = app
 494                 self._session = session
 495                 self._session.messagesUpdated.connect(self._on_messages_updated)
 496                 self._errorLog = errorLog
 497
 498                 self._typeSelection = QtGui.QComboBox()
 499                 self._typeSelection.addItems(self.MESSAGE_TYPES)
 500                 self._typeSelection.setCurrentIndex(
 501                         self.MESSAGE_TYPES.index(self._selectedTypeFilter)
 502                 )
 503                 self._typeSelection.currentIndexChanged[str].connect(self._on_type_filter_changed)
 504
 505                 self._statusSelection = QtGui.QComboBox()
 506                 self._statusSelection.addItems(self.MESSAGE_STATUSES)
 507                 self._statusSelection.setCurrentIndex(
 508                         self.MESSAGE_STATUSES.index(self._selectedStatusFilter)
 509                 )
 510                 self._statusSelection.currentIndexChanged[str].connect(self._on_status_filter_changed)
 511
 512                 refreshIcon = qui_utils.get_theme_icon(
 513                         ("view-refresh", "general_refresh", "gtk-refresh", ),
 514                         _SENTINEL_ICON
 515                 )
 516                 if refreshIcon is not _SENTINEL_ICON:
 517                         self._refreshButton = QtGui.QPushButton(refreshIcon, "")
 518                 else:
 519                         self._refreshButton = QtGui.QPushButton("Refresh")
 520                 self._refreshButton.clicked.connect(self._on_refresh_clicked)
 521                 self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
 522                         QtGui.QSizePolicy.Minimum,
 523                         QtGui.QSizePolicy.Minimum,
 524                         QtGui.QSizePolicy.PushButton,
 525                 ))
 526
 527                 self._selectionLayout = QtGui.QHBoxLayout()
 528                 self._selectionLayout.addWidget(self._typeSelection, 1000)
 529                 self._selectionLayout.addWidget(self._statusSelection, 1000)
 530                 self._selectionLayout.addWidget(self._refreshButton, 0)
 531
 532                 self._itemStore = QtGui.QStandardItemModel()
 533                 self._itemStore.setHorizontalHeaderLabels(["Messages"])
 534                 self._categoryManager = TimeCategories(self._itemStore)
 535
 536                 self._htmlDelegate = qui_utils.QHtmlDelegate()
 537                 self._itemView = QtGui.QTreeView()
 538                 self._itemView.setModel(self._itemStore)
 539                 self._itemView.setUniformRowHeights(False)
 540                 self._itemView.setRootIsDecorated(False)
 541                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 542                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 543                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 544                 self._itemView.setHeaderHidden(True)
 545                 self._itemView.setItemsExpandable(False)
 546                 self._itemView.setItemDelegate(self._htmlDelegate)
 547                 self._itemView.activated.connect(self._on_row_activated)
 548                 self._itemView.header().sectionResized.connect(self._on_column_resized)
 549
 550                 self._layout = QtGui.QVBoxLayout()
 551                 self._layout.addLayout(self._selectionLayout)
 552                 self._layout.addWidget(self._itemView)
 553                 self._widget = QtGui.QWidget()
 554                 self._widget.setLayout(self._layout)
 555
 556                 self._populate_items()
 557
 558         @property
 559         def toplevel(self):
 560                 return self._widget
 561
 562         def enable(self):
 563                 self._itemView.setEnabled(True)
 564
 565         def disable(self):
 566                 self._itemView.setEnabled(False)
 567
 568         def get_settings(self):
 569                 return {
 570                         "type": self._selectedTypeFilter,
 571                         "status": self._selectedStatusFilter,
 572                 }
 573
 574         def set_settings(self, settings):
 575                 selectedType = settings.get("type", self.ALL_TYPES)
 576                 if selectedType in self.MESSAGE_TYPES:
 577                         self._selectedTypeFilter = selectedType
 578                         self._typeSelection.setCurrentIndex(
 579                                 self.MESSAGE_TYPES.index(self._selectedTypeFilter)
 580                         )
 581
 582                 selectedStatus = settings.get("status", self.ALL_STATUS)
 583                 if selectedStatus in self.MESSAGE_STATUSES:
 584                         self._selectedStatusFilter = selectedStatus
 585                         self._statusSelection.setCurrentIndex(
 586                                 self.MESSAGE_STATUSES.index(self._selectedStatusFilter)
 587                         )
 588
 589         def clear(self):
 590                 self._itemView.clear()
 591
 592         def refresh(self, force=True):
 593                 self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
 594
 595                 if self._selectedTypeFilter == self.NO_MESSAGES:
 596                         pass
 597                 elif self._selectedTypeFilter == self.TEXT_MESSAGES:
 598                         self._session.update_messages(self._session.MESSAGE_TEXTS, force)
 599                 elif self._selectedTypeFilter == self.VOICEMAIL_MESSAGES:
 600                         self._session.update_messages(self._session.MESSAGE_VOICEMAILS, force)
 601                 elif self._selectedTypeFilter == self.ALL_TYPES:
 602                         self._session.update_messages(self._session.MESSAGE_ALL, force)
 603                 else:
 604                         assert False, "How did we get here?"
 605
 606                 if (self._app.notifyOnSms or self._app.notifyOnVoicemail) and self._app.alarmHandler.alarmType != self._app.alarmHandler.ALARM_NONE:
 607                         self._app.ledHandler.off()
 608
 609         def _populate_items(self):
 610                 self._categoryManager.prepare_for_update(self._session.get_when_messages_updated())
 611
 612                 rawMessages = self._session.get_messages()
 613                 rawMessages.sort(key=lambda item: item["time"], reverse=True)
 614                 for item in rawMessages:
 615                         isUnarchived = not item["isArchived"]
 616                         isUnread = not item["isRead"]
 617                         visibleStatus = {
 618                                 self.UNREAD_STATUS: isUnarchived and isUnread,
 619                                 self.UNARCHIVED_STATUS: isUnarchived,
 620                                 self.ALL_STATUS: True,
 621                         }[self._selectedStatusFilter]
 622                         visibleType = self._selectedTypeFilter in [item["type"], self.ALL_TYPES]
 623                         if not (visibleType and visibleStatus):
 624                                 continue
 625
 626                         relTime = misc_utils.abbrev_relative_date(item["relTime"])
 627                         number = item["number"]
 628                         prettyNumber = misc_utils.make_pretty(number)
 629                         name = item["name"]
 630                         if not name or name == number:
 631                                 name = item["location"]
 632                         if not name:
 633                                 name = "Unknown"
 634
 635                         messageParts = list(item["messageParts"])
 636                         if len(messageParts) == 0:
 637                                 messages = ("No Transcription", )
 638                         elif len(messageParts) == 1:
 639                                 if messageParts[0][1]:
 640                                         messages = (messageParts[0][1], )
 641                                 else:
 642                                         messages = ("No Transcription", )
 643                         else:
 644                                 messages = [
 645                                         "<b>%s</b>: %s" % (messagePart[0], messagePart[1])
 646                                         for messagePart in messageParts
 647                                 ]
 648
 649                         firstMessage = "<b>%s<br/>%s</b> <i>(%s)</i>" % (name, prettyNumber, relTime)
 650
 651                         expandedMessages = [firstMessage]
 652                         expandedMessages.extend(messages)
 653                         if self._MIN_MESSAGES_SHOWN < len(messages):
 654                                 secondMessage = "<i>%d Messages Hidden...</i>" % (len(messages) - self._MIN_MESSAGES_SHOWN, )
 655                                 collapsedMessages = [firstMessage, secondMessage]
 656                                 collapsedMessages.extend(messages[-(self._MIN_MESSAGES_SHOWN+0):])
 657                         else:
 658                                 collapsedMessages = expandedMessages
 659
 660                         item = dict(item.iteritems())
 661                         item["collapsedMessages"] = "<br/>\n".join(collapsedMessages)
 662                         item["expandedMessages"] = "<br/>\n".join(expandedMessages)
 663
 664                         messageItem = QtGui.QStandardItem(item["collapsedMessages"])
 665                         messageItem.setData(item)
 666                         messageItem.setEditable(False)
 667                         messageItem.setCheckable(False)
 668                         row = (messageItem, )
 669                         self._categoryManager.add_row(item["time"], row)
 670                 self._itemView.expandAll()
 671
 672         @qt_compat.Slot(str)
 673         @misc_utils.log_exception(_moduleLogger)
 674         def _on_type_filter_changed(self, newItem):
 675                 with qui_utils.notify_error(self._errorLog):
 676                         self._selectedTypeFilter = str(newItem)
 677                         self._populate_items()
 678
 679         @qt_compat.Slot(str)
 680         @misc_utils.log_exception(_moduleLogger)
 681         def _on_status_filter_changed(self, newItem):
 682                 with qui_utils.notify_error(self._errorLog):
 683                         self._selectedStatusFilter = str(newItem)
 684                         self._populate_items()
 685
 686         @qt_compat.Slot()
 687         @misc_utils.log_exception(_moduleLogger)
 688         def _on_refresh_clicked(self, arg = None):
 689                 with qui_utils.notify_error(self._errorLog):
 690                         self.refresh(force=True)
 691
 692         @qt_compat.Slot()
 693         @misc_utils.log_exception(_moduleLogger)
 694         def _on_messages_updated(self):
 695                 with qui_utils.notify_error(self._errorLog):
 696                         self._populate_items()
 697
 698         @qt_compat.Slot(QtCore.QModelIndex)
 699         @misc_utils.log_exception(_moduleLogger)
 700         def _on_row_activated(self, index):
 701                 with qui_utils.notify_error(self._errorLog):
 702                         timeIndex = index.parent()
 703                         if not timeIndex.isValid():
 704                                 return
 705                         timeRow = timeIndex.row()
 706                         row = index.row()
 707                         item = self._categoryManager.get_item(timeRow, row, 0)
 708                         contactDetails = item.data()
 709
 710                         name = unicode(contactDetails["name"])
 711                         number = str(contactDetails["number"])
 712                         if not name or name == number:
 713                                 name = unicode(contactDetails["location"])
 714                         if not name:
 715                                 name = "Unknown"
 716
 717                         if str(contactDetails["type"]) == "Voicemail":
 718                                 messageId = str(contactDetails["id"])
 719                         else:
 720                                 messageId = None
 721                         contactId = str(contactDetails["contactId"])
 722                         title = name
 723                         description = unicode(contactDetails["expandedMessages"])
 724                         numbersWithDescriptions = [(number, "")]
 725                         self._session.draft.add_contact(contactId, messageId, title, description, numbersWithDescriptions)
 726
 727         @qt_compat.Slot(QtCore.QModelIndex)
 728         @misc_utils.log_exception(_moduleLogger)
 729         def _on_column_resized(self, index, oldSize, newSize):
 730                 self._htmlDelegate.setWidth(newSize, self._itemStore)
 731
 732
 733 class Contacts(object):
 734
 735         # @todo Provide some sort of letter jump
 736
 737         def __init__(self, app, session, errorLog):
 738                 self._app = app
 739                 self._session = session
 740                 self._session.accountUpdated.connect(self._on_contacts_updated)
 741                 self._errorLog = errorLog
 742                 self._addressBookFactories = [
 743                         null_backend.NullAddressBookFactory(),
 744                         file_backend.FilesystemAddressBookFactory(app.fsContactsPath),
 745                         qt_backend.QtContactsAddressBookFactory(),
 746                 ]
 747                 self._addressBooks = []
 748
 749                 self._listSelection = QtGui.QComboBox()
 750                 self._listSelection.addItems([])
 751                 self._listSelection.currentIndexChanged[str].connect(self._on_filter_changed)
 752                 self._activeList = "None"
 753                 refreshIcon = qui_utils.get_theme_icon(
 754                         ("view-refresh", "general_refresh", "gtk-refresh", ),
 755                         _SENTINEL_ICON
 756                 )
 757                 if refreshIcon is not _SENTINEL_ICON:
 758                         self._refreshButton = QtGui.QPushButton(refreshIcon, "")
 759                 else:
 760                         self._refreshButton = QtGui.QPushButton("Refresh")
 761                 self._refreshButton.clicked.connect(self._on_refresh_clicked)
 762                 self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
 763                         QtGui.QSizePolicy.Minimum,
 764                         QtGui.QSizePolicy.Minimum,
 765                         QtGui.QSizePolicy.PushButton,
 766                 ))
 767                 self._managerLayout = QtGui.QHBoxLayout()
 768                 self._managerLayout.addWidget(self._listSelection, 1000)
 769                 self._managerLayout.addWidget(self._refreshButton, 0)
 770
 771                 self._itemStore = QtGui.QStandardItemModel()
 772                 self._itemStore.setHorizontalHeaderLabels(["Contacts"])
 773                 self._alphaItem = {}
 774
 775                 self._itemView = QtGui.QTreeView()
 776                 self._itemView.setModel(self._itemStore)
 777                 self._itemView.setUniformRowHeights(True)
 778                 self._itemView.setRootIsDecorated(False)
 779                 self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
 780                 self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
 781                 self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
 782                 self._itemView.setHeaderHidden(True)
 783                 self._itemView.setItemsExpandable(False)
 784                 self._itemView.activated.connect(self._on_row_activated)
 785
 786                 self._layout = QtGui.QVBoxLayout()
 787                 self._layout.addLayout(self._managerLayout)
 788                 self._layout.addWidget(self._itemView)
 789                 self._widget = QtGui.QWidget()
 790                 self._widget.setLayout(self._layout)
 791
 792                 self.update_addressbooks()
 793                 self._populate_items()
 794
 795         @property
 796         def toplevel(self):
 797                 return self._widget
 798
 799         def enable(self):
 800                 self._itemView.setEnabled(True)
 801
 802         def disable(self):
 803                 self._itemView.setEnabled(False)
 804
 805         def get_settings(self):
 806                 return {
 807                         "selectedAddressbook": self._activeList,
 808                 }
 809
 810         def set_settings(self, settings):
 811                 currentItem = settings.get("selectedAddressbook", "None")
 812                 bookNames = [book["name"] for book in self._addressBooks]
 813                 try:
 814                         newIndex = bookNames.index(currentItem)
 815                 except ValueError:
 816                         # Switch over to None for the user
 817                         newIndex = 0
 818                 self._listSelection.setCurrentIndex(newIndex)
 819                 self._activeList = currentItem
 820
 821         def clear(self):
 822                 self._itemView.clear()
 823
 824         def refresh(self, force=True):
 825                 self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
 826                 self._backend.update_account(force)
 827
 828         @property
 829         def _backend(self):
 830                 return self._addressBooks[self._listSelection.currentIndex()]["book"]
 831
 832         def update_addressbooks(self):
 833                 self._addressBooks = [
 834                         {"book": book, "name": book.name}
 835                         for factory in self._addressBookFactories
 836                         for book in factory.get_addressbooks()
 837                 ]
 838                 self._addressBooks.append(
 839                         {
 840                                 "book": self._session,
 841                                 "name": "Google Voice",
 842                         }
 843                 )
 844
 845                 currentItem = str(self._listSelection.currentText())
 846                 self._activeList = currentItem
 847                 if currentItem == "":
 848                         # Not loaded yet
 849                         currentItem = "None"
 850                 self._listSelection.clear()
 851                 bookNames = [book["name"] for book in self._addressBooks]
 852                 try:
 853                         newIndex = bookNames.index(currentItem)
 854                 except ValueError:
 855                         # Switch over to None for the user
 856                         newIndex = 0
 857                         self._itemStore.clear()
 858                         _moduleLogger.info("Addressbook %r doesn't exist anymore, switching to None" % currentItem)
 859                 self._listSelection.addItems(bookNames)
 860                 self._listSelection.setCurrentIndex(newIndex)
 861
 862         def _populate_items(self):
 863                 self._itemStore.clear()
 864                 self._alphaItem = dict(
 865                         (letter, QtGui.QStandardItem(letter))
 866                         for letter in self._prefixes()
 867                 )
 868                 for letter in self._prefixes():
 869                         item = self._alphaItem[letter]
 870                         item.setEditable(False)
 871                         item.setCheckable(False)
 872                         row = (item, )
 873                         self._itemStore.appendRow(row)
 874
 875                 for item in self._get_contacts():
 876                         name = item["name"]
 877                         if not name:
 878                                 name = "Unknown"
 879                         numbers = item["numbers"]
 880
 881                         nameItem = QtGui.QStandardItem(name)
 882                         nameItem.setEditable(False)
 883                         nameItem.setCheckable(False)
 884                         nameItem.setData(item)
 885                         nameItemFont = nameItem.font()
 886                         nameItemFont.setPointSize(max(nameItemFont.pointSize() + 4, 5))
 887                         nameItem.setFont(nameItemFont)
 888
 889                         row = (nameItem, )
 890                         rowKey = name[0].upper()
 891                         rowKey = rowKey if rowKey in self._alphaItem else "#"
 892                         self._alphaItem[rowKey].appendRow(row)
 893                 self._itemView.expandAll()
 894
 895         def _prefixes(self):
 896                 return itertools.chain(string.ascii_uppercase, ("#", ))
 897
 898         def _jump_to_prefix(self, letter):
 899                 i = list(self._prefixes()).index(letter)
 900                 rootIndex = self._itemView.rootIndex()
 901                 currentIndex = self._itemView.model().index(i, 0, rootIndex)
 902                 self._itemView.scrollTo(currentIndex)
 903                 self._itemView.setItemSelected(self._itemView.topLevelItem(i), True)
 904
 905         def _get_contacts(self):
 906                 contacts = list(self._backend.get_contacts().itervalues())
 907                 contacts.sort(key=lambda contact: contact["name"].lower())
 908                 return contacts
 909
 910         @qt_compat.Slot(str)
 911         @misc_utils.log_exception(_moduleLogger)
 912         def _on_filter_changed(self, newItem):
 913                 with qui_utils.notify_error(self._errorLog):
 914                         self._activeList = str(newItem)
 915                         self.refresh(force=False)
 916                         self._populate_items()
 917
 918         @qt_compat.Slot()
 919         @misc_utils.log_exception(_moduleLogger)
 920         def _on_refresh_clicked(self, arg = None):
 921                 with qui_utils.notify_error(self._errorLog):
 922                         self.refresh(force=True)
 923
 924         @qt_compat.Slot()
 925         @misc_utils.log_exception(_moduleLogger)
 926         def _on_contacts_updated(self):
 927                 with qui_utils.notify_error(self._errorLog):
 928                         self._populate_items()
 929
 930         @qt_compat.Slot(QtCore.QModelIndex)
 931         @misc_utils.log_exception(_moduleLogger)
 932         def _on_row_activated(self, index):
 933                 with qui_utils.notify_error(self._errorLog):
 934                         letterIndex = index.parent()
 935                         if not letterIndex.isValid():
 936                                 return
 937                         letterRow = letterIndex.row()
 938                         letter = list(self._prefixes())[letterRow]
 939                         letterItem = self._alphaItem[letter]
 940                         rowIndex = index.row()
 941                         item = letterItem.child(rowIndex, 0)
 942                         contactDetails = item.data()
 943
 944                         name = unicode(contactDetails["name"])
 945                         if not name:
 946                                 name = unicode(contactDetails["location"])
 947                         if not name:
 948                                 name = "Unknown"
 949
 950                         contactId = str(contactDetails["contactId"])
 951                         numbers = contactDetails["numbers"]
 952                         numbers = [
 953                                 dict(
 954                                         (str(k), str(v))
 955                                         for (k, v) in number.iteritems()
 956                                 )
 957                                 for number in numbers
 958                         ]
 959                         numbersWithDescriptions = [
 960                                 (
 961                                         number["phoneNumber"],
 962                                         self._choose_phonetype(number),
 963                                 )
 964                                 for number in numbers
 965                         ]
 966                         title = name
 967                         description = name
 968                         self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
 969
 970         @staticmethod
 971         def _choose_phonetype(numberDetails):
 972                 if "phoneTypeName" in numberDetails:
 973                         return numberDetails["phoneTypeName"]
 974                 elif "phoneType" in numberDetails:
 975                         return numberDetails["phoneType"]
 976                 else:
 977                         return ""