File tomboy-tasks-addin-20070903.patch of Package tomboy

Overview Repositories Revisions Requests Users Attributes Meta

File tomboy-tasks-addin-20070903.patch of Package tomboy (Revision e862ff13146d9e35a755bc4fbfb850dd)

Currently displaying revision e862ff13146d9e35a755bc4fbfb850dd , Show latest

Index: configure.in
===================================================================
--- configure.in	(revision 1469)
+++ configure.in	(working copy)
@@ -209,10 +209,8 @@
 Tomboy/Addins/FileSystemSyncService/Makefile
 Tomboy/Addins/WebDavSyncService/Makefile
 Tomboy/Addins/SshSyncService/Makefile
+Tomboy/Addins/Tasks/Makefile
 test/Makefile
 po/Makefile.in
 ])
 
-# Commenting out the Tasks Addin since it's not really ready for 0.8.
-#Tomboy/Addins/Tasks/Makefile
-
Index: Tomboy/Addins/Tasks/TasksNoteAddin.cs
===================================================================
--- Tomboy/Addins/Tasks/TasksNoteAddin.cs	(revision 1469)
+++ Tomboy/Addins/Tasks/TasksNoteAddin.cs	(working copy)
@@ -10,7 +10,6 @@
 	public class TasksNoteAddin : NoteAddin
 	{
 #region Members
-//		TaskManager task_mgr;
 		TaskTag last_removed_tag;
 		
 		// Each time the mouse is clicked in the TextView, update the click_mark
@@ -20,9 +19,6 @@
 		
 		Dictionary<Task, TaskOptionsDialog> options_dialogs;
 		
-		// Use this variable to track the GLib.Idle.Add call to ProcessNewline
-		uint prev_line_handler;
-		
 		const string TASK_REGEX = 
 			@"(^\s*{0}:.*$)";
 
@@ -36,7 +32,6 @@
 					string.Format (TASK_REGEX,
 					Catalog.GetString ("todo")),
 					RegexOptions.IgnoreCase | RegexOptions.Compiled
-//					   | RegexOptions.Multiline);
 					   | RegexOptions.Singleline);
 		}
 #endregion // Constructors
@@ -53,8 +48,6 @@
 			TaskManager.TaskStatusChanged += OnTaskStatusChanged;
 			
 			options_dialogs = new Dictionary<Task, TaskOptionsDialog> ();
-			
-			prev_line_handler = 0;
 		}
 		
 		public override void Shutdown ()
@@ -66,6 +59,7 @@
 			if (Note.HasBuffer) {
 				Buffer.InsertText -= OnInsertText;
 				Buffer.DeleteRange -= OnDeleteRange;
+				Buffer.DeleteRange -= OnDeleteRangeConnectBefore;
 				Buffer.TagRemoved -= OnTagRemoved;
 			}
 			
@@ -80,6 +74,7 @@
 		{
 			Buffer.InsertText += OnInsertText;
 			Buffer.DeleteRange += OnDeleteRange;
+			Buffer.DeleteRange += OnDeleteRangeConnectBefore;
 			Buffer.TagRemoved += OnTagRemoved;
 
 			Window.Editor.ButtonPressEvent += OnButtonPress;
@@ -114,7 +109,15 @@
 		void ApplyTaskTagToBlock (ref Gtk.TextIter start, Gtk.TextIter end)
 		{
 			Gtk.TextIter line_end = start;
-			line_end.ForwardToLineEnd ();
+			while (line_end.EndsLine () == false) {
+				line_end.ForwardChar ();
+			}
+			// For some reason, the above code behaves like it should (i.e.,
+			// without advancing to the next line).  The line below that's
+			// commented out doesn't work.  It ends up advancing the iter to
+			// the end of the next line.  Very strange!
+//			line_end.ForwardToLineEnd ();
+
 			
 			TaskTag task_tag = GetTaskTagFromLineIter (ref start);
 			
@@ -155,10 +158,9 @@
 				task = task_mgr.FindByUri (task_tag.Uri);
 				if (task != null) {
 					task_mgr.Delete (task);
-					last_removed_tag = null;
-				} else {
-					last_removed_tag = null;
 				}
+
+				last_removed_tag = null;
 			}
 		}
 		
@@ -212,8 +214,6 @@
 		/// </summary>
 		bool ProcessNewline ()
 		{
-			prev_line_handler = 0;
-			
 			Gtk.TextIter iter = Buffer.GetIterAtMark (Buffer.InsertMark);
 			Gtk.TextIter prev_line = iter;
 			if (prev_line.BackwardLine () == false)
@@ -242,44 +242,172 @@
 				// If the previous line's task summary is not empty, create a new
 				// task on the current line.
 				
-				Buffer.InsertAtCursor (
-						string.Format ("{0}: ",
-								Catalog.GetString ("todo")));
+				// I'm disabling the following code for now.  It automatically
+				// starts up a new task on the newline.  But since this modifies
+				// the buffer, it sometimes causes problems.
+				// TODO: Make the auto-newline work
+//				Buffer.InsertAtCursor (
+//						string.Format ("{0}: ",
+//								Catalog.GetString ("todo")));
 			}
 			
-			return false;
+			return true; // The buffer was modified
 		}
 		
 		/// <summary>
-		/// Delete the task tag on the line specified by the TextIter.
+		/// Remove the task from the line specified by the TextIter.  This
+		/// will remove the TextTag and also the "todo:" portion of the line
+		/// so it will no longer be a task.  The task summary text will be
+		/// left on the line.
 		/// <param name="iter">The TextIter specifying the line where the
-		/// TaskTag should be removed.</param>
-		/// <returns>True if a TaskTag was removed, otherwise False.</returns>
+		/// task should be removed.</param>
+		/// <returns>True if a task was removed, otherwise False.</returns>
 		/// </summary>
-		bool RemoveTaskTagFromLine (ref Gtk.TextIter iter)
+		bool RemoveTaskFromLine (ref Gtk.TextIter iter)
 		{
-			TaskTag task_tag = GetTaskTagFromLineIter (ref iter);
-			if (task_tag == null)
+			if (RemoveTaskTagFromLine (iter) == false)
 				return false;
-
+			
 			while (iter.StartsLine () == false) {
 				iter.BackwardChar ();
 			}
 			
 			Gtk.TextIter line_end = iter;
-			line_end.ForwardToLineEnd ();
+			while (line_end.EndsLine () == false) {
+				line_end.ForwardChar ();
+			}
+//			line_end.ForwardToLineEnd ();
 			
 			string text = iter.GetText (line_end);
 			
 			Buffer.Delete (ref iter, ref line_end);
-			last_removed_tag = null;
-			Buffer.RemoveTag (task_tag, iter, line_end);
 			
 			text = GetTaskSummaryFromLine (text);
 			if (text.Length > 0)
 				Buffer.Insert (ref iter, text);
 			return true;
 		}
