Merge lp:~do-win/do/keybinding-service into lp:~do-win/do/trunk

[Chris S.]

[lp:~do-win/do/keybinding-service]

80. By Chris S. on 2009-07-20

clean up a few things

81. By Chris S. on 2009-07-21

some initial fixes

82. By Chris S. on 2009-07-21

rename KeyEvent to KeyBinding

Unmerged revisions

82. By Chris S. on 2009-07-21

rename KeyEvent to KeyBinding

81. By Chris S. on 2009-07-21

some initial fixes

80. By Chris S. on 2009-07-20

clean up a few things

79. By Chris S. on 2009-07-20

add region comments

78. By Chris S. on 2009-07-20

clean up and simplify keybinding service

77. By Chris S. on 2009-07-19

remove ManagedWinAPI

76. By Chris S. on 2009-07-19

add all new files

75. By Chris S. on 2009-07-19

remove some old files

74. By Chris S. on 2009-07-19

massive overhaul of keybindings

73. By Chris S. on 2009-07-18

begin to add keybinding service

=== modified file 'Do.Platform.Windows/Do.Platform.Windows.csproj'
--- Do.Platform.Windows/Do.Platform.Windows.csproj	2009-07-17 00:41:31 +0000
+++ Do.Platform.Windows/Do.Platform.Windows.csproj	2009-07-18 23:45:47 +0000
@@ -78,6 +78,7 @@
     <Compile Include="src\Do.Platform\Do.Platform.Windows\ConsoleLogService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\EnvironmentService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\IconExtractor\IconExtractor.cs" />
+    <Compile Include="src\Do.Platform\Do.Platform.Windows\KeyBindingService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\NotificationService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\RegistryPreferencesService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\SecurePreferencesService.cs" />
@@ -93,6 +94,7 @@
     <Compile Include="src\Do.Platform\Do.Platform.Windows\Shell\ShellFileInfo.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\Shell\WinAPIFolder.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\SystemService.cs" />
+    <Compile Include="src\Do.Platform\Do.Platform.Windows\EventDispatchingNativeWindow.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\Tests\RegistryPreferencesServiceTests.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\TrayIconPreferences.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Windows\TrayIconService.cs" />

=== modified file 'Do.Platform.Windows/Resources/Do.Platform.Windows.addin.xml'
--- Do.Platform.Windows/Resources/Do.Platform.Windows.addin.xml	2009-07-17 00:41:31 +0000
+++ Do.Platform.Windows/Resources/Do.Platform.Windows.addin.xml	2009-07-18 23:45:47 +0000
@@ -32,5 +32,6 @@
     <Service type="Do.Platform.Windows.UniverseFactoryService" />
 		<Service type="Do.Platform.Windows.RegistryPreferencesService" />
 		<Service type="Do.Platform.Windows.SecurePreferencesService" />
+		<Service type="Do.Platform.Windows.KeyBindingService" />
 	</Extension>
 </Addin>
\ No newline at end of file

=== added file 'Do.Platform.Windows/src/Do.Platform/Do.Platform.Windows/KeyBindingService.cs'
--- Do.Platform.Windows/src/Do.Platform/Do.Platform.Windows/KeyBindingService.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform.Windows/src/Do.Platform/Do.Platform.Windows/KeyBindingService.cs	2009-07-20 05:32:59 +0000
@@ -0,0 +1,170 @@
+using System;
+using System.Linq;
+using System.Globalization;
+using System.Windows.Forms;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using System.Runtime.InteropServices;
+
+using Mono.Unix;
+using Gdk;
+
+using Do.Platform.Common;
+using Do.Platform.Windows;
+
+namespace Do.Platform.Windows
+{
+	class KeyBindingService : AbstractKeyBindingService
+	{
+		[Flags]
+		enum Modifiers : int
+		{
+			Alt = 0x1,
+			Control = 0x02,
+			Shift = 0x04,
+			Win = 0x08,
+		}
+
+		class HotKey {
+			//Occurs when the hotkey is pressed.
+			public EventCallback PressedEvent { get; set; }
+			//the keystring
+			public string KeyString { get; private set; }
+			//a unique key identifier value in the range 0x0000 through 0xBFFF
+			public int KeyID { get; private set; }
+			//the System.Windows.Forms.Keys enum value of this key
+			public Keys Key { get; private set; }
+			//the key modifiers to use
+			public Modifiers Mods { get; private set; }
+			//constructor
+			public HotKey (string keyString, Keys key, Modifiers mods, int keyID) {
+				this.KeyString = keyString;
+				this.Key = key;
+				this.Mods = mods;
+				this.KeyID = keyID;
+			}
+
+			/*
+			public void HandleEvent () {
+				if (PressedEvent != null)
+					PressedEvent (this, EventArgs.Empty);
+			}
+			*/
+		}
+
+		[DllImport ("user32.dll")]
+		private static extern bool RegisterHotKey (IntPtr hWnd, int id, int fsModifiers, int vlc);
+
+		[DllImport ("user32.dll")]
+		private static extern bool UnregisterHotKey (IntPtr hWnd, int id);
+
+		// the hotkey pressed message identifier
+		const int WM_HOTKEY = 0x0312;
+
+		//this will strip the < > from the keycodes that we use
+		Regex rexp = new Regex ("<.*>", RegexOptions.Compiled | RegexOptions.IgnoreCase);
+
+		//base hotkey index
+		int hotkeyIndex = 0xA000;
+
+		//an IntPtr to our application
+		IntPtr hWnd { get; set; }
+
+		//a dict of OS level bound hot keys, keystring --> hotkey
+		Dictionary <string, HotKey> BoundKeys;
+
+		public KeyBindingService () {
+			EventDispatchingNativeWindow.Instance.EventHandler += KeyPressEvent;
+			this.hWnd = EventDispatchingNativeWindow.Instance.Handle;
+			BoundKeys = new Dictionary<string, HotKey> ();
+		}
+
+		void KeyPressEvent (ref Message m, ref bool handled) {
+			if (handled) return;
+			//get the KEY ID.  If this isn't a WM_HOTKEY message this won't really be the id of the key,
+			//but we don't care about that, because we check for WM_HOTKEY messages below.
+			int keyID = m.WParam.ToInt32 ();
+			if (m.Msg == WM_HOTKEY && BoundKeys.Values.Where (k => k.KeyID == keyID).Any ()) {
+				HotKey key = BoundKeys.Values.Where (k => k.KeyID == keyID).First ();
+				if (key.PressedEvent != null)
+					key.PressedEvent (null);
+				//key.HandleEvent ();
+				handled = true;
+			}
+		}
+
+		HotKey ProcessKeyString (string keyString) {
+			Modifiers modKeys = 0;
+			Keys key;
+
+			// determine modifiers to use
+			if (keyString.ToLower ().Contains ("super"))
+				modKeys |= Modifiers.Win;
+
+			if (keyString.ToLower ().Contains ("shift"))
+				modKeys |= Modifiers.Shift;
+
+			if (keyString.ToLower ().Contains ("alt"))
+				modKeys |= Modifiers.Alt;
+
+			if (keyString.ToLower ().Contains ("control"))
+				modKeys |= Modifiers.Control;
+
+			// figure out what the key is...this is so incredibly hacky but it should work for most cases
+			// -- ootz0rz
+			string thekey = rexp.Replace (keyString, "");
+			thekey = CultureInfo.CurrentCulture.TextInfo.ToTitleCase (thekey);
+
+			try {
+				key = (Keys) Enum.Parse (typeof (Keys), thekey);
+			} catch (Exception e) {
+				Log<KeyBindingService>.Error ("Could not register {0} with the OS.", keyString);
+				Log<KeyBindingService>.Debug (e.StackTrace);
+				return null;
+			}
+
+			return new HotKey (keyString, key, modKeys, hotkeyIndex + BoundKeys.Keys.Count);
+		}
+
+		public override bool RegisterSummonKey (string keyString, EventCallback cb) {
+			bool success = false;
+
+			//check if we already bound this key
+			if (!BoundKeys.ContainsKey (keyString)) {
+				//if not, create the key and add it to the cache of bound keys
+				HotKey key = ProcessKeyString (keyString);
+				//if we failed to parse the keystring, bail
+				if (key == null)
+					return false;
+				//assign the callback function
+				key.PressedEvent = cb;
+				//key.PressedEvent += handler;
+				//attempt to register the key
+				success = RegisterHotKey (this.hWnd, hotkeyIndex, (int) key.Mods, (int) key.Key);
+				//only add this to our dictionary of bound keys if we were successful at binding it.
+				if (success)
+					BoundKeys.Add (keyString, key);
+			} else {
+				Log.Debug ("Key {0} is already bound...", keyString);
+			}
+
+			return success; 
+		}
+
+		public override bool UnRegisterSummonKey (string keyString) {
+			bool success = false;
+
+			if (BoundKeys.ContainsKey (keyString)) {
+				HotKey key = BoundKeys [keyString];
+				//attempt to unregister the key
+				success = UnregisterHotKey (this.hWnd, key.KeyID);
+				//remove this key from the cache
+				BoundKeys.Remove (keyString);
+			} else {
+				Log.Debug ("Key {0} isn't bound... ", keyString);
+			}
+
+			return success;
+		}
+	}
+}
\ No newline at end of file

=== modified file 'Do.Platform/Do.Platform.csproj'
--- Do.Platform/Do.Platform.csproj	2009-06-23 05:41:21 +0000
+++ Do.Platform/Do.Platform.csproj	2009-07-19 02:53:52 +0000
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{6455647D-BA69-4203-962F-D40BF927B87E}</ProjectGuid>
     <OutputType>Library</OutputType>
@@ -49,14 +49,17 @@
     <Compile Include="src\Do.Platform\AbstractApplicationService.cs" />
     <Compile Include="src\Do.Platform\AbstractSystemService.cs" />
     <Compile Include="src\Do.Platform\ActionableNotification.cs" />
+    <Compile Include="src\Do.Platform\Do.Platform.Common\AbstractKeyBindingService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\AbstractLogService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\CommonPathsService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\DictionaryPreferencesService.cs" />
+    <Compile Include="src\Do.Platform\Do.Platform.Common\DoKeyEvents.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\EventsOnlyNotificationsService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\FileLogService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Common\Tests\DictionaryPreferencesServiceTests.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Default\CoreService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Default\DefaultApplicationService.cs" />
+    <Compile Include="src\Do.Platform\Do.Platform.Default\KeyBindingService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Default\DefaultPathsService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Default\DefaultSystemService.cs" />
     <Compile Include="src\Do.Platform\Do.Platform.Default\EnvironmentService.cs" />
@@ -74,6 +77,7 @@
     <Compile Include="src\Do.Platform\Do.Platform.ServiceStack\IService.cs" />
     <Compile Include="src\Do.Platform\ICoreService.cs" />
     <Compile Include="src\Do.Platform\IEnvironmentService.cs" />
+    <Compile Include="src\Do.Platform\IKeyBindingService.cs" />
     <Compile Include="src\Do.Platform\ILogService.cs" />
     <Compile Include="src\Do.Platform\INetworkService.cs" />
     <Compile Include="src\Do.Platform\INotificationsService.cs" />
@@ -82,6 +86,7 @@
     <Compile Include="src\Do.Platform\ISecurePreferencesService.cs" />
     <Compile Include="src\Do.Platform\IUniverseFactoryService.cs" />
     <Compile Include="src\Do.Platform\IWindowingService.cs" />
+    <Compile Include="src\Do.Platform\KeyEvent.cs" />
     <Compile Include="src\Do.Platform\Log.cs" />
     <Compile Include="src\Do.Platform\LogBase.cs" />
     <Compile Include="src\Do.Platform\LogTSender.cs" />
@@ -112,6 +117,8 @@
   </ItemGroup>
   <ItemGroup>
     <Reference Include="gdk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
+    <Reference Include="glade-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
+    <Reference Include="glib-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
     <Reference Include="gtk-sharp, Version=2.12.0.0, Culture=neutral, PublicKeyToken=35e10195dab3c99f" />
     <Reference Include="Mono.Posix, Version=2.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756, processorArchitecture=MSIL" />
     <Reference Include="nunit.framework, Version=2.5.0.9122, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL" />
@@ -119,6 +126,8 @@
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
     <WCFMetadata Include="Service References\" />

=== added file 'Do.Platform/src/Do.Platform/Do.Platform.Common/AbstractKeyBindingService.cs'
--- Do.Platform/src/Do.Platform/Do.Platform.Common/AbstractKeyBindingService.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform/src/Do.Platform/Do.Platform.Common/AbstractKeyBindingService.cs	2009-07-20 05:35:09 +0000
@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Do.Platform.Common;
+
+namespace Do.Platform.Common
+{
+	public abstract class AbstractKeyBindingService : IKeyBindingService
+	{
+
+		public abstract bool RegisterSummonKey (string keyString, EventCallback cb);
+		public abstract bool UnRegisterSummonKey (string keyString);
+
+		IPreferences prefs;
+
+		// Platform.Common.DoKeyEvents -> KeyEvent
+		Dictionary<DoKeyEvents, KeyEvent> KeyEvents;
+
+		#region IInitializedService
+
+		//internal Do keybinding code here...
+		public void Initialize () {
+			KeyEvents = new Dictionary<DoKeyEvents, KeyEvent> ();
+			
+			prefs = Services.Preferences.Get<AbstractKeyBindingService> ();
+		}
+
+		#endregion
+
+		#region IKeyBindingService
+
+		public bool RegisterKeyEvent (KeyEvent evnt) {
+			bool success = true;
+			//first check if this event is already mapped
+			if (GetEvent (evnt.EventName) != null) {
+				Log<AbstractKeyBindingService>.Error ("{0} is already mapped.", evnt.EventName);
+				return false;
+			}
+
+			//try to get the keystring from the prefs.  We default to the doEvent.KeyString, so we can later check
+			//if the prefs value matches that, we're using the default, otherwise we're using a user specified value
+			string prefsKeyString = prefs.Get (evnt.EventName.ToString (), evnt.KeyString);
+			//if these values don't match then the user has specified a new keystring
+			//update the KeyEvent then continue
+			if (prefsKeyString != evnt.KeyString)
+				evnt.ChangeKeyString (prefsKeyString);
+
+			//if we are registering the summon key, do something special
+			if (evnt.EventName == DoKeyEvents.Summon) {
+				//try to register the key from the prefs with the OS
+				success = RegisterSummonKey (evnt.KeyString, evnt.Callback);
+				//if we fail to register the summon key, try again with the default binding
+				if (!success && RegisterSummonKey (evnt.DefaultKeyString, evnt.Callback)) {
+					//if we succeeded now, change the event's keystring
+					evnt.ChangeKeyString (evnt.DefaultKeyString);
+					success = true;
+				}
+			}
+
+			if (success) {
+				//add the event to our mapped events dict
+				KeyEvents.Add (evnt.EventName, evnt);
+				//set the bound keystring in the prefs
+				SetKeyString (evnt.EventName, evnt.KeyString);
+			}
+
+			return success;
+		}
+
+		public KeyEvent GetEvent (DoKeyEvents eventName) {
+			if (KeyEvents.ContainsKey (eventName))
+				return KeyEvents [eventName];
+			return null;
+		}
+
+		public KeyEvent GetEvent (string keyString) {
+			if (KeyEvents.Values.Where (ev => ev.KeyString == keyString).Any ())
+				return KeyEvents.Values.First (ev => ev.KeyString == keyString);
+			return null;
+		}
+
+		public bool SetKeyString (DoKeyEvents eventName, string keyString) {
+			bool success = true;
+			if (GetEvent (eventName) == null) {
+				Log<AbstractKeyBindingService>.Error ("{0} is not mapped.", eventName);
+				return false;
+			}
+
+			//if it's the summon key, reregister it with the OS
+			if (eventName == DoKeyEvents.Summon) {
+				//remove the old keystring from the OS
+				UnRegisterSummonKey (KeyEvents [eventName].KeyString);
+				//register again with the new keystring
+				success = RegisterSummonKey (keyString, KeyEvents [eventName].Callback);
+			}
+
+			if (success) {
+				//change the keystring in the dict of mapped events
+				KeyEvents [eventName].ChangeKeyString (keyString);
+
+				//save the new value in the prefs
+				prefs.Set (KeyEvents [eventName].EventName.ToString (), KeyEvents [eventName].KeyString);
+
+				Log<AbstractKeyBindingService>.Debug ("Event {0} now mapped to: {1}", eventName, keyString);
+			}
+
+			return success;
+		}
+
+		public IEnumerable<KeyEvent> BoundEvents {
+			get {
+				return KeyEvents.Values;
+			}
+		}
+
+		#endregion
+	}
+}
\ No newline at end of file

