removed EventHook dependency; implemented MouseHook and KeyboardHook classes; doesn't crash, but doesn't work either.

Author: retailcoder

RetailCoder.VBE/App.cs

@@ -84,12 +84,11 @@ public App(VBE vbe, IMessageBox messageBox,
 
         private void _hooks_MessageReceived(object sender, HookEventArgs e)
         {
-            if (sender is MouseHookWrapper)
+            if (sender is MouseHook)
             {
-                // right-click detected
                 _appMenus.EvaluateCanExecute(_parser.State);
             }
-            if (sender is KeyboardHookWrapper)
+            if (sender is KeyboardHook)
             {
                 var pane = _vbe.ActiveCodePane;
                 if (pane == null)
@@ -121,10 +120,12 @@ public void Startup()
 
             Task.Delay(1000).ContinueWith(t =>
             {
-                _parser.State.OnParseRequested(this);
-                _hooks.HookHotkeys();
-                _hooks.Attach();
-            });
+                UiDispatcher.Invoke(() =>
+                {
+                    _parser.State.OnParseRequested(this);
+                    _hooks.HookHotkeys();
+                });
+            }).ConfigureAwait(false);
         }
 
         #region sink handlers. todo: move to another class

RetailCoder.VBE/Common/Hotkeys/Hotkey.cs

@@ -147,7 +147,7 @@ private static Keys GetKey(string keyCode)
                     result = Keys.Return;
                     break;
                 default:
-                    if (!String.IsNullOrEmpty(keyCode))
+                    if (!string.IsNullOrEmpty(keyCode))
                     {
                         result = (Keys)Enum.Parse(typeof(Keys), keyCode);
                     }

RetailCoder.VBE/Common/KeyboardHook.cs

@@ -0,0 +1,90 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using Microsoft.Vbe.Interop;
+using Rubberduck.Common.WinAPI;
+
+namespace Rubberduck.Common
+{
+    public class KeyboardHook : IAttachable
+    {
+        private readonly VBE _vbe;
+        private IntPtr _hookId;
+
+        public KeyboardHook(VBE vbe)
+        {
+            _vbe = vbe;
+        }
+
+        private int _lastLineIndex;
+        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            var pane = _vbe.ActiveCodePane;
+            if (pane != null)
+            {
+                int startLine;
+                int endLine;
+                int startColumn;
+                int endColumn;
+
+                // not using extension method because a QualifiedSelection would be overkill:
+                pane.GetSelection(out startLine, out startColumn, out endLine, out endColumn);                
+                if (startLine != _lastLineIndex)
+                {
+                    // if the current line has changed, let the KEYDOWN be written to the IDE, and notify on KEYUP:
+                    _lastLineIndex = startLine;
+                    if (nCode >= 0 && (WM)wParam == WM.KEYUP)
+                    {
+                        //var key = (Keys)Marshal.ReadInt32(lParam);
+                        OnMessageReceived();
+                    }
+                }
+            }
+
+            return User32.CallNextHookEx(_hookId, nCode, wParam, lParam);
+        }
+
+        private void OnMessageReceived()
+        {
+            var handler = MessageReceived;
+            if (handler != null)
+            {
+                handler.Invoke(this, HookEventArgs.Empty);
+            }
+        }
+
+        public bool IsAttached { get; private set; }
+        public event EventHandler<HookEventArgs> MessageReceived;
+
+        public void Attach()
+        {
+            if (IsAttached)
+            {
+                return;
+            }
+
+            _hookId = User32.SetWindowsHookEx(WindowsHook.KEYBOARD, HookCallback, Kernel32.GetModuleHandle("user32"), 0);
+            if (_hookId == IntPtr.Zero)
+            {
+                throw new Win32Exception();
+            }
+            IsAttached = true;
+            Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");
+        }
+
+        public void Detach()
+        {
+            if (!IsAttached)
+            {
+                return;
+            }
+
+            User32.UnhookWindowsHookEx(_hookId);
+
+            IsAttached = false;
+            Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");
+        }
+    }
+}

RetailCoder.VBE/Common/KeyboardHookWrapper.cs

@@ -0,0 +1,71 @@
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using Rubberduck.Common.WinAPI;
+
+namespace Rubberduck.Common
+{
+    public class MouseHook : IAttachable
+    {
+        private IntPtr _hookId;
+
+        private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
+        {
+            if (nCode >= 0)
+            {
+                var button = (WM)wParam;
+                if (button == WM.RBUTTONDOWN || button == WM.LBUTTONDOWN)
+                {
+                    // handle right-click to evaluate commands' CanExecute before the context menu is shown;
+                    // handle left-click to do the same before the Rubberduck menu is drawn, too.
+                    OnMessageReceived();
+                }
+            }
+
+            return User32.CallNextHookEx(_hookId, nCode, wParam, lParam);
+        }
+
+        private void OnMessageReceived()
+        {
+            var handler = MessageReceived;
+            if (handler != null)
+            {
+                handler.Invoke(this, HookEventArgs.Empty);
+            }
+        }
+
+        public bool IsAttached { get; private set; }
+        public event EventHandler<HookEventArgs> MessageReceived;
+
+        public void Attach()
+        {
+            if (IsAttached)
+            {
+                return;
+            }
+
+            _hookId = User32.SetWindowsHookEx(WindowsHook.MOUSE, HookCallback, Kernel32.GetModuleHandle("user32"), 0);
+            if (_hookId == IntPtr.Zero)
+            {
+                throw new Win32Exception();
+            }
+
+
+            IsAttached = true;
+            Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");
+        }
+
+        public void Detach()
+        {
+            if (!IsAttached)
+            {
+                return;
+            }
+
+            User32.UnhookWindowsHookEx(_hookId);
+
+            IsAttached = false;
+            Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");
+        }
+    }
+}