+		
+		/// <summary>
+		/// Remove the task tag on the line specified by the TextIter.  This
+		/// will not remove the "todo:" text (i.e., it will not modify the
+		/// actual characters of the TextBuffer.
+		/// <param name="iter">The TextIter specifying the line where the
+		/// TaskTag should be removed.</param>
+		/// <returns>True if a TaskTag was removed, otherwise False.</returns>
+		/// </summary>
+		bool RemoveTaskTagFromLine (Gtk.TextIter iter)
+		{
+			Gtk.TextIter start = iter;
+			Gtk.TextIter end = iter;
+			TaskTag task_tag = GetTaskTagFromLineIter (ref start);
+			if (task_tag == null)
+				return false;
+
+			while (start.StartsLine () == false) {
+				start.BackwardChar ();
+			}
+			
+			while (end.EndsLine () == false) {
+				end.ForwardChar ();
+			}
+//			end.ForwardToLineEnd ();
+			last_removed_tag = null;
+			Buffer.RemoveTag (task_tag, start, end);
+			return true;
+		}
+		
+		/// <summary>
+		/// This method should be called during a large deletion of a
+		/// range of text so it can properly remove all the task tags.
+		/// </summary>
+		void RemoveTaskTagsFromRange (Gtk.TextIter start, Gtk.TextIter end)
+		{
+			TaskTag task_tag;
+			Gtk.TextIter line;
+			Gtk.TextIter line_start;
+			Gtk.TextIter line_end;
+			if (start.Line == end.Line) {
+Logger.Debug ("0");
+				// The iters are on the same line.
+				
+				// If there's only one character being deleted, don't do
+				// anything here.  This condition will be taken care of
+				// in ApplyTaskTagToBlock ().
+				if (end.LineOffset - start.LineOffset == 1) {
+Logger.Debug ("0.5");
+					return;
+				}
+				
+				// Determine whether this line contains a TaskTag.  If it
+				// does, determine whether deleting the range will delete
+				// the todo.
+				line = start;
+				task_tag = GetTaskTagFromLineIter (ref line);
+				if (task_tag != null) {
+					if (start.LineIndex == 0) {
+Logger.Debug ("1");
+						// Start iter is at beginning of line
+						if (end.LineOffset >= Catalog.GetString ("todo:").Length) {
+Logger.Debug ("2");
+							RemoveTaskTagFromLine (start);
+						}
+					} else if (start.LineIndex < Catalog.GetString ("todo:").Length) {
+Logger.Debug ("3");
+						// The start of the range is inside the "todo:" area,
+						// so the TaskTag needs to be removed.
+						RemoveTaskTagFromLine (start);
+					} else {
+						// Do nothing.  The deletion is just inside the
+						// summary of the task.
+Logger.Debug ("Safe range delete just to modify summary");
+					}
+				}
+			} else {
+Logger.Debug ("4");
+				// The iters are on different lines
+				
+				line = start;
+				do {
+					task_tag = GetTaskTagFromLineIter (ref line);
+					if (task_tag != null) {
+Logger.Debug ("5");
+						// Handle the first and last lines special since their
+						// range may not span the entire line.
+						if (line.Line == start.Line) {
+Logger.Debug ("6");
+							// This is the first line
+							line_end = line;
+							while (line_end.EndsLine () == false) {
+								line_end.ForwardChar ();
+							}
+//							line_end.ForwardToLineEnd ();
+							RemoveTaskTagsFromRange (start, line_end);
+						} else if (line.Line == end.Line) {
+Logger.Debug ("7");
+							// This is the last line
+							line_start = line;
+							while (line_start.StartsLine () == false) {
+								line_start.BackwardChar ();
+							}
+							RemoveTaskTagsFromRange (line_start, end);
+						} else {
+Logger.Debug ("8");
+							// This line is in the middle of the range
+							// so it's completely safe to remove the TaskTag
+							RemoveTaskTagFromLine (line);
+						}
+
+						// Delete the task
+						TaskManager task_mgr = TasksApplicationAddin.DefaultTaskManager;
+						Task task = task_mgr.FindByUri (task_tag.Uri);
+						if (task != null) {
+							task_mgr.Delete (task);
+						}
+					}
+				} while (line.ForwardLine () && line.Line <= end.Line);
+			}
+		}
 #endregion // Private Methods
 
 #region Private Event Handlers
@@ -306,7 +434,7 @@
 					if (task_tag.Uri != task.Uri)
 						continue;
 					
-					RemoveTaskTagFromLine (ref iter);
+					RemoveTaskFromLine (ref iter);
 					break;
 				}
 			} while (iter.ForwardLine());
@@ -342,7 +470,10 @@
 					while (line_start.StartsLine () == false)
 						line_start.BackwardChar ();
 					Gtk.TextIter line_end = iter;
-					line_end.ForwardToLineEnd ();
+					while (line_end.EndsLine () == false) {
+						line_end.ForwardChar ();
+					}
+//					line_end.ForwardToLineEnd ();
 					
 					Buffer.Delete (ref line_start, ref line_end);
 					last_removed_tag = task_tag;
@@ -383,9 +514,23 @@
 				}
 			} while (iter.ForwardLine());
 		}
-
+		
+		[GLib.ConnectBeforeAttribute]
+		void OnDeleteRangeConnectBefore (object sender, Gtk.DeleteRangeArgs args)
+		{
+Logger.Debug ("OnDeleteRangeConnectBefore");
+Logger.Debug ("\t       Start Index: {0}", args.Start.Line);
+Logger.Debug ("\t  Start Line Index: {0}", args.Start.LineIndex);
+Logger.Debug ("\tVisible Line Index: {0}", args.Start.VisibleLineIndex);
+Logger.Debug ("\t         End Index: {0}", args.End.Line);
+Logger.Debug ("\t    End Line Index: {0}", args.End.LineIndex);
+Logger.Debug ("\tVisible Line Index: {0}", args.End.VisibleLineIndex);
+			RemoveTaskTagsFromRange (args.Start, args.End);
+		}
+		
 		void OnDeleteRange (object sender, Gtk.DeleteRangeArgs args)
 		{
+Logger.Debug ("OnDeleteRange");
 			Gtk.TextIter start = args.Start;
 			ApplyTaskTagToBlock (ref start, args.End);
 		}
@@ -402,18 +547,50 @@
 //				args.Pos.Line);
 
 			if (args.Length == 1 && args.Text == "\n") {
+				Gtk.TextIter curr_line = args.Pos;
+				TaskTag task_tag = GetTaskTagFromLineIter (ref curr_line);
+
 				Gtk.TextIter prev_line = args.Pos;
 				prev_line.BackwardLine ();
-				TaskTag task_tag = GetTaskTagFromLineIter (ref prev_line);
+				/*TaskTag*/ task_tag = GetTaskTagFromLineIter (ref prev_line);
 				if (task_tag != null) {
 					// If the user just entered a newline and the previous
 					// line was a task, do some special processing...but
 					// we have to do it on idle since there are other
 					// Buffer.InsertText handlers that we'll screw up if
 					// we modify anything here.
-					if (prev_line_handler != 0)
-						GLib.Source.Remove (prev_line_handler);
-					prev_line_handler = GLib.Idle.Add (ProcessNewline);
+					args.RetVal = ProcessNewline ();
+				} else {
+					// Check to see if the previous line is a todo: line
+					while (prev_line.StartsLine () == false) {
+						prev_line.BackwardChar ();
+					}
+					
+					Gtk.TextIter prev_line_end = prev_line;
+					while (prev_line_end.EndsLine () == false) {
+						prev_line_end.ForwardChar ();
+					}
+					
+					string prev_line_text = prev_line.GetText (prev_line_end);
+					
+					Match match = regex.Match (prev_line_text);
+					if (match.Success && last_removed_tag != null) {
+						TaskManager task_mgr = TasksApplicationAddin.DefaultTaskManager;
+						Task task;
+
+						task = task_mgr.FindByUri (last_removed_tag.Uri);
+						if (task != null) {
+							// Update the task's summary and make sure that
+							// the previous line is appropriately tagged.
+							string summary = GetTaskSummaryFromLine (prev_line_text);
+							task.Summary = summary;
+							Buffer.ApplyTag (last_removed_tag, prev_line, prev_line_end);
+						} else {
+							Logger.Debug ("Shouldn't ever hit this code (hopefully)");
+						}
+					}
+					
+					last_removed_tag = null;
 				}
 			} else {
 				ApplyTaskTagToBlock (ref start, args.Pos);
Index: Tomboy/Addins/Tasks/TaskListWindow.cs
===================================================================
--- Tomboy/Addins/Tasks/TaskListWindow.cs	(revision 1469)
+++ Tomboy/Addins/Tasks/TaskListWindow.cs	(working copy)
@@ -1,5 +1,6 @@
 
 using System;
+using System.Collections.Generic;
 using Gtk;
 using Mono.Unix;
 using Tomboy;
@@ -14,9 +15,13 @@
 			DueDate,
 			CompletionDate,
 			Priority,
-			OriginNote
+//			OriginNote
 		};