=== added file 'Do.Platform/src/Do.Platform/Do.Platform.Common/DoKeyEvents.cs'
--- Do.Platform/src/Do.Platform/Do.Platform.Common/DoKeyEvents.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform/src/Do.Platform/Do.Platform.Common/DoKeyEvents.cs	2009-07-19 02:53:52 +0000
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Do.Platform.Common
+{
+	public enum DoKeyEvents
+	{
+		Summon,
+		EnterTextMode,
+		Copy,
+		Paste,
+		AltEscape,
+		AltActivate,
+		AltDelete,
+		NextPane,
+		PreviousPane,
+		Up,
+		Down,
+		First,
+		Last,
+		PageNext,
+		PageLast,
+		Left,
+		Right,
+		MultiSelect,
+	}
+}

=== added file 'Do.Platform/src/Do.Platform/Do.Platform.Default/KeyBindingService.cs'
--- Do.Platform/src/Do.Platform/Do.Platform.Default/KeyBindingService.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform/src/Do.Platform/Do.Platform.Default/KeyBindingService.cs	2009-07-20 05:32:59 +0000
@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Do.Platform.Common;
+
+namespace Do.Platform.Default
+{
+	class KeyBindingService : IKeyBindingService
+	{
+		public bool RegisterKeyEvent (KeyEvent evnt) {
+			Log.Error ("Default keybinding service cannot register key events. {0}", evnt.KeyString);
+			return false;
+		}
+		public KeyEvent GetEvent (DoKeyEvents eventName) {
+			return null;
+		}
+		public KeyEvent GetEvent (string KeyString) {
+			return null;
+		}
+		public bool SetKeyString (DoKeyEvents eventName, string keyString) {
+			return false;
+		}
+		public IEnumerable<KeyEvent> BoundEvents { get { return Enumerable.Empty<KeyEvent> (); } }
+		public void Initialize () {
+		}
+	}
+}

=== added file 'Do.Platform/src/Do.Platform/IKeyBindingService.cs'
--- Do.Platform/src/Do.Platform/IKeyBindingService.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform/src/Do.Platform/IKeyBindingService.cs	2009-07-20 05:32:59 +0000
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+
+using Do.Platform.Common;
+using Do.Platform.ServiceStack;
+
+using Gdk;
+
+namespace Do.Platform
+{
+	public delegate void EventCallback (EventKey evtky);
+
+	public interface IKeyBindingService : IInitializedService
+	{
+		bool RegisterKeyEvent (KeyEvent evnt);
+		KeyEvent GetEvent (DoKeyEvents eventName);
+		KeyEvent GetEvent (string keyString);
+		bool SetKeyString (DoKeyEvents eventName, string keyString);
+		IEnumerable<KeyEvent> BoundEvents { get; }
+	}
+}

=== added file 'Do.Platform/src/Do.Platform/KeyEvent.cs'
--- Do.Platform/src/Do.Platform/KeyEvent.cs	1970-01-01 00:00:00 +0000
+++ Do.Platform/src/Do.Platform/KeyEvent.cs	2009-07-20 05:32:59 +0000
@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Gdk;
+
+namespace Do.Platform
+{
+	public class KeyEvent
+	{
+		//public delegate void EventCallback (EventKey evtky);
+
+		public Common.DoKeyEvents EventName { get; private set; }
+		public string DisplayName { get; private set; }
+		public EventCallback Callback { get; private set; }
+		public string KeyString { get; private set; }
+		public string DefaultKeyString { get; private set; }
+
+		public KeyEvent (Common.DoKeyEvents eventName, string displayName, string keyString, EventCallback eventFunc) {
+			this.EventName = eventName;
+			this.DisplayName = displayName;
+			this.KeyString = keyString;
+			this.DefaultKeyString = keyString;
+			this.Callback = eventFunc;
+		}
+
+		public void ChangeKeyString (string newKeyString) {
+			this.KeyString = newKeyString;
+		}
+	}
+}
\ No newline at end of file

=== modified file 'Do.Platform/src/Do.Platform/Services.cs'
--- Do.Platform/src/Do.Platform/Services.cs	2009-06-21 03:37:34 +0000
+++ Do.Platform/src/Do.Platform/Services.cs	2009-07-18 23:45:47 +0000
@@ -43,7 +43,8 @@
 		static IEnvironmentService environment;
 		static INotificationsService notifications;
 		static IUniverseFactoryService universe_factory;
-		static INetworkService network;
+		static INetworkService network;
+		static IKeyBindingService keybinder;
 
 		/// <summary>
 		/// Initializes the class. Must be called after Mono.Addins is initialized; if this is
@@ -101,7 +102,9 @@
 			if (service is AbstractSystemService)
 				system = null;
 			if (service is INetworkService)
-				network = null;
+				network = null;
+			if (service is IKeyBindingService)
+				keybinder = null;
 		}
 
 		/// <summary>
@@ -185,7 +188,15 @@
 					network = LocateService<INetworkService, Default.NetworkService> ();
 				return network;
 			}
-		}	
+		}
+
+		public static IKeyBindingService Keybinder {
+			get {
+				if (keybinder == null)
+					keybinder = LocateService<IKeyBindingService, Default.KeyBindingService> ();
+				return keybinder;
+			}
+		}
 			
 		public static PreferencesFactory Preferences {
 			get {

=== modified file 'Do/Do.csproj'
--- Do/Do.csproj	2009-07-06 09:22:35 +0000
+++ Do/Do.csproj	2009-07-19 02:56:23 +0000
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.21022</ProductVersion>
+    <ProductVersion>9.0.30729</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{182DAEB4-34D0-43C7-B0A1-034C72BA643C}</ProjectGuid>
     <OutputType>Exe</OutputType>
@@ -72,7 +72,6 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Resources.resx</DependentUpon>
     </Compile>
-    <Compile Include="src\CoreKeybindings.cs" />
     <Compile Include="src\CorePreferences.cs" />
     <Compile Include="src\Do.Core\Controller.cs" />
     <Compile Include="src\Do.Core\Do.Core.Addins\AddinClassifier.cs" />
@@ -132,7 +131,6 @@
     <Compile Include="src\Notifications.cs" />
     <Compile Include="src\PathExtensions.cs" />
     <Compile Include="src\Util.cs" />
-    <Compile Include="src\XKeybinder.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Do.addins">
@@ -190,10 +188,6 @@
       <Project>{7F9464B7-A890-4E54-AE06-F813E8D1E458}</Project>
       <Name>Do.Universe</Name>
     </ProjectReference>
-    <ProjectReference Include="..\ManagedWinapi\ManagedWinapi.csproj">
-      <Project>{FBD3EC1E-47E2-4D2D-81C9-D6506125A09A}</Project>
-      <Name>ManagedWinapi</Name>
-    </ProjectReference>
     <ProjectReference Include="..\Mono.Addins.CecilReflector\Mono.Addins.CecilReflector.csproj">
       <Project>{E7AAA09F-6715-45C5-903B-184452B52EBF}</Project>
       <Name>Mono.Addins.CecilReflector</Name>

=== removed file 'Do/src/CoreKeybindings.cs'
--- Do/src/CoreKeybindings.cs	2009-06-23 05:57:47 +0000
+++ Do/src/CoreKeybindings.cs	1970-01-01 00:00:00 +0000
@@ -1,230 +0,0 @@
-
-/* 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, string> KeycodeMap ; // keybinding -> shortcut name
-		Dictionary<string, Shortcut> ShortcutMap ; // shortcut name -> shortcut
-		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;
-
-			Shortcuts = new ArrayList ();
-			KeycodeMap = new Dictionary<string, string> (); // keybinding -> shortcut name
-			ShortcutMap = new Dictionary<string, Shortcut> (); // shortcut name -> shortcut
-			DefaultShortcutMap = new Dictionary<string, string> (); // default keybinding -> shortcut name
-			PreferencesCbs = new Dictionary<string, List<KeyChangedCb>> ();
-
-			Initialize ();
-		}
-
-		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)
-		{
-			if (Shortcuts.Contains (sc) || ShortcutMap.ContainsKey (sc.ShortcutName)) 
-				return false;
-
-			Shortcuts.Add (sc);
-			ShortcutMap [sc.ShortcutName] = sc;
-			PreferencesCbs [sc.ShortcutName] = new List<KeyChangedCb> ();
-			SaveShortcuts ();
-			return true;
-		}
-
-		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))
-				return false;
-
-			Shortcuts.Remove (sc);
-			ShortcutMap.Remove (sc.ShortcutName);
-			SaveShortcuts ();
-			return true;
-		}
-
-		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 (PreferencesCbs.ContainsKey (e.Key)) {   
-				foreach (KeyChangedCb cb in PreferencesCbs [e.Key]) {
-					cb (this, e);
-				}
-			}
-		}
-
-	}
-
-}

=== modified file 'Do/src/Do.Core/Controller.cs'
--- Do/src/Do.Core/Controller.cs	2009-06-23 05:57:47 +0000
+++ Do/src/Do.Core/Controller.cs	2009-07-19 02:45:35 +0000
@@ -29,7 +29,8 @@
 using Do;
 using Do.UI;
 using Do.Universe;
-using Do.Platform;
+using Do.Platform;
+using Do.Platform.Common;
 using Do.Interface;
 
 namespace Do.Core
@@ -99,105 +100,42 @@
 		{
 			foreach (char c in e.Str)
 				SearchController.AddChar (c);
-		}
-
-		public void Initialize ()
-		{
-			SetTheme (Do.Preferences.Theme);
-			Do.Preferences.ThemeChanged += OnThemeChanged;
-			Screen.Default.CompositedChanged += OnCompositingChanged;
-			
-			// 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 ("Multiple selection"),
-						OnSelectionKeyPressEvent),
-					"comma");
+		}
+
+		public void Initialize () {
+			SetTheme (Do.Preferences.Theme);
+			Do.Preferences.ThemeChanged += OnThemeChanged;
+			Screen.Default.CompositedChanged += OnCompositingChanged;
+
+			// Register Shortcuts
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.EnterTextMode, Catalog.GetString ("Enter Text Mode"),
+				"period", OnTextModePressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Copy, Catalog.GetString ("Copy to Clipboard"),
+				"<Control>c", OnCopyEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Paste, Catalog.GetString ("Paste Current Text"),
+				"<Control>v", OnPasteEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.PreviousPane, Catalog.GetString ("Previous Pane"),
+				"ISO_Left_Tab", OnPreviousPanePressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.NextPane, Catalog.GetString ("Next Pane"),
+				"Tab", OnNextPanePressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Up , Catalog.GetString ("Previous Item"),
+				"Up", OnUpKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Down, Catalog.GetString ("Next Item"),
+				"Down", OnDownKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.First, Catalog.GetString ("First Item"),
+				"Home", OnHomeKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Last, Catalog.GetString ("Last Item"),
+				"End", OnEndKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.PageLast, Catalog.GetString ("Previous 5 Results"),
+				"Page_Up", OnPageUpKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.PageNext, Catalog.GetString ("Next 5 Results"),
+				"Page_Down", OnPageDownKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Left, Catalog.GetString ("Step Out of Item"),
+				"Left", OnLeftKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Right, Catalog.GetString ("Browse Into Item"),
+				"Right", OnRightKeyPressEvent));
+			Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.MultiSelect, Catalog.GetString ("Select Multiple Items"),
+				"comma", OnSelectionKeyPressEvent));
 		}
 
 		void OnSummoned ()
@@ -508,11 +446,11 @@
 				   key == Key.BackSpace) {
 				OnDeleteKeyPressEvent (evnt);
 			} else {
-				// User set keybindings
-				Shortcut sc = Do.Keybindings.GetShortcutByKeycode (KeyEventToString (evnt));
-				if (sc != null) {
-					sc.Callback (evnt);
-					return;
+				// User set keybindings
+				KeyEvent eve = Services.Keybinder.GetEvent (KeyEventToString (evnt));
+				if (eve != null) {
+					eve.Callback (evnt);
+					return;
 				}
 				OnInputKeyPressEvent (evnt);
 			}
@@ -648,7 +586,7 @@
 			if (SearchController.ItemChildSearch ()) GrowResults ();
 		}
 
-		void OnTabKeyPressEvent (EventKey evnt)
+		void OnNextPanePressEvent (EventKey evnt)
 		{
 			im_context.Reset ();
 			ShrinkResults ();
@@ -661,7 +599,7 @@
 			UpdatePane (CurrentPane);
 		}
 
-		void OnShiftTabKeyPressEvent (EventKey evnt)
+		void OnPreviousPanePressEvent (EventKey evnt)
 		{
 			im_context.Reset ();
 			ShrinkResults ();
@@ -759,7 +697,8 @@
 			}
 			if ((evnt.State & ModifierType.Mod1Mask) != 0) {
 				modifier += "<Alt>";
-			}
+			}
+
 			return modifier + evnt.Key.ToString ();
 		}
 #endregion

=== modified file 'Do/src/Do.UI/KeybindingTreeView.cs'
--- Do/src/Do.UI/KeybindingTreeView.cs	2009-06-23 05:57:47 +0000
+++ Do/src/Do.UI/KeybindingTreeView.cs	2009-07-20 05:32:59 +0000
@@ -19,9 +19,14 @@
  */
 
 
-using System;
+using System;
+using System.Linq;
+
 using Gtk;
-using Mono.Unix;
+using Mono.Unix;
+
+using Do.Platform;
+using Do.Platform.Common;
 
 namespace Do.UI
 {
@@ -31,20 +36,20 @@
 			Action = 0,
 			Binding,
 			DefaultKeybinding,
-			ShortcutName, 
+			KeyEvent,
 			NumColumns
 		}
 		
 		public KeybindingTreeView ()
 		{	
-			Model = new ListStore (typeof (string), typeof (string), typeof (string), typeof (string));
+			Model = new ListStore (typeof (string), typeof (string), typeof (string), typeof (DoKeyEvents));
 			
 			CellRendererText actionCell = new CellRendererText ();
 			actionCell.Width = 150;
 			InsertColumn (-1, Catalog.GetString ("Action"), actionCell, "text", (int)Column.Action);
 			
-			CellRendererAccel bindingCell = new CellRendererAccel ();
-			bindingCell.AccelMode = CellRendererAccelMode.Gtk;
+			CellRendererAccel bindingCell = new CellRendererAccel ();
+			bindingCell.AccelMode = CellRendererAccelMode.Other;
 			bindingCell.Editable = true;
 			bindingCell.AccelEdited += new AccelEditedHandler (OnAccelEdited);
 			bindingCell.AccelCleared += new AccelClearedHandler (OnAccelCleared);
@@ -64,11 +69,10 @@
 		private void AddBindings ()
 		{
 			ListStore store = Model as ListStore;
-			store.Clear ();
-
-			foreach (Shortcut sc in Do.Keybindings.Shortcuts) {
-				store.AppendValues (sc.FriendlyName, Do.Keybindings.GetKeybinding (sc), 
-					Do.Keybindings.GetDefaultKeybinding (sc), sc.ShortcutName);
+			store.Clear ();
+
+			foreach (KeyEvent evnt in Services.Keybinder.BoundEvents.OrderBy (k => k.DisplayName)) {
+				store.AppendValues (evnt.DisplayName, evnt.KeyString, evnt.DefaultKeyString, evnt.EventName);
 			}
 		}
 		
@@ -142,15 +146,21 @@
 		
 		private bool SaveBindingsForeachFunc (TreeModel model, TreePath path, TreeIter iter)
 		{
-			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);
+			string newKeyString;
+			newKeyString = model.GetValue (iter, (int) Column.Binding) as string;
+
+			DoKeyEvents keyEvent = (DoKeyEvents) model.GetValue (iter, (int) Column.KeyEvent);
+
+			if (newKeyString != null) {
+				//try to save
+				if (!Services.Keybinder.SetKeyString (keyEvent, newKeyString)) {
+					//if we fail reset to the default value
+					KeyEvent evnt = Services.Keybinder.GetEvent (keyEvent);
+					model.SetValue (iter, (int) Column.Binding, evnt.DefaultKeyString);
+					Services.Keybinder.SetKeyString (keyEvent, evnt.DefaultKeyString);
+				}
+			}
 			return false;
 		}
-		
 	}
-
 }

=== modified file 'Do/src/Do.cs'
--- Do/src/Do.cs	2009-06-23 20:13:50 +0000
+++ Do/src/Do.cs	2009-07-20 05:32:59 +0000
@@ -26,18 +26,17 @@
 
 using Do.UI;
 using Do.Core;
-using Do.Platform;
+using Do.Platform;
+using Do.Platform.Common;
 
 namespace Do {
 
 	static class Do {
 		
-		static XKeybinder keybinder;
 		static Controller controller;
 		static UniverseManager universe_manager;
 
 		public static CorePreferences Preferences { get; private set; } 
-		public static CoreKeybindings Keybindings { get; private set; } 
 
 		internal static void Main (string [] args)
 		{
@@ -55,8 +54,6 @@
 
 			Preferences = new CorePreferences ();
 
-			Keybindings = new CoreKeybindings ();
-
 			// Now we can set the preferred log level.
 			if (Preferences.QuietStart)
 				Log.DisplayLevel = LogLevel.Error;
@@ -75,7 +72,6 @@
 			Controller.Initialize ();
 			UniverseManager.Initialize ();
 			
-			keybinder = new XKeybinder ();
 			SetupKeybindings ();
 
 			if (!Preferences.QuietStart)
@@ -102,37 +98,18 @@
 				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 (Keybindings.GetKeybinding ("SummonKey"), OnActivate);
+			try {
+				if (!Services.Keybinder.RegisterKeyEvent (new KeyEvent (DoKeyEvents.Summon, Catalog.GetString ("Summon Do"),
+					"<Shift>space", delegate { controller.Summon (); })))
+					throw new Exception ("Could not bind summon key from preferences value or default.");
 			} catch (Exception e) {
 				Log.Error ("Could not bind summon key: {0}", e.Message);
-				Log.Debug (e.StackTrace);
+				Log.Debug (e.StackTrace);
+				Gtk.Application.Quit ();
 			}
-
-			// Watch preferences for changes to the keybinding so we
-			// can change the binding when the user reassigns it.
-			Keybindings.RegisterNotification ("SummonKey", SummonKeyCb);
-		}
-		
-		static void OnActivate (object sender, EventArgs e)
-		{
-			controller.Summon ();
 		}
 	}
-}
+}
\ No newline at end of file

