git.maemo.org Git - doneit/blob - src/rtm_view.py

   1 import webbrowser
   2 import datetime
   3 import urlparse
   4 import base64
   5
   6 import gobject
   7 import gtk
   8
   9 import toolbox
  10 import gtk_toolbox
  11 import rtm_backend
  12 import rtm_api
  13
  14
  15 def abbreviate(text, expectedLen):
  16         singleLine = " ".join(text.split("\n"))
  17         lineLen = len(singleLine)
  18         if lineLen <= expectedLen:
  19                 return singleLine
  20
  21         abbrev = "..."
  22
  23         leftLen = expectedLen // 2 - 1
  24         rightLen = max(expectedLen - leftLen - len(abbrev) + 1, 1)
  25
  26         abbrevText =  singleLine[0:leftLen] + abbrev + singleLine[-rightLen:-1]
  27         assert len(abbrevText) <= expectedLen, "Too long: '%s'" % abbrevText
  28         return abbrevText
  29
  30
  31 def abbreviate_url(url, domainLength, pathLength):
  32         urlParts = urlparse.urlparse(url)
  33
  34         netloc = urlParts.netloc
  35         path = urlParts.path
  36
  37         pathLength += max(domainLength - len(netloc), 0)
  38         domainLength += max(pathLength - len(path), 0)
  39
  40         netloc = abbreviate(netloc, domainLength)
  41         path = abbreviate(path, pathLength)
  42         return netloc + path
  43
  44
  45 def get_token(username, apiKey, secret):
  46         token = None
  47         rtm = rtm_api.RTMapi(username, apiKey, secret, token)
  48
  49         authURL = rtm.getAuthURL()
  50         webbrowser.open(authURL)
  51         mb = gtk_toolbox.MessageBox2("You need to authorize DoneIt with\nRemember The Milk.\nClick OK after you authorize.")
  52         mb.run()
  53
  54         token = rtm.getToken()
  55         return token
  56
  57
  58 def get_credentials(credentialsDialog):
  59         username, password = credentialsDialog.request_credentials()
  60         token = get_token(username, rtm_backend.RtMilkManager.API_KEY, rtm_backend.RtMilkManager.SECRET)
  61         return username, password, token
  62
  63
  64 class GtkRtMilk(object):
  65
  66         ID_IDX = 0
  67         COMPLETION_IDX = 1
  68         NAME_IDX = 2
  69         PRIORITY_IDX = 3
  70         DUE_IDX = 4
  71         FUZZY_IDX = 5
  72         LINK_IDX = 6
  73         NOTES_IDX = 7
  74
  75         def __init__(self, widgetTree):
  76                 """
  77                 @note Thread agnostic
  78                 """
  79                 self._clipboard = gtk.clipboard_get()
  80
  81                 self._showCompleted = False
  82                 self._showIncomplete = True
  83
  84                 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
  85
  86                 self._projectsList = gtk.ListStore(gobject.TYPE_STRING)
  87                 self._projectsCombo = widgetTree.get_widget("projectsCombo")
  88                 self._onListActivateId = 0
  89
  90                 # @todo Need to figure out how to make the list sortable, especially with weird priority sorting
  91                 self._itemList = gtk.ListStore(
  92                         gobject.TYPE_STRING, # id
  93                         gobject.TYPE_BOOLEAN, # is complete
  94                         gobject.TYPE_STRING, # name
  95                         gobject.TYPE_STRING, # priority
  96                         gobject.TYPE_STRING, # due
  97                         gobject.TYPE_STRING, # fuzzy due
  98                         gobject.TYPE_STRING, # Link
  99                         gobject.TYPE_STRING, # Notes
 100                 )
 101                 self._completionColumn = gtk.TreeViewColumn('') # Complete?
 102                 self._completionCell = gtk.CellRendererToggle()
 103                 self._completionCell.set_property("activatable", True)
 104                 self._completionCell.connect("toggled", self._on_completion_change)
 105                 self._completionColumn.pack_start(self._completionCell, False)
 106                 self._completionColumn.set_attributes(self._completionCell, active=self.COMPLETION_IDX)
 107                 self._priorityColumn = gtk.TreeViewColumn('') # Priority
 108                 self._priorityCell = gtk.CellRendererText()
 109                 self._priorityColumn.pack_start(self._priorityCell, False)
 110                 self._priorityColumn.set_attributes(self._priorityCell, text=self.PRIORITY_IDX)
 111                 self._nameColumn = gtk.TreeViewColumn('Name')
 112                 self._nameCell = gtk.CellRendererText()
 113                 self._nameColumn.pack_start(self._nameCell, True)
 114                 self._nameColumn.set_attributes(self._nameCell, text=self.NAME_IDX)
 115                 self._dueColumn = gtk.TreeViewColumn('Due')
 116                 self._dueCell = gtk.CellRendererText()
 117                 self._dueColumn.pack_start(self._nameCell, False)
 118                 self._dueColumn.set_attributes(self._nameCell, text=self.FUZZY_IDX)
 119                 self._linkColumn = gtk.TreeViewColumn('') # Link
 120                 self._linkCell = gtk.CellRendererText()
 121                 self._linkColumn.pack_start(self._nameCell, False)
 122                 self._linkColumn.set_attributes(self._nameCell, text=self.LINK_IDX)
 123                 self._notesColumn = gtk.TreeViewColumn('') # Notes
 124                 self._notesCell = gtk.CellRendererText()
 125                 self._notesColumn.pack_start(self._nameCell, False)
 126                 self._notesColumn.set_attributes(self._nameCell, text=self.NOTES_IDX)
 127
 128                 self._todoItemTree = widgetTree.get_widget("todoItemTree")
 129                 self._onItemSelectId = 0
 130
 131                 self._taskNameEntry = widgetTree.get_widget("add-taskNameEntry")
 132                 self._addTaskButton = widgetTree.get_widget("add-addTaskButton")
 133                 self._pasteTaskNameButton = widgetTree.get_widget("add-pasteTaskNameButton")
 134                 self._clearTaskNameButton = widgetTree.get_widget("add-clearTaskNameButton")
 135                 self._onAddId = None
 136                 self._onAddClickedId = None
 137                 self._onAddReleasedId = None
 138                 self._addToEditTimerId = None
 139                 self._onClearId = None
 140                 self._onPasteId = None
 141
 142                 self._credentialsDialog = gtk_toolbox.LoginWindow(widgetTree)
 143                 self._credentials = "", "", ""
 144                 self._manager = None
 145
 146         @staticmethod
 147         def name():
 148                 return "Remember The Milk"
 149
 150         def load_settings(self, config):
 151                 """
 152                 @note Thread Agnostic
 153                 """
 154                 blobs = (
 155                         config.get(self.name(), "bin_blob_%i" % i)
 156                         for i in xrange(len(self._credentials))
 157                 )
 158                 creds = (
 159                         base64.b64decode(blob)
 160                         for blob in blobs
 161                 )
 162                 self._credentials = tuple(creds)
 163
 164         def save_settings(self, config):
 165                 """
 166                 @note Thread Agnostic
 167                 """
 168                 config.add_section(self.name())
 169                 for i, value in enumerate(self._credentials):
 170                         blob = base64.b64encode(value)
 171                         config.set(self.name(), "bin_blob_%i" % i, blob)
 172
 173         def login(self):
 174                 """
 175                 @note UI Thread
 176                 """
 177                 if self._manager is not None:
 178                         return
 179
 180                 credentials = self._credentials
 181                 while True:
 182                         try:
 183                                 self._manager = rtm_backend.RtMilkManager(*credentials)
 184                                 self._credentials = credentials
 185                                 return # Login succeeded
 186                         except rtm_api.AuthStateMachine.NoData:
 187                                 # Login failed, grab new credentials
 188                                 credentials = get_credentials(self._credentialsDialog)
 189
 190         def logout(self):
 191                 """
 192                 @note Thread Agnostic
 193                 """
 194                 self._credentials = "", "", ""
 195                 self._manager = None
 196
 197         def enable(self):
 198                 """
 199                 @note UI Thread
 200                 """
 201                 self._projectsList.clear()
 202                 self._populate_projects()
 203
 204                 self._itemList.clear()
 205                 self._todoItemTree.append_column(self._completionColumn)
 206                 self._todoItemTree.append_column(self._priorityColumn)
 207                 self._todoItemTree.append_column(self._nameColumn)
 208                 self._todoItemTree.append_column(self._dueColumn)
 209                 self._todoItemTree.append_column(self._linkColumn)
 210                 self._todoItemTree.append_column(self._notesColumn)
 211                 self._reset_task_list()
 212
 213                 self._todoItemTree.set_headers_visible(False)
 214                 self._nameColumn.set_expand(True)
 215
 216                 self._editDialog.enable(self._manager)
 217
 218                 self._onListActivateId = self._projectsCombo.connect("changed", self._on_list_activate)
 219                 self._onItemSelectId = self._todoItemTree.connect("row-activated", self._on_item_select)
 220                 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
 221                 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
 222                 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
 223                 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
 224                 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
 225
 226         def disable(self):
 227                 """
 228                 @note UI Thread
 229                 """
 230                 self._projectsCombo.disconnect(self._onListActivateId)
 231                 self._todoItemTree.disconnect(self._onItemSelectId)
 232                 self._addTaskButton.disconnect(self._onAddId)
 233                 self._addTaskButton.disconnect(self._onAddClickedId)
 234                 self._addTaskButton.disconnect(self._onAddReleasedId)
 235                 self._pasteTaskNameButton.disconnect(self._onPasteId)
 236                 self._clearTaskNameButton.disconnect(self._onClearId)
 237
 238                 self._editDialog.disable()
 239
 240                 self._projectsList.clear()
 241                 self._projectsCombo.set_model(None)
 242                 self._projectsCombo.disconnect("changed", self._on_list_activate)
 243
 244                 self._todoItemTree.remove_column(self._completionColumn)
 245                 self._todoItemTree.remove_column(self._priorityColumn)
 246                 self._todoItemTree.remove_column(self._nameColumn)
 247                 self._todoItemTree.remove_column(self._dueColumn)
 248                 self._todoItemTree.remove_column(self._linkColumn)
 249                 self._todoItemTree.remove_column(self._notesColumn)
 250                 self._itemList.clear()
 251                 self._itemList.set_model(None)
 252
 253                 self._manager = None
 254
 255         def _populate_projects(self):
 256                 for project in self._manager.get_projects():
 257                         projectName = project["name"]
 258                         isVisible = project["isVisible"]
 259                         row = (projectName, )
 260                         if isVisible:
 261                                 self._projectsList.append(row)
 262                 self._projectsCombo.set_model(self._projectsList)
 263                 cell = gtk.CellRendererText()
 264                 self._projectsCombo.pack_start(cell, True)
 265                 self._projectsCombo.add_attribute(cell, 'text', 0)
 266                 self._projectsCombo.set_active(0)
 267
 268         def _reset_task_list(self):
 269                 currentProject = self._get_project()
 270                 projId = self._manager.lookup_project(currentProject)["id"]
 271                 isMeta = self._manager.get_project(projId)["isMeta"]
 272                 # @todo RTM handles this by defaulting to a specific list
 273                 self._addTaskButton.set_sensitive(not isMeta)
 274
 275                 self._itemList.clear()
 276                 self._populate_items()
 277
 278         def _get_project(self):
 279                 currentProjectName = self._projectsCombo.get_active_text()
 280                 return currentProjectName
 281
 282         def _populate_items(self):
 283                 # @todo Look into using a button for notes and links, and labels for all else
 284                 currentProject = self._get_project()
 285                 projId = self._manager.lookup_project(currentProject)["id"]
 286                 sortedTasks = list(self._manager.get_tasks_with_details(projId))
 287                 sortedTasks.sort(key = lambda taskDetails: (taskDetails["priority"].get_nothrow(1000), taskDetails["dueDate"].get_nothrow(datetime.datetime.max)))
 288                 for taskDetails in sortedTasks:
 289                         show = self._showCompleted if taskDetails["isCompleted"] else self._showIncomplete
 290                         if not show:
 291                                 continue
 292                         id = taskDetails["id"]
 293                         isCompleted = taskDetails["isCompleted"]
 294                         name = abbreviate(taskDetails["name"], 100)
 295                         priority = str(taskDetails["priority"].get_nothrow(""))
 296                         if taskDetails["dueDate"].is_good():
 297                                 dueDate = taskDetails["dueDate"].get()
 298                                 dueDescription = dueDate.strftime("%Y-%m-%d %H:%M:%S")
 299                                 fuzzyDue = toolbox.to_fuzzy_date(dueDate)
 300                         else:
 301                                 dueDescription = ""
 302                                 fuzzyDue = ""
 303
 304                         linkDisplay = taskDetails["url"]
 305                         linkDisplay = abbreviate_url(linkDisplay, 20, 10)
 306
 307                         notes = taskDetails["notes"]
 308                         notesDisplay = "%d Notes" % len(notes) if notes else ""
 309
 310                         row = (id, isCompleted, name, priority, dueDescription, fuzzyDue, linkDisplay, notesDisplay)
 311                         self._itemList.append(row)
 312                 self._todoItemTree.set_model(self._itemList)
 313
 314         def _on_list_activate(self, *args):
 315                 self._reset_task_list()
 316
 317         def _on_item_select(self, treeView, path, viewColumn):
 318                 # @todo See if there is a way to get a right click / tap'n'hold for more task goodness
 319                 #       https://garage.maemo.org/plugins/wiki/index.php?TapAndHold&id=40&type=g
 320                 taskId = self._itemList[path[0]][self.ID_IDX]
 321
 322                 if viewColumn is self._priorityColumn:
 323                         pass
 324                 elif viewColumn is self._nameColumn:
 325                         self._editDialog.request_task(self._manager, taskId)
 326                         self._reset_task_list()
 327                 elif viewColumn is self._dueColumn:
 328                         self._editDialog.request_task(self._manager, taskId)
 329                         self._reset_task_list()
 330                 elif viewColumn is self._linkColumn:
 331                         webbrowser.open(self._manager.get_task_details(taskId)["url"])
 332                 elif viewColumn is self._notesColumn:
 333                         pass
 334
 335         def _on_add(self, *args):
 336                 name = self._taskNameEntry.get_text()
 337
 338                 currentProject = self._get_project()
 339                 projId = self._manager.lookup_project(currentProject)["id"]
 340                 taskId = self._manager.add_task(projId, name)
 341
 342                 self._taskNameEntry.set_text("")
 343                 self._reset_task_list()
 344
 345         def _on_add_edit(self, *args):
 346                 name = self._taskNameEntry.get_text()
 347
 348                 currentProject = self._get_project()
 349                 projId = self._manager.lookup_project(currentProject)["id"]
 350                 taskId = self._manager.add_task(projId, name)
 351
 352                 try:
 353                         self._editDialog.request_task(self._manager, taskId)
 354                 finally:
 355                         self._taskNameEntry.set_text("")
 356                         self._reset_task_list()
 357
 358         def _on_add_pressed(self, widget):
 359                 self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
 360
 361         def _on_add_released(self, widget):
 362                 if self._addToEditTimerId is not None:
 363                         gobject.source_remove(self._addToEditTimerId)
 364                 self._addToEditTimerId = None
 365
 366         def _on_paste(self, *args):
 367                 entry = self._taskNameEntry.get_text()
 368                 entry += self._clipboard.wait_for_text()
 369                 self._taskNameEntry.set_text(entry)
 370
 371         def _on_clear(self, *args):
 372                 self._taskNameEntry.set_text("")
 373
 374         def _on_completion_change(self, cell, path):
 375                 taskId = self._itemList[path[0]][self.ID_IDX]
 376                 self._manager.complete_task(taskId)
 377                 self._reset_task_list()