-		
+
+		public const string ShowCompletedTasksPreference = "/apps/tomboy/tasks/show_completed_tasks";
+		public const string ShowDueDateColumnPreference = "/apps/tomboy/tasks/show_due_date_column";
+		public const string ShowPriorityColumnPreference = "/apps/tomboy/tasks/show_priority_column";
+
 		TaskManager manager;
 		
 		Gtk.ActionGroup action_group;
@@ -28,12 +33,13 @@
 		Gtk.VBox content_vbox;
 
 		Gtk.TreeView tree;
+		Gtk.TreeModelFilter store_filter;
 		Gtk.TreeModelSort store_sort;
 		SortColumn sort_column;
 		Gtk.TreeViewColumn note_column;
 		Gtk.TreeViewColumn summary_column;
 		Gtk.TreeViewColumn due_date_column;
-		Gtk.TreeViewColumn completion_column;
+//		Gtk.TreeViewColumn completion_column;
 		Gtk.TreeViewColumn priority_column;
 		
 		Gtk.Menu ctx_menu;
@@ -41,6 +47,12 @@
 		// Use this to select the task that was created inside
 		// this window.
 		bool expecting_newly_created_task;
+		
+		Gtk.ToggleAction show_completed_tasks_toggle_action;
+		Gtk.ToggleAction show_due_date_column_toggle_action;
+		Gtk.ToggleAction show_priority_column_toggle_action;
+		
+		bool show_completed_tasks;
 
 		static TaskListWindow instance;
 		
@@ -100,7 +112,10 @@
 				new Gtk.ActionEntry ("OpenOriginNoteAction", null,
 					Catalog.GetString ("Open Associated _Note"), null,
 					Catalog.GetString ("Open the note containing the task"), null),
-
+				
+				new Gtk.ActionEntry ("TaskListViewMenuAction", null,
+					Catalog.GetString ("_View"), null, null, null),
+				
 				new Gtk.ActionEntry ("TaskListHelpMenuAction", null,
 					Catalog.GetString ("_Help"), null, null, null),
 					
@@ -109,6 +124,20 @@
 					Catalog.GetString ("Tasks Help"), null)
 			});
 			
+			action_group.Add (new Gtk.ToggleActionEntry [] {
+				new Gtk.ToggleActionEntry ("ShowCompletedTasksAction", null,
+					Catalog.GetString ("Show _Completed Tasks"), null,
+					Catalog.GetString ("Show completed tasks in the list"), null, true),
+
+				new Gtk.ToggleActionEntry ("ShowDueDateColumnAction", null,
+					Catalog.GetString ("Show _Due Date Column"), null,
+					Catalog.GetString ("Show the due date column in the list"), null, true),
+
+				new Gtk.ToggleActionEntry ("ShowPriorityColumnAction", null,
+					Catalog.GetString ("Show _Priority Column"), null,
+					Catalog.GetString ("Show the priority column in the list"), null, true)
+			});
+			
 			Tomboy.ActionManager.UI.InsertActionGroup (action_group, 0);
 
 			menu_bar = CreateMenuBar ();
@@ -184,9 +213,39 @@
 			am ["DeleteTaskAction"].Activated += OnDeleteTask;
 			am ["ShowTaskHelpAction"].Activated += OnShowHelp;
 			
+			// View Options
+			bool pref_val;
+			
+			show_completed_tasks_toggle_action = am ["ShowCompletedTasksAction"] as Gtk.ToggleAction;
+			pref_val = GetPref (TaskListWindow.ShowCompletedTasksPreference);
+			show_completed_tasks_toggle_action.Active = pref_val;
+			show_completed_tasks_toggle_action.Activated += OnShowCompletedTasks;
+			show_completed_tasks = pref_val;
+
+			show_due_date_column_toggle_action = am ["ShowDueDateColumnAction"] as Gtk.ToggleAction;
+			pref_val = GetPref (TaskListWindow.ShowDueDateColumnPreference);
+			show_due_date_column_toggle_action.Active = pref_val;
+			show_due_date_column_toggle_action.Activated += OnShowDueDateColumn;
+			
+			show_priority_column_toggle_action = am ["ShowPriorityColumnAction"] as Gtk.ToggleAction;
+			pref_val = GetPref (TaskListWindow.ShowPriorityColumnPreference);
+			show_priority_column_toggle_action.Active = pref_val;
+			show_priority_column_toggle_action.Activated += OnShowPriorityColumn;
+			
 			return menubar;
 		}
 		
