#!/usr/bin/env python
-"""
-DialCentral - Front end for Google's GoogleVoice service.
-Copyright (C) 2008 Mark Bergman bergman AT merctech DOT com
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-
-@todo Collapse voicemails
-"""
-
from __future__ import with_statement
+from __future__ import division
-import re
-import ConfigParser
+import datetime
+import string
import itertools
import logging
-import gobject
-import pango
-import gtk
-
-import gtk_toolbox
-import hildonize
-from backends import gv_backend
-from backends import null_backend
-
-
-_moduleLogger = logging.getLogger("gv_views")
-
-
-def make_ugly(prettynumber):
- """
- function to take a phone number and strip out all non-numeric
- characters
-
- >>> make_ugly("+012-(345)-678-90")
- '+01234567890'
- """
- return normalize_number(prettynumber)
-
-
-def normalize_number(prettynumber):
- """
- function to take a phone number and strip out all non-numeric
- characters
-
- >>> normalize_number("+012-(345)-678-90")
- '+01234567890'
- >>> normalize_number("1-(345)-678-9000")
- '13456789000'
- >>> normalize_number("+1-(345)-678-9000")
- '+13456789000'
- """
- uglynumber = re.sub('[^0-9+]', '', prettynumber)
-
- return uglynumber
-
-
-def _make_pretty_with_areacodde(phonenumber):
- prettynumber = "(%s)" % (phonenumber[0:3], )
- if 3 < len(phonenumber):
- prettynumber += " %s" % (phonenumber[3:6], )
- if 6 < len(phonenumber):
- prettynumber += "-%s" % (phonenumber[6:], )
- return prettynumber
-
-
-def _make_pretty_local(phonenumber):
- prettynumber = "%s" % (phonenumber[0:3], )
- if 3 < len(phonenumber):
- prettynumber += "-%s" % (phonenumber[3:], )
- return prettynumber
-
-
-def _make_pretty_international(phonenumber):
- prettynumber = phonenumber
- if phonenumber.startswith("0"):
- prettynumber = "+%s " % (phonenumber[0:3], )
- if 3 < len(phonenumber):
- prettynumber += _make_pretty_with_areacodde(phonenumber[3:])
- if phonenumber.startswith("1"):
- prettynumber = "1 "
- prettynumber += _make_pretty_with_areacodde(phonenumber[1:])
- return prettynumber
-
-
-def make_pretty(phonenumber):
- """
- Function to take a phone number and return the pretty version
- pretty numbers:
- if phonenumber begins with 0:
- ...-(...)-...-....
- if phonenumber begins with 1: ( for gizmo callback numbers )
- 1 (...)-...-....
- if phonenumber is 13 digits:
- (...)-...-....
- if phonenumber is 10 digits:
- ...-....
- >>> make_pretty("12")
- '12'
- >>> make_pretty("1234567")
- '123-4567'
- >>> make_pretty("2345678901")
- '+1 (234) 567-8901'
- >>> make_pretty("12345678901")
- '+1 (234) 567-8901'
- >>> make_pretty("01234567890")
- '+012 (345) 678-90'
- >>> make_pretty("+01234567890")
- '+012 (345) 678-90'
- >>> make_pretty("+12")
- '+1 (2)'
- >>> make_pretty("+123")
- '+1 (23)'
- >>> make_pretty("+1234")
- '+1 (234)'
- """
- if phonenumber is None or phonenumber is "":
- return ""
-
- phonenumber = normalize_number(phonenumber)
-
- if phonenumber[0] == "+":
- prettynumber = _make_pretty_international(phonenumber[1:])
- if not prettynumber.startswith("+"):
- prettynumber = "+"+prettynumber
- elif 8 < len(phonenumber) and phonenumber[0] in ("0", "1"):
- prettynumber = _make_pretty_international(phonenumber)
- elif 7 < len(phonenumber):
- prettynumber = _make_pretty_with_areacodde(phonenumber)
- elif 3 < len(phonenumber):
- prettynumber = _make_pretty_local(phonenumber)
- else:
- prettynumber = phonenumber
- return prettynumber.strip()
-
-
-def abbrev_relative_date(date):
- """
- >>> abbrev_relative_date("42 hours ago")
- '42 h'
- >>> abbrev_relative_date("2 days ago")
- '2 d'
- >>> abbrev_relative_date("4 weeks ago")
- '4 w'
- """
- parts = date.split(" ")
- return "%s %s" % (parts[0], parts[1][0])
-
-
-def _collapse_message(messageLines, maxCharsPerLine, maxLines):
- lines = 0
-
- numLines = len(messageLines)
- for line in messageLines[0:min(maxLines, numLines)]:
- linesPerLine = max(1, int(len(line) / maxCharsPerLine))
- allowedLines = maxLines - lines
- acceptedLines = min(allowedLines, linesPerLine)
- acceptedChars = acceptedLines * maxCharsPerLine
-
- if acceptedChars < (len(line) + 3):
- suffix = "..."
- else:
- acceptedChars = len(line) # eh, might as well complete the line
- suffix = ""
- abbrevMessage = "%s%s" % (line[0:acceptedChars], suffix)
- yield abbrevMessage
-
- lines += acceptedLines
- if maxLines <= lines:
- break
-
-
-def collapse_message(message, maxCharsPerLine, maxLines):
- r"""
- >>> collapse_message("Hello", 60, 2)
- 'Hello'
- >>> collapse_message("Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789", 60, 2)
- 'Hello world how are you doing today? 01234567890123456789012...'
- >>> collapse_message('''Hello world how are you doing today?
- ... 01234567890123456789
- ... 01234567890123456789
- ... 01234567890123456789
- ... 01234567890123456789''', 60, 2)
- 'Hello world how are you doing today?\n01234567890123456789'
- >>> collapse_message('''
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789
- ... Hello world how are you doing today? 01234567890123456789012345678901234567890123456789012345678901234567890123456789''', 60, 2)
- '\nHello world how are you doing today? 01234567890123456789012...'
- """
- messageLines = message.split("\n")
- return "\n".join(_collapse_message(messageLines, maxCharsPerLine, maxLines))
-
-
-def _get_contact_numbers(backend, contactId, number):
- if contactId:
- contactPhoneNumbers = list(backend.get_contact_details(contactId))
- uglyContactNumbers = (
- make_ugly(contactNumber)
- for (numberDescription, contactNumber) in contactPhoneNumbers
- )
- defaultMatches = [
- (
- number == contactNumber or
- number[1:] == contactNumber and number.startswith("1") or
- number[2:] == contactNumber and number.startswith("+1") or
- number == contactNumber[1:] and contactNumber.startswith("1") or
- number == contactNumber[2:] and contactNumber.startswith("+1")
- )
- for contactNumber in uglyContactNumbers
- ]
- try:
- defaultIndex = defaultMatches.index(True)
- except ValueError:
- contactPhoneNumbers.append(("Other", number))
- defaultIndex = len(contactPhoneNumbers)-1
- _moduleLogger.warn(
- "Could not find contact %r's number %s among %r" % (
- contactId, number, contactPhoneNumbers
- )
- )
- else:
- contactPhoneNumbers = [("Phone", number)]
- defaultIndex = -1
-
- return contactPhoneNumbers, defaultIndex
-
-
-class SmsEntryWindow(object):
-
- MAX_CHAR = 160
-
- def __init__(self, widgetTree, parent, app):
- self._clipboard = gtk.clipboard_get()
- self._widgetTree = widgetTree
- self._window = self._widgetTree.get_widget("smsWindow")
- self._window.connect("delete-event", self._on_delete)
- self._window.connect("key-press-event", self._on_key_press)
- self._window.connect("window-state-event", self._on_window_state_change)
- self._isFullScreen = False
- self._parent = parent
-
- errorBox = self._widgetTree.get_widget("smsErrorEventBox")
- errorDescription = self._widgetTree.get_widget("smsErrorDescription")
- errorClose = self._widgetTree.get_widget("smsErrorClose")
- self._errorDisplay = gtk_toolbox.ErrorDisplay(errorBox, errorDescription, errorClose)
-
- self._smsButton = self._widgetTree.get_widget("sendSmsButton")
- self._smsButton.connect("clicked", self._on_send)
- self._dialButton = self._widgetTree.get_widget("dialButton")
- self._dialButton.connect("clicked", self._on_dial)
-
- self._letterCountLabel = self._widgetTree.get_widget("smsLetterCount")
-
- self._messagemodel = gtk.ListStore(gobject.TYPE_STRING)
- self._messagesView = self._widgetTree.get_widget("smsMessages")
-
- textrenderer = gtk.CellRendererText()
- textrenderer.set_property("wrap-mode", pango.WRAP_WORD)
- textrenderer.set_property("wrap-width", 450)
- messageColumn = gtk.TreeViewColumn("")
- messageColumn.pack_start(textrenderer, expand=True)
- messageColumn.add_attribute(textrenderer, "markup", 0)
- messageColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
- self._messagesView.append_column(messageColumn)
- self._messagesView.set_headers_visible(False)
- self._messagesView.set_model(self._messagemodel)
- self._messagesView.set_fixed_height_mode(False)
-
- self._conversationView = self._messagesView.get_parent()
- self._conversationViewPort = self._conversationView.get_parent()
- self._scrollWindow = self._conversationViewPort.get_parent()
-
- self._targetList = self._widgetTree.get_widget("smsTargetList")
- self._phoneButton = self._widgetTree.get_widget("phoneTypeSelection")
- self._phoneButton.connect("clicked", self._on_phone)
- self._smsEntry = self._widgetTree.get_widget("smsEntry")
- self._smsEntry.get_buffer().connect("changed", self._on_entry_changed)
- self._smsEntrySize = None
-
- self._app = app
- self._window = hildonize.hildonize_window(self._app, self._window)
-
- self._contacts = []
-
- def add_contact(self, name, contactDetails, messages = (), defaultIndex = -1):
- contactNumbers = list(self._to_contact_numbers(contactDetails))
- assert contactNumbers
- contactIndex = defaultIndex if defaultIndex != -1 else 0
- contact = contactNumbers, contactIndex, messages
- self._contacts.append(contact)
-
- nameLabel = gtk.Label(name)
- selector = gtk.Button(contactNumbers[0][1])
- if len(contactNumbers) == 1:
- selector.set_sensitive(False)
- removeContact = gtk.Button(stock="gtk-delete")
- row = gtk.HBox()
- row.pack_start(nameLabel, True, True)
- row.pack_start(selector, True, True)
- row.pack_start(removeContact, False, False)
- row.show_all()
- self._targetList.pack_start(row)
- selector.connect("clicked", self._on_choose_phone_n, row)
- removeContact.connect("clicked", self._on_remove_phone_n, row)
- self._update_button_state()
- self._update_context()
-
- parentSize = self._parent.get_size()
- self._window.resize(parentSize[0], max(parentSize[1]-10, 100))
- self._window.show()
- self._window.present()
-
- self._smsEntry.grab_focus()
- dx = self._conversationView.get_allocation().height - self._conversationViewPort.get_allocation().height
- dx = max(dx, 0)
- adjustment = self._scrollWindow.get_vadjustment()
- adjustment.value = dx
-
- def clear(self):
- del self._contacts[:]
-
- for row in list(self._targetList.get_children()):
- self._targetList.remove(row)
- self._smsEntry.get_buffer().set_text("")
- self._update_letter_count()
- self._update_context()
-
- def fullscreen(self):
- self._window.fullscreen()
-
- def unfullscreen(self):
- self._window.unfullscreen()
-
- def _remove_contact(self, contactIndex):
- del self._contacts[contactIndex]
-
- row = list(self._targetList.get_children())[contactIndex]
- self._targetList.remove(row)
- self._update_button_state()
- self._update_context()
-
- def _update_letter_count(self):
- if self._smsEntrySize is None:
- self._smsEntrySize = self._smsEntry.size_request()
- else:
- self._smsEntry.set_size_request(*self._smsEntrySize)
- entryLength = self._smsEntry.get_buffer().get_char_count()
-
- numTexts, numCharInText = divmod(entryLength, self.MAX_CHAR)
- if numTexts:
- self._letterCountLabel.set_text("%s.%s" % (numTexts, numCharInText))
- else:
- self._letterCountLabel.set_text("%s" % (numCharInText, ))
-
- self._update_button_state()
-
- def _update_context(self):
- self._messagemodel.clear()
- if len(self._contacts) == 0:
- self._messagesView.hide()
- self._targetList.hide()
- self._phoneButton.hide()
- self._phoneButton.set_label("Error: You shouldn't see this")
- elif len(self._contacts) == 1:
- contactNumbers, index, messages = self._contacts[0]
- if messages:
- self._messagesView.show()
- for message in messages:
- row = (message, )
- self._messagemodel.append(row)
- messagesSelection = self._messagesView.get_selection()
- messagesSelection.select_path((len(messages)-1, ))
- else:
- self._messagesView.hide()
- self._targetList.hide()
- self._phoneButton.show()
- self._phoneButton.set_label(contactNumbers[index][1])
- if 1 < len(contactNumbers):
- self._phoneButton.set_sensitive(True)
- else:
- self._phoneButton.set_sensitive(False)
- else:
- self._messagesView.hide()
- self._targetList.show()
- self._phoneButton.hide()
- self._phoneButton.set_label("Error: You shouldn't see this")
-
- def _update_button_state(self):
- if len(self._contacts) == 0:
- self._dialButton.set_sensitive(False)
- self._smsButton.set_sensitive(False)
- elif len(self._contacts) == 1:
- entryLength = self._smsEntry.get_buffer().get_char_count()
- if entryLength == 0:
- self._dialButton.set_sensitive(True)
- self._smsButton.set_sensitive(False)
- else:
- self._dialButton.set_sensitive(False)
- self._smsButton.set_sensitive(True)
- else:
- self._dialButton.set_sensitive(False)
- self._smsButton.set_sensitive(True)
-
- def _to_contact_numbers(self, contactDetails):
- for phoneType, phoneNumber in contactDetails:
- display = " - ".join((make_pretty(phoneNumber), phoneType))
- yield (phoneNumber, display)
-
- def _hide(self):
- self.clear()
- self._window.hide()
-
- def _request_number(self, contactIndex):
- contactNumbers, index, messages = self._contacts[contactIndex]
- assert 0 <= index, "%r" % index
-
- index = hildonize.touch_selector(
- self._window,
- "Phone Numbers",
- (description for (number, description) in contactNumbers),
- index,
- )
- self._contacts[contactIndex] = contactNumbers, index, messages
-
- def send_sms(self, numbers, message):
- raise NotImplementedError()
+import util.qt_compat as qt_compat
+QtCore = qt_compat.QtCore
+QtGui = qt_compat.import_module("QtGui")
- def dial(self, number):
- raise NotImplementedError()
-
- def _on_phone(self, *args):
- try:
- assert len(self._contacts) == 1
- self._request_number(0)
-
- contactNumbers, numberIndex, messages = self._contacts[0]
- self._phoneButton.set_label(contactNumbers[numberIndex][1])
- row = list(self._targetList.get_children())[0]
- phoneButton = list(row.get_children())[1]
- phoneButton.set_label(contactNumbers[numberIndex][1])
- except TypeError, e:
- self._errorDisplay.push_exception()
-
- def _on_choose_phone_n(self, button, row):
- try:
- assert 1 < len(self._contacts)
- targetList = list(self._targetList.get_children())
- index = targetList.index(row)
- self._request_number(index)
-
- contactNumbers, numberIndex, messages = self._contacts[0]
- phoneButton = list(row.get_children())[1]
- phoneButton.set_label(contactNumbers[numberIndex][1])
- except TypeError, e:
- self._errorDisplay.push_exception()
-
- def _on_remove_phone_n(self, button, row):
- try:
- assert 1 < len(self._contacts)
- targetList = list(self._targetList.get_children())
- index = targetList.index(row)
-
- del self._contacts[index]
- self._targetList.remove(row)
- self._update_context()
- self._update_button_state()
- except TypeError, e:
- self._errorDisplay.push_exception()
-
- def _on_entry_changed(self, *args):
- try:
- self._update_letter_count()
- except TypeError, e:
- self._errorDisplay.push_exception()
+from util import qtpie
+from util import qui_utils
+from util import misc as misc_utils
- def _on_send(self, *args):
- try:
- assert 0 < len(self._contacts), "%r" % self._contacts
- phoneNumbers = [
- make_ugly(contact[0][contact[1]][0])
- for contact in self._contacts
- ]
+import backends.null_backend as null_backend
+import backends.file_backend as file_backend
+import backends.qt_backend as qt_backend
- entryBuffer = self._smsEntry.get_buffer()
- enteredMessage = entryBuffer.get_text(entryBuffer.get_start_iter(), entryBuffer.get_end_iter())
- enteredMessage = enteredMessage.strip()
- assert enteredMessage
- self.send_sms(phoneNumbers, enteredMessage)
- self._hide()
- except TypeError, e:
- self._errorDisplay.push_exception()
- def _on_dial(self, *args):
- try:
- assert len(self._contacts) == 1, "%r" % self._contacts
- contact = self._contacts[0]
- contactNumber = contact[0][contact[1]][0]
- phoneNumber = make_ugly(contactNumber)
- self.dial(phoneNumber)
- self._hide()
- except TypeError, e:
- self._errorDisplay.push_exception()
-
- def _on_delete(self, *args):
- try:
- self._window.emit_stop_by_name("delete-event")
- self._hide()
- except TypeError, e:
- self._errorDisplay.push_exception()
- return True
+_moduleLogger = logging.getLogger(__name__)
- def _on_window_state_change(self, widget, event, *args):
- try:
- if event.new_window_state & gtk.gdk.WINDOW_STATE_FULLSCREEN:
- self._isFullScreen = True
- else:
- self._isFullScreen = False
- except Exception, e:
- self._errorDisplay.push_exception()
- def _on_key_press(self, widget, event):
- RETURN_TYPES = (gtk.keysyms.Return, gtk.keysyms.ISO_Enter, gtk.keysyms.KP_Enter)
- try:
- if (
- event.keyval == gtk.keysyms.F6 or
- event.keyval in RETURN_TYPES and event.get_state() & gtk.gdk.CONTROL_MASK
- ):
- if self._isFullScreen:
- self._window.unfullscreen()
- else:
- self._window.fullscreen()
- elif event.keyval == ord("c") and event.get_state() & gtk.gdk.CONTROL_MASK:
- message = "\n".join(
- messagePart[0]
- for messagePart in self._messagemodel
- )
- self._clipboard.set_text(str(message))
- elif (
- event.keyval == gtk.keysyms.w and
- event.get_state() & gtk.gdk.CONTROL_MASK
- ):
- self._hide()
- elif (
- event.keyval == gtk.keysyms.q and
- event.get_state() & gtk.gdk.CONTROL_MASK
- ):
- self._parent.destroy()
- except TypeError, e:
- self._errorDisplay.push_exception()
+_SENTINEL_ICON = QtGui.QIcon()
class Dialpad(object):
- def __init__(self, widgetTree, errorDisplay):
- self._clipboard = gtk.clipboard_get()
- self._errorDisplay = errorDisplay
-
- self._numberdisplay = widgetTree.get_widget("numberdisplay")
- self._okButton = widgetTree.get_widget("dialpadOk")
- self._backButton = widgetTree.get_widget("back")
- self._plusButton = widgetTree.get_widget("plus")
- self._phonenumber = ""
- self._prettynumber = ""
-
- callbackMapping = {
- "on_digit_clicked": self._on_digit_clicked,
- }
- widgetTree.signal_autoconnect(callbackMapping)
- self._okButton.connect("clicked", self._on_ok_clicked)
- self._plusButton.connect("clicked", self._on_plus)
-
- self._originalLabel = self._backButton.get_label()
- self._backTapHandler = gtk_toolbox.TapOrHold(self._backButton)
- self._backTapHandler.on_tap = self._on_backspace
- self._backTapHandler.on_hold = self._on_clearall
- self._backTapHandler.on_holding = self._set_clear_button
- self._backTapHandler.on_cancel = self._reset_back_button
-
- self._window = gtk_toolbox.find_parent_window(self._numberdisplay)
- self._keyPressEventId = 0
+ def __init__(self, app, session, errorLog):
+ self._app = app
+ self._session = session
+ self._errorLog = errorLog
+
+ self._plus = QtGui.QPushButton("+")
+ self._plus.clicked.connect(lambda: self._on_keypress("+"))
+ self._entry = QtGui.QLineEdit()
+
+ backAction = QtGui.QAction(None)
+ backAction.setText("Back")
+ backAction.triggered.connect(self._on_backspace)
+ backPieItem = qtpie.QActionPieItem(backAction)
+ clearAction = QtGui.QAction(None)
+ clearAction.setText("Clear")
+ clearAction.triggered.connect(self._on_clear_text)
+ clearPieItem = qtpie.QActionPieItem(clearAction)
+ backSlices = [
+ qtpie.PieFiling.NULL_CENTER,
+ clearPieItem,
+ qtpie.PieFiling.NULL_CENTER,
+ qtpie.PieFiling.NULL_CENTER,
+ ]
+ self._back = qtpie.QPieButton(backPieItem)
+ self._back.set_center(backPieItem)
+ for slice in backSlices:
+ self._back.insertItem(slice)
+
+ self._entryLayout = QtGui.QHBoxLayout()
+ self._entryLayout.addWidget(self._plus, 1, QtCore.Qt.AlignCenter)
+ self._entryLayout.addWidget(self._entry, 1000)
+ self._entryLayout.addWidget(self._back, 1, QtCore.Qt.AlignCenter)
+
+ smsIcon = self._app.get_icon("messages.png")
+ self._smsButton = QtGui.QPushButton(smsIcon, "SMS")
+ self._smsButton.clicked.connect(self._on_sms_clicked)
+ self._smsButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.PushButton,
+ ))
+ callIcon = self._app.get_icon("dialpad.png")
+ self._callButton = QtGui.QPushButton(callIcon, "Call")
+ self._callButton.clicked.connect(self._on_call_clicked)
+ self._callButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.PushButton,
+ ))
+
+ self._padLayout = QtGui.QGridLayout()
+ rows = [0, 0, 0, 1, 1, 1, 2, 2, 2]
+ columns = [0, 1, 2] * 3
+ keys = [
+ ("1", ""),
+ ("2", "ABC"),
+ ("3", "DEF"),
+ ("4", "GHI"),
+ ("5", "JKL"),
+ ("6", "MNO"),
+ ("7", "PQRS"),
+ ("8", "TUV"),
+ ("9", "WXYZ"),
+ ]
+ for (num, letters), (row, column) in zip(keys, zip(rows, columns)):
+ self._padLayout.addWidget(self._generate_key_button(num, letters), row, column)
+ self._zerothButton = QtGui.QPushButton("0")
+ self._zerothButton.clicked.connect(lambda: self._on_keypress("0"))
+ self._zerothButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.PushButton,
+ ))
+ self._padLayout.addWidget(self._smsButton, 3, 0)
+ self._padLayout.addWidget(self._zerothButton)
+ self._padLayout.addWidget(self._callButton, 3, 2)
+
+ self._layout = QtGui.QVBoxLayout()
+ self._layout.addLayout(self._entryLayout, 0)
+ self._layout.addLayout(self._padLayout, 1000000)
+ self._widget = QtGui.QWidget()
+ self._widget.setLayout(self._layout)
+
+ @property
+ def toplevel(self):
+ return self._widget
def enable(self):
- self._okButton.grab_focus()
- self._backTapHandler.enable()
- self._keyPressEventId = self._window.connect("key-press-event", self._on_key_press)
+ self._smsButton.setEnabled(True)
+ self._callButton.setEnabled(True)
def disable(self):
- self._window.disconnect(self._keyPressEventId)
- self._keyPressEventId = 0
- self._reset_back_button()
- self._backTapHandler.disable()
-
- def add_contact(self, *args, **kwds):
- """
- @note Actual dial function is patched in later
- """
- raise NotImplementedError("Horrible unknown error has occurred")
-
- def get_number(self):
- return self._phonenumber
-
- def set_number(self, number):
- """
- Set the number to dial
- """
- try:
- self._phonenumber = make_ugly(number)
- self._prettynumber = make_pretty(self._phonenumber)
- self._numberdisplay.set_label("<span size='30000' weight='bold'>%s</span>" % (self._prettynumber))
- except TypeError, e:
- self._errorDisplay.push_exception()
-
- def clear(self):
- self.set_number("")
+ self._smsButton.setEnabled(False)
+ self._callButton.setEnabled(False)
- @staticmethod
- def name():
- return "Dialpad"
+ def get_settings(self):
+ return {}
- def load_settings(self, config, section):
+ def set_settings(self, settings):
pass
- def save_settings(self, config, section):
- """
- @note Thread Agnostic
- """
- pass
-
- def _on_key_press(self, widget, event):
- try:
- if event.keyval == ord("v") and event.get_state() & gtk.gdk.CONTROL_MASK:
- contents = self._clipboard.wait_for_text()
- if contents is not None:
- self.set_number(contents)
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_ok_clicked(self, widget):
- try:
- phoneNumber = self.get_number()
- self.add_contact(
- "(Dialpad)",
- [("Dialer", phoneNumber)], ()
- )
- self.set_number("")
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_digit_clicked(self, widget):
- try:
- self.set_number(self._phonenumber + widget.get_name()[-1])
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_plus(self, *args):
- try:
- self.set_number(self._phonenumber + "+")
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_backspace(self, taps):
- try:
- self.set_number(self._phonenumber[:-taps])
- self._reset_back_button()
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_clearall(self, taps):
- try:
- self.clear()
- self._reset_back_button()
- except Exception, e:
- self._errorDisplay.push_exception()
- return False
-
- def _set_clear_button(self):
- try:
- self._backButton.set_label("gtk-clear")
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _reset_back_button(self):
- try:
- self._backButton.set_label(self._originalLabel)
- except Exception, e:
- self._errorDisplay.push_exception()
-
-
-class AccountInfo(object):
-
- def __init__(self, widgetTree, backend, alarmHandler, errorDisplay):
- self._errorDisplay = errorDisplay
- self._backend = backend
- self._isPopulated = False
- self._alarmHandler = alarmHandler
- self._notifyOnMissed = False
- self._notifyOnVoicemail = False
- self._notifyOnSms = False
-
- self._callbackList = []
- self._accountViewNumberDisplay = widgetTree.get_widget("gcnumber_display")
- self._callbackSelectButton = widgetTree.get_widget("callbackSelectButton")
- self._onCallbackSelectChangedId = 0
-
- self._notifyCheckbox = widgetTree.get_widget("notifyCheckbox")
- self._minutesEntryButton = widgetTree.get_widget("minutesEntryButton")
- self._missedCheckbox = widgetTree.get_widget("missedCheckbox")
- self._voicemailCheckbox = widgetTree.get_widget("voicemailCheckbox")
- self._smsCheckbox = widgetTree.get_widget("smsCheckbox")
- self._onNotifyToggled = 0
- self._onMinutesChanged = 0
- self._onMissedToggled = 0
- self._onVoicemailToggled = 0
- self._onSmsToggled = 0
- self._applyAlarmTimeoutId = None
-
- self._window = gtk_toolbox.find_parent_window(self._minutesEntryButton)
- self._callbackNumber = ""
-
- def enable(self):
- assert self._backend.is_authed(), "Attempting to enable backend while not logged in"
-
- self._accountViewNumberDisplay.set_use_markup(True)
- self.set_account_number("")
-
- del self._callbackList[:]
- self._onCallbackSelectChangedId = self._callbackSelectButton.connect("clicked", self._on_callbackentry_clicked)
- self._set_callback_label("")
-
- if self._alarmHandler is not None:
- self._notifyCheckbox.set_active(self._alarmHandler.isEnabled)
- self._minutesEntryButton.set_label("%d minutes" % self._alarmHandler.recurrence)
- self._missedCheckbox.set_active(self._notifyOnMissed)
- self._voicemailCheckbox.set_active(self._notifyOnVoicemail)
- self._smsCheckbox.set_active(self._notifyOnSms)
-
- self._onNotifyToggled = self._notifyCheckbox.connect("toggled", self._on_notify_toggled)
- self._onMinutesChanged = self._minutesEntryButton.connect("clicked", self._on_minutes_clicked)
- self._onMissedToggled = self._missedCheckbox.connect("toggled", self._on_missed_toggled)
- self._onVoicemailToggled = self._voicemailCheckbox.connect("toggled", self._on_voicemail_toggled)
- self._onSmsToggled = self._smsCheckbox.connect("toggled", self._on_sms_toggled)
- else:
- self._notifyCheckbox.set_sensitive(False)
- self._minutesEntryButton.set_sensitive(False)
- self._missedCheckbox.set_sensitive(False)
- self._voicemailCheckbox.set_sensitive(False)
- self._smsCheckbox.set_sensitive(False)
-
- self.update(force=True)
-
- def disable(self):
- self._callbackSelectButton.disconnect(self._onCallbackSelectChangedId)
- self._onCallbackSelectChangedId = 0
- self._set_callback_label("")
-
- if self._alarmHandler is not None:
- self._notifyCheckbox.disconnect(self._onNotifyToggled)
- self._minutesEntryButton.disconnect(self._onMinutesChanged)
- self._missedCheckbox.disconnect(self._onNotifyToggled)
- self._voicemailCheckbox.disconnect(self._onNotifyToggled)
- self._smsCheckbox.disconnect(self._onNotifyToggled)
- self._onNotifyToggled = 0
- self._onMinutesChanged = 0
- self._onMissedToggled = 0
- self._onVoicemailToggled = 0
- self._onSmsToggled = 0
- else:
- self._notifyCheckbox.set_sensitive(True)
- self._minutesEntryButton.set_sensitive(True)
- self._missedCheckbox.set_sensitive(True)
- self._voicemailCheckbox.set_sensitive(True)
- self._smsCheckbox.set_sensitive(True)
-
- self.clear()
- del self._callbackList[:]
-
- def set_account_number(self, number):
- """
- Displays current account number
- """
- self._accountViewNumberDisplay.set_label("<span size='23000' weight='bold'>%s</span>" % (number))
-
- def update(self, force = False):
- if not force and self._isPopulated:
- return False
- self._populate_callback_combo()
- self.set_account_number(self._backend.get_account_number())
- return True
-
def clear(self):
- self._set_callback_label("")
- self.set_account_number("")
- self._isPopulated = False
-
- def save_everything(self):
- raise NotImplementedError
-
- @staticmethod
- def name():
- return "Account Info"
-
- def load_settings(self, config, section):
- self._callbackNumber = make_ugly(config.get(section, "callback"))
- self._notifyOnMissed = config.getboolean(section, "notifyOnMissed")
- self._notifyOnVoicemail = config.getboolean(section, "notifyOnVoicemail")
- self._notifyOnSms = config.getboolean(section, "notifyOnSms")
-
- def save_settings(self, config, section):
- """
- @note Thread Agnostic
- """
- config.set(section, "callback", self._callbackNumber)
- config.set(section, "notifyOnMissed", repr(self._notifyOnMissed))
- config.set(section, "notifyOnVoicemail", repr(self._notifyOnVoicemail))
- config.set(section, "notifyOnSms", repr(self._notifyOnSms))
-
- def _populate_callback_combo(self):
- self._isPopulated = True
- del self._callbackList[:]
- try:
- callbackNumbers = self._backend.get_callback_numbers()
- except Exception, e:
- self._errorDisplay.push_exception()
- self._isPopulated = False
- return
-
- if len(callbackNumbers) == 0:
- callbackNumbers = {"": "No callback numbers available"}
-
- for number, description in callbackNumbers.iteritems():
- self._callbackList.append((make_pretty(number), description))
-
- self._set_callback_number(self._callbackNumber)
-
- def _set_callback_number(self, number):
- try:
- if not self._backend.is_valid_syntax(number) and 0 < len(number):
- self._errorDisplay.push_message("%s is not a valid callback number" % number)
- elif number == self._backend.get_callback_number() and 0 < len(number):
- _moduleLogger.warning(
- "Callback number already is %s" % (
- self._backend.get_callback_number(),
- ),
- )
- self._set_callback_label(number)
- else:
- if number.startswith("1747"): number = "+" + number
- self._backend.set_callback_number(number)
- assert make_ugly(number) == make_ugly(self._backend.get_callback_number()), "Callback number should be %s but instead is %s" % (
- make_pretty(number), make_pretty(self._backend.get_callback_number())
- )
- self._callbackNumber = make_ugly(number)
- self._set_callback_label(number)
- _moduleLogger.info(
- "Callback number set to %s" % (
- self._backend.get_callback_number(),
- ),
- )
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _set_callback_label(self, uglyNumber):
- prettyNumber = make_pretty(uglyNumber)
- if len(prettyNumber) == 0:
- prettyNumber = "No Callback Number"
- self._callbackSelectButton.set_label(prettyNumber)
-
- def _update_alarm_settings(self, recurrence):
- try:
- isEnabled = self._notifyCheckbox.get_active()
- if isEnabled != self._alarmHandler.isEnabled or recurrence != self._alarmHandler.recurrence:
- self._alarmHandler.apply_settings(isEnabled, recurrence)
- finally:
- self.save_everything()
- self._notifyCheckbox.set_active(self._alarmHandler.isEnabled)
- self._minutesEntryButton.set_label("%d Minutes" % self._alarmHandler.recurrence)
-
- def _on_callbackentry_clicked(self, *args):
- try:
- actualSelection = make_pretty(self._callbackNumber)
+ pass
- userOptions = dict(
- (number, "%s (%s)" % (number, description))
- for (number, description) in self._callbackList
- )
- defaultSelection = userOptions.get(actualSelection, actualSelection)
+ def refresh(self, force = True):
+ pass
- userSelection = hildonize.touch_selector_entry(
- self._window,
- "Callback Number",
- list(userOptions.itervalues()),
- defaultSelection,
- )
- reversedUserOptions = dict(
- itertools.izip(userOptions.itervalues(), userOptions.iterkeys())
+ def _generate_key_button(self, center, letters):
+ button = QtGui.QPushButton("%s\n%s" % (center, letters))
+ button.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.MinimumExpanding,
+ QtGui.QSizePolicy.PushButton,
+ ))
+ button.clicked.connect(lambda: self._on_keypress(center))
+ return button
+
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_keypress(self, key):
+ with qui_utils.notify_error(self._errorLog):
+ self._entry.insert(key)
+
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_backspace(self, toggled = False):
+ with qui_utils.notify_error(self._errorLog):
+ self._entry.backspace()
+
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_clear_text(self, toggled = False):
+ with qui_utils.notify_error(self._errorLog):
+ self._entry.clear()
+
+ @qt_compat.Slot()
+ @qt_compat.Slot(bool)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_sms_clicked(self, checked = False):
+ with qui_utils.notify_error(self._errorLog):
+ number = misc_utils.make_ugly(str(self._entry.text()))
+ self._entry.clear()
+
+ contactId = number
+ title = misc_utils.make_pretty(number)
+ description = misc_utils.make_pretty(number)
+ numbersWithDescriptions = [(number, "")]
+ self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
+
+ @qt_compat.Slot()
+ @qt_compat.Slot(bool)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_call_clicked(self, checked = False):
+ with qui_utils.notify_error(self._errorLog):
+ number = misc_utils.make_ugly(str(self._entry.text()))
+ self._entry.clear()
+
+ contactId = number
+ title = misc_utils.make_pretty(number)
+ description = misc_utils.make_pretty(number)
+ numbersWithDescriptions = [(number, "")]
+ self._session.draft.clear()
+ self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
+ self._session.draft.call()
+
+
+class TimeCategories(object):
+
+ _NOW_SECTION = 0
+ _TODAY_SECTION = 1
+ _WEEK_SECTION = 2
+ _MONTH_SECTION = 3
+ _REST_SECTION = 4
+ _MAX_SECTIONS = 5
+
+ _NO_ELAPSED = datetime.timedelta(hours=1)
+ _WEEK_ELAPSED = datetime.timedelta(weeks=1)
+ _MONTH_ELAPSED = datetime.timedelta(days=30)
+
+ def __init__(self, parentItem):
+ self._timeItems = [
+ QtGui.QStandardItem(description)
+ for (i, description) in zip(
+ xrange(self._MAX_SECTIONS),
+ ["Now", "Today", "Week", "Month", "Past"],
)
- selectedNumber = reversedUserOptions.get(userSelection, userSelection)
-
- number = make_ugly(selectedNumber)
- self._set_callback_number(number)
- except RuntimeError, e:
- _moduleLogger.exception("%s" % str(e))
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_notify_toggled(self, *args):
- try:
- if self._applyAlarmTimeoutId is not None:
- gobject.source_remove(self._applyAlarmTimeoutId)
- self._applyAlarmTimeoutId = None
- self._applyAlarmTimeoutId = gobject.timeout_add(500, self._on_apply_timeout)
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_minutes_clicked(self, *args):
- recurrenceChoices = [
- (1, "1 minute"),
- (2, "2 minutes"),
- (3, "3 minutes"),
- (5, "5 minutes"),
- (8, "8 minutes"),
- (10, "10 minutes"),
- (15, "15 minutes"),
- (30, "30 minutes"),
- (45, "45 minutes"),
- (60, "1 hour"),
- (3*60, "3 hours"),
- (6*60, "6 hours"),
- (12*60, "12 hours"),
]
- try:
- actualSelection = self._alarmHandler.recurrence
-
- closestSelectionIndex = 0
- for i, possible in enumerate(recurrenceChoices):
- if possible[0] <= actualSelection:
- closestSelectionIndex = i
- recurrenceIndex = hildonize.touch_selector(
- self._window,
- "Minutes",
- (("%s" % m[1]) for m in recurrenceChoices),
- closestSelectionIndex,
- )
- recurrence = recurrenceChoices[recurrenceIndex][0]
+ for item in self._timeItems:
+ item.setEditable(False)
+ item.setCheckable(False)
+ row = (item, )
+ parentItem.appendRow(row)
- self._update_alarm_settings(recurrence)
- except RuntimeError, e:
- _moduleLogger.exception("%s" % str(e))
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_apply_timeout(self, *args):
- try:
- self._applyAlarmTimeoutId = None
+ self._today = datetime.datetime(1900, 1, 1)
- self._update_alarm_settings(self._alarmHandler.recurrence)
- except Exception, e:
- self._errorDisplay.push_exception()
- return False
+ self.prepare_for_update(self._today)
- def _on_missed_toggled(self, *args):
+ def prepare_for_update(self, newToday):
+ self._today = newToday
+ for item in self._timeItems:
+ item.removeRows(0, item.rowCount())
try:
- self._notifyOnMissed = self._missedCheckbox.get_active()
- self.save_everything()
- except Exception, e:
- self._errorDisplay.push_exception()
+ hour = self._today.strftime("%X")
+ day = self._today.strftime("%x")
+ except ValueError:
+ _moduleLogger.exception("Can't format times")
+ hour = "Now"
+ day = "Today"
+ self._timeItems[self._NOW_SECTION].setText(hour)
+ self._timeItems[self._TODAY_SECTION].setText(day)
+
+ def add_row(self, rowDate, row):
+ elapsedTime = self._today - rowDate
+ todayTuple = self._today.timetuple()
+ rowTuple = rowDate.timetuple()
+ if elapsedTime < self._NO_ELAPSED:
+ section = self._NOW_SECTION
+ elif todayTuple[0:3] == rowTuple[0:3]:
+ section = self._TODAY_SECTION
+ elif elapsedTime < self._WEEK_ELAPSED:
+ section = self._WEEK_SECTION
+ elif elapsedTime < self._MONTH_ELAPSED:
+ section = self._MONTH_SECTION
+ else:
+ section = self._REST_SECTION
+ self._timeItems[section].appendRow(row)
- def _on_voicemail_toggled(self, *args):
- try:
- self._notifyOnVoicemail = self._voicemailCheckbox.get_active()
- self.save_everything()
- except Exception, e:
- self._errorDisplay.push_exception()
+ def get_item(self, timeIndex, rowIndex, column):
+ timeItem = self._timeItems[timeIndex]
+ item = timeItem.child(rowIndex, column)
+ return item
- def _on_sms_toggled(self, *args):
- try:
- self._notifyOnSms = self._smsCheckbox.get_active()
- self.save_everything()
- except Exception, e:
- self._errorDisplay.push_exception()
+class History(object):
-class CallHistoryView(object):
+ DETAILS_IDX = 0
+ FROM_IDX = 1
+ MAX_IDX = 2
- NUMBER_IDX = 0
- DATE_IDX = 1
- ACTION_IDX = 2
- FROM_IDX = 3
- FROM_ID_IDX = 4
+ HISTORY_RECEIVED = "Received"
+ HISTORY_MISSED = "Missed"
+ HISTORY_PLACED = "Placed"
+ HISTORY_ALL = "All"
- HISTORY_ITEM_TYPES = ["All", "Received", "Missed", "Placed"]
+ HISTORY_ITEM_TYPES = [HISTORY_RECEIVED, HISTORY_MISSED, HISTORY_PLACED, HISTORY_ALL]
+ HISTORY_COLUMNS = ["", "From"]
+ assert len(HISTORY_COLUMNS) == MAX_IDX
- def __init__(self, widgetTree, backend, errorDisplay):
- self._errorDisplay = errorDisplay
- self._backend = backend
-
- self._isPopulated = False
- self._historymodel = gtk.ListStore(
- gobject.TYPE_STRING, # number
- gobject.TYPE_STRING, # date
- gobject.TYPE_STRING, # action
- gobject.TYPE_STRING, # from
- gobject.TYPE_STRING, # from id
+ def __init__(self, app, session, errorLog):
+ self._selectedFilter = self.HISTORY_ITEM_TYPES[-1]
+ self._app = app
+ self._session = session
+ self._session.historyUpdated.connect(self._on_history_updated)
+ self._errorLog = errorLog
+
+ self._typeSelection = QtGui.QComboBox()
+ self._typeSelection.addItems(self.HISTORY_ITEM_TYPES)
+ self._typeSelection.setCurrentIndex(
+ self.HISTORY_ITEM_TYPES.index(self._selectedFilter)
)
- self._historymodelfiltered = self._historymodel.filter_new()
- self._historymodelfiltered.set_visible_func(self._is_history_visible)
- self._historyview = widgetTree.get_widget("historyview")
- self._historyviewselection = None
- self._onRecentviewRowActivatedId = 0
-
- textrenderer = gtk.CellRendererText()
- textrenderer.set_property("yalign", 0)
- self._dateColumn = gtk.TreeViewColumn("Date")
- self._dateColumn.pack_start(textrenderer, expand=True)
- self._dateColumn.add_attribute(textrenderer, "text", self.DATE_IDX)
-
- textrenderer = gtk.CellRendererText()
- textrenderer.set_property("yalign", 0)
- self._actionColumn = gtk.TreeViewColumn("Action")
- self._actionColumn.pack_start(textrenderer, expand=True)
- self._actionColumn.add_attribute(textrenderer, "text", self.ACTION_IDX)
-
- textrenderer = gtk.CellRendererText()
- textrenderer.set_property("yalign", 0)
- textrenderer.set_property("ellipsize", pango.ELLIPSIZE_END)
- textrenderer.set_property("width-chars", len("1 (555) 555-1234"))
- self._numberColumn = gtk.TreeViewColumn("Number")
- self._numberColumn.pack_start(textrenderer, expand=True)
- self._numberColumn.add_attribute(textrenderer, "text", self.NUMBER_IDX)
-
- textrenderer = gtk.CellRendererText()
- textrenderer.set_property("yalign", 0)
- hildonize.set_cell_thumb_selectable(textrenderer)
- self._nameColumn = gtk.TreeViewColumn("From")
- self._nameColumn.pack_start(textrenderer, expand=True)
- self._nameColumn.add_attribute(textrenderer, "text", self.FROM_IDX)
- self._nameColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
-
- self._window = gtk_toolbox.find_parent_window(self._historyview)
-
- self._historyFilterSelector = widgetTree.get_widget("historyFilterSelector")
- self._historyFilterSelector.connect("clicked", self._on_history_filter_clicked)
- self._selectedFilter = "All"
-
- self._updateSink = gtk_toolbox.threaded_stage(
- gtk_toolbox.comap(
- self._idly_populate_historyview,
- gtk_toolbox.null_sink(),
- )
+ self._typeSelection.currentIndexChanged[str].connect(self._on_filter_changed)
+ refreshIcon = qui_utils.get_theme_icon(
+ ("view-refresh", "general_refresh", "gtk-refresh", ),
+ _SENTINEL_ICON
)
+ if refreshIcon is not _SENTINEL_ICON:
+ self._refreshButton = QtGui.QPushButton(refreshIcon, "")
+ else:
+ self._refreshButton = QtGui.QPushButton("Refresh")
+ self._refreshButton.clicked.connect(self._on_refresh_clicked)
+ self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.PushButton,
+ ))
+ self._managerLayout = QtGui.QHBoxLayout()
+ self._managerLayout.addWidget(self._typeSelection, 1000)
+ self._managerLayout.addWidget(self._refreshButton, 0)
+
+ self._itemStore = QtGui.QStandardItemModel()
+ self._itemStore.setHorizontalHeaderLabels(self.HISTORY_COLUMNS)
+ self._categoryManager = TimeCategories(self._itemStore)
+
+ self._itemView = QtGui.QTreeView()
+ self._itemView.setModel(self._itemStore)
+ self._itemView.setUniformRowHeights(True)
+ self._itemView.setRootIsDecorated(False)
+ self._itemView.setIndentation(0)
+ self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+ self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+ self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+ self._itemView.setHeaderHidden(True)
+ self._itemView.setItemsExpandable(False)
+ self._itemView.header().setResizeMode(QtGui.QHeaderView.ResizeToContents)
+ self._itemView.activated.connect(self._on_row_activated)
+
+ self._layout = QtGui.QVBoxLayout()
+ self._layout.addLayout(self._managerLayout)
+ self._layout.addWidget(self._itemView)
+ self._widget = QtGui.QWidget()
+ self._widget.setLayout(self._layout)
+
+ self._actionIcon = {
+ "Placed": self._app.get_icon("placed.png"),
+ "Missed": self._app.get_icon("missed.png"),
+ "Received": self._app.get_icon("received.png"),
+ }
- def enable(self):
- assert self._backend.is_authed(), "Attempting to enable backend while not logged in"
- self._historyFilterSelector.set_label(self._selectedFilter)
-
- self._historyview.set_model(self._historymodelfiltered)
- self._historyview.set_fixed_height_mode(False)
+ self._populate_items()
- self._historyview.append_column(self._dateColumn)
- self._historyview.append_column(self._actionColumn)
- self._historyview.append_column(self._numberColumn)
- self._historyview.append_column(self._nameColumn)
- self._historyviewselection = self._historyview.get_selection()
- self._historyviewselection.set_mode(gtk.SELECTION_SINGLE)
+ @property
+ def toplevel(self):
+ return self._widget
- self._onRecentviewRowActivatedId = self._historyview.connect("row-activated", self._on_historyview_row_activated)
+ def enable(self):
+ self._itemView.setEnabled(True)
def disable(self):
- self._historyview.disconnect(self._onRecentviewRowActivatedId)
-
- self.clear()
-
- self._historyview.remove_column(self._dateColumn)
- self._historyview.remove_column(self._actionColumn)
- self._historyview.remove_column(self._nameColumn)
- self._historyview.remove_column(self._numberColumn)
- self._historyview.set_model(None)
-
- def add_contact(self, *args, **kwds):
- """
- @note Actual dial function is patched in later
- """
- raise NotImplementedError("Horrible unknown error has occurred")
-
- def update(self, force = False):
- if not force and self._isPopulated:
- return False
- self._updateSink.send(())
- return True
-
- def clear(self):
- self._isPopulated = False
- self._historymodel.clear()
-
- @staticmethod
- def name():
- return "Recent Calls"
-
- def load_settings(self, config, sectionName):
- try:
- self._selectedFilter = config.get(sectionName, "filter")
- if self._selectedFilter not in self.HISTORY_ITEM_TYPES:
- self._messageType = self.HISTORY_ITEM_TYPES[0]
- except ConfigParser.NoOptionError:
- pass
+ self._itemView.setEnabled(False)
- def save_settings(self, config, sectionName):
- """
- @note Thread Agnostic
- """
- config.set(sectionName, "filter", self._selectedFilter)
-
- def _is_history_visible(self, model, iter):
- try:
- action = model.get_value(iter, self.ACTION_IDX)
- if action is None:
- return False # this seems weird but oh well
-
- if self._selectedFilter in [action, "All"]:
- return True
- else:
- return False
- except Exception, e:
- self._errorDisplay.push_exception()
+ def get_settings(self):
+ return {
+ "filter": self._selectedFilter,
+ }
- def _idly_populate_historyview(self):
- with gtk_toolbox.gtk_lock():
- banner = hildonize.show_busy_banner_start(self._window, "Loading Call History")
- try:
- self._historymodel.clear()
- self._isPopulated = True
-
- try:
- historyItems = self._backend.get_recent()
- except Exception, e:
- self._errorDisplay.push_exception_with_lock()
- self._isPopulated = False
- historyItems = []
-
- historyItems = (
- gv_backend.decorate_recent(data)
- for data in gv_backend.sort_messages(historyItems)
+ def set_settings(self, settings):
+ selectedFilter = settings.get("filter", self.HISTORY_ITEM_TYPES[-1])
+ if selectedFilter in self.HISTORY_ITEM_TYPES:
+ self._selectedFilter = selectedFilter
+ self._typeSelection.setCurrentIndex(
+ self.HISTORY_ITEM_TYPES.index(selectedFilter)
)
- for contactId, personName, phoneNumber, date, action in historyItems:
- if not personName:
- personName = "Unknown"
- date = abbrev_relative_date(date)
- prettyNumber = phoneNumber[2:] if phoneNumber.startswith("+1") else phoneNumber
- prettyNumber = make_pretty(prettyNumber)
- item = (prettyNumber, date, action.capitalize(), personName, contactId)
- with gtk_toolbox.gtk_lock():
- self._historymodel.append(item)
- except Exception, e:
- self._errorDisplay.push_exception_with_lock()
- finally:
- with gtk_toolbox.gtk_lock():
- hildonize.show_busy_banner_end(banner)
-
- return False
-
- def _on_history_filter_clicked(self, *args, **kwds):
- try:
- selectedComboIndex = self.HISTORY_ITEM_TYPES.index(self._selectedFilter)
-
- try:
- newSelectedComboIndex = hildonize.touch_selector(
- self._window,
- "History",
- self.HISTORY_ITEM_TYPES,
- selectedComboIndex,
- )
- except RuntimeError:
- return
-
- option = self.HISTORY_ITEM_TYPES[newSelectedComboIndex]
- self._selectedFilter = option
- self._historyFilterSelector.set_label(self._selectedFilter)
- self._historymodelfiltered.refilter()
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _history_summary(self, expectedNumber):
- for number, action, date, whoFrom, whoFromId in self._historymodel:
- if expectedNumber is not None and expectedNumber == number:
- yield "%s <i>(%s)</i> - %s %s" % (number, whoFrom, date, action)
-
- def _on_historyview_row_activated(self, treeview, path, view_column):
- try:
- childPath = self._historymodelfiltered.convert_path_to_child_path(path)
- itr = self._historymodel.get_iter(childPath)
- if not itr:
+ def clear(self):
+ self._itemView.clear()
+
+ def refresh(self, force=True):
+ self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
+
+ if self._selectedFilter == self.HISTORY_RECEIVED:
+ self._session.update_history(self._session.HISTORY_RECEIVED, force)
+ elif self._selectedFilter == self.HISTORY_MISSED:
+ self._session.update_history(self._session.HISTORY_MISSED, force)
+ elif self._selectedFilter == self.HISTORY_PLACED:
+ self._session.update_history(self._session.HISTORY_PLACED, force)
+ elif self._selectedFilter == self.HISTORY_ALL:
+ self._session.update_history(self._session.HISTORY_ALL, force)
+ else:
+ assert False, "How did we get here?"
+
+ if self._app.notifyOnMissed and self._app.alarmHandler.alarmType != self._app.alarmHandler.ALARM_NONE:
+ self._app.ledHandler.off()
+
+ def _populate_items(self):
+ self._categoryManager.prepare_for_update(self._session.get_when_history_updated())
+
+ history = self._session.get_history()
+ history.sort(key=lambda item: item["time"], reverse=True)
+ for event in history:
+ if self._selectedFilter not in [self.HISTORY_ITEM_TYPES[-1], event["action"]]:
+ continue
+
+ relTime = event["relTime"]
+ action = event["action"]
+ number = event["number"]
+ prettyNumber = misc_utils.make_pretty(number)
+ if prettyNumber.startswith("+1 "):
+ prettyNumber = prettyNumber[len("+1 "):]
+ name = event["name"]
+ if not name or name == number:
+ name = event["location"]
+ if not name:
+ name = "Unknown"
+
+ detailsItem = QtGui.QStandardItem(self._actionIcon[action], "%s\n%s" % (prettyNumber, relTime))
+ detailsFont = detailsItem.font()
+ detailsFont.setPointSize(max(detailsFont.pointSize() - 6, 5))
+ detailsItem.setFont(detailsFont)
+ nameItem = QtGui.QStandardItem(name)
+ nameFont = nameItem.font()
+ nameFont.setPointSize(nameFont.pointSize() + 4)
+ nameItem.setFont(nameFont)
+ row = detailsItem, nameItem
+ for item in row:
+ item.setEditable(False)
+ item.setCheckable(False)
+ row[self.DETAILS_IDX].setData(event)
+ self._categoryManager.add_row(event["time"], row)
+ self._itemView.expandAll()
+
+ @qt_compat.Slot(str)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_filter_changed(self, newItem):
+ with qui_utils.notify_error(self._errorLog):
+ self._selectedFilter = str(newItem)
+ self._populate_items()
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_history_updated(self):
+ with qui_utils.notify_error(self._errorLog):
+ self._populate_items()
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_refresh_clicked(self, arg = None):
+ with qui_utils.notify_error(self._errorLog):
+ self.refresh(force=True)
+
+ @qt_compat.Slot(QtCore.QModelIndex)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_row_activated(self, index):
+ with qui_utils.notify_error(self._errorLog):
+ timeIndex = index.parent()
+ if not timeIndex.isValid():
return
-
- prettyNumber = self._historymodel.get_value(itr, self.NUMBER_IDX)
- number = make_ugly(prettyNumber)
- description = list(self._history_summary(prettyNumber))
- contactName = self._historymodel.get_value(itr, self.FROM_IDX)
- contactId = self._historymodel.get_value(itr, self.FROM_ID_IDX)
- contactPhoneNumbers, defaultIndex = _get_contact_numbers(self._backend, contactId, number)
-
- self.add_contact(
- contactName,
- contactPhoneNumbers,
- messages = description,
- defaultIndex = defaultIndex,
- )
- self._historyviewselection.unselect_all()
- except Exception, e:
- self._errorDisplay.push_exception()
-
-
-class MessagesView(object):
-
- NUMBER_IDX = 0
- DATE_IDX = 1
- HEADER_IDX = 2
- MESSAGE_IDX = 3
- MESSAGES_IDX = 4
- FROM_ID_IDX = 5
- MESSAGE_DATA_IDX = 6
+ timeRow = timeIndex.row()
+ row = index.row()
+ detailsItem = self._categoryManager.get_item(timeRow, row, self.DETAILS_IDX)
+ fromItem = self._categoryManager.get_item(timeRow, row, self.FROM_IDX)
+ contactDetails = detailsItem.data()
+
+ title = unicode(fromItem.text())
+ number = str(contactDetails["number"])
+ contactId = number # ids don't seem too unique so using numbers
+
+ descriptionRows = []
+ for t in xrange(self._itemStore.rowCount()):
+ randomTimeItem = self._itemStore.item(t, 0)
+ for i in xrange(randomTimeItem.rowCount()):
+ iItem = randomTimeItem.child(i, 0)
+ iContactDetails = iItem.data()
+ iNumber = str(iContactDetails["number"])
+ if number != iNumber:
+ continue
+ relTime = misc_utils.abbrev_relative_date(iContactDetails["relTime"])
+ action = str(iContactDetails["action"])
+ number = str(iContactDetails["number"])
+ prettyNumber = misc_utils.make_pretty(number)
+ rowItems = relTime, action, prettyNumber
+ descriptionRows.append("<tr><td>%s</td></tr>" % "</td><td>".join(rowItems))
+ description = "<table>%s</table>" % "".join(descriptionRows)
+ numbersWithDescriptions = [(str(contactDetails["number"]), "")]
+ self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
+
+
+class Messages(object):
NO_MESSAGES = "None"
VOICEMAIL_MESSAGES = "Voicemail"
ALL_STATUS = "Any"
MESSAGE_STATUSES = [UNREAD_STATUS, UNARCHIVED_STATUS, ALL_STATUS]
- def __init__(self, widgetTree, backend, errorDisplay):
- self._errorDisplay = errorDisplay
- self._backend = backend
-
- self._isPopulated = False
- self._messagemodel = gtk.ListStore(
- gobject.TYPE_STRING, # number
- gobject.TYPE_STRING, # date
- gobject.TYPE_STRING, # header
- gobject.TYPE_STRING, # message
- object, # messages
- gobject.TYPE_STRING, # from id
- object, # message data
- )
- self._messagemodelfiltered = self._messagemodel.filter_new()
- self._messagemodelfiltered.set_visible_func(self._is_message_visible)
- self._messageview = widgetTree.get_widget("messages_view")
- self._messageviewselection = None
- self._onMessageviewRowActivatedId = 0
-
- self._messageRenderer = gtk.CellRendererText()
- self._messageRenderer.set_property("wrap-mode", pango.WRAP_WORD)
- self._messageRenderer.set_property("wrap-width", 500)
- self._messageColumn = gtk.TreeViewColumn("Messages")
- self._messageColumn.pack_start(self._messageRenderer, expand=True)
- self._messageColumn.add_attribute(self._messageRenderer, "markup", self.MESSAGE_IDX)
- self._messageColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
-
- self._window = gtk_toolbox.find_parent_window(self._messageview)
-
- self._messageTypeButton = widgetTree.get_widget("messageTypeButton")
- self._onMessageTypeClickedId = 0
- self._messageType = self.ALL_TYPES
- self._messageStatusButton = widgetTree.get_widget("messageStatusButton")
- self._onMessageStatusClickedId = 0
- self._messageStatus = self.ALL_STATUS
-
- self._updateSink = gtk_toolbox.threaded_stage(
- gtk_toolbox.comap(
- self._idly_populate_messageview,
- gtk_toolbox.null_sink(),
- )
- )
-
- def enable(self):
- assert self._backend.is_authed(), "Attempting to enable backend while not logged in"
- self._messageview.set_model(self._messagemodelfiltered)
- self._messageview.set_headers_visible(False)
- self._messageview.set_fixed_height_mode(False)
-
- self._messageview.append_column(self._messageColumn)
- self._messageviewselection = self._messageview.get_selection()
- self._messageviewselection.set_mode(gtk.SELECTION_SINGLE)
-
- self._messageTypeButton.set_label(self._messageType)
- self._messageStatusButton.set_label(self._messageStatus)
+ _MIN_MESSAGES_SHOWN = 1
- self._onMessageviewRowActivatedId = self._messageview.connect(
- "row-activated", self._on_messageview_row_activated
+ def __init__(self, app, session, errorLog):
+ self._selectedTypeFilter = self.ALL_TYPES
+ self._selectedStatusFilter = self.ALL_STATUS
+ self._app = app
+ self._session = session
+ self._session.messagesUpdated.connect(self._on_messages_updated)
+ self._errorLog = errorLog
+
+ self._typeSelection = QtGui.QComboBox()
+ self._typeSelection.addItems(self.MESSAGE_TYPES)
+ self._typeSelection.setCurrentIndex(
+ self.MESSAGE_TYPES.index(self._selectedTypeFilter)
)
- self._onMessageTypeClickedId = self._messageTypeButton.connect(
- "clicked", self._on_message_type_clicked
+ self._typeSelection.currentIndexChanged[str].connect(self._on_type_filter_changed)
+
+ self._statusSelection = QtGui.QComboBox()
+ self._statusSelection.addItems(self.MESSAGE_STATUSES)
+ self._statusSelection.setCurrentIndex(
+ self.MESSAGE_STATUSES.index(self._selectedStatusFilter)
)
- self._onMessageStatusClickedId = self._messageStatusButton.connect(
- "clicked", self._on_message_status_clicked
+ self._statusSelection.currentIndexChanged[str].connect(self._on_status_filter_changed)
+
+ refreshIcon = qui_utils.get_theme_icon(
+ ("view-refresh", "general_refresh", "gtk-refresh", ),
+ _SENTINEL_ICON
)
+ if refreshIcon is not _SENTINEL_ICON:
+ self._refreshButton = QtGui.QPushButton(refreshIcon, "")
+ else:
+ self._refreshButton = QtGui.QPushButton("Refresh")
+ self._refreshButton.clicked.connect(self._on_refresh_clicked)
+ self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.PushButton,
+ ))
+
+ self._selectionLayout = QtGui.QHBoxLayout()
+ self._selectionLayout.addWidget(self._typeSelection, 1000)
+ self._selectionLayout.addWidget(self._statusSelection, 1000)
+ self._selectionLayout.addWidget(self._refreshButton, 0)
+
+ self._itemStore = QtGui.QStandardItemModel()
+ self._itemStore.setHorizontalHeaderLabels(["Messages"])
+ self._categoryManager = TimeCategories(self._itemStore)
+
+ self._htmlDelegate = qui_utils.QHtmlDelegate()
+ self._itemView = QtGui.QTreeView()
+ self._itemView.setModel(self._itemStore)
+ self._itemView.setUniformRowHeights(False)
+ self._itemView.setRootIsDecorated(False)
+ self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+ self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+ self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+ self._itemView.setHeaderHidden(True)
+ self._itemView.setItemsExpandable(False)
+ self._itemView.setItemDelegate(self._htmlDelegate)
+ self._itemView.activated.connect(self._on_row_activated)
+ self._itemView.header().sectionResized.connect(self._on_column_resized)
+
+ self._layout = QtGui.QVBoxLayout()
+ self._layout.addLayout(self._selectionLayout)
+ self._layout.addWidget(self._itemView)
+ self._widget = QtGui.QWidget()
+ self._widget.setLayout(self._layout)
+
+ self._populate_items()
+
+ @property
+ def toplevel(self):
+ return self._widget
- def disable(self):
- self._messageview.disconnect(self._onMessageviewRowActivatedId)
- self._messageTypeButton.disconnect(self._onMessageTypeClickedId)
- self._messageStatusButton.disconnect(self._onMessageStatusClickedId)
+ def enable(self):
+ self._itemView.setEnabled(True)
- self.clear()
+ def disable(self):
+ self._itemView.setEnabled(False)
- self._messageview.remove_column(self._messageColumn)
- self._messageview.set_model(None)
+ def get_settings(self):
+ return {
+ "type": self._selectedTypeFilter,
+ "status": self._selectedStatusFilter,
+ }
- def add_contact(self, *args, **kwds):
- """
- @note Actual dial function is patched in later
- """
- raise NotImplementedError("Horrible unknown error has occurred")
+ def set_settings(self, settings):
+ selectedType = settings.get("type", self.ALL_TYPES)
+ if selectedType in self.MESSAGE_TYPES:
+ self._selectedTypeFilter = selectedType
+ self._typeSelection.setCurrentIndex(
+ self.MESSAGE_TYPES.index(self._selectedTypeFilter)
+ )
- def update(self, force = False):
- if not force and self._isPopulated:
- return False
- self._updateSink.send(())
- return True
+ selectedStatus = settings.get("status", self.ALL_STATUS)
+ if selectedStatus in self.MESSAGE_STATUSES:
+ self._selectedStatusFilter = selectedStatus
+ self._statusSelection.setCurrentIndex(
+ self.MESSAGE_STATUSES.index(self._selectedStatusFilter)
+ )
def clear(self):
- self._isPopulated = False
- self._messagemodel.clear()
+ self._itemView.clear()
- @staticmethod
- def name():
- return "Messages"
+ def refresh(self, force=True):
+ self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
- def load_settings(self, config, sectionName):
- try:
- self._messageType = config.get(sectionName, "type")
- if self._messageType not in self.MESSAGE_TYPES:
- self._messageType = self.ALL_TYPES
- self._messageStatus = config.get(sectionName, "status")
- if self._messageStatus not in self.MESSAGE_STATUSES:
- self._messageStatus = self.ALL_STATUS
- except ConfigParser.NoOptionError:
+ if self._selectedTypeFilter == self.NO_MESSAGES:
pass
-
- def save_settings(self, config, sectionName):
- """
- @note Thread Agnostic
- """
- config.set(sectionName, "status", self._messageStatus)
- config.set(sectionName, "type", self._messageType)
-
- def _is_message_visible(self, model, iter):
- try:
- message = model.get_value(iter, self.MESSAGE_DATA_IDX)
- if message is None:
- return False # this seems weird but oh well
- return self._filter_messages(message, self._messageType, self._messageStatus)
- except Exception, e:
- self._errorDisplay.push_exception()
-
- @classmethod
- def _filter_messages(cls, message, type, status):
- if type == cls.ALL_TYPES:
- isType = True
+ elif self._selectedTypeFilter == self.TEXT_MESSAGES:
+ self._session.update_messages(self._session.MESSAGE_TEXTS, force)
+ elif self._selectedTypeFilter == self.VOICEMAIL_MESSAGES:
+ self._session.update_messages(self._session.MESSAGE_VOICEMAILS, force)
+ elif self._selectedTypeFilter == self.ALL_TYPES:
+ self._session.update_messages(self._session.MESSAGE_ALL, force)
else:
- messageType = message["type"]
- isType = messageType == type
-
- if status == cls.ALL_STATUS:
- isStatus = True
- else:
- isUnarchived = not message["isArchived"]
- isUnread = not message["isRead"]
- if status == cls.UNREAD_STATUS:
- isStatus = isUnarchived and isUnread
- elif status == cls.UNARCHIVED_STATUS:
- isStatus = isUnarchived
+ assert False, "How did we get here?"
+
+ if (self._app.notifyOnSms or self._app.notifyOnVoicemail) and self._app.alarmHandler.alarmType != self._app.alarmHandler.ALARM_NONE:
+ self._app.ledHandler.off()
+
+ def _populate_items(self):
+ self._categoryManager.prepare_for_update(self._session.get_when_messages_updated())
+
+ rawMessages = self._session.get_messages()
+ rawMessages.sort(key=lambda item: item["time"], reverse=True)
+ for item in rawMessages:
+ isUnarchived = not item["isArchived"]
+ isUnread = not item["isRead"]
+ visibleStatus = {
+ self.UNREAD_STATUS: isUnarchived and isUnread,
+ self.UNARCHIVED_STATUS: isUnarchived,
+ self.ALL_STATUS: True,
+ }[self._selectedStatusFilter]
+ visibleType = self._selectedTypeFilter in [item["type"], self.ALL_TYPES]
+ if not (visibleType and visibleStatus):
+ continue
+
+ relTime = misc_utils.abbrev_relative_date(item["relTime"])
+ number = item["number"]
+ prettyNumber = misc_utils.make_pretty(number)
+ name = item["name"]
+ if not name or name == number:
+ name = item["location"]
+ if not name:
+ name = "Unknown"
+
+ messageParts = list(item["messageParts"])
+ if len(messageParts) == 0:
+ messages = ("No Transcription", )
+ elif len(messageParts) == 1:
+ if messageParts[0][1]:
+ messages = (messageParts[0][1], )
+ else:
+ messages = ("No Transcription", )
else:
- assert "Status %s is bad for %r" % (status, message)
-
- return isType and isStatus
-
- _MIN_MESSAGES_SHOWN = 4
-
- def _idly_populate_messageview(self):
- with gtk_toolbox.gtk_lock():
- banner = hildonize.show_busy_banner_start(self._window, "Loading Messages")
- try:
- self._messagemodel.clear()
- self._isPopulated = True
-
- if self._messageType == self.NO_MESSAGES:
- messageItems = []
+ messages = [
+ "<b>%s</b>: %s" % (messagePart[0], messagePart[1])
+ for messagePart in messageParts
+ ]
+
+ firstMessage = "<b>%s<br/>%s</b> <i>(%s)</i>" % (name, prettyNumber, relTime)
+
+ expandedMessages = [firstMessage]
+ expandedMessages.extend(messages)
+ if self._MIN_MESSAGES_SHOWN < len(messages):
+ secondMessage = "<i>%d Messages Hidden...</i>" % (len(messages) - self._MIN_MESSAGES_SHOWN, )
+ collapsedMessages = [firstMessage, secondMessage]
+ collapsedMessages.extend(messages[-(self._MIN_MESSAGES_SHOWN+0):])
else:
- try:
- messageItems = self._backend.get_messages()
- except Exception, e:
- self._errorDisplay.push_exception_with_lock()
- self._isPopulated = False
- messageItems = []
-
- messageItems = (
- (gv_backend.decorate_message(message), message)
- for message in gv_backend.sort_messages(messageItems)
- )
-
- for (contactId, header, number, relativeDate, messages), messageData in messageItems:
- prettyNumber = number[2:] if number.startswith("+1") else number
- prettyNumber = make_pretty(prettyNumber)
-
- firstMessage = "<b>%s - %s</b> <i>(%s)</i>" % (header, prettyNumber, relativeDate)
- expandedMessages = [firstMessage]
- expandedMessages.extend(messages)
- if (self._MIN_MESSAGES_SHOWN + 1) < len(messages):
- firstMessage = "<b>%s - %s</b> <i>(%s)</i>" % (header, prettyNumber, relativeDate)
- secondMessage = "<i>%d Messages Hidden...</i>" % (len(messages) - self._MIN_MESSAGES_SHOWN, )
- collapsedMessages = [firstMessage, secondMessage]
- collapsedMessages.extend(messages[-(self._MIN_MESSAGES_SHOWN+0):])
- else:
- collapsedMessages = expandedMessages
- #collapsedMessages = _collapse_message(collapsedMessages, 60, self._MIN_MESSAGES_SHOWN)
-
- number = make_ugly(number)
-
- row = number, relativeDate, header, "\n".join(collapsedMessages), expandedMessages, contactId, messageData
- with gtk_toolbox.gtk_lock():
- self._messagemodel.append(row)
- except Exception, e:
- self._errorDisplay.push_exception_with_lock()
- finally:
- with gtk_toolbox.gtk_lock():
- hildonize.show_busy_banner_end(banner)
- self._messagemodelfiltered.refilter()
-
- return False
-
- def _on_messageview_row_activated(self, treeview, path, view_column):
- try:
- childPath = self._messagemodelfiltered.convert_path_to_child_path(path)
- itr = self._messagemodel.get_iter(childPath)
- if not itr:
- return
-
- number = make_ugly(self._messagemodel.get_value(itr, self.NUMBER_IDX))
- description = self._messagemodel.get_value(itr, self.MESSAGES_IDX)
-
- contactId = self._messagemodel.get_value(itr, self.FROM_ID_IDX)
- header = self._messagemodel.get_value(itr, self.HEADER_IDX)
- contactPhoneNumbers, defaultIndex = _get_contact_numbers(self._backend, contactId, number)
-
- self.add_contact(
- header,
- contactPhoneNumbers,
- messages = description,
- defaultIndex = defaultIndex,
- )
- self._messageviewselection.unselect_all()
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_message_type_clicked(self, *args, **kwds):
- try:
- selectedIndex = self.MESSAGE_TYPES.index(self._messageType)
-
- try:
- newSelectedIndex = hildonize.touch_selector(
- self._window,
- "Message Type",
- self.MESSAGE_TYPES,
- selectedIndex,
- )
- except RuntimeError:
+ collapsedMessages = expandedMessages
+
+ item = dict(item.iteritems())
+ item["collapsedMessages"] = "<br/>\n".join(collapsedMessages)
+ item["expandedMessages"] = "<br/>\n".join(expandedMessages)
+
+ messageItem = QtGui.QStandardItem(item["collapsedMessages"])
+ messageItem.setData(item)
+ messageItem.setEditable(False)
+ messageItem.setCheckable(False)
+ row = (messageItem, )
+ self._categoryManager.add_row(item["time"], row)
+ self._itemView.expandAll()
+
+ @qt_compat.Slot(str)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_type_filter_changed(self, newItem):
+ with qui_utils.notify_error(self._errorLog):
+ self._selectedTypeFilter = str(newItem)
+ self._populate_items()
+
+ @qt_compat.Slot(str)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_status_filter_changed(self, newItem):
+ with qui_utils.notify_error(self._errorLog):
+ self._selectedStatusFilter = str(newItem)
+ self._populate_items()
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_refresh_clicked(self, arg = None):
+ with qui_utils.notify_error(self._errorLog):
+ self.refresh(force=True)
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_messages_updated(self):
+ with qui_utils.notify_error(self._errorLog):
+ self._populate_items()
+
+ @qt_compat.Slot(QtCore.QModelIndex)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_row_activated(self, index):
+ with qui_utils.notify_error(self._errorLog):
+ timeIndex = index.parent()
+ if not timeIndex.isValid():
return
+ timeRow = timeIndex.row()
+ row = index.row()
+ item = self._categoryManager.get_item(timeRow, row, 0)
+ contactDetails = item.data()
+
+ name = unicode(contactDetails["name"])
+ number = str(contactDetails["number"])
+ if not name or name == number:
+ name = unicode(contactDetails["location"])
+ if not name:
+ name = "Unknown"
+
+ if str(contactDetails["type"]) == "Voicemail":
+ messageId = str(contactDetails["id"])
+ else:
+ messageId = None
+ contactId = str(contactDetails["contactId"])
+ title = name
+ description = unicode(contactDetails["expandedMessages"])
+ numbersWithDescriptions = [(number, "")]
+ self._session.draft.add_contact(contactId, messageId, title, description, numbersWithDescriptions)
- if selectedIndex != newSelectedIndex:
- self._messageType = self.MESSAGE_TYPES[newSelectedIndex]
- self._messageTypeButton.set_label(self._messageType)
- self._messagemodelfiltered.refilter()
- except Exception, e:
- self._errorDisplay.push_exception()
-
- def _on_message_status_clicked(self, *args, **kwds):
- try:
- selectedIndex = self.MESSAGE_STATUSES.index(self._messageStatus)
-
- try:
- newSelectedIndex = hildonize.touch_selector(
- self._window,
- "Message Status",
- self.MESSAGE_STATUSES,
- selectedIndex,
- )
- except RuntimeError:
- return
-
- if selectedIndex != newSelectedIndex:
- self._messageStatus = self.MESSAGE_STATUSES[newSelectedIndex]
- self._messageStatusButton.set_label(self._messageStatus)
- self._messagemodelfiltered.refilter()
- except Exception, e:
- self._errorDisplay.push_exception()
-
-
-class ContactsView(object):
-
- CONTACT_TYPE_IDX = 0
- CONTACT_NAME_IDX = 1
- CONTACT_ID_IDX = 2
+ @qt_compat.Slot(QtCore.QModelIndex)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_column_resized(self, index, oldSize, newSize):
+ self._htmlDelegate.setWidth(newSize, self._itemStore)
- def __init__(self, widgetTree, backend, errorDisplay):
- self._errorDisplay = errorDisplay
- self._backend = backend
- self._addressBook = None
- self._selectedComboIndex = 0
- self._addressBookFactories = [null_backend.NullAddressBook()]
+class Contacts(object):
- self._booksList = []
- self._bookSelectionButton = widgetTree.get_widget("addressbookSelectButton")
+ # @todo Provide some sort of letter jump
- self._isPopulated = False
- self._contactsmodel = gtk.ListStore(
- gobject.TYPE_STRING, # Contact Type
- gobject.TYPE_STRING, # Contact Name
- gobject.TYPE_STRING, # Contact ID
- )
- self._contactsviewselection = None
- self._contactsview = widgetTree.get_widget("contactsview")
-
- self._contactColumn = gtk.TreeViewColumn("Contact")
- displayContactSource = False
- if displayContactSource:
- textrenderer = gtk.CellRendererText()
- self._contactColumn.pack_start(textrenderer, expand=False)
- self._contactColumn.add_attribute(textrenderer, 'text', self.CONTACT_TYPE_IDX)
- textrenderer = gtk.CellRendererText()
- hildonize.set_cell_thumb_selectable(textrenderer)
- self._contactColumn.pack_start(textrenderer, expand=True)
- self._contactColumn.add_attribute(textrenderer, 'text', self.CONTACT_NAME_IDX)
- self._contactColumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
- self._contactColumn.set_sort_column_id(1)
- self._contactColumn.set_visible(True)
-
- self._onContactsviewRowActivatedId = 0
- self._onAddressbookButtonChangedId = 0
- self._window = gtk_toolbox.find_parent_window(self._contactsview)
-
- self._updateSink = gtk_toolbox.threaded_stage(
- gtk_toolbox.comap(
- self._idly_populate_contactsview,
- gtk_toolbox.null_sink(),
- )
+ def __init__(self, app, session, errorLog):
+ self._app = app
+ self._session = session
+ self._session.accountUpdated.connect(self._on_contacts_updated)
+ self._errorLog = errorLog
+ self._addressBookFactories = [
+ null_backend.NullAddressBookFactory(),
+ file_backend.FilesystemAddressBookFactory(app.fsContactsPath),
+ qt_backend.QtContactsAddressBookFactory(),
+ ]
+ self._addressBooks = []
+
+ self._listSelection = QtGui.QComboBox()
+ self._listSelection.addItems([])
+ self._listSelection.currentIndexChanged[str].connect(self._on_filter_changed)
+ self._activeList = "None"
+ refreshIcon = qui_utils.get_theme_icon(
+ ("view-refresh", "general_refresh", "gtk-refresh", ),
+ _SENTINEL_ICON
)
+ if refreshIcon is not _SENTINEL_ICON:
+ self._refreshButton = QtGui.QPushButton(refreshIcon, "")
+ else:
+ self._refreshButton = QtGui.QPushButton("Refresh")
+ self._refreshButton.clicked.connect(self._on_refresh_clicked)
+ self._refreshButton.setSizePolicy(QtGui.QSizePolicy(
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.Minimum,
+ QtGui.QSizePolicy.PushButton,
+ ))
+ self._managerLayout = QtGui.QHBoxLayout()
+ self._managerLayout.addWidget(self._listSelection, 1000)
+ self._managerLayout.addWidget(self._refreshButton, 0)
+
+ self._itemStore = QtGui.QStandardItemModel()
+ self._itemStore.setHorizontalHeaderLabels(["Contacts"])
+ self._alphaItem = {}
+
+ self._itemView = QtGui.QTreeView()
+ self._itemView.setModel(self._itemStore)
+ self._itemView.setUniformRowHeights(True)
+ self._itemView.setRootIsDecorated(False)
+ self._itemView.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
+ self._itemView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
+ self._itemView.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
+ self._itemView.setHeaderHidden(True)
+ self._itemView.setItemsExpandable(False)
+ self._itemView.activated.connect(self._on_row_activated)
+
+ self._layout = QtGui.QVBoxLayout()
+ self._layout.addLayout(self._managerLayout)
+ self._layout.addWidget(self._itemView)
+ self._widget = QtGui.QWidget()
+ self._widget.setLayout(self._layout)
+
+ self.update_addressbooks()
+ self._populate_items()
+
+ @property
+ def toplevel(self):
+ return self._widget
def enable(self):
- assert self._backend.is_authed(), "Attempting to enable backend while not logged in"
-
- self._contactsview.set_model(self._contactsmodel)
- self._contactsview.set_fixed_height_mode(False)
- self._contactsview.append_column(self._contactColumn)
- self._contactsviewselection = self._contactsview.get_selection()
- self._contactsviewselection.set_mode(gtk.SELECTION_SINGLE)
-
- del self._booksList[:]
- for (factoryId, bookId), (factoryName, bookName) in self.get_addressbooks():
- if factoryName and bookName:
- entryName = "%s: %s" % (factoryName, bookName)
- elif factoryName:
- entryName = factoryName
- elif bookName:
- entryName = bookName
- else:
- entryName = "Bad name (%d)" % factoryId
- row = (str(factoryId), bookId, entryName)
- self._booksList.append(row)
-
- self._onContactsviewRowActivatedId = self._contactsview.connect("row-activated", self._on_contactsview_row_activated)
- self._onAddressbookButtonChangedId = self._bookSelectionButton.connect("clicked", self._on_addressbook_button_changed)
-
- if len(self._booksList) <= self._selectedComboIndex:
- self._selectedComboIndex = 0
- self._bookSelectionButton.set_label(self._booksList[self._selectedComboIndex][2])
-
- selectedFactoryId = self._booksList[self._selectedComboIndex][0]
- selectedBookId = self._booksList[self._selectedComboIndex][1]
- self.open_addressbook(selectedFactoryId, selectedBookId)
+ self._itemView.setEnabled(True)
def disable(self):
- self._contactsview.disconnect(self._onContactsviewRowActivatedId)
- self._bookSelectionButton.disconnect(self._onAddressbookButtonChangedId)
-
- self.clear()
-
- self._bookSelectionButton.set_label("")
- self._contactsview.set_model(None)
- self._contactsview.remove_column(self._contactColumn)
-
- def add_contact(self, *args, **kwds):
- """
- @note Actual dial function is patched in later
- """
- raise NotImplementedError("Horrible unknown error has occurred")
-
- def get_addressbooks(self):
- """
- @returns Iterable of ((Factory Id, Book Id), (Factory Name, Book Name))
- """
- for i, factory in enumerate(self._addressBookFactories):
- for bookFactory, bookId, bookName in factory.get_addressbooks():
- yield (str(i), bookId), (factory.factory_name(), bookName)
-
- def open_addressbook(self, bookFactoryId, bookId):
- bookFactoryIndex = int(bookFactoryId)
- addressBook = self._addressBookFactories[bookFactoryIndex].open_addressbook(bookId)
- self._addressBook = addressBook
-
- def update(self, force = False):
- if not force and self._isPopulated:
- return False
- self._updateSink.send(())
- return True
-
- def clear(self):
- self._isPopulated = False
- self._contactsmodel.clear()
- for factory in self._addressBookFactories:
- factory.clear_caches()
- self._addressBook.clear_caches()
-
- def append(self, book):
- self._addressBookFactories.append(book)
+ self._itemView.setEnabled(False)
- def extend(self, books):
- self._addressBookFactories.extend(books)
-
- @staticmethod
- def name():
- return "Contacts"
+ def get_settings(self):
+ return {
+ "selectedAddressbook": self._activeList,
+ }
- def load_settings(self, config, sectionName):
+ def set_settings(self, settings):
+ currentItem = settings.get("selectedAddressbook", "None")
+ bookNames = [book["name"] for book in self._addressBooks]
try:
- self._selectedComboIndex = config.getint(sectionName, "selectedAddressbook")
- except ConfigParser.NoOptionError:
- self._selectedComboIndex = 0
-
- def save_settings(self, config, sectionName):
- config.set(sectionName, "selectedAddressbook", str(self._selectedComboIndex))
+ newIndex = bookNames.index(currentItem)
+ except ValueError:
+ # Switch over to None for the user
+ newIndex = 0
+ self._listSelection.setCurrentIndex(newIndex)
+ self._activeList = currentItem
- def _idly_populate_contactsview(self):
- with gtk_toolbox.gtk_lock():
- banner = hildonize.show_busy_banner_start(self._window, "Loading Contacts")
- try:
- addressBook = None
- while addressBook is not self._addressBook:
- addressBook = self._addressBook
- with gtk_toolbox.gtk_lock():
- self._contactsview.set_model(None)
- self.clear()
-
- try:
- contacts = addressBook.get_contacts()
- except Exception, e:
- contacts = []
- self._isPopulated = False
- self._errorDisplay.push_exception_with_lock()
- for contactId, contactName in contacts:
- contactType = addressBook.contact_source_short_name(contactId)
- row = contactType, contactName, contactId
- self._contactsmodel.append(row)
-
- with gtk_toolbox.gtk_lock():
- self._contactsview.set_model(self._contactsmodel)
-
- self._isPopulated = True
- except Exception, e:
- self._errorDisplay.push_exception_with_lock()
- finally:
- with gtk_toolbox.gtk_lock():
- hildonize.show_busy_banner_end(banner)
- return False
-
- def _on_addressbook_button_changed(self, *args, **kwds):
- try:
- try:
- newSelectedComboIndex = hildonize.touch_selector(
- self._window,
- "Addressbook",
- (("%s" % m[2]) for m in self._booksList),
- self._selectedComboIndex,
- )
- except RuntimeError:
- return
+ def clear(self):
+ self._itemView.clear()
- selectedFactoryId = self._booksList[newSelectedComboIndex][0]
- selectedBookId = self._booksList[newSelectedComboIndex][1]
+ def refresh(self, force=True):
+ self._itemView.setFocus(QtCore.Qt.OtherFocusReason)
+ self._backend.update_account(force)
- oldAddressbook = self._addressBook
- self.open_addressbook(selectedFactoryId, selectedBookId)
- forceUpdate = True if oldAddressbook is not self._addressBook else False
- self.update(force=forceUpdate)
+ @property
+ def _backend(self):
+ return self._addressBooks[self._listSelection.currentIndex()]["book"]
- self._selectedComboIndex = newSelectedComboIndex
- self._bookSelectionButton.set_label(self._booksList[self._selectedComboIndex][2])
- except Exception, e:
- self._errorDisplay.push_exception()
+ def update_addressbooks(self):
+ self._addressBooks = [
+ {"book": book, "name": book.name}
+ for factory in self._addressBookFactories
+ for book in factory.get_addressbooks()
+ ]
+ self._addressBooks.append(
+ {
+ "book": self._session,
+ "name": "Google Voice",
+ }
+ )
- def _on_contactsview_row_activated(self, treeview, path, view_column):
+ currentItem = str(self._listSelection.currentText())
+ self._activeList = currentItem
+ if currentItem == "":
+ # Not loaded yet
+ currentItem = "None"
+ self._listSelection.clear()
+ bookNames = [book["name"] for book in self._addressBooks]
try:
- itr = self._contactsmodel.get_iter(path)
- if not itr:
- return
-
- contactId = self._contactsmodel.get_value(itr, self.CONTACT_ID_IDX)
- contactName = self._contactsmodel.get_value(itr, self.CONTACT_NAME_IDX)
- try:
- contactDetails = self._addressBook.get_contact_details(contactId)
- except Exception, e:
- contactDetails = []
- self._errorDisplay.push_exception()
- contactPhoneNumbers = [phoneNumber for phoneNumber in contactDetails]
-
- if len(contactPhoneNumbers) == 0:
+ newIndex = bookNames.index(currentItem)
+ except ValueError:
+ # Switch over to None for the user
+ newIndex = 0
+ self._itemStore.clear()
+ _moduleLogger.info("Addressbook %r doesn't exist anymore, switching to None" % currentItem)
+ self._listSelection.addItems(bookNames)
+ self._listSelection.setCurrentIndex(newIndex)
+
+ def _populate_items(self):
+ self._itemStore.clear()
+ self._alphaItem = dict(
+ (letter, QtGui.QStandardItem(letter))
+ for letter in self._prefixes()
+ )
+ for letter in self._prefixes():
+ item = self._alphaItem[letter]
+ item.setEditable(False)
+ item.setCheckable(False)
+ row = (item, )
+ self._itemStore.appendRow(row)
+
+ for item in self._get_contacts():
+ name = item["name"]
+ if not name:
+ name = "Unknown"
+ numbers = item["numbers"]
+
+ nameItem = QtGui.QStandardItem(name)
+ nameItem.setEditable(False)
+ nameItem.setCheckable(False)
+ nameItem.setData(item)
+ nameItemFont = nameItem.font()
+ nameItemFont.setPointSize(max(nameItemFont.pointSize() + 4, 5))
+ nameItem.setFont(nameItemFont)
+
+ row = (nameItem, )
+ rowKey = name[0].upper()
+ rowKey = rowKey if rowKey in self._alphaItem else "#"
+ self._alphaItem[rowKey].appendRow(row)
+ self._itemView.expandAll()
+
+ def _prefixes(self):
+ return itertools.chain(string.ascii_uppercase, ("#", ))
+
+ def _jump_to_prefix(self, letter):
+ i = list(self._prefixes()).index(letter)
+ rootIndex = self._itemView.rootIndex()
+ currentIndex = self._itemView.model().index(i, 0, rootIndex)
+ self._itemView.scrollTo(currentIndex)
+ self._itemView.setItemSelected(self._itemView.topLevelItem(i), True)
+
+ def _get_contacts(self):
+ contacts = list(self._backend.get_contacts().itervalues())
+ contacts.sort(key=lambda contact: contact["name"].lower())
+ return contacts
+
+ @qt_compat.Slot(str)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_filter_changed(self, newItem):
+ with qui_utils.notify_error(self._errorLog):
+ self._activeList = str(newItem)
+ self.refresh(force=False)
+ self._populate_items()
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_refresh_clicked(self, arg = None):
+ with qui_utils.notify_error(self._errorLog):
+ self.refresh(force=True)
+
+ @qt_compat.Slot()
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_contacts_updated(self):
+ with qui_utils.notify_error(self._errorLog):
+ self._populate_items()
+
+ @qt_compat.Slot(QtCore.QModelIndex)
+ @misc_utils.log_exception(_moduleLogger)
+ def _on_row_activated(self, index):
+ with qui_utils.notify_error(self._errorLog):
+ letterIndex = index.parent()
+ if not letterIndex.isValid():
return
+ letterRow = letterIndex.row()
+ letter = list(self._prefixes())[letterRow]
+ letterItem = self._alphaItem[letter]
+ rowIndex = index.row()
+ item = letterItem.child(rowIndex, 0)
+ contactDetails = item.data()
+
+ name = unicode(contactDetails["name"])
+ if not name:
+ name = unicode(contactDetails["location"])
+ if not name:
+ name = "Unknown"
+
+ contactId = str(contactDetails["contactId"])
+ numbers = contactDetails["numbers"]
+ numbers = [
+ dict(
+ (str(k), str(v))
+ for (k, v) in number.iteritems()
+ )
+ for number in numbers
+ ]
+ numbersWithDescriptions = [
+ (
+ number["phoneNumber"],
+ self._choose_phonetype(number),
+ )
+ for number in numbers
+ ]
+ title = name
+ description = name
+ self._session.draft.add_contact(contactId, None, title, description, numbersWithDescriptions)
- self.add_contact(
- contactName,
- contactPhoneNumbers,
- messages = (contactName, ),
- )
- self._contactsviewselection.unselect_all()
- except Exception, e:
- self._errorDisplay.push_exception()
+ @staticmethod
+ def _choose_phonetype(numberDetails):
+ if "phoneTypeName" in numberDetails:
+ return numberDetails["phoneTypeName"]
+ elif "phoneType" in numberDetails:
+ return numberDetails["phoneType"]
+ else:
+ return ""
projects / gc-dialer / blobdiff