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
5 Using new api widgets people are developing)
6 Integrate GPS w/ fallback to default location
7 Use locations for mapping
8 @todo Add a quick search (OR within a property type, and between property types) view
9 Drop down for multi selecting priority
10 Drop down for multi selecting tags
11 Drop down for multi selecting locations
12 Calendar selector for choosing due date range
13 @todo Remove blocking operations from UI thread
31 def abbreviate(text, expectedLen):
32 singleLine = " ".join(text.split("\n"))
33 lineLen = len(singleLine)
34 if lineLen <= expectedLen:
39 leftLen = expectedLen // 2 - 1
40 rightLen = max(expectedLen - leftLen - len(abbrev) + 1, 1)
42 abbrevText = singleLine[0:leftLen] + abbrev + singleLine[-rightLen:-1]
43 assert len(abbrevText) <= expectedLen, "Too long: '%s'" % abbrevText
47 def abbreviate_url(url, domainLength, pathLength):
48 urlParts = urlparse.urlparse(url)
50 netloc = urlParts.netloc
53 pathLength += max(domainLength - len(netloc), 0)
54 domainLength += max(pathLength - len(path), 0)
56 netloc = abbreviate(netloc, domainLength)
57 path = abbreviate(path, pathLength)
61 def get_token(username, apiKey, secret):
63 rtm = rtm_api.RTMapi(username, apiKey, secret, token)
65 authURL = rtm.getAuthURL()
66 webbrowser.open(authURL)
67 mb = gtk_toolbox.MessageBox2("You need to authorize DoneIt with\nRemember The Milk.\nClick OK after you authorize.")
70 token = rtm.getToken()
74 def get_credentials(credentialsDialog):
75 username, password = credentialsDialog.request_credentials()
76 token = get_token(username, rtm_backend.RtMilkManager.API_KEY, rtm_backend.RtMilkManager.SECRET)
77 return username, password, token
80 def item_sort_by_priority_then_date(items):
81 sortedTasks = list(items)
83 key = lambda taskDetails: (
84 taskDetails["priority"].get_nothrow(4),
85 taskDetails["dueDate"].get_nothrow(datetime.datetime.max),
91 def item_sort_by_date_then_priority(items):
92 sortedTasks = list(items)
94 key = lambda taskDetails: (
95 taskDetails["dueDate"].get_nothrow(datetime.datetime.max),
96 taskDetails["priority"].get_nothrow(4),
102 def item_in_agenda(item):
103 taskDate = item["dueDate"].get_nothrow(datetime.datetime.max)
104 today = datetime.datetime.now()
105 delta = taskDate - today
106 dayDelta = abs(delta.days)
108 priority = item["priority"].get_nothrow(4)
109 weeksVisible = 5 - priority
111 isVisible = not bool(dayDelta / (weeksVisible * 7))
115 def item_sort_by_fuzzydate_then_priority(items):
116 sortedTasks = list(items)
118 def advanced_key(taskDetails):
119 dueDate = taskDetails["dueDate"].get_nothrow(datetime.datetime.max)
120 priority = taskDetails["priority"].get_nothrow(4)
121 isNotSameYear = not toolbox.is_same_year(dueDate)
122 isNotSameMonth = not toolbox.is_same_month(dueDate)
123 isNotSameDay = not toolbox.is_same_day(dueDate)
124 return isNotSameDay, isNotSameMonth, isNotSameYear, priority, dueDate
126 sortedTasks.sort(key=advanced_key)
130 class ItemListView(object):
141 def __init__(self, widgetTree, errorDisplay):
142 self._errorDisplay = errorDisplay
145 self._showCompleted = False
146 self._showIncomplete = True
148 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
149 self._notesDialog = gtk_toolbox.NotesDialog(widgetTree)
151 self._itemList = gtk.ListStore(
152 gobject.TYPE_STRING, # id
153 gobject.TYPE_BOOLEAN, # is complete
154 gobject.TYPE_STRING, # name
155 gobject.TYPE_STRING, # priority
156 gobject.TYPE_STRING, # due
157 gobject.TYPE_STRING, # fuzzy due
158 gobject.TYPE_STRING, # Link
159 gobject.TYPE_STRING, # Notes
161 self._completionColumn = gtk.TreeViewColumn('') # Complete?
162 self._completionCell = gtk.CellRendererToggle()
163 self._completionCell.set_property("activatable", True)
164 self._completionCell.connect("toggled", self._on_completion_change)
165 self._completionColumn.pack_start(self._completionCell, False)
166 self._completionColumn.set_attributes(self._completionCell, active=self.COMPLETION_IDX)
167 self._priorityColumn = gtk.TreeViewColumn('') # Priority
168 self._priorityCell = gtk.CellRendererText()
169 self._priorityColumn.pack_start(self._priorityCell, False)
170 self._priorityColumn.set_attributes(self._priorityCell, text=self.PRIORITY_IDX)
171 self._nameColumn = gtk.TreeViewColumn('Name')
172 self._nameCell = gtk.CellRendererText()
173 self._nameColumn.pack_start(self._nameCell, True)
174 self._nameColumn.set_attributes(self._nameCell, text=self.NAME_IDX)
175 self._dueColumn = gtk.TreeViewColumn('Due')
176 self._dueCell = gtk.CellRendererText()
177 self._dueColumn.pack_start(self._nameCell, False)
178 self._dueColumn.set_attributes(self._nameCell, text=self.FUZZY_IDX)
179 self._linkColumn = gtk.TreeViewColumn('') # Link
180 self._linkCell = gtk.CellRendererText()
181 self._linkColumn.pack_start(self._nameCell, False)
182 self._linkColumn.set_attributes(self._nameCell, text=self.LINK_IDX)
183 self._notesColumn = gtk.TreeViewColumn('') # Notes
184 self._notesCell = gtk.CellRendererText()
185 self._notesColumn.pack_start(self._nameCell, False)
186 self._notesColumn.set_attributes(self._nameCell, text=self.NOTES_IDX)
188 self._todoBox = widgetTree.get_widget("todoBox")
189 self._todoItemScroll = gtk.ScrolledWindow()
190 self._todoItemScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
191 self._todoItemTree = gtk.TreeView()
192 self._todoItemScroll.add(self._todoItemTree)
193 self._onItemSelectId = 0
195 def enable(self, manager, projId):
196 self._manager = manager
197 self._projId = projId
199 self._todoBox.pack_start(self._todoItemScroll)
200 self._todoItemScroll.show_all()
202 self._itemList.clear()
203 self._todoItemTree.append_column(self._completionColumn)
204 self._todoItemTree.append_column(self._priorityColumn)
205 self._todoItemTree.append_column(self._nameColumn)
206 self._todoItemTree.append_column(self._dueColumn)
207 self._todoItemTree.append_column(self._linkColumn)
208 self._todoItemTree.append_column(self._notesColumn)
210 self.reset_task_list(self._projId)
211 except StandardError, e:
212 self._errorDisplay.push_exception()
214 self._todoItemTree.set_headers_visible(False)
215 self._nameColumn.set_expand(True)
217 self._onItemSelectId = self._todoItemTree.connect("row-activated", self._on_item_select)
223 self._todoBox.remove(self._todoItemScroll)
224 self._todoItemScroll.hide_all()
225 self._todoItemTree.disconnect(self._onItemSelectId)
227 self._todoItemTree.remove_column(self._completionColumn)
228 self._todoItemTree.remove_column(self._priorityColumn)
229 self._todoItemTree.remove_column(self._nameColumn)
230 self._todoItemTree.remove_column(self._dueColumn)
231 self._todoItemTree.remove_column(self._linkColumn)
232 self._todoItemTree.remove_column(self._notesColumn)
233 self._itemList.clear()
234 self._itemList.set_model(None)
236 def reset_task_list(self, projId):
237 self._projId = projId
238 self._itemList.clear()
239 self._populate_items()
241 def _populate_items(self):
242 projId = self._projId
243 rawTasks = self._manager.get_tasks_with_details(projId)
246 for taskDetails in rawTasks
247 if self._showCompleted and taskDetails["isCompleted"] or self._showIncomplete and not taskDetails["isCompleted"]
249 # filteredTasks = (taskDetails for taskDetails in filteredTasks if item_in_agenda(taskDetails))
250 sortedTasks = item_sort_by_priority_then_date(filteredTasks)
251 # sortedTasks = item_sort_by_date_then_priority(filteredTasks)
252 # sortedTasks = item_sort_by_fuzzydate_then_priority(filteredTasks)
253 for taskDetails in sortedTasks:
254 id = taskDetails["id"]
255 isCompleted = taskDetails["isCompleted"]
256 name = abbreviate(taskDetails["name"], 100)
257 priority = str(taskDetails["priority"].get_nothrow(""))
258 if taskDetails["dueDate"].is_good():
259 dueDate = taskDetails["dueDate"].get()
260 dueDescription = dueDate.strftime("%Y-%m-%d %H:%M:%S")
261 fuzzyDue = toolbox.to_fuzzy_date(dueDate)
266 linkDisplay = taskDetails["url"]
267 linkDisplay = abbreviate_url(linkDisplay, 20, 10)
269 notes = taskDetails["notes"]
270 notesDisplay = "%d Notes" % len(notes) if notes else ""
272 row = (id, isCompleted, name, priority, dueDescription, fuzzyDue, linkDisplay, notesDisplay)
273 self._itemList.append(row)
274 self._todoItemTree.set_model(self._itemList)
276 def _on_item_select(self, treeView, path, viewColumn):
278 # @todo See if there is a way to use the new gtk_toolbox.ContextHandler
279 taskId = self._itemList[path[0]][self.ID_IDX]
281 if viewColumn is self._priorityColumn:
283 elif viewColumn is self._nameColumn:
284 self._editDialog.enable(self._manager)
286 self._editDialog.request_task(self._manager, taskId)
288 self._editDialog.disable()
289 self.reset_task_list(self._projId)
290 elif viewColumn is self._dueColumn:
291 due = self._manager.get_task_details(taskId)["dueDate"]
293 calendar = gtk_toolbox.PopupCalendar(None, due.get())
295 elif viewColumn is self._linkColumn:
296 webbrowser.open(self._manager.get_task_details(taskId)["url"])
297 elif viewColumn is self._notesColumn:
298 self._notesDialog.enable()
300 self._notesDialog.run(self._manager, taskId)
302 self._notesDialog.disable()
303 except StandardError, e:
304 self._errorDisplay.push_exception()
306 def _on_completion_change(self, cell, path):
308 taskId = self._itemList[path[0]][self.ID_IDX]
309 self._manager.complete_task(taskId)
310 self.reset_task_list(self._projId)
311 except StandardError, e:
312 self._errorDisplay.push_exception()
315 class QuickAddView(object):
317 def __init__(self, widgetTree, errorDisplay, addSink):
318 self._errorDisplay = errorDisplay
321 self._addSink = addSink
323 self._clipboard = gtk.clipboard_get()
324 self._editDialog = gtk_toolbox.EditTaskDialog(widgetTree)
326 self._taskNameEntry = widgetTree.get_widget("add-taskNameEntry")
327 self._addTaskButton = widgetTree.get_widget("add-addTaskButton")
328 self._pasteTaskNameButton = widgetTree.get_widget("add-pasteTaskNameButton")
329 self._clearTaskNameButton = widgetTree.get_widget("add-clearTaskNameButton")
331 self._onAddClickedId = None
332 self._onAddReleasedId = None
333 self._addToEditTimerId = None
334 self._onClearId = None
335 self._onPasteId = None
337 def enable(self, manager, projId):
338 self._manager = manager
339 self._projId = projId
341 self._onAddId = self._addTaskButton.connect("clicked", self._on_add)
342 self._onAddClickedId = self._addTaskButton.connect("pressed", self._on_add_pressed)
343 self._onAddReleasedId = self._addTaskButton.connect("released", self._on_add_released)
344 self._onPasteId = self._pasteTaskNameButton.connect("clicked", self._on_paste)
345 self._onClearId = self._clearTaskNameButton.connect("clicked", self._on_clear)
351 self._addTaskButton.disconnect(self._onAddId)
352 self._addTaskButton.disconnect(self._onAddClickedId)
353 self._addTaskButton.disconnect(self._onAddReleasedId)
354 self._pasteTaskNameButton.disconnect(self._onPasteId)
355 self._clearTaskNameButton.disconnect(self._onClearId)
357 def reset_task_list(self, projId):
358 self._projId = projId
359 isMeta = self._manager.get_project(self._projId)["isMeta"]
360 # @todo RTM handles this by defaulting to a specific list
361 self._addTaskButton.set_sensitive(not isMeta)
363 def _on_add(self, *args):
365 name = self._taskNameEntry.get_text()
367 projId = self._projId
368 taskId = self._manager.add_task(projId, name)
370 self._taskNameEntry.set_text("")
371 self._addSink.send((projId, taskId))
372 except StandardError, e:
373 self._errorDisplay.push_exception()
375 def _on_add_edit(self, *args):
377 name = self._taskNameEntry.get_text()
379 projId = self._projId
380 taskId = self._manager.add_task(projId, name)
383 self._editDialog.enable(self._manager)
385 self._editDialog.request_task(self._manager, taskId)
387 self._editDialog.disable()
389 self._taskNameEntry.set_text("")
390 self._addSink.send((projId, taskId))
391 except StandardError, e:
392 self._errorDisplay.push_exception()
394 def _on_add_pressed(self, widget):
396 self._addToEditTimerId = gobject.timeout_add(1000, self._on_add_edit)
397 except StandardError, e:
398 self._errorDisplay.push_exception()
400 def _on_add_released(self, widget):
402 if self._addToEditTimerId is not None:
403 gobject.source_remove(self._addToEditTimerId)
404 self._addToEditTimerId = None
405 except StandardError, e:
406 self._errorDisplay.push_exception()
408 def _on_paste(self, *args):
410 entry = self._taskNameEntry.get_text()
411 entry += self._clipboard.wait_for_text()
412 self._taskNameEntry.set_text(entry)
413 except StandardError, e:
414 self._errorDisplay.push_exception()
416 def _on_clear(self, *args):
418 self._taskNameEntry.set_text("")
419 except StandardError, e:
420 self._errorDisplay.push_exception()
423 class GtkRtMilk(object):
425 def __init__(self, widgetTree, errorDisplay):
427 @note Thread agnostic
429 self._errorDisplay = errorDisplay
431 self._credentials = "", "", ""
433 self._projectsList = gtk.ListStore(gobject.TYPE_STRING)
434 self._projectsCombo = widgetTree.get_widget("projectsCombo")
435 self._onListActivateId = 0
437 self._itemView = ItemListView(widgetTree, self._errorDisplay)
438 addSink = coroutines.func_sink(lambda eventData: self._itemView.reset_task_list(eventData[0]))
439 self._addView = QuickAddView(widgetTree, self._errorDisplay, addSink)
440 self._credentialsDialog = gtk_toolbox.LoginWindow(widgetTree)
444 return "Remember The Milk"
446 def load_settings(self, config):
448 @note Thread Agnostic
451 config.get(self.name(), "bin_blob_%i" % i)
452 for i in xrange(len(self._credentials))
455 base64.b64decode(blob)
458 self._credentials = tuple(creds)
460 def save_settings(self, config):
462 @note Thread Agnostic
464 config.add_section(self.name())
465 for i, value in enumerate(self._credentials):
466 blob = base64.b64encode(value)
467 config.set(self.name(), "bin_blob_%i" % i, blob)
473 if self._manager is not None:
476 credentials = self._credentials
479 self._manager = rtm_backend.RtMilkManager(*credentials)
480 self._credentials = credentials
481 return # Login succeeded
482 except rtm_api.AuthStateMachine.NoData:
483 # Login failed, grab new credentials
484 credentials = get_credentials(self._credentialsDialog)
488 @note Thread Agnostic
490 self._credentials = "", "", ""
497 self._projectsList.clear()
498 self._populate_projects()
500 currentProject = self._get_project()
501 projId = self._manager.lookup_project(currentProject)["id"]
502 self._addView.enable(self._manager, projId)
503 self._itemView.enable(self._manager, projId)
505 self._onListActivateId = self._projectsCombo.connect("changed", self._on_list_activate)
511 self._projectsCombo.disconnect(self._onListActivateId)
513 self._addView.disable()
514 self._itemView.disable()
516 self._projectsList.clear()
517 self._projectsCombo.set_model(None)
518 self._projectsCombo.disconnect("changed", self._on_list_activate)
522 def _populate_projects(self):
523 for project in self._manager.get_projects():
524 projectName = project["name"]
525 isVisible = project["isVisible"]
526 row = (projectName, )
528 self._projectsList.append(row)
529 self._projectsCombo.set_model(self._projectsList)
530 cell = gtk.CellRendererText()
531 self._projectsCombo.pack_start(cell, True)
532 self._projectsCombo.add_attribute(cell, 'text', 0)
533 self._projectsCombo.set_active(0)
535 def _reset_task_list(self):
536 projectName = self._get_project()
537 projId = self._manager.lookup_project(projectName)["id"]
538 self._addView.reset_task_list(projId)
539 self._itemView.reset_task_list(projId)
541 def _get_project(self):
542 currentProjectName = self._projectsCombo.get_active_text()
543 return currentProjectName
545 def _on_list_activate(self, *args):
547 self._reset_task_list()
548 except StandardError, e:
549 self._errorDisplay.push_exception()