=== removed file 'Do/src/XKeybinder.cs'
--- Do/src/XKeybinder.cs	2009-06-24 06:06:11 +0000
+++ Do/src/XKeybinder.cs	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-/*****************************************************************************/
-/* XKeybinder.cs - Keybinding code taken from Tomboy			     */
-/* Copyright (C) 2004-2007 Alex Graveley <[e-mail]>	     */
-/* 									     */
-/* This library is free software; you can redistribute it and/or	     */
-/* modify it under the terms of the GNU Lesser General Public		     */
-/* License as published by the Free Software Foundation; either		     */
-/* version 2.1 of the License, or (at your option) any later version.	     */
-/* 									     */
-/* This library 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	     */
-/* Lesser General Public License for more details.			     */
-/* 									     */
-/* You should have received a copy of the GNU Lesser General Public	     */
-/* License along with this library; if not, write to the Free Software	     */
-/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-/*****************************************************************************/
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using System.Windows.Forms;
-
-using Do.Platform;
-using ManagedWinapi;
-using System.Text.RegularExpressions;
-using System.Globalization;
-
-namespace Do
-{
-	public class XKeybinder 
-	{
-		public delegate void BindkeyHandler (string key, IntPtr user_data);
-
-		/// <summary>
-		/// Key bindings, key string -> Binding
-		/// </summary>
-		private Dictionary<string, Binding> bindings;
-		BindkeyHandler key_handler;
-
-		private Regex rexp = new Regex ("<.*>", RegexOptions.Compiled | RegexOptions.IgnoreCase);
-
-		struct Binding {
-			internal string       keystring;
-			internal EventHandler handler;
-			internal Hotkey	hkey;
-		}
-
-		public XKeybinder ()
-			: base ()
-		{
-			bindings = new Dictionary<string, Binding> ();
-			key_handler = new BindkeyHandler (KeybindingPressed);
-		}
-
-		void KeybindingPressed (string keystring, IntPtr user_data)
-		{
-			if (bindings.ContainsKey (keystring)) {
-				bindings [keystring].handler (this, new EventArgs ());
-			}
-		}
-
-		public void Bind (string keystring, EventHandler handler)
-		{
-			Hotkey new_key = new Hotkey ();
-			new_key.HotkeyPressed += handler;
-
-			// determine modifiers to use
-			if (keystring.ToLower ().Contains ("super"))
-				new_key.WindowsKey = true;
-
-			if (keystring.ToLower ().Contains ("shift"))
-				new_key.Shift = true;
-
-			if (keystring.ToLower ().Contains ("alt"))
-				new_key.Alt = true;
-
-			if (keystring.ToLower ().Contains ("ctrl"))
-				new_key.Ctrl = true;
-
-			// figure out what the key is...this is so incredibly hacky but it should work for most cases
-			// -- ootz0rz
-			string thekey = rexp.Replace (keystring, "");
-			thekey = CultureInfo.CurrentCulture.TextInfo.ToTitleCase (thekey);
-			new_key.KeyCode = (Keys) Enum.Parse (typeof (Keys), thekey);
-
-			// enable the bind
-			new_key.Enabled = true;
-
-			Binding bind = new Binding ();
-			bind.keystring = keystring;
-			bind.handler = handler;
-			bind.hkey = new_key;
-			bindings.Add (keystring, bind);
-		}
-
-		public void Unbind (string keystring)
-		{
-			if (bindings.ContainsKey (keystring)) {
-				bindings [keystring].hkey.Enabled = false;
-				bindings [keystring].hkey.HotkeyPressed -= bindings [keystring].handler;
-				bindings [keystring].hkey.Dispose ();
-				bindings.Remove (keystring);
-			}
-		}
-
-		public virtual void UnbindAll ()
-		{
-			foreach (string key in bindings.Keys) {
-				Unbind (key);
-			}
-		}
-	}
-}