+		bool GetPref (string pref)
+		{
+			bool val;
+			try {
+				val = (bool) Preferences.Get (pref);
+				return val;
+			} catch {}
+			
+			return false;
+		}
+		
 		void MakeTasksTree ()
 		{
 			tree = new Gtk.TreeView ();
@@ -196,29 +255,31 @@
 			tree.Selection.Changed += OnSelectionChanged;
 			tree.ButtonPressEvent += OnButtonPressed;
 			
-			// Columns: OriginNote, Completion Status Summary, Due Date (No Date/Date), Completed (No Date/Date), Priority
-
+			tree.Selection.Mode = Gtk.SelectionMode.Multiple;
+			
+			LoadColumns ();
+		}
+		
+		void RefreshColumns ()
+		{
+			ClearColumns ();
+			LoadColumns ();
+		}
+		
+		void ClearColumns ()
+		{
+			Gtk.TreeViewColumn [] columns = tree.Columns;
+			foreach (Gtk.TreeViewColumn col in columns) {
+				tree.RemoveColumn (col);
+			}
+		}
+		
+		void LoadColumns ()
+		{
+			bool pref_val;
 			Gtk.CellRenderer renderer;
 			
 			///
-			/// OriginNote
-			///
-			note_column = new Gtk.TreeViewColumn ();
-			note_column.Title = string.Empty;
-			note_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
-			note_column.Resizable = false;
-			note_column.Clickable = true;
-			note_column.Clicked += OnNoteColumnClicked;
-			note_column.Reorderable = true;
-			note_column.SortIndicator = true;
-			
-			renderer = new Gtk.CellRendererPixbuf ();
-			note_column.PackStart (renderer, false);
-			note_column.SetCellDataFunc (renderer,
-					new Gtk.TreeCellDataFunc (NoteIconCellDataFunc));
-			tree.AppendColumn (note_column);
-			
-			///
 			/// Completion Status
 			///
 			Gtk.TreeViewColumn status = new Gtk.TreeViewColumn ();
@@ -260,91 +321,74 @@
 			summary_column.SetCellDataFunc (renderer,
 					new Gtk.TreeCellDataFunc (SummaryCellDataFunc));
 			tree.AppendColumn (summary_column);
+
+			// Due Date Column
+			pref_val = GetPref (TaskListWindow.ShowDueDateColumnPreference);
+			if (pref_val == true) {
+				// Show the Due Date Column
+				due_date_column = new Gtk.TreeViewColumn ();
+				due_date_column.Title = Catalog.GetString ("Due Date");
+				due_date_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
+				due_date_column.Resizable = false;
+				due_date_column.Clickable = true;
+				due_date_column.Clicked += OnDueDateColumnClicked;
+				due_date_column.Reorderable = true;
+				due_date_column.SortIndicator = true;
+				
+				renderer = new Gtk.Extras.CellRendererDate ();
+				(renderer as Gtk.Extras.CellRendererDate).Editable = true;
+				(renderer as Gtk.Extras.CellRendererDate).Edited += OnDueDateEdited;
+				(renderer as Gtk.Extras.CellRendererDate).ShowTime = false;
+				renderer.Xalign = 0.0f;
+				due_date_column.PackStart (renderer, true);
+				due_date_column.SetCellDataFunc (renderer,
+						new Gtk.TreeCellDataFunc (DueDateCellDataFunc));
+				tree.AppendColumn (due_date_column);
+			}
 			
-			///
-			/// Due Date
-			///
-			due_date_column = new Gtk.TreeViewColumn ();
-			due_date_column.Title = Catalog.GetString ("Due Date");
-			due_date_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
-			due_date_column.Resizable = false;
-			due_date_column.Clickable = true;
-			due_date_column.Clicked += OnDueDateColumnClicked;
-			due_date_column.Reorderable = true;
-			due_date_column.SortIndicator = true;
-			
-			renderer = new Gtk.Extras.CellRendererDate ();
-			(renderer as Gtk.Extras.CellRendererDate).Editable = true;
-			(renderer as Gtk.Extras.CellRendererDate).Edited += OnDueDateEdited;
-			(renderer as Gtk.Extras.CellRendererDate).ShowTime = false;
-			renderer.Xalign = 0.0f;
-			due_date_column.PackStart (renderer, true);
-			due_date_column.SetCellDataFunc (renderer,
-					new Gtk.TreeCellDataFunc (DueDateCellDataFunc));
-			tree.AppendColumn (due_date_column);
-			
-			///
-			/// Completion Date
-			///
-			completion_column = new Gtk.TreeViewColumn ();
-			completion_column.Title = Catalog.GetString ("Completion Date");
-			completion_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
-			completion_column.Resizable = false;
-			completion_column.Clickable = true;
-			completion_column.Clicked += OnCompletionColumnClicked;
-			completion_column.Reorderable = true;
-			completion_column.SortIndicator = true;
-			
-			renderer = new Gtk.Extras.CellRendererDate ();
-			(renderer as Gtk.Extras.CellRendererDate).Editable = false;
-			(renderer as Gtk.Extras.CellRendererDate).ShowTime = true;
-			renderer.Xalign = 0.0f;
-			completion_column.PackStart (renderer, true);
-			completion_column.SetCellDataFunc (renderer,
-					new Gtk.TreeCellDataFunc (CompletionDateCellDataFunc));
-			tree.AppendColumn (completion_column);
-			
-			///
-			/// Priority
-			///
-			priority_column = new Gtk.TreeViewColumn ();
-			priority_column.Title = Catalog.GetString ("Priority");
-			priority_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
-			priority_column.Resizable = false;
-			priority_column.Clickable = true;
-			priority_column.Clicked += OnPriorityColumnClicked;
-			priority_column.Reorderable = true;
-			priority_column.SortIndicator = true;
-			
-			renderer = new Gtk.CellRendererCombo ();
-			(renderer as Gtk.CellRendererCombo).Editable = true;
-			(renderer as Gtk.CellRendererCombo).HasEntry = false;
-			(renderer as Gtk.CellRendererCombo).Edited += OnTaskPriorityEdited;
-			Gtk.ListStore priority_store = new Gtk.ListStore (typeof (string));
-			priority_store.AppendValues (Catalog.GetString ("None"));
-			priority_store.AppendValues (Catalog.GetString ("Low"));
-			priority_store.AppendValues (Catalog.GetString ("Normal"));
-			priority_store.AppendValues (Catalog.GetString ("High"));
-			(renderer as Gtk.CellRendererCombo).Model = priority_store;
-			(renderer as Gtk.CellRendererCombo).TextColumn = 0;
-			renderer.Xalign = 0.0f;
-			priority_column.PackStart (renderer, true);
-			priority_column.SetCellDataFunc (renderer,
-					new Gtk.TreeCellDataFunc (PriorityCellDataFunc));
-			tree.AppendColumn (priority_column);
+			// Priority Column
+			pref_val = GetPref (TaskListWindow.ShowPriorityColumnPreference);
+			if (pref_val == true) {
+				// Show the Priority Column
+				priority_column = new Gtk.TreeViewColumn ();
+				priority_column.Title = Catalog.GetString ("Priority");
+				priority_column.Sizing = Gtk.TreeViewColumnSizing.Autosize;
+				priority_column.Resizable = false;
+				priority_column.Clickable = true;
+				priority_column.Clicked += OnPriorityColumnClicked;
+				priority_column.Reorderable = true;
+				priority_column.SortIndicator = true;
+				
+				renderer = new Gtk.CellRendererCombo ();
+				(renderer as Gtk.CellRendererCombo).Editable = true;
+				(renderer as Gtk.CellRendererCombo).HasEntry = false;
+				(renderer as Gtk.CellRendererCombo).Edited += OnTaskPriorityEdited;
+				Gtk.ListStore priority_store = new Gtk.ListStore (typeof (string));
+				priority_store.AppendValues (Catalog.GetString ("None"));
+				priority_store.AppendValues (Catalog.GetString ("Low"));
+				priority_store.AppendValues (Catalog.GetString ("Normal"));
+				priority_store.AppendValues (Catalog.GetString ("High"));
+				(renderer as Gtk.CellRendererCombo).Model = priority_store;
+				(renderer as Gtk.CellRendererCombo).TextColumn = 0;
+				renderer.Xalign = 0.0f;
+				priority_column.PackStart (renderer, true);
+				priority_column.SetCellDataFunc (renderer,
+						new Gtk.TreeCellDataFunc (PriorityCellDataFunc));
+				tree.AppendColumn (priority_column);
+			}
 		}
 		
-		void NoteIconCellDataFunc (Gtk.TreeViewColumn tree_column,
-				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
-				Gtk.TreeIter iter)
-		{
-			Gtk.CellRendererPixbuf crp = cell as Gtk.CellRendererPixbuf;
-			Task task = tree_model.GetValue (iter, 0) as Task;
-			if (task != null && task.OriginNoteUri != string.Empty)
-				crp.Pixbuf = note_pixbuf;
-			else
-				crp.Pixbuf = null;
-		}
+//		void NoteIconCellDataFunc (Gtk.TreeViewColumn tree_column,
+//				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
+//				Gtk.TreeIter iter)
+//		{
+//			Gtk.CellRendererPixbuf crp = cell as Gtk.CellRendererPixbuf;
+//			Task task = tree_model.GetValue (iter, 0) as Task;
+//			if (task != null && task.OriginNoteUri != string.Empty)
+//				crp.Pixbuf = note_pixbuf;
+//			else
+//				crp.Pixbuf = null;
+//		}
 
 		void ToggleCellDataFunc (Gtk.TreeViewColumn tree_column,
 				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
@@ -383,17 +427,17 @@
 				crd.Date = task.DueDate;
 		}
 		
-		void CompletionDateCellDataFunc (Gtk.TreeViewColumn tree_column,
-				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
-				Gtk.TreeIter iter)
-		{
-			Gtk.Extras.CellRendererDate crd = cell as Gtk.Extras.CellRendererDate;
-			Task task = tree_model.GetValue (iter, 0) as Task;
-			if (task == null)
-				crd.Date = DateTime.MinValue;
-			else
-				crd.Date = task.CompletionDate;
-		}
+//		void CompletionDateCellDataFunc (Gtk.TreeViewColumn tree_column,
+//				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
+//				Gtk.TreeIter iter)
+//		{
+//			Gtk.Extras.CellRendererDate crd = cell as Gtk.Extras.CellRendererDate;
+//			Task task = tree_model.GetValue (iter, 0) as Task;
+//			if (task == null)
+//				crd.Date = DateTime.MinValue;
+//			else
+//				crd.Date = task.CompletionDate;
+//		}
 		
 		void PriorityCellDataFunc (Gtk.TreeViewColumn tree_column,
 				Gtk.CellRenderer cell, Gtk.TreeModel tree_model,
@@ -420,8 +464,9 @@
 
 		void SetUpTreeModel ()
 		{
-			store_sort = new Gtk.TreeModelSort (manager.Tasks);
-Logger.Debug ("store_sort has {0} columns", store_sort.NColumns);
+			store_filter = new Gtk.TreeModelFilter (manager.Tasks, null);
+			store_filter.VisibleFunc = FilterTasks;
+			store_sort = new Gtk.TreeModelSort (store_filter);
 			store_sort.DefaultSortFunc = 
 				new Gtk.TreeIterCompareFunc (TaskSortFunc);
 				
@@ -436,6 +481,23 @@
 				cnt);
 		}
 		
