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

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