=== removed directory 'ManagedWinapi'
=== removed file 'ManagedWinapi/AccessibleObjectListener.cs'
--- ManagedWinapi/AccessibleObjectListener.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/AccessibleObjectListener.cs	1970-01-01 00:00:00 +0000
@@ -1,522 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006, 2007 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-using Accessibility;
-
-namespace ManagedWinapi.Accessibility
-{
-    /// <summary>
-    /// Listens to events from the Windows accessibility system. These events are useful
-    /// if you want to write a screenreader or similar program.
-    /// </summary>
-    public class AccessibleEventListener : Component
-    {
-        /// <summary>
-        /// Occurs when an accessible event is received.
-        /// </summary>
-        public event AccessibleEventHandler EventOccurred;
-
-        private bool enabled;
-        private IntPtr handle = IntPtr.Zero;
-        private AccessibleEventType min = AccessibleEventType.EVENT_MIN;
-        private AccessibleEventType max = AccessibleEventType.EVENT_MAX;
-        private WinEventDelegate internalDelegate;
-        private GCHandle gch;
-        private UInt32 processId = 0;
-        private UInt32 threadId = 0;
-
-        /// <summary>
-        /// Initializes a new instance of this class with the specified container.
-        /// </summary>
-        /// <param name="container">The container to add it to.</param>
-        public AccessibleEventListener(IContainer container)
-            : this()
-        {
-            container.Add(this);
-        }
-
-        /// <summary>
-        /// Initializes a new instance of this class.
-        /// </summary>
-        public AccessibleEventListener()
-        {
-            internalDelegate = new WinEventDelegate(InternalCallback);
-            gch = GCHandle.Alloc(internalDelegate);
-        }
-
-        /// <summary>
-        /// Enables this listener so that it reports accessible events.
-        /// </summary>
-        public bool Enabled
-        {
-            get
-            {
-                return enabled;
-            }
-            set
-            {
-                enabled = value;
-                updateListener();
-            }
-        }
-
-        /// <summary>
-        /// The minimal event type to listen to.
-        /// </summary>
-        public AccessibleEventType MinimalEventType
-        {
-            get { return min; }
-            set { min = value; updateListener(); }
-        }
-
-        /// <summary>
-        /// The maximal event type to listen to.
-        /// </summary>
-        public AccessibleEventType MaximalEventType
-        {
-            get { return max; }
-            set { max = value; updateListener(); }
-        }
-
-        /// <summary>
-        /// The Process ID to listen to.
-        /// Default 0 listens to all processes.
-        /// </summary>
-        public UInt32 ProcessId
-        {
-            get { return processId; }
-            set { processId = value; updateListener(); }
-        }
-
-        /// <summary>
-        /// The Thread ID to listen to.
-        /// Default 0 listens to all threads.
-        /// </summary> 
-        public UInt32 ThreadId
-        {
-            get { return threadId; }
-            set { threadId = value; updateListener(); }
-        }
-
-        private void updateListener()
-        {
-            if (handle != IntPtr.Zero)
-            {
-                UnhookWinEvent(handle);
-                handle = IntPtr.Zero;
-            }
-            if (enabled)
-            {
-                handle = SetWinEventHook(min, max, IntPtr.Zero, internalDelegate, processId, threadId, 0);
-            }
-        }
-
-        /// <summary>
-        /// Releases all resources used by the System.ComponentModel.Component.
-        /// </summary>
-        /// <param name="disposing">Whether to dispose managed resources.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (enabled)
-            {
-                enabled = false;
-                updateListener();
-            }
-            gch.Free();
-            base.Dispose(disposing);
-        }
-
-        private void InternalCallback(IntPtr hWinEventHook, AccessibleEventType eventType,
-            IntPtr hwnd, uint idObject, uint idChild, uint dwEventThread, uint dwmsEventTime)
-        {
-            if (hWinEventHook != handle) return;
-            AccessibleEventArgs aea = new AccessibleEventArgs(eventType, hwnd, idObject, idChild, dwEventThread, dwmsEventTime);
-            if (EventOccurred != null)
-                EventOccurred(this, aea);
-        }
-
-        internal static SystemAccessibleObject GetAccessibleObject(AccessibleEventArgs e)
-        {
-            IAccessible iacc;
-            object child;
-            uint result = AccessibleObjectFromEvent(e.HWnd, e.ObjectID, e.ChildID, out iacc, out child);
-            if (result != 0) throw new Exception("AccessibleObjectFromPoint returned " + result);
-            return new SystemAccessibleObject(iacc, (int)child);
-        }
-
-        #region PInvoke Declarations
-
-        [DllImport("user32.dll")]
-        private static extern IntPtr SetWinEventHook(AccessibleEventType eventMin, AccessibleEventType eventMax, IntPtr
-           hmodWinEventProc, WinEventDelegate lpfnWinEventProc, uint idProcess,
-           uint idThread, uint dwFlags);
-
-        [DllImport("user32.dll")]
-        static extern bool UnhookWinEvent(IntPtr hWinEventHook);
-
-        private delegate void WinEventDelegate(IntPtr hWinEventHook, AccessibleEventType eventType,
-            IntPtr hwnd, uint idObject, uint idChild, uint dwEventThread, uint dwmsEventTime);
-
-        [DllImport("oleacc.dll")]
-        private static extern uint AccessibleObjectFromEvent(IntPtr hwnd, uint dwObjectID, uint dwChildID, out IAccessible ppacc, [MarshalAs(UnmanagedType.Struct)] out object pvarChild);
-
-        #endregion
-    }
-
-    /// <summary>
-    /// Represents the method that will handle accessibility events.
-    /// </summary>
-    public delegate void AccessibleEventHandler(object sender, AccessibleEventArgs e);
-
-    /// <summary>
-    /// Provides data for accessible events.
-    /// </summary>
-    public class AccessibleEventArgs : EventArgs
-    {
-        private AccessibleEventType eventType;
-        private IntPtr hWnd;
-        private uint idObject;
-        private uint idChild;
-        private uint dwEventThread;
-        private uint dwmsEventTime;
-
-        /// <summary>
-        /// Initializes a new instance of the AccessibleEventArgs class.
-        /// </summary>
-        public AccessibleEventArgs(AccessibleEventType eventType,
-            IntPtr hwnd, uint idObject, uint idChild, uint dwEventThread, uint dwmsEventTime)
-        {
-            this.eventType = eventType;
-            this.hWnd = hwnd;
-            this.idObject = idObject;
-            this.idChild = idChild;
-            this.dwEventThread = dwEventThread;
-            this.dwmsEventTime = dwmsEventTime;
-        }
-
-        /// <summary>
-        /// Type of this accessible event
-        /// </summary>
-        public AccessibleEventType EventType
-        {
-            get { return eventType; }
-        }
-
-        /// <summary>
-        /// Handle of the affected window, if any.
-        /// </summary>
-        public IntPtr HWnd
-        {
-            get { return hWnd; }
-        }
-
-        /// <summary>
-        /// Object ID.
-        /// </summary>
-        public uint ObjectID
-        {
-            get { return idObject; }
-        }
-
-        /// <summary>
-        /// Child ID.
-        /// </summary>
-        public uint ChildID
-        {
-            get { return idChild; }
-        }
-
-        /// <summary>
-        /// The thread that generated this event.
-        /// </summary>
-        public uint Thread
-        {
-            get { return dwEventThread; }
-        }
-
-        /// <summary>
-        /// Time in milliseconds when the event was generated.
-        /// </summary>
-        public uint Time
-        {
-            get { return dwmsEventTime; }
-        }
-
-        /// <summary>
-        /// The accessible object related to this event.
-        /// </summary>
-        public SystemAccessibleObject AccessibleObject
-        {
-            get
-            {
-                return AccessibleEventListener.GetAccessibleObject(this);
-            }
-        }
-    }
-
-    /// <summary>
-    /// This enumeration lists known accessible event types.
-    /// </summary>
-    public enum AccessibleEventType
-    {
-        /// <summary>
-        ///  Sent when a sound is played.  Currently nothing is generating this, we
-        ///  are going to be cleaning up the SOUNDSENTRY feature in the control panel
-        ///  and will use this at that time.  Applications implementing WinEvents
-        ///  are perfectly welcome to use it.  Clients of IAccessible* will simply
-        ///  turn around and get back a non-visual object that describes the sound.
-        /// </summary>
-        EVENT_SYSTEM_SOUND = 0x0001,
-
-        /// <summary>
-        /// Sent when an alert needs to be given to the user.  MessageBoxes generate
-        /// alerts for example.
-        /// </summary>
-        EVENT_SYSTEM_ALERT = 0x0002,
-
-        /// <summary>
-        /// Sent when the foreground (active) window changes, even if it is changing
-        /// to another window in the same thread as the previous one.
-        /// </summary>
-        EVENT_SYSTEM_FOREGROUND = 0x0003,
-
-        /// <summary>
-        /// Sent when entering into and leaving from menu mode (system, app bar, and
-        /// track popups).
-        /// </summary>
-        EVENT_SYSTEM_MENUSTART = 0x0004,
-
-        /// <summary>
-        /// Sent when entering into and leaving from menu mode (system, app bar, and
-        /// track popups).
-        /// </summary>
-        EVENT_SYSTEM_MENUEND = 0x0005,
-
-        /// <summary>
-        /// Sent when a menu popup comes up and just before it is taken down.  Note
-        /// that for a call to TrackPopupMenu(), a client will see EVENT_SYSTEM_MENUSTART
-        /// followed almost immediately by EVENT_SYSTEM_MENUPOPUPSTART for the popup
-        /// being shown.
-        /// </summary>
-        EVENT_SYSTEM_MENUPOPUPSTART = 0x0006,
-
-        /// <summary>
-        /// Sent when a menu popup comes up and just before it is taken down.  Note
-        /// that for a call to TrackPopupMenu(), a client will see EVENT_SYSTEM_MENUSTART
-        /// followed almost immediately by EVENT_SYSTEM_MENUPOPUPSTART for the popup
-        /// being shown.
-        /// </summary>
-        EVENT_SYSTEM_MENUPOPUPEND = 0x0007,
-
-
-        /// <summary>
-        /// Sent when a window takes the capture and releases the capture.
-        /// </summary>
-        EVENT_SYSTEM_CAPTURESTART = 0x0008,
-
-        /// <summary>
-        /// Sent when a window takes the capture and releases the capture.
-        /// </summary>
-        EVENT_SYSTEM_CAPTUREEND = 0x0009,
-
-        /// <summary>
-        /// Sent when a window enters and leaves move-size dragging mode.
-        /// </summary>
-        EVENT_SYSTEM_MOVESIZESTART = 0x000A,
-
-        /// <summary>
-        /// Sent when a window enters and leaves move-size dragging mode.
-        /// </summary>
-        EVENT_SYSTEM_MOVESIZEEND = 0x000B,
-
-        /// <summary>
-        /// Sent when a window enters and leaves context sensitive help mode.
-        /// </summary>
-        EVENT_SYSTEM_CONTEXTHELPSTART = 0x000C,
-
-        /// <summary>
-        /// Sent when a window enters and leaves context sensitive help mode.
-        /// </summary>
-        EVENT_SYSTEM_CONTEXTHELPEND = 0x000D,
-
-        /// <summary>
-        /// Sent when a window enters and leaves drag drop mode.  Note that it is up
-        /// to apps and OLE to generate this, since the system doesn't know.  Like
-        /// EVENT_SYSTEM_SOUND, it will be a while before this is prevalent.
-        /// </summary>
-        EVENT_SYSTEM_DRAGDROPSTART = 0x000E,
-
-        /// <summary>
-        /// Sent when a window enters and leaves drag drop mode.  Note that it is up
-        /// to apps and OLE to generate this, since the system doesn't know.  Like
-        /// EVENT_SYSTEM_SOUND, it will be a while before this is prevalent.
-        /// </summary>
-        EVENT_SYSTEM_DRAGDROPEND = 0x000F,
-
-        /// <summary>
-        /// Sent when a dialog comes up and just before it goes away.
-        /// </summary>
-        EVENT_SYSTEM_DIALOGSTART = 0x0010,
-
-        /// <summary>
-        /// Sent when a dialog comes up and just before it goes away.
-        /// </summary>
-        EVENT_SYSTEM_DIALOGEND = 0x0011,
-
-        /// <summary>
-        /// Sent when beginning and ending the tracking of a scrollbar in a window,
-        /// and also for scrollbar controls.
-        /// </summary>
-        EVENT_SYSTEM_SCROLLINGSTART = 0x0012,
-
-        /// <summary>
-        /// Sent when beginning and ending the tracking of a scrollbar in a window,
-        /// and also for scrollbar controls.
-        /// </summary>
-        EVENT_SYSTEM_SCROLLINGEND = 0x0013,
-
-        /// <summary>
-        /// Sent when beginning and ending alt-tab mode with the switch window.
-        /// </summary>
-        EVENT_SYSTEM_SWITCHSTART = 0x0014,
-
-        /// <summary>
-        /// Sent when beginning and ending alt-tab mode with the switch window.
-        /// </summary>
-        EVENT_SYSTEM_SWITCHEND = 0x0015,
-
-        /// <summary>
-        /// Sent when a window minimizes.
-        /// </summary>
-        EVENT_SYSTEM_MINIMIZESTART = 0x0016,
-
-        /// <summary>
-        /// Sent just before a window restores.
-        /// </summary>
-        EVENT_SYSTEM_MINIMIZEEND = 0x0017,
-
-        /// <summary>
-        /// hwnd + ID + idChild is created item
-        /// </summary>
-        EVENT_OBJECT_CREATE = 0x8000,
-
-        /// <summary>
-        /// hwnd + ID + idChild is destroyed item
-        /// </summary>
-        EVENT_OBJECT_DESTROY = 0x8001,
-
-        /// <summary>
-        /// hwnd + ID + idChild is shown item
-        /// </summary>
-        EVENT_OBJECT_SHOW = 0x8002,
-
-        /// <summary>
-        /// hwnd + ID + idChild is hidden item
-        /// </summary>
-        EVENT_OBJECT_HIDE = 0x8003,
-
-        /// <summary>
-        /// hwnd + ID + idChild is parent of zordering children
-        /// </summary>
-        EVENT_OBJECT_REORDER = 0x8004,
-
-        /// <summary>
-        /// hwnd + ID + idChild is focused item
-        /// </summary>
-        EVENT_OBJECT_FOCUS = 0x8005,
-
-        /// <summary>
-        /// hwnd + ID + idChild is selected item (if only one), or idChild is OBJID_WINDOW if complex
-        /// </summary>
-        EVENT_OBJECT_SELECTION = 0x8006,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item added
-        /// </summary>
-        EVENT_OBJECT_SELECTIONADD = 0x8007,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item removed
-        /// </summary>
-        EVENT_OBJECT_SELECTIONREMOVE = 0x8008,
-
-        /// <summary>
-        /// hwnd + ID + idChild is parent of changed selected items
-        /// </summary>
-        EVENT_OBJECT_SELECTIONWITHIN = 0x8009,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ state change
-        /// </summary>
-        EVENT_OBJECT_STATECHANGE = 0x800A,
-
-        /// <summary>
-        /// hwnd + ID + idChild is moved/sized item
-        /// </summary>
-        EVENT_OBJECT_LOCATIONCHANGE = 0x800B,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ name change
-        /// </summary>
-        EVENT_OBJECT_NAMECHANGE = 0x800C,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ desc change
-        /// </summary>
-        EVENT_OBJECT_DESCRIPTIONCHANGE = 0x800D,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ value change
-        /// </summary>
-        EVENT_OBJECT_VALUECHANGE = 0x800E,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ new parent
-        /// </summary>
-        EVENT_OBJECT_PARENTCHANGE = 0x800F,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ help change
-        /// </summary>
-        EVENT_OBJECT_HELPCHANGE = 0x8010,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ def action change
-        /// </summary>
-        EVENT_OBJECT_DEFACTIONCHANGE = 0x8011,
-
-        /// <summary>
-        /// hwnd + ID + idChild is item w/ keybd accel change
-        /// </summary>
-        EVENT_OBJECT_ACCELERATORCHANGE = 0x8012,
-
-        /// <summary>
-        /// The lowest possible event value
-        /// </summary>
-        EVENT_MIN = 0x00000001,
-
-        /// <summary>
-        /// The highest possible event value
-        /// </summary>
-        EVENT_MAX = 0x7FFFFFFF,
-    }
-}

=== removed file 'ManagedWinapi/ApiHelper.cs'
--- ManagedWinapi/ApiHelper.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/ApiHelper.cs	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// Helper class that contains static methods useful for API programming. This
-    /// class is not exposed to the user.
-    /// </summary>
-    internal class ApiHelper
-    {
-        /// <summary>
-        /// Throw a <see cref="Win32Exception"/> if the supplied (return) value is zero.
-        /// This exception uses the last Win32 error code as error message.
-        /// </summary>
-        /// <param name="returnValue">The return value to test.</param>
-        internal static int FailIfZero(int returnValue)
-        {
-            if (returnValue == 0)
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-            return returnValue;
-        }
-
-        /// <summary>
-        /// Throw a <see cref="Win32Exception"/> if the supplied (return) value is zero.
-        /// This exception uses the last Win32 error code as error message.
-        /// </summary>
-        /// <param name="returnValue">The return value to test.</param>
-        internal static IntPtr FailIfZero(IntPtr returnValue)
-        {
-            if (returnValue == IntPtr.Zero)
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-            return returnValue;
-        }
-    }
-}

=== removed file 'ManagedWinapi/COPYING'
--- ManagedWinapi/COPYING	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/COPYING	1970-01-01 00:00:00 +0000
@@ -1,456 +0,0 @@
-  GNU LESSER GENERAL PUBLIC LICENSE
-		       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-

-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-

-		  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-

-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-

-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-

-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-

-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-

-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-

-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.

=== removed file 'ManagedWinapi/ClipboardNotifier.cs'
--- ManagedWinapi/ClipboardNotifier.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/ClipboardNotifier.cs	1970-01-01 00:00:00 +0000
@@ -1,132 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.ComponentModel;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
-using ManagedWinapi.Windows;
-using System.Runtime.InteropServices;
-using Microsoft.Win32;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// Specifies a component that monitors the system clipboard for changes.
-    /// </summary>
-    [DefaultEvent("ClipboardChanged")]
-    public class ClipboardNotifier : Component
-    {
-
-        /// <summary>
-        /// Occurs when the clipboard contents have changed.
-        /// </summary>
-        public event EventHandler ClipboardChanged;
-
-        private readonly IntPtr hWnd;
-        private IntPtr nextHWnd;
-        private readonly EventDispatchingNativeWindow ednw;
-
-        private static Boolean instantiated = false;
-
-        /// <summary>
-        /// Creates a new clipboard notifier.
-        /// </summary>
-        /// <param name="container">The container.</param>
-        public ClipboardNotifier(IContainer container)
-            : this()
-        {
-            container.Add(this);
-        }
-
-        /// <summary>
-        /// Creates a new clipboard notifier.
-        /// </summary>
-        public ClipboardNotifier()
-        {
-            if (instantiated)
-            {
-                // use new windows if more than one instance is used.
-                System.Diagnostics.Debug.WriteLine("WARNING: More than one ClipboardNotifier used!");
-                ednw = new EventDispatchingNativeWindow();
-            }
-            else
-            {
-                ednw = EventDispatchingNativeWindow.Instance;
-                instantiated = true;
-            }
-            ednw.EventHandler += clipboardEventHandler;
-            hWnd = ednw.Handle;
-            nextHWnd = SetClipboardViewer(hWnd);
-        }
-
-        /// <summary>
-        /// Frees resources.
-        /// </summary>
-        protected override void Dispose(bool disposing)
-        {
-            ChangeClipboardChain(hWnd, nextHWnd);
-            ednw.EventHandler -= clipboardEventHandler;
-            base.Dispose(disposing);
-        }
-
-        void clipboardEventHandler(ref System.Windows.Forms.Message m, ref bool handled)
-        {
-            if (handled) return;
-            if (m.Msg == WM_DRAWCLIPBOARD)
-            {
-                // notify me
-                if (ClipboardChanged != null)
-                    ClipboardChanged(this, EventArgs.Empty);
-                // pass on message
-                SendMessage(nextHWnd, m.Msg, m.WParam, m.LParam);
-                handled = true;
-            }
-            else if (m.Msg == WM_CHANGECBCHAIN)
-            {
-                if (m.WParam == nextHWnd)
-                {
-                    nextHWnd = m.LParam;
-                }
-                else
-                {
-                    SendMessage(nextHWnd, m.Msg, m.WParam, m.LParam);
-                }
-            }
-        }
-
-        #region PInvoke Declarations
-
-        [DllImport("User32.dll", CharSet = CharSet.Auto)]
-        private static extern IntPtr SetClipboardViewer(IntPtr hWndNewViewer);
-
-        [DllImport("user32.dll")]
-        private static extern bool ChangeClipboardChain(IntPtr hWndRemove, IntPtr hWndNewNext);
-
-        [DllImport("user32.dll", CharSet = CharSet.Auto)]
-        private static extern int SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);
-
-        private static readonly int 
-            WM_DRAWCLIPBOARD = 0x0308, 
-            WM_CHANGECBCHAIN = 0x030D;
-
-        #endregion
-    }
-}