+		/// <summary>
+		/// Filter out the tasks based on whether they're complete.
+		/// </summary>
+		bool FilterTasks (Gtk.TreeModel model, Gtk.TreeIter iter)
+		{
+			Task task = model.GetValue (iter, 0) as Task;
+			if (task == null)
+				return false;
+			
+			if (show_completed_tasks)
+				return true; // Show all tasks
+			else if (task.CompletionDate == DateTime.MinValue)
+				return true; // No completion date set
+			
+			return false;
+		}
+		
 		void UpdateTaskCount (int total)
 		{
 			string cnt = string.Format (
@@ -449,12 +511,18 @@
 		
 		void OnSelectionChanged (object sender, EventArgs args)
 		{
-			Task task = GetSelectedTask ();
-			if (task != null) {
-				Tomboy.ActionManager ["OpenTaskAction"].Sensitive = true;
+			List<Task> tasks = GetSelectedTasks ();
+//			Task task = GetSelectedTask ();
+			if (tasks != null && tasks.Count > 0) {
+				if (tasks.Count == 1) {
+					Tomboy.ActionManager ["OpenTaskAction"].Sensitive = true;
+				} else {
+					Tomboy.ActionManager ["OpenTaskAction"].Sensitive = false;
+				}
+				
 				Tomboy.ActionManager ["DeleteTaskAction"].Sensitive = true;
 				
-				if (task.OriginNoteUri != string.Empty)
+				if (tasks.Count == 1 && tasks [0].OriginNoteUri != string.Empty)
 					Tomboy.ActionManager ["OpenOriginNoteAction"].Sensitive = true;
 				else
 					Tomboy.ActionManager ["OpenOriginNoteAction"].Sensitive = false;
@@ -472,33 +540,28 @@
 				Gtk.TreePath path = null;
 				Gtk.TreeViewColumn column = null;
 				
-				if (tree.GetPathAtPos ((int) args.Event.X,
-						(int) args.Event.Y,
-						out path,
-						out column) == false)
-					break;
+				if (tree.Selection.CountSelectedRows () == 0) {
+					if (tree.GetPathAtPos ((int) args.Event.X,
+							(int) args.Event.Y,
+							out path,
+							out column) == false)
+						break;
+
+					Gtk.TreeIter iter;
+					if (store_sort.GetIter (out iter, path) == false)
+						break;
 				
-				Gtk.TreeIter iter;
-				if (store_sort.GetIter (out iter, path) == false)
-					break;
+					tree.Selection.SelectIter (iter);
+				}
 				
-				tree.Selection.SelectIter (iter);
-				
-				Task task = store_sort.GetValue (iter, 0) as Task;
-				if (task == null)
-					break;
-				
-				PopupContextMenuAtLocation (task, (int) args.Event.X,
+				PopupContextMenuAtLocation ((int) args.Event.X,
 						(int) args.Event.Y);
 
 				break;
 			}
 		}
 		
-		/// <summary>
-		/// <param name="task">The selected task</param>
-		/// </summary>
-		void PopupContextMenuAtLocation (Task task, int x, int y)
+		void PopupContextMenuAtLocation (int x, int y)
 		{
 			if (ctx_menu == null) {
 				ctx_menu = Tomboy.ActionManager.GetWidget (
@@ -534,8 +597,13 @@
 			y = 0;
 			
 			selection = tree.Selection;
-			if (!selection.GetSelected (out iter))
-				return;
+			if (selection.CountSelectedRows () > 1) {
+				Gtk.TreePath [] paths = selection.GetSelectedRows ();
+				store_sort.GetIter (out iter, paths [0]);
+			} else {
+				if (!selection.GetSelected (out iter))
+					return;
+			}
 			
 			path = store_sort.GetPath (iter);
 			
@@ -578,15 +646,32 @@
 			y += widget_y;
 		}
 
+		List<Task> GetSelectedTasks ()
+		{
+			List<Task> list = new List<Task> ();
+			Gtk.TreeModel model;
+			Gtk.TreePath [] paths = tree.Selection.GetSelectedRows (out model);
+			if (paths != null && paths.Length > 0) {
+				foreach (Gtk.TreePath path in paths) {
+					Gtk.TreeIter iter; 
+					if (model.GetIter (out iter, path)) {
+						Task task = model.GetValue (iter, 0) as Task;
+						if (task != null)
+							list.Add (task);
+					}
+				}
+			}
+			
+			return list;
+		}
+		
 		Task GetSelectedTask ()
 		{
-			Gtk.TreeModel model;
-			Gtk.TreeIter iter;
-
-			if (!tree.Selection.GetSelected (out model, out iter))
+			List<Task> list = GetSelectedTasks ();
+			if (list == null || list.Count == 0)
 				return null;
-
-			return (Task) model.GetValue (iter, 0);
+			
+			return list [0];
 		}
 
 		/// <summary>
@@ -627,13 +712,52 @@
 		
 		void OnDeleteTask (object sender, EventArgs args)
 		{
-			Task task = GetSelectedTask ();
-			if (task == null)
+			List<Task> tasks = GetSelectedTasks ();
+			if (tasks == null || tasks.Count == 0)
 				return;
 			
-			ShowDeletionDialog (task);
+			ShowDeletionDialog (tasks);
 		}
 		
+		/// <summary>
+		/// Called when the user selects the "Show Completed Columns"
+		/// menuitem in the View menu.
+		/// </summary>
+		void OnShowCompletedTasks (object sender, EventArgs args)
+		{
+			ActionManager am = Tomboy.ActionManager;
+			bool active = show_completed_tasks_toggle_action.Active;
+			Preferences.Set (
+				TaskListWindow.ShowCompletedTasksPreference,
+				active);
+			show_completed_tasks = active;
+			
+			// Refilter the TreeModel to show/hide the completed tasks
+			store_filter.Refilter ();
+		}
+		
+		void OnShowDueDateColumn (object sender, EventArgs args)
+		{
+			ActionManager am = Tomboy.ActionManager;
+			bool active = show_due_date_column_toggle_action.Active;
+			Preferences.Set (
+				TaskListWindow.ShowDueDateColumnPreference,
+				active);
+			
+			RefreshColumns ();
+		}
+		
+		void OnShowPriorityColumn (object sender, EventArgs args)
+		{
+			ActionManager am = Tomboy.ActionManager;
+			bool active = show_priority_column_toggle_action.Active;
+			Preferences.Set (
+				TaskListWindow.ShowPriorityColumnPreference,
+				active);
+			
+			RefreshColumns ();
+		}
+		
 		void OnShowHelp (object sender, EventArgs args)
 		{
 			GuiUtils.ShowHelp ("tomboy.xml", "tasks", Screen, this);
@@ -681,9 +805,8 @@
 				break;
 			case Gdk.Key.Menu:
 				// Pop up the context menu if a note is selected
-				Task task = GetSelectedTask ();
-				if (task != null)
-					PopupContextMenuAtLocation (task, 0, 0);
+				if (tree.Selection.CountSelectedRows () > 0)
+					PopupContextMenuAtLocation (0, 0);
 
 				break;
 			}
@@ -692,13 +815,12 @@
 		void OnOpenOriginNote (object sender, EventArgs args)
 		{
 			Gtk.TreeSelection selection;
-			Gtk.TreeIter iter;
 			
 			selection = tree.Selection;
-			if (!selection.GetSelected (out iter))
+			if (selection.CountSelectedRows () != 1)
 				return;
 			
-			Task task = store_sort.GetValue (iter, 0) as Task;
+			Task task = GetSelectedTask ();
 			if (task == null || task.OriginNoteUri == string.Empty)
 				return;
 			
@@ -729,8 +851,8 @@
 					result = CompareTasks (task_a, task_b, SortColumn.Priority);
 				if (result == 0)
 					result = CompareTasks (task_a, task_b, SortColumn.Summary);
-				if (completion_column.SortOrder == Gtk.SortType.Descending)
-					result = result * -1;
+//				if (completion_column.SortOrder == Gtk.SortType.Descending)
+//					result = result * -1;
 				break;
 			case SortColumn.DueDate:
 				result = CompareTasks (task_a, task_b, SortColumn.DueDate);
@@ -743,17 +865,17 @@
 				if (due_date_column.SortOrder == Gtk.SortType.Descending)
 					result = result * -1;
 				break;
-			case SortColumn.OriginNote:
-				result = CompareTasks (task_a, task_b, SortColumn.OriginNote);
-				if (result == 0)
-					result = CompareTasks (task_a, task_b, SortColumn.CompletionDate);
-				if (result == 0)
-					result = CompareTasks (task_a, task_b, SortColumn.Priority);
-				if (result == 0)
-					result = CompareTasks (task_a, task_b, SortColumn.Summary);
-				if (note_column.SortOrder == Gtk.SortType.Descending)
-					result = result * -1;
-				break;
+//			case SortColumn.OriginNote:
+//				result = CompareTasks (task_a, task_b, SortColumn.OriginNote);
+//				if (result == 0)
+//					result = CompareTasks (task_a, task_b, SortColumn.CompletionDate);
+//				if (result == 0)
+//					result = CompareTasks (task_a, task_b, SortColumn.Priority);
+//				if (result == 0)
+//					result = CompareTasks (task_a, task_b, SortColumn.Summary);
+//				if (note_column.SortOrder == Gtk.SortType.Descending)
+//					result = result * -1;
+//				break;
 			case SortColumn.Priority:
 				result = CompareTasks (task_a, task_b, SortColumn.Priority);
 				if (result == 0)
@@ -795,8 +917,8 @@
 					return DateTime.Compare (a.CompletionDate, b.CompletionDate);
 				case SortColumn.DueDate:
 					return DateTime.Compare (a.DueDate, b.DueDate);
-				case SortColumn.OriginNote:
-					return a.OriginNoteUri.CompareTo (b.OriginNoteUri);
+//				case SortColumn.OriginNote:
+//					return a.OriginNoteUri.CompareTo (b.OriginNoteUri);
 				case SortColumn.Priority:
 					return (int) a.Priority - (int) b.Priority;
 				case SortColumn.Summary:
@@ -815,7 +937,7 @@
 			Tomboy.ActionManager ["OpenTaskAction"].Activate ();
 		}
 		
-		void ShowDeletionDialog (Task task)
+		void ShowDeletionDialog (List<Task> tasks)
 		{
 			HIGMessageDialog dialog = 
 				new HIGMessageDialog (
@@ -823,7 +945,9 @@
 					Gtk.DialogFlags.DestroyWithParent,
 					Gtk.MessageType.Question,
 					Gtk.ButtonsType.None,
-					Catalog.GetString ("Really delete this task?"),
+					tasks.Count > 1 ?
+						Catalog.GetString ("Really delete these tasks?") :
+						Catalog.GetString ("Really delete this task?"),
 					Catalog.GetString ("If you delete a task it is " +
 							   "permanently lost."));
 
@@ -842,7 +966,14 @@
 
 			int result = dialog.Run ();
 			if (result == 666) {
-				task.Manager.Delete (task);
+				// Disable the selection changed handler while we nuke tasks
+				tree.Selection.Changed -= OnSelectionChanged;
+				
+				foreach (Task task in tasks) {
+					task.Manager.Delete (task);
+				}
+				
+				tree.Selection.Changed += OnSelectionChanged;
 			}
 
 			dialog.Destroy();
@@ -867,8 +998,6 @@
 		
 		void OnTaskSummaryEdited (object sender, Gtk.EditedArgs args)
 		{
-	Logger.Debug ("TaskListWindow.OnTaskSummaryEdited");
-			
 			Gtk.TreeIter iter;
 			Gtk.TreePath path = new TreePath (args.Path);
 			if (store_sort.GetIter (out iter, path) == false)
@@ -880,8 +1009,6 @@
 		
 		void OnDueDateEdited (Gtk.Extras.CellRendererDate renderer, string path)
 		{
-			Logger.Debug ("OnDueDateEdited");
-			
 			Gtk.TreeIter iter;
 			Gtk.TreePath tree_path = new TreePath (path);
 			if (store_sort.GetIter (out iter, tree_path) == false)
@@ -920,6 +1047,8 @@
 				// A user just created this task inside this window
 				expecting_newly_created_task = false;
 				
+				tree.Selection.UnselectAll ();
+				
 				SelectTask (task);
 			}
 			
@@ -956,33 +1085,29 @@
 			} while (store_sort.IterNext (ref iter));
 		}
 		
-		void OnNoteColumnClicked (object sender, EventArgs args)
-		{
-			Logger.Debug ("TaskListWindow.OnNoteColumnClicked");
-			OnColumnClicked (note_column, SortColumn.OriginNote);
-		}
+//		void OnNoteColumnClicked (object sender, EventArgs args)
+//		{
+//			Logger.Debug ("TaskListWindow.OnNoteColumnClicked");
+//			OnColumnClicked (note_column, SortColumn.OriginNote);
+//		}
 		
 		void OnSummaryColumnClicked (object sender, EventArgs args)
 		{
-			Logger.Debug ("TaskListWindow.OnSummaryColumnClicked");
 			OnColumnClicked (summary_column, SortColumn.Summary);
 		}
 		
 		void OnDueDateColumnClicked (object sender, EventArgs args)
 		{
-			Logger.Debug ("TaskListWindow.OnDueDateColumnClicked");
 			OnColumnClicked (due_date_column, SortColumn.DueDate);
 		}
 		
 		void OnCompletionColumnClicked (object sender, EventArgs args)
 		{
-			Logger.Debug ("TaskListWindow.OnCompletionColumnClicked");
-			OnColumnClicked (completion_column, SortColumn.CompletionDate);
+//			OnColumnClicked (completion_column, SortColumn.CompletionDate);
 		}
 		
 		void OnPriorityColumnClicked (object sender, EventArgs args)
 		{
-			Logger.Debug ("TaskListWindow.OnPriorityColumnClicked");
 			OnColumnClicked (priority_column, SortColumn.Priority);
 		}
 		
Index: Tomboy/Addins/Tasks/TaskManager.cs
===================================================================
--- Tomboy/Addins/Tasks/TaskManager.cs	(revision 1469)
+++ Tomboy/Addins/Tasks/TaskManager.cs	(working copy)
@@ -168,6 +168,26 @@
 				} while (tasks.IterNext (ref iter));
 			}
 		}
+		
+		/// <summary>
+		/// Return a list of tasks whose origin note is the note specified.
+		/// </summary>
+		public List<Task> GetTasksForNote (Note note)
+		{
+			List<Task> list = new List<Task> ();
+			
+			Gtk.TreeIter iter;
+			if (tasks.GetIterFirst (out iter)) {
+				do {
+					Task task = tasks.GetValue (iter, 0) as Task;
+					if (task.OriginNoteUri != null &&
+							task.OriginNoteUri.CompareTo (note.Uri) == 0)
+						list.Add (task);
+				} while (tasks.IterNext (ref iter));
+			}
+			
+			return list;
+		}
 	#endregion // Public Methods
 
 	#region Events
Index: Tomboy/Addins/Tasks/Tasks.addin.xml
===================================================================
--- Tomboy/Addins/Tasks/Tasks.addin.xml	(revision 1469)
+++ Tomboy/Addins/Tasks/Tasks.addin.xml	(working copy)
@@ -3,8 +3,8 @@
 	name="Tasks"
 	author="Tomboy Project"
 	description="Add-in to enable tasks support for Tomboy"
-	category="Experimental (WARNING: Use at your own risk)"
-	defaultEnabled="false"
+	category="Tools"
+	defaultEnabled="true"
 	version="0.1">
 
 	<Runtime>
Index: Tomboy/Addins/Tasks/Makefile.am
===================================================================
--- Tomboy/Addins/Tasks/Makefile.am	(revision 1469)
+++ Tomboy/Addins/Tasks/Makefile.am	(working copy)
@@ -18,6 +18,7 @@
 TASKS_TARGET = Tasks.dll
 TASKS_CSFILES = \
 	$(srcdir)/CellRendererDate.cs \
+	$(srcdir)/ComplexMenuItem.cs \
 	$(srcdir)/DateButton.cs \
 	$(srcdir)/Task.cs \
 	$(srcdir)/TasksApplicationAddin.cs \
Index: Tomboy/Addins/Tasks/TasksUIManagerLayout.xml
===================================================================
--- Tomboy/Addins/Tasks/TasksUIManagerLayout.xml	(revision 1469)
+++ Tomboy/Addins/Tasks/TasksUIManagerLayout.xml	(working copy)
@@ -11,6 +11,11 @@
         <menu name="TaskListEditMenu" action="TaskListEditMenuAction">
             <menuitem name="DeleteTask" action="DeleteTaskAction" />
         </menu>
+        <menu name="TaskListViewMenu" action="TaskListViewMenuAction">
+        	<menuitem name="ShowCompletedTasks" action="ShowCompletedTasksAction" />
+        	<menuitem name="ShowDueDateColumn" action="ShowDueDateColumnAction" />
+        	<menuitem name="ShowPriorityColumn" action="ShowPriorityColumnAction" />
+        </menu>
         <menu name="TaskListHelpMenu" action="TaskListHelpMenuAction">
             <menuitem name="ShowTaskHelp" action="ShowTaskHelpAction" />
         </menu>
Index: Tomboy/Addins/Tasks/TasksApplicationAddin.cs
===================================================================
--- Tomboy/Addins/Tasks/TasksApplicationAddin.cs	(revision 1469)
+++ Tomboy/Addins/Tasks/TasksApplicationAddin.cs	(working copy)
@@ -1,9 +1,12 @@
 
 using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
 using System.IO;
 using Mono.Unix;
 using Tomboy;
 using Gtk;
+using Gtk.Extras;
 
 using Mono.Addins;
 
@@ -21,6 +24,9 @@
 		static TaskListWindow task_list_window = null;
 		
 		bool initialized;
+		
+		Gtk.Menu tomboy_tray_menu;
+		List<Gtk.MenuItem> top_tasks = new List<Gtk.MenuItem> ();
 
 		public static TaskManager DefaultTaskManager
 		{
@@ -56,13 +62,13 @@
 						delegate { OnOpenToDoListAction (); })
 				});
 				
-				tray_icon_ui = Tomboy.ActionManager.UI.AddUiFromString (@"
-					<ui>
-						<popup name='TrayIconMenu' action='TrayIconMenuAction'>
-							<menuitem name='OpenToDoList' action='OpenToDoListAction' />
-						</popup>
-					</ui>
-				");
+//				tray_icon_ui = Tomboy.ActionManager.UI.AddUiFromString (@"
+//					<ui>
+//						<popup name='TrayIconMenu' action='TrayIconMenuAction'>
+//							<menuitem name='OpenToDoList' action='OpenToDoListAction' />
+//						</popup>
+//					</ui>
+//				");
 				
 				tools_menu_ui = Tomboy.ActionManager.UI.AddUiFromString (@"
 					<ui>
@@ -78,6 +84,12 @@
 				
 				Tomboy.ActionManager.UI.InsertActionGroup (action_group, 0);
 				
+				Tomboy.DefaultNoteManager.NoteDeleted += OnNoteDeleted;
+				
+				tomboy_tray_menu = GetTomboyTrayMenu ();
+				tomboy_tray_menu.Shown += OnTomboyTrayMenuShown;
+				tomboy_tray_menu.Hidden += OnTomboyTrayMenuHidden;
+				
 				initialized = true;
 			}
 		}
@@ -98,7 +110,84 @@
 			
 			initialized = false;
 		}
