Merge lp:~whatah/do/keybindings into lp:do

[whatah]

[whatah (whatah)]

Keybindings support - I'd like some feedback on the code

[Alex Launi (alexlauni)]

Couple of minor formatting things, you have a few cases of ! bool, remove the space and do !bool.
Can you rearrange some of the lines in CoreKeybindings so they're sorted by length? It just makes the code a little bit easier to read.
In a bunch of places you do
if (bool) {
  //block
  return true;
}
return false;

you should do
if (!bool)
  return false;

//block
return true;

^ this is a mono guidelines thing

It looks like youre using ',' as a delimeter for something in saving shortcuts, does this mean that ',' can not be used in a shortcut?

In Controller.cs, you have some odd newline formatting. We don't adhere to 80 cols rule, we say around 120, but that's not a hard rule; whatever is most readable is preferred.

Please clear out all of the commented code

review: Needs Fixing

[lp:~whatah/do/keybindings]

1113. By whatah on 2009-03-26

fixed some formatting issues (! bool -> !bool) and rearranged blocks so that return true is at the end of a function. Also sorted some lines by length

[Alex Launi (alexlauni)]

There is still whitespace issues in a bunch of the files, this needs cleared up, but can be done easily in vim. If you're using monodevelop, this is why. MD does weird stuff with whitespace.

line 104 in KeyBindingTreeView.cs, you should turn that anonymous function into a real function. It'll make the code cleaner, it's confusing to see a return statement in the middle of another function.

In the same file, can you localize the column headers?