=== removed file 'ManagedWinapi/CodepointRange.cs'
--- ManagedWinapi/CodepointRange.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/CodepointRange.cs	1970-01-01 00:00:00 +0000
@@ -1,204 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Drawing;
-using System.Runtime.InteropServices;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// The unicode range of codepoints supported by a font.
-    /// </summary>
-    public class CodepointRange
-    {
-        char[] ranges;
-        readonly int codepointCount;
-
-        /// <summary>
-        /// Creates a new CodepointRange object for a font.
-        /// </summary>
-        public CodepointRange(Font font)
-        {
-            List<char> rangeList = new List<char>();
-            Graphics g = Graphics.FromImage(new Bitmap(1, 1));
-            IntPtr hdc = g.GetHdc();
-            IntPtr hFont = font.ToHfont();
-            IntPtr oldFont = SelectObject(hdc, hFont);
-            uint size = GetFontUnicodeRanges(hdc, IntPtr.Zero);
-            IntPtr glyphSet = Marshal.AllocHGlobal((int)size);
-            GetFontUnicodeRanges(hdc, glyphSet);
-            codepointCount = Marshal.ReadInt32(glyphSet, 8);
-            int tmp = 0;
-            int count = Marshal.ReadInt32(glyphSet, 12);
-            for (int i = 0; i < count; i++)
-            {
-                char firstIncluded = (char)Marshal.ReadInt16(glyphSet, 16 + i * 4);
-                char firstExcluded = (char)(firstIncluded + Marshal.ReadInt16(glyphSet, 18 + i * 4));
-                tmp += firstExcluded - firstIncluded;
-                rangeList.Add(firstIncluded);
-                rangeList.Add(firstExcluded);
-            }
-            SelectObject(hdc, oldFont);
-            DeleteObject(hFont);
-            Marshal.FreeHGlobal(glyphSet);
-            g.ReleaseHdc(hdc);
-            g.Dispose();
-            if (tmp != codepointCount) throw new Exception(font.FontFamily.Name);
-            ranges = rangeList.ToArray();
-            if (ranges.Length < 2) throw new Exception();
-        }
-
-        /// <summary>
-        /// Returns a dictionary containing codepoint ranges of all fonts.
-        /// If multiple fonts of one family (bold, italic, etc.) share their
-        /// codepoint range, only their base font is included in this list,
-        /// otherwise all different variants are included.
-        /// </summary>
-        public static Dictionary<Font, CodepointRange> GetRangesForAllFonts()
-        {
-            Dictionary<Font, CodepointRange> result = new Dictionary<Font, CodepointRange>();
-            foreach (FontFamily ff in FontFamily.Families)
-            {
-                Font[] fonts = new Font[16];
-                CodepointRange[] range = new CodepointRange[fonts.Length];
-                for (int i = 0; i < fonts.Length; i++)
-                {
-                    if (ff.IsStyleAvailable((FontStyle)i))
-                    {
-                        fonts[i] = new Font(ff, 10, (FontStyle)i);
-                        range[i] = new CodepointRange(fonts[i]);
-                    }
-                }
-                int importantBits = 0;
-                for (int bit = 1; bit < fonts.Length; bit <<= 1)
-                {
-                    for (int i = 0; i < fonts.Length; i++)
-                    {
-                        if ((i & bit) != 0) continue;
-                        if (range[i] != null && range[i | bit] != null)
-                        {
-                            if (!range[i].Equals(range[i | bit]))
-                            {
-                                importantBits |= bit;
-                                break;
-                            }
-                        }
-                        else if (range[i] != null || range[i | bit] != null)
-                        {
-                            importantBits |= bit;
-                            break;
-                        }
-                    }
-                }
-                for (int i = 0; i < fonts.Length; i++)
-                {
-                    if ((i & importantBits) != i || fonts[i] == null) continue;
-                    result.Add(fonts[i], range[i]);
-                }
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// The number of codepoints supported by this font.
-        /// </summary>
-        public int SupportedCodepointCount { get { return codepointCount; } }
-
-        /// <summary>
-        /// The first (lowest) supported codepoint.
-        /// </summary>
-        public char FirstCodepoint { get { return ranges[0]; } }
-
-        /// <summary>
-        /// The last (highest) supported codepoint.
-        /// </summary>
-        public char LastCodepoint { get { return (char)(ranges[ranges.Length - 1] - 1); } }
-
-        /// <summary>
-        /// Tests whether a specific codepoint is supported by this font.
-        /// </summary>
-        public bool IsSupported(char codepoint)
-        {
-            bool result = false;
-            foreach (char c in ranges)
-            {
-                if (c > codepoint) break;
-                result = !result;
-            }
-            return result;
-        }
-
-        /// <summary>
-        /// Finds the next codepoint that is either supported or not.
-        /// </summary>
-        public char FindNext(char from, bool supported)
-        {
-            if (IsSupported(from) == supported) return from;
-            foreach (char c in ranges)
-            {
-                if (c > from) return c;
-            }
-            return (char)0xFFFF;
-        }
-
-        /// <summary>
-        /// Returns a <see cref="String"/> representation of this codepoint range.
-        /// </summary>
-        public override string ToString()
-        {
-            StringBuilder sb = new StringBuilder("[");
-            for (int i = 0; i < ranges.Length; i++)
-            {
-                if (i % 2 == 1)
-                {
-                    if (ranges[i] == ranges[i - 1] + 1) continue;
-                    sb.Append("-");
-                }
-                else if (i != 0)
-                {
-                    sb.Append(", ");
-                }
-                sb.Append(((int)ranges[i] - i % 2).ToString("X4"));
-            }
-            return sb.Append("]").ToString();
-        }
-
-        #region Equals and HashCode
-
-        ///
-        public override bool Equals(object obj)
-        {
-            CodepointRange cr = obj as CodepointRange;
-            if (cr == null)
-                return false;
-            if (codepointCount != cr.codepointCount || ranges.Length != cr.ranges.Length)
-                return false;
-            for (int i = 0; i < ranges.Length; i++)
-            {
-                if (ranges[i] != cr.ranges[i])
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
-        ///
-        public override int GetHashCode()
-        {
-            return 3 * codepointCount + 7 * ranges.Length + 9 * FirstCodepoint + 11 * LastCodepoint;
-        }
-        #endregion
-
-        #region PInvoke Declarations
-        [DllImport("gdi32.dll")]
-        private static extern uint GetFontUnicodeRanges(IntPtr hdc, IntPtr lpgs);
-
-        [DllImport("gdi32.dll")]
-        private static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
-
-        [DllImport("gdi32.dll")]
-        private static extern bool DeleteObject(IntPtr hObject);
-        #endregion
-    }
-}

=== removed directory 'ManagedWinapi/Contents'
=== removed file 'ManagedWinapi/Contents/AccessibleWindowParser.cs'
--- ManagedWinapi/Contents/AccessibleWindowParser.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/AccessibleWindowParser.cs	1970-01-01 00:00:00 +0000
@@ -1,193 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.InteropServices;
-using ManagedWinapi.Accessibility;
-
-namespace ManagedWinapi.Windows.Contents
-{
-    /// <summary>
-    /// The content of an object that supports the Accessibility API 
-    /// (used by screen readers and similar programs).
-    /// </summary>
-    public class AccessibleWindowContent : WindowContent
-    {
-
-        bool parsed = false;
-        readonly string name;
-        string menu, sysmenu, clientarea;
-        readonly bool hasMenu, hasSysMenu, hasClientArea;
-        SystemWindow sw;
-
-        internal AccessibleWindowContent(string name, bool hasMenu, bool hasSysMenu, bool hasClientArea, SystemWindow sw)
-        {
-            this.name = name;
-            this.hasMenu = hasMenu;
-            this.hasSysMenu = hasSysMenu;
-            this.hasClientArea = hasClientArea;
-            this.sw = sw;
-        }
-
-        ///
-        public string ComponentType
-        {
-            get { return "AccessibleWindow"; }
-        }
-
-        ///
-        public string ShortDescription
-        {
-            get
-            {
-                return name + " <AccessibleWindow:" +
-                    (hasSysMenu ? " SystemMenu" : "") +
-                    (hasMenu ? " Menu" : "") +
-                    (hasClientArea ? " ClientArea" : "") + ">";
-            }
-        }
-
-        ///
-        public string LongDescription
-        {
-            get
-            {
-                ParseIfNeeded();
-                string result = ShortDescription + "\n";
-                if (sysmenu != null)
-                    result += "System menu:\n" + sysmenu + "\n";
-                if (menu != null)
-                    result += "Menu:\n" + menu + "\n";
-                if (clientarea != null)
-                    result += "Client area:\n" + clientarea + "\n";
-                return result;
-            }
-        }
-
-        private void ParseIfNeeded()
-        {
-            if (parsed) return;
-            if (hasSysMenu) sysmenu = ParseMenu(sw, AccessibleObjectID.OBJID_SYSMENU);
-            if (hasMenu) menu = ParseMenu(sw, AccessibleObjectID.OBJID_MENU);
-            if (hasClientArea) clientarea = ParseClientArea(sw);
-            parsed = true;
-        }
-
-        private string ParseMenu(SystemWindow sw, AccessibleObjectID accessibleObjectID)
-        {
-            SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, accessibleObjectID);
-            StringBuilder menuitems = new StringBuilder();
-            ParseSubMenu(menuitems, sao, 1);
-            return menuitems.ToString();
-        }
-
-        private void ParseSubMenu(StringBuilder menuitems, SystemAccessibleObject sao, int depth)
-        {
-            foreach (SystemAccessibleObject c in sao.Children)
-            {
-                if (c.RoleIndex == 11 || c.RoleIndex == 12)
-                {
-                    menuitems.Append(ListContent.Repeat('\t', depth) + c.Name + "\n");
-                    ParseSubMenu(menuitems, c, depth + 1);
-                }
-            }
-        }
-
-        private string ParseClientArea(SystemWindow sw)
-        {
-            SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, AccessibleObjectID.OBJID_CLIENT);
-            StringBuilder sb = new StringBuilder();
-            ParseClientAreaElement(sb, sao, 1);
-            return sb.ToString();
-        }
-
-        private void ParseClientAreaElement(StringBuilder sb, SystemAccessibleObject sao, int depth)
-        {
-            sb.Append("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
-            sb.Append(ListContent.Repeat('*', depth) + " " + sao.ToString() + "\n");
-            try
-            {
-                sb.Append("D: " + sao.Description + "\n");
-            }
-            catch (COMException) { }
-            try
-            {
-                sb.Append("V: " + sao.Value + "\n");
-            }
-            catch (COMException) { }
-            foreach (SystemAccessibleObject c in sao.Children)
-            {
-                if (c.Window == sao.Window)
-                    ParseClientAreaElement(sb, c, depth + 1);
-            }
-        }
-
-        ///
-        public Dictionary<string, string> PropertyList
-        {
-            get
-            {
-                Dictionary<string, string> result = new Dictionary<string, string>();
-                return result;
-            }
-        }
-
-    }
-
-    class AccessibleWindowParser : WindowContentParser
-    {
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            return TestMenu(sw, AccessibleObjectID.OBJID_MENU) ||
-                TestMenu(sw, AccessibleObjectID.OBJID_SYSMENU) ||
-                TestClientArea(sw);
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, AccessibleObjectID.OBJID_WINDOW);
-            bool sysmenu = TestMenu(sw, AccessibleObjectID.OBJID_SYSMENU);
-            bool menu = TestMenu(sw, AccessibleObjectID.OBJID_MENU);
-            bool clientarea = TestClientArea(sw);
-            return new AccessibleWindowContent(sao.Name, menu, sysmenu, clientarea, sw);
-        }
-
-        private bool TestClientArea(SystemWindow sw)
-        {
-            try
-            {
-                SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, AccessibleObjectID.OBJID_CLIENT);
-                foreach (SystemAccessibleObject c in sao.Children)
-                {
-                    if (c.Window == sw) return true;
-                }
-            }
-            catch (COMException) { }
-            return false;
-        }
-
-        private bool TestMenu(SystemWindow sw, AccessibleObjectID accessibleObjectID)
-        {
-            SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, accessibleObjectID);
-            return sao.Children.Length > 0;
-        }
-    }
-}

=== removed file 'ManagedWinapi/Contents/ContentParserRegistry.cs'
--- ManagedWinapi/Contents/ContentParserRegistry.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/ContentParserRegistry.cs	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-
-namespace ManagedWinapi.Windows.Contents
-{
-    internal class ContentParserRegistry
-    {
-        static ContentParserRegistry instance = null;
-
-        public static ContentParserRegistry Instance
-        {
-            get
-            {
-                if (instance == null)
-                    instance = new ContentParserRegistry();
-                return instance;
-            }
-        }
-
-        List<WindowContentParser> parsers = new List<WindowContentParser>();
-
-        private ContentParserRegistry()
-        {
-            parsers.Add(new ComboBoxParser());
-            parsers.Add(new ListBoxParser());
-            parsers.Add(new TextFieldParser(true));
-            parsers.Add(new ListViewParser());
-            parsers.Add(new TreeViewParser());
-            parsers.Add(new AccessibleWindowParser());
-            parsers.Add(new TextFieldParser(false));
-        }
-
-        public WindowContentParser GetParser(SystemWindow sw)
-        {
-            foreach(WindowContentParser p in parsers) {
-                if (p.CanParseContent(sw))
-                    return p;
-            }
-            return null;
-        }
-    }
-}