+		
+		private void OnTomboyTrayMenuShown (object sender, EventArgs args)
+		{
+			// Add in the top tasks
+			// TODO: Read the number of todo items to show from Preferences
+			int max_size = 5;
+			int list_size = 0;
+			Gtk.MenuItem item;
+			
+			// Filter the tasks to the ones that are incomplete
+			Gtk.TreeModelFilter store_filter =
+				new Gtk.TreeModelFilter (TasksApplicationAddin.DefaultTaskManager.Tasks, null);
+			store_filter.VisibleFunc = FilterTasks;
 
+			// TODO: Sort the tasks to order by due date and priority
+//			store_sort = new Gtk.TreeModelSort (store_filter);
+//			store_sort.DefaultSortFunc = 
+//				new Gtk.TreeIterCompareFunc (TaskSortFunc);
+				
+//			tree.Model = store_sort;
+			
+//			int cnt = tree.Model.IterNChildren ();
+			
+//			task_count.Text = string.Format (
+//				Catalog.GetPluralString("Total: {0} task",
+//							"Total: {0} tasks",
+//							cnt),
+//				cnt);
+
+			
+			// List the top "max_size" tasks
+			Gtk.TreeIter iter;
+			Gtk.SeparatorMenuItem separator;
+			
+			// Determine whether the icon is near the top/bottom of the screen
+			// TODO: Do this better!
+			int x, y;
+			Tomboy.Tray.GdkWindow.GetOrigin (out x, out y);
+			int position;
+			if (y < 24)
+				position = 2;
+			else
+				position = tomboy_tray_menu.Children.Length - 7;
+
+			separator = new Gtk.SeparatorMenuItem ();
+			tomboy_tray_menu.Insert (separator, position++);
+			separator.Show ();
+			top_tasks.Add (separator);
+
+			item = new Gtk.MenuItem (Catalog.GetString ("To Do List"));
+			tomboy_tray_menu.Insert (item, position++);
+			item.ShowAll ();
+			top_tasks.Add (item);
+			item.Activated += OnOpenTodoList;
+			
+			if (store_filter.GetIterFirst (out iter)) {
+				do {
+					Task task = store_filter.GetValue (iter, 0) as Task;
+					item = new TomboyTaskMenuItem (task);
+					tomboy_tray_menu.Insert (item, list_size + position);
+					item.ShowAll ();
+					top_tasks.Add (item);
+					list_size++;
+				} while (store_filter.IterNext (ref iter) && list_size < max_size);
+			}
+		}
+		
+		private void OnTomboyTrayMenuHidden (object sender, EventArgs args)
+		{
+			// Remove the tasks
+			foreach (Gtk.Widget item in top_tasks) {
+				tomboy_tray_menu.Remove (item);
+			}
+			
+			top_tasks.Clear ();
+		}
+
+
 		private void OnOpenToDoListAction ()
 		{
 			TaskListWindow task_list_window = TaskListWindow.GetInstance (manager);
@@ -110,5 +199,247 @@
 		{
 			get { return initialized; }
 		}
+		
+		private void OnNoteDeleted (object sender, Note note)
+		{
+			// Delete all the tasks associated with this note
+			foreach (Task task in DefaultTaskManager.GetTasksForNote (note)) {
+				Logger.Info ("Deleting task: {0}", task.Summary);
+				DefaultTaskManager.Delete (task);
+			}
+		}
+		
+		private Gtk.Menu GetTomboyTrayMenu ()
+		{
+			Gtk.Menu menu =
+				Tomboy.ActionManager.GetWidget ("/TrayIconMenu") as Gtk.Menu;
+			
+			return menu;
+		}
+
+		/// <summary>
+		/// Only allow incomplete tasks to pass this filter
+		/// </summary>
+		bool FilterTasks (Gtk.TreeModel model, Gtk.TreeIter iter)
+		{
+			Task task = model.GetValue (iter, 0) as Task;
+			if (task == null)
+				return false;
+			
+			if (task.CompletionDate == DateTime.MinValue)
+				return true; // No completion date set
+			
+			return false;
+		}
+		
+		void OnOpenTodoList (object sender, EventArgs args)
+		{
+			Tomboy.ActionManager ["OpenToDoListAction"].Activate ();
+		}
 	}