You mix { placement styles, in some places you do
foreach (...)
{
in others you do
foreach (...) {

use the latter. The same for if statements.

Does the keybinding class need an initialize method? Can the stuff in the init method actually go in the constructor?

[lp:~whatah/do/keybindings]

1114. By whatah on 2009-03-28

Fixed inconsistent use of braces after foreach and if.
Added localization support for column strings in KeybindingTreeView
Removed call of Initialize method in Do.cs and placed in Keybinding ctor.

1115. By whatah on 2009-03-28

Changed anonymous function to a declared function

1116. By whatah on 2009-03-28

Fixed whitespacing issues (all 8 spaces are converted to hard tabs)

1117. By whatah on 2009-03-28

Fixed namespace/class { style issues and moved Shortcut into Do.Core

[Jason Smith (jassmith)]

> Keybindings support - I'd like some feedback on the code

Use tabs instead of spaces as per the new regulation that we just made up but we all followed to this point by pure fluke.

Love, DBO

=== modified file 'Do/Makefile.am'
--- Do/Makefile.am	2009-02-19 03:09:17 +0000
+++ Do/Makefile.am	2009-03-22 05:41:46 +0000
@@ -16,6 +16,7 @@
 	gtk-gui/generated.cs \
 	src/AssemblyInfo.cs \
 	src/CorePreferences.cs \
+	src/CoreKeybindings.cs \
 	src/Do.Core/Do.Core.Addins/AddinClassifier.cs \
 	src/Do.Core/Do.Core.Addins/CommunityAddinClassifier.cs \
 	src/Do.Core/Do.Core.Addins/GreedyAddinClassifier.cs \
@@ -31,6 +32,8 @@
 	src/Do.Core/PluginManager.cs \
 	src/Do.Core/RelevanceProvider.cs \
 	src/Do.Core/SecondSearchController.cs \
+	src/Do.Core/Shortcut.cs \
+	src/Do.Core/ShortcutCallback.cs \
 	src/Do.Core/SimpleSearchContext.cs \
 	src/Do.Core/SimpleSearchController.cs \
 	src/Do.Core/ThirdSearchController.cs \

=== added file 'Do/src/CoreKeybindings.cs'
--- Do/src/CoreKeybindings.cs	1970-01-01 00:00:00 +0000
+++ Do/src/CoreKeybindings.cs	2009-03-23 03:42:03 +0000
@@ -0,0 +1,241 @@
+
+/* Keybindings.cs
+ *
+ * GNOME Do is the legal property of its developers. Please refer to the
+ * COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using Env = System.Environment;
+
+using Do.Platform;
+
+namespace Do
+{
+
+        class CoreKeybindings {
+                Dictionary<string, Shortcut> ShortcutMap ; // shortcut name -> shortcut
+                Dictionary<string, string> KeycodeMap ; // keybinding -> shortcut name
+                Dictionary<string, string> DefaultShortcutMap ; // default keybinding -> shortcut name
+
+                IPreferences Preferences { get; set; }
+
+                public ArrayList Shortcuts ;
+                public Dictionary<string, List<KeyChangedCb>> PreferencesCbs;
+                public delegate void KeyChangedCb (object sender, PreferencesChangedEventArgs e);
+
+                public CoreKeybindings ()
+                {
+
+                        Preferences = Services.Preferences.Get<CoreKeybindings> ();
+                        Preferences.PreferencesChanged += PreferencesChanged;
+
+                        ShortcutMap = new Dictionary<string, Shortcut> (); // shortcut name -> shortcut
+                        KeycodeMap = new Dictionary<string, string> (); // keybinding -> shortcut name
+                        DefaultShortcutMap = new Dictionary<string, string> (); // default keybinding -> shortcut name
+                        Shortcuts = new ArrayList ();
+                        PreferencesCbs = new Dictionary<string, List<KeyChangedCb>> ();
+                }
+
+                public void Initialize ()
+                {
+                        // Read all values out of preferences and populate the KeybindingMap
+                        ReadShortcuts ();
+                }
+                
+                public bool RegisterShortcut (Shortcut sc, string defaultBinding)
+                {
+                        if (!RegisterShortcut (sc))
+                                return false; 
+                        if (!BindDefault (sc, defaultBinding))
+                                return false;
+                        return true;
+                }
+
+                public bool RegisterShortcut (Shortcut sc)
+                {
+                        // Add this shortcut to what?
+                        if (! Shortcuts.Contains (sc) && ! ShortcutMap.ContainsKey (sc.ShortcutName)) 
+                        {
+                                Shortcuts.Add (sc);
+                                ShortcutMap [sc.ShortcutName] = sc;
+                                PreferencesCbs [sc.ShortcutName] = new List<KeyChangedCb> ();
+                                SaveShortcuts ();
+                                return true;
+                        }
+                        return false;
+                }
+
+                public Shortcut GetShortcutByKeycode (string keycode)
+                {
+                        if (!KeycodeMap.ContainsKey (keycode)) {
+                                return null;
+                        }
+                        string scname = KeycodeMap [keycode];
+
+                        if (!ShortcutMap.ContainsKey (scname)) {
+                                return null;
+                        }
+
+                        return ShortcutMap [scname];
+
+                }
+
+                public string GetKeybinding (Shortcut sc)
+                {
+                        return GetKeybinding (sc.ShortcutName);
+                }
+
+                public string GetKeybinding (string sc)
+                {
+
+                        foreach (KeyValuePair<string, string> entry in KeycodeMap)
+                        {
+                                if (entry.Value == sc) {
+                                        return entry.Key;
+                                }
+                        }
+                        return null;
+                }
+
+                public string GetDefaultKeybinding (Shortcut sc)
+                {
+                        return GetDefaultKeybinding (sc.ShortcutName);
+                }
+
+                public string GetDefaultKeybinding (string sc)
+                {
+                        foreach (KeyValuePair<string, string> entry in DefaultShortcutMap)
+                        {
+                                if (entry.Value == sc) {
+                                        return entry.Key;
+                                }
+                        }
+                        return null;
+                }
+
+
+                public bool BindShortcut (Shortcut sc, string keycode)
+                {
+                        // Add this function to our keybinding map
+                        return BindShortcut (sc.ShortcutName, keycode);
+
+                }
+
+                public bool BindShortcut (string sc, string keycode)
+                {
+                        string oldcode = GetKeybinding (sc);
+                        if (oldcode != null)
+                                KeycodeMap.Remove (oldcode); // remove the old keybinding from the map
+
+                        KeycodeMap [keycode] = sc;
+                        Preferences.Set (sc, keycode);
+
+                        return true;
+                }
+
+                // Add Default Keycode mapping - used for resetting to default or not overwriting read values
+                public bool BindDefault (Shortcut sc, string keycode)
+                {
+                        return BindDefault (sc.ShortcutName, keycode);
+
+                }
+
+                public bool BindDefault (string sc, string keycode)
+                {
+
+                        string assigned_keycode = GetKeybinding (sc);
+                        if (assigned_keycode == null)
+                        {
+                                // Put this shortcut in the mapping
+                                BindShortcut (sc, keycode);
+                        }
+
+                        DefaultShortcutMap [keycode] = sc;
+                        return true;
+
+                }
+
+                public bool UnregisterShortcut (Shortcut sc)
+                {
+                        if (Shortcuts.Contains (sc))
+                        {
+                                Shortcuts.Remove (sc);
+                                ShortcutMap.Remove (sc.ShortcutName);
+                                SaveShortcuts ();
+                                return true;
+                        }
+                        return false;
+                }
+
+                public bool RegisterNotification (Shortcut sc, KeyChangedCb cb)
+                {
+                        return RegisterNotification (sc.ShortcutName, cb);
+                }
+
+                public bool RegisterNotification (string scname, KeyChangedCb cb)
+                {
+                        PreferencesCbs [scname].Add (cb);
+                        return true;
+                }
+
+                void SaveShortcuts () 
+                {
+                        string scstring = "";
+                        foreach (Shortcut sc in Shortcuts)
+                        {
+                                scstring += sc.ShortcutName.Trim () + ",";
+                        }
+                        Preferences.Set ("RegisteredShortcuts", scstring);
+                } 
+
+                void ReadShortcuts ()
+                {
+                        string scstring = Preferences.Get ("RegisteredShortcuts", "").Trim ();
+                        if (scstring == "") 
+                                return;
+
+                        foreach (string sc in scstring.Split (',')) {
+                                if (sc.Trim () == "") 
+                                        continue;
+
+                                string keycode = Preferences.Get (sc, "");
+                                if (keycode != "")
+                                        BindShortcut (sc, keycode);
+                        }
+                }
+
+                void PreferencesChanged (object sender, PreferencesChangedEventArgs e)
+                {
+
+                        //        if (GetKeybinding (e.Key) != null && GetKeybinding (e.Key).ToString ().Trim () == e.OldValue.ToString ().Trim ())
+                        //            return;
+                        //
+                        if (PreferencesCbs.ContainsKey (e.Key))
+                        {   
+                                foreach (KeyChangedCb cb in PreferencesCbs [e.Key]) {
+                                        cb (this, e);
+                                }
+                        }
+                }
+
+        }
+
+}

=== modified file 'Do/src/CorePreferences.cs'
--- Do/src/CorePreferences.cs	2009-01-09 01:17:59 +0000
+++ Do/src/CorePreferences.cs	2009-03-23 03:05:45 +0000
@@ -20,22 +20,21 @@
 
 using System;
 using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
 using Env = System.Environment;
 
 using Do.Platform;
 
 namespace Do
 {
-	
 	class CorePreferences  {
 
 		#region Key constants and default values
 		const string ThemeKey = "Theme";
 		const string QuietStartKey = "QuietStart";
 		const string StartAtLoginKey = "StartAtLogin";
-		const string SummonKeybindingKey = "SummonKeybinding";
 		const string AlwaysShowResultsKey = "AlwaysShowResults";
-		const string TextModeKeybindingKey = "TextModeKeybinding";
 
 		const string ThemeDefaultValue = "Classic Interface";
 		const bool QuietStartDefaultValue = false;
@@ -46,10 +45,11 @@
 
 		const string DebugOption = "--debug";
 		const string LogToFileOption = "--log-to-file";
+                
+
 		#endregion
 
 		public event EventHandler<PreferencesChangedEventArgs> ThemeChanged;
-		public event EventHandler<PreferencesChangedEventArgs> SummonKeybindingChanged;
 		
 		IPreferences Preferences { get; set; }
 		
@@ -71,16 +71,6 @@
 			get { return CorePreferences.PeekDebug; }
 		}
 
-		public string SummonKeybinding {
-			get { return Preferences.Get (SummonKeybindingKey, SummonKeybindingDefaultValue); }
-			set { Preferences.Set (SummonKeybindingKey, value); }
-		}
-		
-		public string TextModeKeybinding {
-			get { return Preferences.Get (TextModeKeybindingKey, TextModeKeybindingDefaultValue); }
-			set { Preferences.Set (TextModeKeybindingKey, value); }
-		}
-
 		public string Theme {
 			get { return Preferences.Get (ThemeKey, ThemeDefaultValue); }
 			set { Preferences.Set (ThemeKey, value); }
@@ -106,6 +96,7 @@
 			return Env.GetCommandLineArgs ().Contains (option);
 		}
 
+
 		void PreferencesChanged (object sender, PreferencesChangedEventArgs e)
 		{
 			switch (e.Key) {
@@ -113,10 +104,6 @@
 				if (ThemeChanged != null)
 					ThemeChanged (this, e);
 				break;
-			case SummonKeybindingKey:
-				if (SummonKeybindingChanged != null)
-					SummonKeybindingChanged (this, e);
-				break;
 			}
 		}
 	}

=== modified file 'Do/src/Do.Core/Controller.cs'
--- Do/src/Do.Core/Controller.cs	2009-01-27 05:19:42 +0000
+++ Do/src/Do.Core/Controller.cs	2009-03-23 03:42:03 +0000
@@ -86,6 +86,7 @@
 			im_context.UsePreedit = false;
 			im_context.Commit += OnIMCommit;
 			im_context.FocusIn ();
+                        
 		}
 		
 		void OnIMCommit (object sender, Gtk.CommitArgs e)
@@ -98,6 +99,99 @@
 		{
 			SetTheme (Do.Preferences.Theme);
 			Do.Preferences.ThemeChanged += OnThemeChanged;
+                        
+                        // Register Shortcuts
+                        // TODO: Localize the text here.
+                        // Previous shortcuts
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("SummonKey", 
+                                                Catalog.GetString ("Summon Gnome-Do"), 
+                                                OnSummonKeyPressEvent),
+                                        "<Super>space");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("TextModeKey",
+                                                Catalog.GetString ("Enter text mode"),
+                                                OnTextModePressEvent),
+                                        "period");
+                        // New shortcuts
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("CopyKey",
+                                                Catalog.GetString ("Copy Text"),
+                                                OnCopyEvent),
+                                        "<Control>c");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("PasteKey",
+                                                Catalog.GetString ("Paste Text"),
+                                                OnPasteEvent),
+                                        "<Control>v");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("AlternateEscapeKey",
+                                                Catalog.GetString ("Alternate Escape"),
+                                                OnEscapeKeyPressEvent));
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("AlternateActivateKey",
+                                                Catalog.GetString ("Alternate Activate"),
+                                                OnActivateKeyPressEvent));
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("AlternateDeleteKey",
+                                                Catalog.GetString ("Alternate Delete"),
+                                                OnDeleteKeyPressEvent));
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("ShiftTabKey",
+                                                Catalog.GetString ("Previous Pane"),
+                                                OnShiftTabKeyPressEvent),
+                                        "ISO_Left_Tab");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("TabKey",
+                                                Catalog.GetString ("Next Pane"),
+                                                OnTabKeyPressEvent),
+                                        "Tab");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("UpKey",
+                                                Catalog.GetString ("Previous Result"),
+                                                OnUpKeyPressEvent),
+                                        "Up");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("DownKey",
+                                                Catalog.GetString ("Next Result"),
+                                                OnDownKeyPressEvent),
+                                        "Down");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("HomeKey",
+                                                Catalog.GetString ("First Result"),
+                                                OnHomeKeyPressEvent),
+                                        "Home");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("EndKey",
+                                                Catalog.GetString ("Last Result"),
+                                                OnEndKeyPressEvent),
+                                        "End");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("PageUpKey",
+                                                Catalog.GetString ("Previous 5 Results"),
+                                                OnPageUpKeyPressEvent),
+                                        "Page_Up");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("PageDownKey",
+                                                Catalog.GetString ("Next 5 Results"),
+                                                OnPageDownKeyPressEvent),
+                                        "Page_Down");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("LeftKey",
+                                                Catalog.GetString ("Step out of Item"),
+                                                OnLeftKeyPressEvent),
+                                        "Left");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("RightKey",
+                                                Catalog.GetString ("Browse Into Item"),
+                                                OnRightKeyPressEvent),
+                                        "Right");
+                        Do.Keybindings.RegisterShortcut (
+                                        new Shortcut ("CommaKey",
+                                                Catalog.GetString ("Selection mode"),
+                                                OnSelectionKeyPressEvent),
+                                        "Comma");
+                        
 		}
 
 		void OnSummoned ()
@@ -319,8 +413,8 @@
 		{
 			return controllers [(int) pane].TextType == TextModeType.Explicit ||
 				controllers [(int) pane].TextType == TextModeType.ExplicitFinalized;
-		}
-		
+		}	
+
 #region KeyPress Handling
 
 		Key IfVertical (Key ifKey, Key elseKey)
@@ -337,29 +431,8 @@
 		{
 			Key key = (Key) evnt.KeyValue;
 
-			// User set keybindings
-			if (KeyEventToString (evnt).Equals (Do.Preferences.SummonKeybinding)) {
-				OnSummonKeyPressEvent (evnt);
-				return;
-			} 
-			
-			if (KeyEventToString (evnt).Equals (Do.Preferences.TextModeKeybinding)) {
-				OnTextModePressEvent (evnt);
-				return;
-			}
-			
-			// Check for paste
-			if ((evnt.State & ModifierType.ControlMask) != 0) {
-				if (evnt.Key == Key.v) {
-					OnPasteEvent ();
-					return;
-				}
-				if (evnt.Key == Key.c) {
-					OnCopyEvent ();
-					return;
-				}
-			}
-
+                        
+                        // Currently - only hardcoded are enter keys, escape and delete/backspace
 			if (key == Key.Escape) {
 				OnEscapeKeyPressEvent (evnt);
 			} else if (key == Key.Return ||
@@ -369,27 +442,19 @@
 			} else if (key == Key.Delete ||
 			           key == Key.BackSpace) {
 				OnDeleteKeyPressEvent (evnt);
-			} else if (key == Key.Tab ||
-			           key == Key.ISO_Left_Tab) {
-				OnTabKeyPressEvent (evnt);
-			} else if (key == UpKey ||
-			           key == DownKey ||
-			           key == Key.Home ||
-			           key == Key.End ||
-			           key == Key.Page_Up ||
-			           key == Key.Page_Down) {
-				OnUpDownKeyPressEvent (evnt);
-			} else if (key == RightKey ||
-			           key == LeftKey) {
-				OnRightLeftKeyPressEvent (evnt);
-			} else if (key == Key.comma) {
-				OnSelectionKeyPressEvent (evnt);
-			} else {
-				OnInputKeyPressEvent (evnt);
-			}
+                        } else {
+                                // User set keybindings
+                                Shortcut sc = Do.Keybindings.GetShortcutByKeycode (KeyEventToString (evnt));
+                                if (sc != null)
+                                {
+                                        sc.Callback (evnt);
+                                        return;
+                                }
+                                OnInputKeyPressEvent (evnt);
+                        }
 		}
 		
-		void OnPasteEvent ()
+		void OnPasteEvent (EventKey evnt)
 		{
 			Gtk.Clipboard clip = Gtk.Clipboard.Get (Selection.Clipboard);
 			if (!clip.WaitIsTextAvailable ()) {
@@ -399,7 +464,7 @@
 			SearchController.SetString (SearchController.Query + str);
 		}
 		
-		void OnCopyEvent ()
+		void OnCopyEvent (EventKey evnt)
 		{
 			Gtk.Clipboard clip = Gtk.Clipboard.Get (Selection.Clipboard);
 			if (SearchController.Selection != null)
@@ -408,14 +473,14 @@
 		
 		void OnActivateKeyPressEvent (EventKey evnt)
 		{
-			im_context.Reset ();
-			if (SearchController.TextType == TextModeType.Explicit) {
-				OnInputKeyPressEvent (evnt);
-				return;
-			}
-			bool shift_pressed = (evnt.State & ModifierType.ShiftMask) != 0;
-			PerformAction (!shift_pressed);
-		}
+                        im_context.Reset ();
+                        if (SearchController.TextType == TextModeType.Explicit) {
+                                OnInputKeyPressEvent (evnt);
+                                return;
+                        }
+                        bool shift_pressed = (evnt.State & ModifierType.ShiftMask) != 0;
+                        PerformAction (!shift_pressed);
+                }
 		
 		/// <summary>
 		/// This will set a secondary cursor unless we are operating on a text
@@ -494,28 +559,32 @@
 			}
 		}
 		
-		void OnRightLeftKeyPressEvent (EventKey evnt)
+		void OnLeftKeyPressEvent (EventKey evnt)
 		{
 			im_context.Reset ();
 			if (!SearchController.Results.Any ()) return;
 
-			if ((Key) evnt.KeyValue == RightKey) {
-				// We're attempting to browse the contents of an item, so increase its
-				// relevance.
-				SearchController.Selection
-					.IncreaseRelevance (SearchController.Query, null);
-				if (SearchController.ItemChildSearch ()) GrowResults ();
-			} else if ((Key) evnt.KeyValue == LeftKey) {
-				// We're attempting to browse the parent of an item, so decrease its
-				// relevance. This makes it so we can merely visit an item's children,
-				// and navigate back out of the item, and leave that item's relevance
-				// unchanged.
-				SearchController.Selection
-					.DecreaseRelevance (SearchController.Query, null);
-				if (SearchController.ItemParentSearch ()) GrowResults ();
-			}
+                        // We're attempting to browse the parent of an item, so decrease its
+                        // relevance. This makes it so we can merely visit an item's children,
+                        // and navigate back out of the item, and leave that item's relevance
+                        // unchanged.
+                        SearchController.Selection
+                                .DecreaseRelevance (SearchController.Query, null);
+                        if (SearchController.ItemParentSearch ()) GrowResults ();
 		}
-		
+
+                // Hmm.
+                void OnRightKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    if (!SearchController.Results.Any ()) return;
+
+                    // We're attempting to browse the contents of an item, so increase its
+                    // relevance.
+                    SearchController.Selection.IncreaseRelevance (SearchController.Query, null);
+                    if (SearchController.ItemChildSearch ()) GrowResults ();
+                }
+
 		void OnTabKeyPressEvent (EventKey evnt)
 		{
 			im_context.Reset ();
@@ -526,12 +595,21 @@
 				UpdatePane (CurrentPane);
 			}
 				
-			if (evnt.Key == Key.Tab) {
-				NextPane ();
-			} else if (evnt.Key == Key.ISO_Left_Tab) {
-				PrevPane ();
-			}
+                        NextPane ();
 		}
+
+                void OnShiftTabKeyPressEvent (EventKey evnt)
+                {
+                        im_context.Reset ();
+                        ShrinkResults ();
+
+                        if (SearchController.TextType == TextModeType.Explicit) {
+                                SearchController.FinalizeTextMode ();
+                                UpdatePane (CurrentPane);
+                        }
+                        PrevPane ();
+                }
+                        
 		
 		void OnTextModePressEvent (EventKey evnt)
 		{
@@ -548,38 +626,56 @@
 			UpdatePane (CurrentPane);
 		}
 		
-		void OnUpDownKeyPressEvent (EventKey evnt)
+                void OnUpKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    if (!results_grown) {
+                        if (SearchController.Cursor > 0)
+                            GrowResults ();
+                        return;
+                    } else {
+                        if (SearchController.Cursor <= 0) {
+                            ShrinkResults ();
+                            return;
+                        }
+                        SearchController.Cursor--;
+                    }
+                }
+
+		void OnDownKeyPressEvent (EventKey evnt)
 		{
-			im_context.Reset ();
-			if (evnt.Key == UpKey) {
-				if (!results_grown) {
-					if (SearchController.Cursor > 0)
-						GrowResults ();
-					return;
-				} else {
-					if (SearchController.Cursor <= 0) {
-						ShrinkResults ();
-						return;
-					}
-					SearchController.Cursor--;
-                }
-			} else if (evnt.Key == DownKey) {
-				if (!results_grown) {
-					GrowResults ();
-					return;
-				}
-				SearchController.Cursor++;
-			} else if (evnt.Key == Key.Home) {
-				SearchController.Cursor = 0;
-			} else if (evnt.Key == Key.End) {
-				SearchController.Cursor = SearchController.Results.Count - 1;
-			} else if (evnt.Key == Key.Page_Down) {
-				SearchController.Cursor += 5;
-			} else if (evnt.Key == Key.Page_Up) {
-				SearchController.Cursor -= 5;
-			}
+                    im_context.Reset ();
+                    if (!results_grown) {
+                            GrowResults ();
+                            return;
+                    }
+                    SearchController.Cursor++;
 		}
-		
+	        
+                void OnHomeKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    SearchController.Cursor = 0;
+                }
+
+                void OnEndKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    SearchController.Cursor = SearchController.Results.Count - 1;
+                }
+
+                void OnPageUpKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    SearchController.Cursor -= 5;
+                }
+                
+                void OnPageDownKeyPressEvent (EventKey evnt)
+                {
+                    im_context.Reset ();
+                    SearchController.Cursor += 5;
+                }
+                        	
 		/// <summary>
 		/// Converts a keypress into a human readable string for comparing
 		/// against values in GConf.

=== added file 'Do/src/Do.Core/Shortcut.cs'
--- Do/src/Do.Core/Shortcut.cs	1970-01-01 00:00:00 +0000
+++ Do/src/Do.Core/Shortcut.cs	2009-03-23 03:26:01 +0000
@@ -0,0 +1,46 @@
+/* Shortcut.cs
+ *
+ * GNOME Do is the legal property of its developers. Please refer to the
+ * COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using System.Linq;
+using System.Collections;
+using System.Collections.Generic;
+using Env = System.Environment;
+
+using Do.Platform;
+
+namespace Do
+{
+        class Shortcut {
+                public string ShortcutName; // name of the shortcut
+                public string FriendlyName; // display name of the shortcut
+                public ShortcutCallback Callback; // callback function for this shortcut
+
+                public Shortcut (string name, string friendly, ShortcutCallback cb)
+                {
+                        ShortcutName = name;
+                        FriendlyName = friendly;
+                        Callback = cb;
+
+                }
+        }
+}
+
+

=== added file 'Do/src/Do.Core/ShortcutCallback.cs'
--- Do/src/Do.Core/ShortcutCallback.cs	1970-01-01 00:00:00 +0000
+++ Do/src/Do.Core/ShortcutCallback.cs	2009-03-23 03:05:45 +0000
@@ -0,0 +1,28 @@
+/* ShortcutCallback.cs
+ *
+ * GNOME Do is the legal property of its developers. Please refer to the
+ * COPYRIGHT file distributed with this
+ * source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System;
+using Do;
+using Gdk;
+using Mono.Unix;
+namespace Do.Platform {
+
+    public delegate void ShortcutCallback (EventKey evtky);
+}

=== modified file 'Do/src/Do.UI/KeybindingTreeView.cs'
--- Do/src/Do.UI/KeybindingTreeView.cs	2008-12-05 20:37:01 +0000
+++ Do/src/Do.UI/KeybindingTreeView.cs	2009-03-23 03:05:45 +0000
@@ -29,22 +29,29 @@
 		enum Column {
 			Action = 0,
 			Binding,
+                        DefaultKeybinding,
+                        ShortcutName, 
 			NumColumns
 		}
 		
 		public KeybindingTreeView ()
 		{	
-			Model = new ListStore (typeof (string), typeof (string));
+			Model = new ListStore (typeof (string), typeof (string), typeof (string), typeof (string));
 			
 			CellRendererText actionCell = new CellRendererText ();
 			actionCell.Width = 150;
 			InsertColumn (-1, "Action", actionCell, "text", (int)Column.Action);
 			
 			CellRendererAccel bindingCell = new CellRendererAccel ();
+                        bindingCell.AccelMode = CellRendererAccelMode.Gtk;
 			bindingCell.Editable = true;
 			bindingCell.AccelEdited += new AccelEditedHandler (OnAccelEdited);
 			bindingCell.AccelCleared += new AccelClearedHandler (OnAccelCleared);
 			InsertColumn (-1, "Shortcut", bindingCell, "text", (int)Column.Binding);
+                        
+                        CellRendererText defaultbindingCell = new CellRendererText ();
+                        actionCell.Width = 150;
+                        InsertColumn (-1, "Default Shortcut", defaultbindingCell, "text", (int)Column.DefaultKeybinding);
 			
 			RowActivated += new RowActivatedHandler (OnRowActivated);
 			ButtonPressEvent += new ButtonPressEventHandler (OnButtonPress);
@@ -57,9 +64,12 @@
 		{
 			ListStore store = Model as ListStore;
 			store.Clear ();
-			
-			store.AppendValues ("Summon", Do.Preferences.SummonKeybinding);
-			store.AppendValues ("Text Mode", Do.Preferences.TextModeKeybinding);
+
+                        foreach (Shortcut sc in Do.Keybindings.Shortcuts)
+                        {
+                            store.AppendValues (sc.FriendlyName, Do.Keybindings.GetKeybinding (sc), 
+                                                Do.Keybindings.GetDefaultKeybinding (sc), sc.ShortcutName);
+                        }
 		}
 		
 		[GLib.ConnectBefore]
@@ -91,7 +101,18 @@
 			
 			string realKey = Gtk.Accelerator.Name (args.AccelKey, args.AccelMods);
 			
+                        // Look for any other rows that have the same binding and then zero that binding out
+                        Model.Foreach ((model, path, treeiter) => 
+                        {
+                            string binding = model.GetValue (treeiter, (int)Column.Binding) as string;
+                            if (binding == realKey) {
+                                model.SetValue (treeiter, (int)Column.Binding, "");
+                            }
+                            return false;
+                        } );
+
 			store.SetValue (iter, (int)Column.Binding, realKey);
+
 			SaveBindings ();
 		}
 		
@@ -102,7 +123,9 @@
 			
 			store = Model as ListStore;
 			store.GetIter (out iter, new TreePath (args.PathString));
-			store.SetValue (iter, (int)Column.Binding, "DISABLED");
+			store.SetValue (iter, (int)Column.Binding, "");
+
+                        SaveBindings ();
 		}
 		
 		private void SaveBindings ()
@@ -112,20 +135,15 @@
 		
 		private bool SaveBindingsForeachFunc (TreeModel model, TreePath path, TreeIter iter)
 		{
-			string action, binding;
-			action = model.GetValue (iter, (int)Column.Action) as string;
-			
-			switch (action.ToLower ()) {
-			case "summon":
-				binding = model.GetValue (iter, (int)Column.Binding) as string;
-				Do.Preferences.SummonKeybinding = binding;
-				break;
-			case "text mode":
-				binding = model.GetValue (iter, (int)Column.Binding) as string;
-				Do.Preferences.TextModeKeybinding = binding;
-				break;
-			}
+                        string binding, shortcutname;
+                        binding = model.GetValue (iter, (int)Column.Binding) as string;
+                        shortcutname = model.GetValue (iter, (int)Column.ShortcutName) as string;
+                    
+                        if (binding != null && binding != "DISABLED" && binding != Do.Keybindings.GetKeybinding (shortcutname))
+        			Do.Keybindings.BindShortcut (shortcutname, binding);
 			return false;
 		}
+                
 	}
+
 }

=== modified file 'Do/src/Do.cs'
--- Do/src/Do.cs	2009-01-20 04:56:39 +0000
+++ Do/src/Do.cs	2009-03-23 03:26:01 +0000
@@ -37,6 +37,7 @@
 		static UniverseManager universe_manager;
 
 		public static CorePreferences Preferences { get; private set; } 
+                public static CoreKeybindings Keybindings { get; private set; } 
 
 		internal static void Main (string [] args)
 		{
@@ -54,6 +55,9 @@
 
 			Preferences = new CorePreferences ();
 
+                        Keybindings = new CoreKeybindings ();
+                        Keybindings.Initialize ();
+
 			// Now we can set the preferred log level.
 			if (Preferences.QuietStart)
 				Log.DisplayLevel = LogLevel.Error;
@@ -95,11 +99,24 @@
 				return universe_manager;
 			}
 		}
+
+                static void SummonKeyCb (object sender, PreferencesChangedEventArgs e)
+                {
+                        try {
+                                if (e.OldValue != null)
+                                        keybinder.Unbind (e.OldValue as string);
+                                keybinder.Bind (Keybindings.GetKeybinding ("SummonKey"), OnActivate);
+                        } catch (Exception ex) {
+                                Log.Error ("Could not bind summon key: {0}", ex.Message);
+                                Log.Debug (ex.StackTrace);
+                        }
+
+                }
 		
 		static void SetupKeybindings ()
 		{
 			try {
-				keybinder.Bind (Preferences.SummonKeybinding, OnActivate);
+				keybinder.Bind (Keybindings.GetKeybinding ("SummonKey"), OnActivate);
 			} catch (Exception e) {
 				Log.Error ("Could not bind summon key: {0}", e.Message);
 				Log.Debug (e.StackTrace);
@@ -107,16 +124,7 @@
 
 			// Watch preferences for changes to the keybinding so we
 			// can change the binding when the user reassigns it.
-			Preferences.SummonKeybindingChanged += (sender, e) => {
-				try {
-					if (e.OldValue != null)
-						keybinder.Unbind (e.OldValue as string);
-					keybinder.Bind (Preferences.SummonKeybinding, OnActivate);
-				} catch (Exception ex) {
-					Log.Error ("Could not bind summon key: {0}", ex.Message);
-					Log.Debug (ex.StackTrace);
-				}
-			};
+			Keybindings.RegisterNotification ("SummonKey", SummonKeyCb);
 		}
 		
 		static void OnActivate (object sender, EventArgs e)