=== removed file 'ManagedWinapi/Contents/ListParser.cs'
--- ManagedWinapi/Contents/ListParser.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/ListParser.cs	1970-01-01 00:00:00 +0000
@@ -1,361 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.InteropServices;
-using ManagedWinapi.Accessibility;
-
-namespace ManagedWinapi.Windows.Contents
-{
-    /// <summary>
-    /// The content of a list box or combo box.
-    /// </summary>
-    public class ListContent : WindowContent
-    {
-        string type, current;
-        string[] values;
-        int selected;
-
-        internal ListContent(string type, int selected, string current, string[] values)
-        {
-            this.type = type;
-            this.selected = selected;
-            this.current = current;
-            this.values = values;
-        }
-
-        ///
-        public string ComponentType
-        {
-            get { return type; }
-        }
-
-        ///
-        public string ShortDescription
-        {
-            get { return (current == null ? "" : current + " ") + "<" + type + ">"; }
-        }
-
-        ///
-        public string LongDescription
-        {
-            get
-            {
-                StringBuilder sb = new StringBuilder();
-                sb.Append("<" + type + ">");
-                if (current != null)
-                    sb.Append(" (selected value: \"" + current + "\")");
-                sb.Append("\nAll values:\n");
-                int idx = 0;
-                foreach (string v in values)
-                {
-                    if (selected == idx) sb.Append("*");
-                    sb.Append("\t" + v + "\n");
-                    idx++;
-                }
-                return sb.ToString();
-            }
-        }
-
-        ///
-        public Dictionary<string, string> PropertyList
-        {
-            get
-            {
-                Dictionary<string, string> result = new Dictionary<string, string>();
-                result.Add("SelectedValue", current);
-                result.Add("SelectedIndex", "" + selected);
-                result.Add("Count", "" + values.Length);
-                for (int i = 0; i < values.Length; i++)
-                {
-                    result.Add("Value" + i, values[i]);
-                }
-                return result;
-            }
-        }
-
-        /// <summary>
-        /// The value in this list or combo box that is selected.
-        /// In a combo box, this value may not be in the list.
-        /// </summary>
-        public String SelectedValue
-        {
-            get { return current; }
-        }
-
-        /// <summary>
-        /// The index of the selected item, or -1 if no item
-        /// is selected.
-        /// </summary>
-        public int SelectedIndex
-        {
-            get
-            {
-                return selected;
-            }
-        }
-
-        /// <summary>
-        /// The number of items in this list.
-        /// </summary>
-        public int Count
-        {
-            get
-            {
-                return values.Length;
-            }
-        }
-
-        /// <summary>
-        /// Accesses individual list items.
-        /// </summary>
-        /// <param name="index">Index of list item.</param>
-        /// <returns>The list item.</returns>
-        public string this[int index]
-        {
-            get
-            {
-                return values[index];
-            }
-        }
-
-        internal static string Repeat(char ch, int count)
-        {
-            char[] tmp = new char[count];
-            for (int i = 0; i < tmp.Length; i++)
-            {
-                tmp[i] = ch;
-            }
-            return new string(tmp);
-        }
-    }
-
-    internal class ListBoxParser : WindowContentParser
-    {
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            return SystemListBox.FromSystemWindow(sw) != null;
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            SystemListBox slb = SystemListBox.FromSystemWindow(sw);
-            int c = slb.Count;
-            string[] values = new string[c];
-            for (int i = 0; i < c; i++)
-            {
-                values[i] = slb[i];
-            }
-            return new ListContent("ListBox", slb.SelectedIndex, slb.SelectedItem, values);
-        }
-    }
-
-    internal class ComboBoxParser : WindowContentParser
-    {
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            return SystemComboBox.FromSystemWindow(sw) != null;
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            SystemComboBox slb = SystemComboBox.FromSystemWindow(sw);
-            int c = slb.Count;
-            string[] values = new string[c];
-            for (int i = 0; i < c; i++)
-            {
-                values[i] = slb[i];
-            }
-            return new ListContent("ComboBox", -1, sw.Title, values);
-        }
-    }
-
-    internal class ListViewParser : WindowContentParser
-    {
-
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            uint LVM_GETITEMCOUNT = (0x1000 + 4);
-            int cnt = sw.SendGetMessage(LVM_GETITEMCOUNT);
-            return cnt != 0;
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            uint LVM_GETITEMCOUNT = (0x1000 + 4);
-            int cnt = sw.SendGetMessage(LVM_GETITEMCOUNT);
-            if (cnt == 0) throw new Exception();
-            SystemAccessibleObject o = SystemAccessibleObject.FromWindow(sw, AccessibleObjectID.OBJID_CLIENT);
-            if (o.RoleIndex == 33)
-            {
-                // are there column headers?
-                int cs = o.Children.Length;
-                string[] hdr = null;
-                if (cs > 0)
-                {
-                    SystemAccessibleObject headers = o.Children[cs - 1];
-                    if (headers.RoleIndex == 9 && headers.Window != sw)
-                    {
-                        SystemAccessibleObject hdrL = SystemAccessibleObject.FromWindow(headers.Window, AccessibleObjectID.OBJID_CLIENT);
-                        hdr = new string[hdrL.Children.Length];
-                        for (int i = 0; i < hdr.Length; i++)
-                        {
-                            if (hdrL.Children[i].RoleIndex != 25)
-                            {
-                                hdr = null;
-                                break;
-                            }
-                            hdr[i] = hdrL.Children[i].Name;
-                        }
-                        if (hdr != null)
-                        {
-                            cs--;
-                        }
-                    }
-                }
-                List<string> values = new List<string>();
-                for (int i = 0; i < cs; i++)
-                {
-                    if (o.Children[i].RoleIndex == 34)
-                    {
-                        string name = o.Children[i].Name;
-                        if (hdr != null)
-                        {
-                            try
-                            {
-                                string cols = o.Children[i].Description;
-                                if (cols == null && values.Count == 0) { hdr = null; }
-                                else
-                                {
-                                    string tmpCols = "; " + cols;
-                                    List<string> usedHdr = new List<string>();
-                                    foreach (string header in hdr)
-                                    {
-                                        string h = "; " + header + ": ";
-                                        if (tmpCols.Contains(h))
-                                        {
-                                            usedHdr.Add(header);
-                                            tmpCols = tmpCols.Substring(tmpCols.IndexOf(h) + h.Length);
-                                        }
-                                    }
-                                    foreach (string header in hdr)
-                                    {
-                                        name += "\t";
-                                        if (usedHdr.Count > 0 && usedHdr[0] == header)
-                                        {
-                                            if (!cols.StartsWith(header + ": "))
-                                                throw new Exception();
-                                            cols = cols.Substring(header.Length + 1);
-                                            string elem;
-                                            if (usedHdr.Count > 1)
-                                            {
-                                                int pos = cols.IndexOf("; " + usedHdr[1] + ": ");
-                                                elem = cols.Substring(0, pos);
-                                                cols = cols.Substring(pos + 2);
-                                            }
-                                            else
-                                            {
-                                                elem = cols;
-                                                cols = "";
-                                            }
-                                            name += elem;
-                                            usedHdr.RemoveAt(0);
-                                        }
-                                    }
-                                }
-                            }
-                            catch (COMException ex)
-                            {
-                                if (ex.ErrorCode == -2147352573 && values.Count == 0)
-                                {
-                                    hdr = null;
-                                }
-                                else
-                                {
-                                    throw ex;
-                                }
-                            }
-                        }
-                        values.Add(name);
-                    }
-                }
-                if (hdr != null)
-                {
-                    string lines = "", headers = "";
-                    foreach (string h in hdr)
-                    {
-                        if (lines.Length > 0) lines += "\t";
-                        if (headers.Length > 0) headers += "\t";
-                        headers += h;
-                        lines += ListContent.Repeat('~', h.Length);
-                    }
-                    values.Insert(0, lines);
-                    values.Insert(0, headers);
-                    return new ListContent("DetailsListView", -1, null, values.ToArray());
-                }
-                else
-                {
-                    return new ListContent("ListView", -1, null, values.ToArray());
-                }
-            }
-            else
-            {
-                return new ListContent("EmptyListView", -1, null, new string[0]);
-            }
-        }
-    }
-
-    class TreeViewParser : WindowContentParser
-    {
-        uint TVM_GETCOUNT = 0x1100 + 5;
-
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            int cnt = sw.SendGetMessage(TVM_GETCOUNT, 0);
-            return cnt != 0;
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            SystemAccessibleObject sao = SystemAccessibleObject.FromWindow(sw, AccessibleObjectID.OBJID_CLIENT);
-            if (sao.RoleIndex == 35)
-            {
-                List<string> treeNodes = new List<string>();
-                int selected = -1;
-                foreach(SystemAccessibleObject n in sao.Children) {
-                    if (n.RoleIndex == 36)
-                    {
-                        if ((n.State & 0x2) != 0)
-                        {
-                            selected = treeNodes.Count;
-                        }
-                        treeNodes.Add(ListContent.Repeat('\t', int.Parse(n.Value)) + n.Name);
-                    }
-                }
-                if (treeNodes.Count > 0)
-                {
-                    return new ListContent("TreeView", selected, null, treeNodes.ToArray());
-                }
-            }
-            return new ListContent("EmptyTreeView", -1, null, new string[0]);
-        }
-    }
-}

=== removed file 'ManagedWinapi/Contents/TextFieldParser.cs'
--- ManagedWinapi/Contents/TextFieldParser.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/TextFieldParser.cs	1970-01-01 00:00:00 +0000
@@ -1,116 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-
-namespace ManagedWinapi.Windows.Contents
-{
-
-    /// <summary>
-    /// The content of a text box.
-    /// </summary>
-    public class TextContent : WindowContent
-    {
-        readonly string text;
-        readonly bool password;
-        readonly bool strict;
-
-        internal TextContent(string text, bool password, bool strict)
-        {
-            this.text = text;
-            this.password = password;
-            this.strict = strict;
-        }
-
-        ///
-        public string ComponentType
-        {
-            get { return strict ? "TextBox" : "Text"; }
-        }
-
-        ///
-        public string ShortDescription
-        {
-            get
-            {
-                string s = strict ? " <TextBox>" : "";
-                if (text.IndexOf("\n") != -1)
-                    return "<MultiLine>" + s;
-                else if (password)
-                    return text + " <Password>" + s;
-                else
-                    return text + s;
-            }
-        }
-
-        ///
-        public string LongDescription
-        {
-            get
-            {
-                if (password)
-                    return text + " <Password>";
-                else
-                    return text;
-            }
-        }
-
-        ///
-        public Dictionary<string, string> PropertyList
-        {
-            get
-            {
-                Dictionary<string, string> result = new Dictionary<string, string>();
-                result.Add("Password", password ? "True" : "False");
-                result.Add("MultiLine", text.IndexOf('\n') != -1 ? "True" : "False");
-                result.Add("Text", text);
-                return result;
-            }
-        }
-    }
-
-    class TextFieldParser : WindowContentParser
-    {
-        readonly bool strict;
-
-        public TextFieldParser(bool strict)
-        {
-            this.strict = strict;
-        }
-
-        internal override bool CanParseContent(SystemWindow sw)
-        {
-            if (strict)
-            {
-                uint EM_GETLINECOUNT = 0xBA;
-                return sw.SendGetMessage(EM_GETLINECOUNT) != 0;
-            }
-            else
-            {
-                return sw.Title != "";
-            }
-        }
-
-        internal override WindowContent ParseContent(SystemWindow sw)
-        {
-            return new TextContent(sw.Title, sw.PasswordCharacter != 0, strict);
-        }
-    }
-}

=== removed file 'ManagedWinapi/Contents/WindowContent.cs'
--- ManagedWinapi/Contents/WindowContent.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/WindowContent.cs	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-
-namespace ManagedWinapi.Windows.Contents
-{
-    /// <summary>
-    /// An abstract representation of the content of a window or control.
-    /// </summary>
-    public interface WindowContent
-    {
-        /// <summary>
-        /// A short description of the type of this window.
-        /// </summary>
-        string ComponentType { get;}
-
-        /// <summary>
-        /// A short description of this content.
-        /// </summary>
-        string ShortDescription { get;}
-
-        /// <summary>
-        /// The full description of this content.
-        /// </summary>
-        string LongDescription { get;}
-
-        /// <summary>
-        /// A list of properties of this content.
-        /// </summary>
-        Dictionary<String, String> PropertyList { get;}
-    }
-}

=== removed file 'ManagedWinapi/Contents/WindowContentParser.cs'
--- ManagedWinapi/Contents/WindowContentParser.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Contents/WindowContentParser.cs	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-
-namespace ManagedWinapi.Windows.Contents
-{
-    internal abstract class WindowContentParser
-    {
-        internal abstract bool CanParseContent(SystemWindow sw);
-        internal abstract WindowContent ParseContent(SystemWindow sw);
-
-        internal static WindowContent Parse(SystemWindow sw)
-        {
-            WindowContentParser parser = ContentParserRegistry.Instance.GetParser(sw);
-            if (parser == null) return null;
-            return parser.ParseContent(sw);
-        }
-    }
-}

=== removed file 'ManagedWinapi/Crosshair.Designer.cs'
--- ManagedWinapi/Crosshair.Designer.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Crosshair.Designer.cs	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-namespace ManagedWinapi
-{
-    partial class Crosshair
-    {
-        /// <summary> 
-        /// Required designer variable.
-        /// </summary>
-        private System.ComponentModel.IContainer components = null;
-
-        /// <summary> 
-        /// Clean up any resources being used.
-        /// </summary>
-        /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
-        protected override void Dispose(bool disposing)
-        {
-            if (disposing && (components != null))
-            {
-                components.Dispose();
-            }
-            base.Dispose(disposing);
-        }
-
-        #region Component Designer generated code
-
-        /// <summary> 
-        /// Required method for Designer support - do not modify 
-        /// the contents of this method with the code editor.
-        /// </summary>
-        private void InitializeComponent()
-        {
-            this.dragger = new System.Windows.Forms.PictureBox();
-            ((System.ComponentModel.ISupportInitialize)(this.dragger)).BeginInit();
-            this.SuspendLayout();
-            // 
-            // dragger
-            // 
-            this.dragger.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
-            this.dragger.Cursor = System.Windows.Forms.Cursors.Cross;
-            this.dragger.Dock = System.Windows.Forms.DockStyle.Fill;
-            this.dragger.Location = new System.Drawing.Point(0, 0);
-            this.dragger.Name = "dragger";
-            this.dragger.Size = new System.Drawing.Size(36, 36);
-            this.dragger.TabIndex = 0;
-            this.dragger.TabStop = false;
-            this.dragger.MouseDown += new System.Windows.Forms.MouseEventHandler(this.dragger_MouseDown);
-            this.dragger.MouseMove += new System.Windows.Forms.MouseEventHandler(this.dragger_MouseMove);
-            this.dragger.MouseUp += new System.Windows.Forms.MouseEventHandler(this.dragger_MouseUp);
-            // 
-            // Crosshair
-            // 
-            this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-            this.Controls.Add(this.dragger);
-            this.Name = "Crosshair";
-            this.Size = new System.Drawing.Size(36, 36);
-            ((System.ComponentModel.ISupportInitialize)(this.dragger)).EndInit();
-            this.ResumeLayout(false);
-
-        }
-
-        #endregion
-
-        private System.Windows.Forms.PictureBox dragger;
-    }
-}

=== removed file 'ManagedWinapi/Crosshair.cs'
--- ManagedWinapi/Crosshair.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Crosshair.cs	1970-01-01 00:00:00 +0000
@@ -1,83 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Drawing;
-using System.Data;
-using System.Text;
-using System.Windows.Forms;
-using System.Runtime.InteropServices;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// This component displays a crosshair icon that can be dragged to any point
-    /// on screen. This is useful to select other programs by dragging the crosshair
-    /// to a program window.
-    /// </summary>
-    [DefaultEvent("CrosshairDragged")]
-    public partial class Crosshair : UserControl
-    {
-        Image myImage;
-        Cursor myCursor;
-
-        /// <summary>
-        /// Occurs when the user finished dragging the crosshair. Use 
-        /// <see cref="Cursor.Position"/> to detect the cursor position.
-        /// </summary>
-        public event EventHandler CrosshairDragged;
-
-        /// <summary>
-        /// Occurs while the user drags the crosshair. Use 
-        /// <see cref="Cursor.Position"/> to detect the cursor position.
-        /// </summary>
-        public event EventHandler CrosshairDragging;
-
-        /// <summary>
-        /// Creates a new crosshair control.
-        /// </summary>
-        public Crosshair()
-        {
-            InitializeComponent();
-            myImage = new Bitmap(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("ManagedWinapi.crosshair.ico"));
-            myCursor = new Cursor(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("ManagedWinapi.crosshair.ico"));
-            dragger.Image = myImage;
-        }
-
-        private void dragger_MouseDown(object sender, MouseEventArgs e)
-        {
-            dragger.Image = null;
-            dragger.Cursor = myCursor;
-        }
-
-        private void dragger_MouseUp(object sender, MouseEventArgs e)
-        {
-            dragger.Image = myImage;
-            dragger.Cursor = Cursors.Cross;
-            if (CrosshairDragged != null)
-            {
-                CrosshairDragged(this, new EventArgs());
-            }
-        }
-
-        private void dragger_MouseMove(object sender, MouseEventArgs e)
-        {
-            if (dragger.Cursor == myCursor)
-            {
-                if (CrosshairDragging != null)
-                {
-                    CrosshairDragging(this, new EventArgs());
-                }
-            }
-        }
-
-        /// <summary>
-        /// When a window is hidden, the .NET framework releases mouse capture.
-        /// If you hide your window while the crosshair is dragged, invoke
-        /// this method afterwards to restore mouse capture.
-        /// </summary>
-        public void RestoreMouseCapture()
-        {
-            dragger.Capture = true;
-        }
-    }
-}

=== removed file 'ManagedWinapi/Crosshair.resx'
--- ManagedWinapi/Crosshair.resx	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Crosshair.resx	1970-01-01 00:00:00 +0000
@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!-- 
-    Microsoft ResX Schema 
-    
-    Version 2.0
-    
-    The primary goals of this format is to allow a simple XML format 
-    that is mostly human readable. The generation and parsing of the 
-    various data types are done through the TypeConverter classes 
-    associated with the data types.
-    
-    Example:
-    
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-                
-    There are any number of "resheader" rows that contain simple 
-    name/value pairs.
-    
-    Each data row contains a name, and value. The row also contains a 
-    type or mimetype. Type corresponds to a .NET class that support 
-    text/value conversion through the TypeConverter architecture. 
-    Classes that don't support this are serialized and stored with the 
-    mimetype set.
-    
-    The mimetype is used for serialized objects, and tells the 
-    ResXResourceReader how to depersist the object. This is currently not 
-    extensible. For a given mimetype the value must be set accordingly:
-    
-    Note - application/x-microsoft.net.object.binary.base64 is the format 
-    that the ResXResourceWriter will generate, however the reader can 
-    read any of the formats listed below.
-    
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-    
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with 
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array 
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>
\ No newline at end of file