+	
+	public class TomboyTaskMenuItem : Gtk.ImageMenuItem
+//	public class TomboyTaskMenuItem : ComplexMenuItem
+	{
+		Task task;
+		BetterCheckButton check_button;
+		Gtk.Label summary;
+		bool inhibit_activate;
+		Gtk.RcStyle old_style;
+
+		static Dictionary<Task, TaskOptionsDialog> options_dialogs =
+			new Dictionary<Task, TaskOptionsDialog> ();
+		
+		public TomboyTaskMenuItem (Task task)
+			: base ()
+		{
+			this.task = task;
+			
+			summary = new Label ();
+			summary.Markup = task.Summary;
+			summary.UseUnderline = false;
+			summary.UseMarkup = true;
+			summary.Xalign = 0;
+			
+			summary.Show ();
+			Add (summary);
+
+			check_button = new BetterCheckButton ();
+			check_button.Toggled += OnCheckButtonToggled;
+			Image = check_button;
+		}
+
+		public Task Task
+		{
+			get { return task; }
+		}
+		
+		static string FormatForLabel (string summary)
+		{
+			// Replace underscores ("_") with double-underscores ("__")
+			// so Note menuitems are not created with mnemonics.
+			return summary.Replace ("_", "__");
+		}
+
+		static string GetDisplayText (string summary)
+		{
+			// TODO: use ellipsed summary if it's too long
+			return FormatForLabel (summary);
+		}
+
+		protected override bool OnButtonPressEvent (Gdk.EventButton ev)
+		{
+			if (ev.X >= check_button.Allocation.X &&
+				ev.X < check_button.Allocation.X + check_button.Allocation.Width) {
+				inhibit_activate = true;
+				check_button.Active = !check_button.Active;
+				return true;
+			}
+			
+			return base.OnButtonPressEvent (ev);
+		}
+
+		protected override bool OnButtonReleaseEvent (Gdk.EventButton ev)
+		{
+			if (inhibit_activate) {
+				inhibit_activate = false;
+				return true;
+			}
+			return base.OnButtonReleaseEvent (ev);
+		}
+
+		/// <summary>
+		/// If the user has just clicked on the checkbutton, the standard
+		/// behavior of the OnActivated should be suppressed.
+		/// </summary>
+		protected override void OnActivated () 
+		{
+			// Open the option dialog
+			if (!inhibit_activate) {
+				TaskOptionsDialog dialog;
+				if (options_dialogs.ContainsKey (task)) {
+					dialog = options_dialogs [task];
+				} else {
+					dialog =
+						new TaskOptionsDialog (
+							null,
+							Gtk.DialogFlags.DestroyWithParent,
+							task);
+					dialog.WindowPosition = Gtk.WindowPosition.CenterOnParent;
+					dialog.DeleteEvent += OnOptionsDialogDeleted;
+					options_dialogs [task] = dialog;
+				}
+				
+				dialog.Present ();
+				dialog.GrabFocus ();
+			}
+		}
+		
+		protected override bool OnEnterNotifyEvent (Gdk.EventCrossing evnt)
+		{
+			Rc.ParseString ("class \"*<GtkMenuItem>.GtkCheckButton\" style \"theme-menu-item\"");
+			return base.OnEnterNotifyEvent (evnt);
+		}
+		
+		protected override bool OnLeaveNotifyEvent (Gdk.EventCrossing evnt)
+		{
+			Rc.ReparseAll ();
+			return base.OnLeaveNotifyEvent (evnt);
+		}
+		
+		private void OnCheckButtonToggled (object sender, EventArgs args)
+		{
+			if (check_button.Active) {
+				task.Complete ();
+				summary.Markup =
+					String.Format (
+						"<span strikethrough='true'>{0}</span>",
+						GetDisplayText (task.Summary));
+				summary.Sensitive = false;
+			} else {
+				task.ReOpen ();
+				summary.Markup =
+					String.Format (
+						"<span strikethrough='false'>{0}</span>",
+						GetDisplayText (task.Summary));
+				summary.Sensitive = true;
+			}
+		}
+		
+		void OnOptionsDialogDeleted (object sender, Gtk.DeleteEventArgs args)
+		{
+			TaskOptionsDialog dialog = sender as TaskOptionsDialog;
+			if (dialog == null)
+				return;
+			
+			if (options_dialogs.ContainsKey (dialog.Task))
+				options_dialogs.Remove (dialog.Task);
+		}
+	}
+
+	public class BetterCheckButton : Gtk.MenuItem
+	{
+		bool active;
+		static int indicator_size = 13;
+		static int indicator_spacing = 2;
+		
+		#region Constructors
+		public BetterCheckButton () : base ()
+		{
+			active = false;
+			SetSizeRequest (indicator_size + indicator_spacing,
+				indicator_size + indicator_spacing);
+		}
+		#endregion // Constructors
+		
+		#region Properties
+		public bool Active
+		{
+			get { return active; }
+			set { this.Toggle (); }
+		}
+		#endregion // Properties
+		
+		#region Private Methods
+		void Paint (Gdk.Rectangle area)
+		{
+			int x;
+			int y;
+			Widget child;
+			Gtk.ShadowType shadow_type;
+			Gtk.StateType state_type;
+			
+			x = Allocation.X + indicator_spacing + (int) BorderWidth;
+			y = Allocation.Y + (Allocation.Height - indicator_size) / 2;
+			
+			child = this.Child;
+			
+			if (active) {
+				shadow_type = Gtk.ShadowType.In;
+				state_type = Gtk.StateType.Insensitive;
+			} else {
+				shadow_type = Gtk.ShadowType.Out;
+				state_type = Gtk.StateType.Normal;
+			}
+			
+			Gtk.Style.PaintCheck (Style, GdkWindow,
+								  state_type, shadow_type,
+								  area, this, "checkbutton",
+								  x, y, indicator_size, indicator_size);
+		}
+		
+		protected override bool OnExposeEvent (Gdk.EventExpose evnt)
+		{
+			Paint (evnt.Area);
+			
+			return false;
+		}
+		
+		protected override void OnToggled ()
+		{
+			active = !active;
+		}
+
+		#endregion // Private Methods
+	}
 }