=== removed file 'ManagedWinapi/EventDispatchingNativeWindow.cs'
--- ManagedWinapi/EventDispatchingNativeWindow.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/EventDispatchingNativeWindow.cs	1970-01-01 00:00:00 +0000
@@ -1,93 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Windows.Forms;
-
-namespace ManagedWinapi.Windows
-{
-
-    /// <summary>
-    /// Called by an EventDispatchingNativeWindow when a window message is received
-    /// </summary>
-    /// <param name="m">The message to handle.</param>
-    /// <param name="handled">Whether the event has already been handled. If this value is true, the handler
-    /// should return immediately. It may set the value to true to indicate that no others 
-    /// should handle it. If the event is not handled by any handler, it is passed to the
-    /// default WindowProc.</param>
-    public delegate void WndProcEventHandler(ref Message m, ref bool handled);
-
-    /// <summary>
-    /// A Win32 native window that delegates window messages to handlers. So several
-    /// components can use the same native window to save "USER resources". This class
-    /// is useful when writing your own components.
-    /// </summary>
-    public class EventDispatchingNativeWindow : NativeWindow
-    {
-
-        private static Object myLock = new Object();
-        private static EventDispatchingNativeWindow _instance;
-
-        /// <summary>
-        /// A global instance which can be used by components that do not need
-        /// their own window.
-        /// </summary>
-        public static EventDispatchingNativeWindow Instance
-        {
-            get
-            {
-                lock (myLock)
-                {
-                    if (_instance == null)
-                        _instance = new EventDispatchingNativeWindow();
-                    return _instance;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Attach your event handlers here.
-        /// </summary>
-        public event WndProcEventHandler EventHandler;
-
-        /// <summary>
-        /// Create your own event dispatching window.
-        /// </summary>
-        public EventDispatchingNativeWindow()
-        {
-            CreateHandle(new CreateParams());
-        }
-
-        /// <summary>
-        /// Parse messages passed to this window and send them to the event handlers.
-        /// </summary>
-        /// <param name="m">A System.Windows.Forms.Message that is associated with the 
-        /// current Windows message.</param>
-        protected override void WndProc(ref Message m)
-        {
-            bool handled = false;
-            if (EventHandler != null)
-                EventHandler(ref m, ref handled);
-            if (!handled)
-                base.WndProc(ref m);
-        }
-    }
-}

=== removed file 'ManagedWinapi/ExtendedFileInfo.cs'
--- ManagedWinapi/ExtendedFileInfo.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/ExtendedFileInfo.cs	1970-01-01 00:00:00 +0000
@@ -1,177 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006, 2007 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Drawing;
-using System.Runtime.InteropServices;
-using System.IO;
-using System.ComponentModel;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// Provides methods for getting additional information about
-    /// files, like icons or compressed file size.
-    /// </summary>
-    public sealed class ExtendedFileInfo
-    {
-        /// <summary>
-        /// Get the icon used for folders.
-        /// </summary>
-        /// <param name="small">Whether to get the small icon instead of the large one</param>
-        public static Icon GetFolderIcon(bool small)
-        {
-            return GetIconForFilename(Environment.GetFolderPath(Environment.SpecialFolder.System), small);
-        }
-
-        /// <summary>
-        /// Get the icon used for files that do not have their own icon
-        /// </summary>
-        /// <param name="small">Whether to get the small icon instead of the large one</param>
-        public static Icon GetFileIcon(bool small)
-        {
-            return GetExtensionIcon("", small);
-        }
-
-        /// <summary>
-        /// Get the icon used by files of a given extension.
-        /// </summary>
-        /// <param name="extension">The extension without leading dot</param>
-        /// <param name="small">Whether to get the small icon instead of the large one</param>
-        public static Icon GetExtensionIcon(string extension, bool small)
-        {
-            string tmp = Path.GetTempFileName();
-            File.Delete(tmp);
-            string fn = tmp + "." + extension;
-            try
-            {
-                File.Create(fn).Close();
-                return GetIconForFilename(fn, small);
-            }
-            finally
-            {
-                File.Delete(fn);
-            }
-        }
-
-        /// <summary>
-        /// Get the icon used for a given, existing file.
-        /// </summary>
-        /// <param name="fileName">Name of the file</param>
-        /// <param name="small">Whether to get the small icon instead of the large one</param>
-        public static Icon GetIconForFilename(string fileName, bool small)
-        {
-            SHFILEINFO shinfo = new SHFILEINFO();
-
-            if (small)
-            {
-                IntPtr hImgSmall = SHGetFileInfo(fileName, 0, ref shinfo,
-                                   (uint)Marshal.SizeOf(shinfo),
-                                    SHGFI_ICON |
-                                    SHGFI_SMALLICON);
-            }
-            else
-            {
-                IntPtr hImgLarge = SHGetFileInfo(fileName, 0,
-                ref shinfo, (uint)Marshal.SizeOf(shinfo),
-                SHGFI_ICON | SHGFI_LARGEICON);
-            }
-
-            if (shinfo.hIcon == IntPtr.Zero) return null;
-
-            System.Drawing.Icon myIcon =
-                   System.Drawing.Icon.FromHandle(shinfo.hIcon);
-            return myIcon;
-        }
-
-        /// <summary>
-        /// Get the size a file requires on disk. This takes NTFS
-        /// compression into account.
-        /// </summary>
-        public static ulong GetPhysicalFileSize(string filename)
-        {
-            uint high;
-            uint low;
-            low = GetCompressedFileSize(filename, out high);
-            int error = Marshal.GetLastWin32Error();
-            if (error == 32)
-            {
-                return (ulong)new FileInfo(filename).Length;
-            }
-            if (high == 0 && low == 0xFFFFFFFF && error != 0)
-                throw new Win32Exception(error);
-            else
-                return ((ulong)high << 32) + low;
-        }
-
-        /// <summary>
-        /// Get the cluster size for the filesystem that contains the given file.
-        /// </summary>
-        public static uint GetClusterSize(string filename)
-        {
-            uint sectors, bytes, dummy;
-            string drive = Path.GetPathRoot(filename);
-            if (!GetDiskFreeSpace(drive, out sectors, out bytes,
-                    out dummy, out dummy))
-            {
-                throw new Win32Exception(Marshal.GetLastWin32Error());
-            }
-            return sectors * bytes;
-        }
-
-        #region PInvoke Declarations
-
-        private const uint SHGFI_ICON = 0x100;
-        private const uint SHGFI_LARGEICON = 0x0;    // 'Large icon
-        private const uint SHGFI_SMALLICON = 0x1;    // 'Small icon
-
-        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
-        static extern bool GetDiskFreeSpace(string lpRootPathName,
-           out uint lpSectorsPerCluster,
-           out uint lpBytesPerSector,
-           out uint lpNumberOfFreeClusters,
-           out uint lpTotalNumberOfClusters);
-
-        [DllImport("kernel32.dll")]
-        private static extern uint GetCompressedFileSize(string lpFileName,
-           out uint lpFileSizeHigh);
-
-        [DllImport("shell32.dll")]
-        private static extern IntPtr SHGetFileInfo(string pszPath,
-                                    uint dwFileAttributes,
-                                    ref SHFILEINFO psfi,
-                                    uint cbSizeFileInfo,
-                                    uint uFlags);
-
-        [StructLayout(LayoutKind.Sequential)]
-        private struct SHFILEINFO
-        {
-            public IntPtr hIcon;
-            public IntPtr iIcon;
-            public uint dwAttributes;
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
-            public string szDisplayName;
-            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
-            public string szTypeName;
-        };
-        #endregion
-    }
-}
\ No newline at end of file

=== removed file 'ManagedWinapi/Hook.cs'
--- ManagedWinapi/Hook.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Hook.cs	1970-01-01 00:00:00 +0000
@@ -1,309 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006, 2007 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-using System.Windows.Forms;
-using System.Diagnostics;
-using System.Reflection;
-using System.Threading;
-
-namespace ManagedWinapi.Hooks
-{
-    /// <summary>
-    /// A hook is a point in the system message-handling mechanism where an application
-    /// can install a subroutine to monitor the message traffic in the system and process 
-    /// certain types of messages before they reach the target window procedure.
-    /// </summary>
-    public class Hook : Component
-    {
-        private HookType type;
-        internal bool hooked = false;
-        private IntPtr hHook;
-        private bool wrapCallback, global;
-        private IntPtr wrappedDelegate;
-        private IntPtr hWrapperInstance;
-        private readonly HookProc managedDelegate;
-
-        /// <summary>
-        /// Occurs when the hook's callback is called.
-        /// </summary>
-        public event HookCallback Callback;
-
-        /// <summary>
-        /// Represents a method that handles a callback from a hook.
-        /// </summary>
-        public delegate int HookCallback(int code, IntPtr wParam, IntPtr lParam, ref bool callNext);
-
-        /// <summary>
-        /// Creates a new hook and hooks it.
-        /// </summary>
-        public Hook(HookType type, HookCallback callback, bool wrapCallback, bool global)
-            : this(type, wrapCallback, global)
-        {
-            this.Callback += callback;
-            StartHook();
-        }
-
-        /// <summary>
-        /// Creates a new hook.
-        /// </summary>
-        public Hook(HookType type, bool wrapCallback, bool global)
-            : this()
-        {
-            this.type = type;
-            this.wrapCallback = wrapCallback;
-            this.global = global;
-        }
-
-        /// <summary>
-        /// Creates a new hook.
-        /// </summary>
-        public Hook(IContainer container)
-            : this()
-        {
-            container.Add(this);
-        }
-
-        /// <summary>
-        /// Creates a new hook.
-        /// </summary>
-        public Hook()
-        {
-            managedDelegate = new HookProc(InternalCallback);
-        }
-
-        /// <summary>
-        /// The type of the hook.
-        /// </summary>
-        public HookType Type
-        {
-            get { return type; }
-            set { type = value; }
-        }
-
-        /// <summary>
-        /// Whether this hook has been started.
-        /// </summary>
-        public bool Hooked
-        {
-            get { return hooked; }
-        }
-
-        /// <summary>
-        /// Hooks the hook.
-        /// </summary>
-        public virtual void StartHook()
-        {
-            if (hooked) return;
-            IntPtr delegt = Marshal.GetFunctionPointerForDelegate(managedDelegate);
-            if (wrapCallback)
-            {
-                wrappedDelegate = AllocHookWrapper(delegt);
-                hWrapperInstance = LoadLibrary("ManagedWinapiNativeHelper.dll");
-                hHook = SetWindowsHookEx(type, wrappedDelegate, hWrapperInstance, 0);
-            }
-            else if (global)
-            {
-                hHook = SetWindowsHookEx(type, delegt, Marshal.GetHINSTANCE(typeof(Hook).Assembly.GetModules()[0]), 0);
-            }
-            else
-            {
-                hHook = SetWindowsHookEx(type, delegt, IntPtr.Zero, getThreadID());
-            }
-            if (hHook == IntPtr.Zero) throw new Win32Exception(Marshal.GetLastWin32Error());
-            hooked = true;
-        }
-
-        private uint getThreadID()
-        {
-#pragma warning disable 0618
-            return (uint)AppDomain.GetCurrentThreadId();
-#pragma warning restore 0618
-        }
-
-        /// <summary>
-        /// Unhooks the hook.
-        /// </summary>
-        public virtual void Unhook()
-        {
-            if (!hooked) return;
-            if (!UnhookWindowsHookEx(hHook)) throw new Win32Exception(Marshal.GetLastWin32Error());
-            if (wrapCallback)
-            {
-                if (!FreeHookWrapper(wrappedDelegate)) throw new Win32Exception();
-                if (!FreeLibrary(hWrapperInstance)) throw new Win32Exception();
-            }
-            hooked = false;
-        }
-
-        /// <summary>
-        /// Unhooks the hook if necessary.
-        /// </summary>
-        protected override void Dispose(bool disposing)
-        {
-            if (hooked)
-            {
-                Unhook();
-            }
-            base.Dispose(disposing);
-        }
-
-        /// <summary>
-        /// Override this method if you want to prevent a call
-        /// to the CallNextHookEx method or if you want to return
-        /// a different return value. For most hooks this is not needed.
-        /// </summary>
-        protected virtual int InternalCallback(int code, IntPtr wParam, IntPtr lParam)
-        {
-            if (code >= 0 && Callback != null)
-            {
-                bool callNext = true;
-                int retval = Callback(code, wParam, lParam, ref callNext);
-                if (!callNext) return retval;
-            }
-            return CallNextHookEx(hHook, code, wParam, lParam);
-        }
-
-        #region PInvoke Declarations
-
-        [DllImport("user32.dll", SetLastError = true)]
-        private static extern IntPtr SetWindowsHookEx(HookType hook, IntPtr callback,
-           IntPtr hMod, uint dwThreadId);
-
-        [DllImport("user32.dll", SetLastError = true)]
-        internal static extern bool UnhookWindowsHookEx(IntPtr hhk);
-
-        [DllImport("user32.dll")]
-        internal static extern int CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam,
-           IntPtr lParam);
-
-        [DllImport("ManagedWinapiNativeHelper.dll")]
-        private static extern IntPtr AllocHookWrapper(IntPtr callback);
-
-        [DllImport("ManagedWinapiNativeHelper.dll")]
-        private static extern bool FreeHookWrapper(IntPtr wrapper);
-
-        [DllImport("kernel32.dll")]
-        private static extern IntPtr LoadLibrary(string lpFileName);
-
-        [DllImport("kernel32.dll", SetLastError = true)]
-        private static extern bool FreeLibrary(IntPtr hModule);
-
-        private delegate int HookProc(int code, IntPtr wParam, IntPtr lParam);
-
-        internal static readonly int HC_ACTION = 0,
-            HC_GETNEXT = 1,
-            HC_SKIP = 2,
-            HC_NOREMOVE = 3,
-            HC_SYSMODALON = 4,
-            HC_SYSMODALOFF = 5;
-        #endregion
-    }
-
-    /// <summary>
-    /// A hook that intercepts local window messages.
-    /// </summary>
-    public class LocalMessageHook : Hook
-    {
-        /// <summary>
-        /// Called when a message has been intercepted.
-        /// </summary>
-        public event MessageCallback MessageOccurred;
-
-        /// <summary>
-        /// Represents a method that handles a message from a message hook.
-        /// </summary>
-        /// <param name="msg"></param>
-        public delegate void MessageCallback(Message msg);
-
-        /// <summary>
-        /// Creates a local message hook and hooks it.
-        /// </summary>
-        /// <param name="callback"></param>
-        public LocalMessageHook(MessageCallback callback)
-            : this()
-        {
-            this.MessageOccurred = callback;
-            StartHook();
-        }
-
-        /// <summary>
-        /// Creates a local message hook.
-        /// </summary>
-        public LocalMessageHook()
-            : base(HookType.WH_GETMESSAGE, false, false)
-        {
-            base.Callback += MessageHookCallback;
-        }
-
-        private int MessageHookCallback(int code, IntPtr lParam, IntPtr wParam, ref bool callNext)
-        {
-            if (code == HC_ACTION)
-            {
-                Message msg = (Message)Marshal.PtrToStructure(wParam, typeof(Message));
-                if (MessageOccurred != null)
-                {
-                    MessageOccurred(msg);
-                }
-            }
-            return 0;
-        }
-    }
-
-    /// <summary>
-    /// Hook Types. See the documentation of SetWindowsHookEx for reference.
-    /// </summary>
-    public enum HookType : int
-    {
-        ///
-        WH_JOURNALRECORD = 0,
-        ///
-        WH_JOURNALPLAYBACK = 1,
-        ///
-        WH_KEYBOARD = 2,
-        ///
-        WH_GETMESSAGE = 3,
-        ///
-        WH_CALLWNDPROC = 4,
-        ///
-        WH_CBT = 5,
-        ///
-        WH_SYSMSGFILTER = 6,
-        ///
-        WH_MOUSE = 7,
-        ///
-        WH_HARDWARE = 8,
-        ///
-        WH_DEBUG = 9,
-        ///
-        WH_SHELL = 10,
-        ///
-        WH_FOREGROUNDIDLE = 11,
-        ///
-        WH_CALLWNDPROCRET = 12,
-        ///
-        WH_KEYBOARD_LL = 13,
-        ///
-        WH_MOUSE_LL = 14
-    }
-}

=== removed file 'ManagedWinapi/Hotkey.cs'
--- ManagedWinapi/Hotkey.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/Hotkey.cs	1970-01-01 00:00:00 +0000
@@ -1,206 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
-using System.Windows.Forms;
-using System.Runtime.InteropServices;
-using ManagedWinapi.Windows;
-
-namespace ManagedWinapi
-{
-
-    /// <summary>
-    /// Specifies a component that creates a global keyboard hotkey.
-    /// </summary>
-    [DefaultEvent("HotkeyPressed")]
-    public class Hotkey : Component
-    {
-
-        /// <summary>
-        /// Occurs when the hotkey is pressed.
-        /// </summary>
-        public event EventHandler HotkeyPressed;
-
-        private static Object myStaticLock = new Object();
-        private static int hotkeyCounter = 0xA000;
-
-        private int hotkeyIndex;
-        private bool isDisposed = false, isEnabled = false, isRegistered = false;
-        private Keys _keyCode;
-        private bool _ctrl, _alt, _shift, _windows;
-        private readonly IntPtr hWnd;
-
-        /// <summary>
-        /// Initializes a new instance of this class with the specified container.
-        /// </summary>
-        /// <param name="container">The container to add it to.</param>
-        public Hotkey(IContainer container) : this()
-        {
-            container.Add(this);
-        }
-
-        /// <summary>
-        /// Initializes a new instance of this class.
-        /// </summary>
-        public Hotkey() 
-        {
-            EventDispatchingNativeWindow.Instance.EventHandler += nw_EventHandler;
-            lock(myStaticLock) 
-            {
-                hotkeyIndex = ++hotkeyCounter;
-            }
-            hWnd = EventDispatchingNativeWindow.Instance.Handle;
-        }
-
-        /// <summary>
-        /// Enables the hotkey. When the hotkey is enabled, pressing it causes a
-        /// <c>HotkeyPressed</c> event instead of being handled by the active 
-        /// application.
-        /// </summary>
-        public bool Enabled
-        {
-            get
-            {
-                return isEnabled;
-            }
-            set
-            {
-                isEnabled = value;
-                updateHotkey(false);
-            }
-        }
-
-        /// <summary>
-        /// The key code of the hotkey.
-        /// </summary>
-        public Keys KeyCode
-        {
-            get
-            {
-                return _keyCode;
-            }
-
-            set
-            {
-                _keyCode = value;
-                updateHotkey(true);
-            }
-        }
-
-        /// <summary>
-        /// Whether the shortcut includes the Control modifier.
-        /// </summary>
-        public bool Ctrl {
-            get { return _ctrl; }
-            set {_ctrl = value; updateHotkey(true);}
-        }
-
-        /// <summary>
-        /// Whether this shortcut includes the Alt modifier.
-        /// </summary>
-        public bool Alt {
-            get { return _alt; }
-            set {_alt = value; updateHotkey(true);}
-        }     
-   
-        /// <summary>
-        /// Whether this shortcut includes the shift modifier.
-        /// </summary>
-        public bool Shift {
-            get { return _shift; }
-            set {_shift = value; updateHotkey(true);}
-        }
-        
-        /// <summary>
-        /// Whether this shortcut includes the Windows key modifier. The windows key
-        /// is an addition by Microsoft to the keyboard layout. It is located between
-        /// Control and Alt and depicts a Windows flag.
-        /// </summary>
-        public bool WindowsKey {
-            get { return _windows; }
-            set {_windows = value; updateHotkey(true);}
-        }
-
-        void nw_EventHandler(ref Message m, ref bool handled)
-        {
-            if (handled) return;
-            if (m.Msg == WM_HOTKEY && m.WParam.ToInt32() == hotkeyIndex)
-            {
-                if (HotkeyPressed != null)
-                    HotkeyPressed(this, EventArgs.Empty);
-                handled = true;
-            }
-        }
-
-        /// <summary>
-        /// Releases all resources used by the System.ComponentModel.Component.
-        /// </summary>
-        /// <param name="disposing">Whether to dispose managed resources.</param>
-        protected override void Dispose(bool disposing)
-        {
-            isDisposed = true;
-            updateHotkey(false);
-            EventDispatchingNativeWindow.Instance.EventHandler -= nw_EventHandler;
-            base.Dispose(disposing);
-        }
-
-        private void updateHotkey(bool reregister)
-        {
-            bool shouldBeRegistered = isEnabled && !isDisposed && !DesignMode;
-            if (isRegistered && (!shouldBeRegistered || reregister))
-            {
-                // unregister hotkey
-                UnregisterHotKey(hWnd, hotkeyIndex);
-                isRegistered = false;
-            }
-            if (!isRegistered && shouldBeRegistered)
-            {
-                // register hotkey
-                bool success = RegisterHotKey(hWnd, hotkeyIndex, 
-                    (_shift ? MOD_SHIFT : 0) + (_ctrl ? MOD_CONTROL : 0) +
-                    (_alt ? MOD_ALT : 0) + (_windows ? MOD_WIN : 0), (int)_keyCode);
-                if (!success) throw new HotkeyAlreadyInUseException();
-                isRegistered = true;
-            }
-        }
-
-        #region PInvoke Declarations
-
-        [DllImport("user32.dll", SetLastError=true)]
-        private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vlc);
-        [DllImport("user32.dll", SetLastError=true)]
-        private static extern bool UnregisterHotKey(IntPtr hWnd, int id);
-
-        private static readonly int MOD_ALT = 0x0001,
-            MOD_CONTROL = 0x0002, MOD_SHIFT = 0x0004, MOD_WIN = 0x0008;
-
-        private static readonly int WM_HOTKEY = 0x0312;
-
-        #endregion
-    }
-
-    /// <summary>
-    /// The exception is thrown when a hotkey should be registered that
-    /// has already been registered by another application.
-    /// </summary>
-    public class HotkeyAlreadyInUseException : Exception { }
-}

=== removed file 'ManagedWinapi/InputBlocker.cs'
--- ManagedWinapi/InputBlocker.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/InputBlocker.cs	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-using System;
-using System.Runtime.InteropServices;
-
-namespace ManagedWinapi
-{
-    /// <summary>
-    /// Blocks keyboard and mouse input until this object is disposed.
-    /// Unlike <see cref="ManagedWinapi.Hooks.InputLocker"/>, you cannot detect when the systems
-    /// removes the block (which happens when the user presses CTRL+ALT+DEL),
-    /// but it works on Windows Vista as well.
-    /// </summary>
-    public class InputBlocker : IDisposable
-    {
-        bool needUnblock;
-
-        /// <summary>
-        /// Blocks keyboard and mouse input until this object is disposed.
-        /// </summary>
-        public InputBlocker()
-        {
-            needUnblock = BlockInput(true);
-        }
-
-        /// <summary>
-        /// Unblocks keyboard and mouse input.
-        /// </summary>
-        public void Dispose()
-        {
-            if (needUnblock) BlockInput(false);
-            needUnblock = false;
-        }
-
-        #region PInvoke Declarations
-        [DllImport("user32.dll")]
-        static extern bool BlockInput(bool fBlockIt);
-        #endregion
-    }
-}

=== removed file 'ManagedWinapi/JournalHook.cs'
--- ManagedWinapi/JournalHook.cs	2009-06-24 06:06:11 +0000
+++ ManagedWinapi/JournalHook.cs	1970-01-01 00:00:00 +0000
@@ -1,423 +0,0 @@
-/*
- * ManagedWinapi - A collection of .NET components that wrap PInvoke calls to 
- * access native API by managed code. http://mwinapi.sourceforge.net/
- * Copyright (C) 2006, 2007 Michael Schierl
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- * This library 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
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; see the file COPYING. if not, visit
- * http://www.gnu.org/licenses/lgpl.html or write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-
-namespace ManagedWinapi.Hooks
-{
-    /// <summary>
-    /// Abstract base class for hooks that can be used to create or playback 
-    /// a log of keyboard and mouse events.
-    /// </summary>
-    public abstract class JournalHook : Hook
-    {
-        /// <summary>
-        /// Occurs when the journal activity has been cancelled by
-        /// CTRL+ALT+DEL or CTRL+ESC.
-        /// </summary>
-        public event EventHandler JournalCancelled;
-        private readonly LocalMessageHook lmh;
-
-        /// <summary>
-        /// Creates a new journal hook.
-        /// </summary>
-        public JournalHook(HookType type)
-            : base(type, true, false)
-        {
-            lmh = new LocalMessageHook();
-            lmh.MessageOccurred += new LocalMessageHook.MessageCallback(lmh_Callback);
-        }
-
-        private void lmh_Callback(System.Windows.Forms.Message msg)
-        {
-            if (msg.Msg == WM_CANCELJOURNAL)
-            {
-                hooked = false;
-                lmh.Unhook();
-                if (JournalCancelled != null)
-                {
-                    JournalCancelled(this, new EventArgs());
-                }
-            }
-        }
-
-        /// <summary>
-        /// Hooks the hook.
-        /// </summary>
-        public override void StartHook()
-        {
-            if (Hooked) return;
-            lmh.StartHook();
-            base.StartHook();
-        }
-
-        /// <summary>
-        /// Unhooks the hook.
-        /// </summary>
-        public override void Unhook()
-        {
-            if (!Hooked) return;
-            base.Unhook();
-            lmh.Unhook();
-        }
-
-        #region PInvoke Declarations
-
-        private static readonly int WM_CANCELJOURNAL = 0x4B;
-
-        [StructLayout(LayoutKind.Sequential)]
-        internal struct EVENTMSG
-        {
-            public uint message;
-            public uint paramL;
-            public uint paramH;
-            public int time;
-            public IntPtr hWnd;
-        }
-        #endregion
-    }
-
-    /// <summary>
-    /// An event that has been recorded by a journal hook.
-    /// </summary>
-    public class JournalMessage
-    {
-        internal static JournalMessage Create(JournalHook.EVENTMSG msg)
-        {
-            return new JournalMessage(msg);
-        }
-
-        private JournalHook.EVENTMSG msg;
-        private JournalMessage(JournalHook.EVENTMSG msg)
-        {
-            this.msg = msg;
-        }
-
-        /// <summary>
-        /// Creates a new journal message.
-        /// </summary>
-        public JournalMessage(IntPtr hWnd, uint message, uint paramL, uint paramH, uint time)
-        {
-            msg = new JournalHook.EVENTMSG();
-            msg.hWnd = hWnd;
-            msg.message = message;
-            msg.paramL = paramL;
-            msg.paramH = paramH;
-            msg.time = 0;
-        }
-
-        /// <summary>
-        /// The window this message has been sent to.
-        /// </summary>
-        public IntPtr HWnd { get { return msg.hWnd; } }
-
-        /// <summary>
-        /// The message.
-        /// </summary>
-        public uint Message { get { return msg.message; } }
-
-        /// <summary>
-        /// The first parameter of the message.
-        /// </summary>
-        public uint ParamL { get { return msg.paramL; } }
-
-        /// <summary>
-        /// The second parameter of the message.
-        /// </summary>
-        public uint ParamH { get { return msg.paramH; } }
-
-        /// <summary>
-        /// The timestamp of the message.
-        /// </summary>
-        public int Time
-        {
-            get { return msg.time; }
-            set { msg.time = value; }
-        }
-
-        /// <summary>
-        /// Returns a System.String that represents the current System.Object.
-        /// </summary>
-        public override string ToString()
-        {
-            return "JournalMessage[hWnd=" + msg.hWnd + ",message=" + msg.message + ",L=" + msg.paramL +
-                ",H=" + msg.paramH + ",time=" + msg.time + "]";
-        }
-    }
-
-    /// <summary>
-    /// Event data for a journal record event.
-    /// </summary>
-    public class JournalRecordEventArgs : EventArgs
-    {
-        private JournalMessage msg;
-
-        internal JournalRecordEventArgs(JournalMessage msg)
-        {
-            this.msg = msg;
-        }
-
-        /// <summary>
-        /// The recorded message.
-        /// </summary>
-        public JournalMessage RecordedMessage
-        {
-            get { return msg; }
-        }
-    }
-
-    /// <summary>
-    /// A hook that can be used to create a log of keyboard and mouse events.
-    /// </summary>
-    public class JournalRecordHook : JournalHook
-    {
-        /// <summary>
-        /// Occurs when a system modal dialog appears. This may be used
-        /// to stop recording.
-        /// </summary>
-        public event EventHandler SystemModalDialogAppeared;
-
-        /// <summary>
-        /// Occurs when a system modal dialog disappears. This may be used
-        /// to continue recording.
-        /// </summary>
-        public event EventHandler SystemModalDialogDisappeared;
-
-        /// <summary>
-        /// Occurs when an event can be recorded.
-        /// </summary>
-        public event EventHandler<JournalRecordEventArgs> RecordEvent;
-
-        /// <summary>
-        /// Creates a new journal record hook.
-        /// </summary>
-        public JournalRecordHook()
-            : base(HookType.WH_JOURNALRECORD)
-        {
-            base.Callback += JournalRecordHook_Callback;
-        }
-
-        private int JournalRecordHook_Callback(int code, IntPtr wParam, IntPtr lParam, ref bool callNext)
-        {
-            if (code == HC_ACTION)
-            {
-                EVENTMSG em = (EVENTMSG)Marshal.PtrToStructure(lParam, typeof(EVENTMSG));
-                JournalMessage jm = JournalMessage.Create(em);
-                if (RecordEvent != null)
-                {
-                    RecordEvent(this, new JournalRecordEventArgs(jm));
-                }
-            }
-            else if (code == HC_SYSMODALON)
-            {
-                if (SystemModalDialogAppeared != null)
-                {
-                    SystemModalDialogAppeared(this, new EventArgs());
-                }
-            }
-            else if (code == HC_SYSMODALOFF)
-            {
-                if (SystemModalDialogDisappeared != null)
-                {
-                    SystemModalDialogDisappeared(this, new EventArgs());
-                }
-            }
-            return 0;
-        }
-    }
-
-    /// <summary>
-    /// A hook that can be used to playback a log of keyboard and mouse events.
-    /// </summary>
-    public class JournalPlaybackHook : JournalHook
-    {
-        /// <summary>
-        /// Occurs when a system modal dialog appears. This may be used to