Index: Tomboy/Addins/Makefile.am
===================================================================
--- Tomboy/Addins/Makefile.am	(revision 1469)
+++ Tomboy/Addins/Makefile.am	(working copy)
@@ -10,9 +10,6 @@
 	StickyNoteImport	\
 	FileSystemSyncService	\
 	WebDavSyncService	\
-	SshSyncService
+	SshSyncService		\
+	Tasks
 
-# Commenting out tasks from being built right now since it's
-# not ready for prime-time yet.
-#	Tasks
-
Index: data/UIManagerLayout.xml
===================================================================
--- data/UIManagerLayout.xml	(revision 1469)
+++ data/UIManagerLayout.xml	(working copy)
@@ -24,8 +24,10 @@
     	<placeholder name="MainWindowContextMenuPlaceholder" />
     </popup>
     <popup name="TrayIconMenu" action="TrayIconMenuAction">
+    	<placeholder name="TrayIconMenuPlaceholder0" />
         <menuitem name="TrayNewNote" action="TrayNewNoteAction" />
         <menuitem name="ShowSearchAllNotes" action="ShowSearchAllNotesAction" />
+        <placeholder name="TrayIconMenuPlaceholder1" />
     </popup>
 <!-- The following are not implemented yet
     <toolbar name="NoteWindowToolbar" action="NoteWindowToolbarAction">

Places

File tomboy-tasks-addin-20070903.patch of Package tomboy (Revision e862ff13146d9e35a755bc4fbfb850dd)

Places