added LL Mouse hook to evaluate menu state on right-click, but it's throwing NRE during COM reflection when it's attached.. no idea why

retailcoder · retailcoder · commit 8b8deab6e768 · 2016-04-04T02:34:18.000-04:00
diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs
@@ -5,7 +5,6 @@
 using System.Linq;
 using System.Runtime.InteropServices.ComTypes;
 using System.Windows.Forms;
-using System.Windows.Input;
 using Microsoft.Vbe.Interop;
 using NLog;
 using Rubberduck.Common;
@@ -61,6 +60,7 @@ public App(VBE vbe, IMessageBox messageBox,
             _hooks = hooks;
             _logger = LogManager.GetCurrentClassLogger();
 
+            _hooks.MessageReceived += _hooks_MessageReceived;
             _configService.SettingsChanged += _configService_SettingsChanged;
             _configService.LanguageChanged += ConfigServiceLanguageChanged;
             _parser.State.StateChanged += Parser_StateChanged;
@@ -81,6 +81,15 @@ public App(VBE vbe, IMessageBox messageBox,
             UiDispatcher.Initialize();
         }
 
+        private void _hooks_MessageReceived(object sender, HookEventArgs e)
+        {
+            if (sender is LowLevelMouseHook)
+            {
+                // right-click detected
+                _appMenus.EvaluateCanExecute(_parser.State);
+            }
+        }
+
         private void _configService_SettingsChanged(object sender, EventArgs e)
         {
             // also updates the ShortcutKey text
diff --git a/RetailCoder.VBE/Common/LowLevelMouseHook.cs b/RetailCoder.VBE/Common/LowLevelMouseHook.cs
@@ -0,0 +1,64 @@
+using System;
+using Rubberduck.Common.WinAPI;
+
+namespace Rubberduck.Common
+{
+    public class LowLevelMouseHook : IAttachable, IDisposable
+    {
+        private IntPtr HookCallback(int code, IntPtr wParam, IntPtr lParam)
+        {
+            if (code >= 0 && (WM)wParam == WM.RBUTTONDOWN)
+            {
+                OnRightClickCaptured();
+            }
+            return User32.CallNextHookEx(_hookId, code, wParam, lParam);
+        }
+
+        public event EventHandler RightClickCaptured;
+        private void OnRightClickCaptured()
+        {
+            var handler = RightClickCaptured;
+            if (handler != null)
+            {
+                handler.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        //private const int WH_MOUSE_LL = 14;
+
+        private IntPtr _hookId = IntPtr.Zero;
+
+        public bool IsAttached { get; private set; }
+        public event EventHandler<HookEventArgs> MessageReceived;
+        public void Attach()
+        {
+            if (IsAttached)
+            {
+                return;
+            }
+
+            _hookId = User32.SetWindowsHookEx(WindowsHook.MOUSE_LL, HookCallback, Kernel32.GetModuleHandle("user32"), 0);
+            if (_hookId == IntPtr.Zero)
+            {
+                throw new System.ComponentModel.Win32Exception();
+            }
+
+            IsAttached = true;
+        }
+
+        public void Detach()
+        {
+            if (!IsAttached)
+            {
+                return;
+            }
+
+            IsAttached = !User32.UnhookWindowsHookEx(_hookId);
+        }
+
+        public void Dispose()
+        {
+            Detach();
+        }
+    }
+}
diff --git a/RetailCoder.VBE/Common/RubberduckHooks.cs b/RetailCoder.VBE/Common/RubberduckHooks.cs
@@ -19,6 +19,7 @@ public class RubberduckHooks : IRubberduckHooks
         private User32.WndProc _newWndProc;
 
         private readonly IAttachable _timerHook;
+        private readonly IAttachable _mouseHook;
         private readonly IGeneralConfigService _config;
         private readonly IList<IAttachable> _hooks = new List<IAttachable>();
 
@@ -31,16 +32,19 @@ public RubberduckHooks(VBE vbe, IAttachable timerHook, IGeneralConfigService con
             _oldWndPointer = User32.SetWindowLong(_mainWindowHandle, (int)WindowLongFlags.GWL_WNDPROC, _newWndProc);
             _oldWndProc = (User32.WndProc)Marshal.GetDelegateForFunctionPointer(_oldWndPointer, typeof(User32.WndProc));
 
-            _timerHook = timerHook;
             _config = config;
+            _timerHook = timerHook;
             _timerHook.MessageReceived += timerHook_MessageReceived;
         }
 
+
         public void HookHotkeys()
         {
             Detach();
             _hooks.Clear();
 
+            //AddHook(new LowLevelMouseHook()); // todo: understand how this line throws a NRE in COM reflection
+
             var config = _config.LoadConfiguration();
             var settings = config.UserSettings.GeneralSettings.HotkeySettings;
             foreach (var hotkey in settings.Where(hotkey => hotkey.IsEnabled))
@@ -89,12 +93,17 @@ public void Attach()
 
         private void hook_MessageReceived(object sender, HookEventArgs e)
         {
-            if (sender is ILowLevelKeyboardHook)
+            if (sender is LowLevelKeyboardHook)
             {
                 // todo: handle 2-step hotkeys?
                 return;
             }
 
+            if (sender is LowLevelMouseHook)
+            {
+                OnMessageReceived(sender, HookEventArgs.Empty);
+            }
+
             var hotkey = sender as IHotkey;
             if (hotkey != null)
             {
diff --git a/RetailCoder.VBE/Rubberduck.csproj b/RetailCoder.VBE/Rubberduck.csproj
@@ -298,6 +298,7 @@
     <Compile Include="Common\Hotkeys\IHotkey.cs" />
     <Compile Include="Common\ILowLevelKeyboardHook.cs" />
     <Compile Include="Common\IRubberduckHooks.cs" />
+    <Compile Include="Common\LowLevelMouseHook.cs" />
     <Compile Include="Common\ModuleExporter.cs" />
     <Compile Include="Common\RubberduckHooks.cs" />
     <Compile Include="Common\TimerHook.cs" />
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/CommandMenuItemBase.cs b/RetailCoder.VBE/UI/Command/MenuItems/CommandMenuItemBase.cs
@@ -36,7 +36,7 @@ public Func<string> Caption
         /// <remarks>Returns <c>true</c> if not overridden.</remarks>
         public virtual bool EvaluateCanExecute(RubberduckParserState state)
         {
-            return true;
+            return _command.CanExecute(state);
         }
 
         public virtual bool BeginGroup { get { return false; } }
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/ProjectExplorerRefactorRenameCommandMenuItem.cs b/RetailCoder.VBE/UI/Command/MenuItems/ProjectExplorerRefactorRenameCommandMenuItem.cs
@@ -1,5 +1,4 @@
 using System.Windows.Input;
-using Rubberduck.Parsing.VBA;
 using Rubberduck.UI.Command.MenuItems.ParentMenus;
 
 namespace Rubberduck.UI.Command.MenuItems
@@ -13,10 +12,5 @@ public ProjectExplorerRefactorRenameCommandMenuItem(ICommand command)
 
         public override string Key { get { return "RefactorMenu_Rename"; } }
         public override int DisplayOrder { get { return (int)RefactoringsMenuItemDisplayOrder.RenameIdentifier; } }
-
-        public override bool EvaluateCanExecute(RubberduckParserState state)
-        {
-            return state.Status == ParserState.Ready;
-        }
     }
 }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs
@@ -2,6 +2,7 @@
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 using System.Runtime.InteropServices;
+using NLog.Targets;
 using Rubberduck.Common;
 using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
@@ -24,6 +25,17 @@ public CodePaneRefactorRenameCommand(VBE vbe, RubberduckParserState state, IActi
             _wrapperWrapperFactory = wrapperWrapperFactory;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            if (Vbe.ActiveCodePane == null) { return false; }
+
+            var selection = Vbe.ActiveCodePane.GetSelection();
+            var target = _state.AllDeclarations.FindTarget(selection);
+
+            return _state.Status == ParserState.Ready
+                && target != null;
+        }
+
         public override void Execute(object parameter)
         {
             if (Vbe.ActiveCodePane == null) { return; }
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/FormDesignerRefactorRenameCommand.cs
@@ -24,6 +24,11 @@ public FormDesignerRefactorRenameCommand(VBE vbe, RubberduckParserState state, I
             _wrapperWrapperFactory = wrapperWrapperFactory;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            return _state.Status == ParserState.Ready;
+        }
+
         public override void Execute(object parameter)
         {
             using (var view = new RenameDialog())
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractMethodCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/RefactorExtractMethodCommand.cs
@@ -1,9 +1,13 @@
 using Microsoft.Vbe.Interop;
 using System.Runtime.InteropServices;
+using Antlr4.Runtime;
+using Rubberduck.Common;
+using Rubberduck.Parsing;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Refactorings.ExtractMethod;
 using Rubberduck.Settings;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
 
 namespace Rubberduck.UI.Command.Refactorings
 {
@@ -18,14 +22,24 @@ public RefactorExtractMethodCommand(VBE vbe, RubberduckParserState state, IActiv
             _state = state;
         }
 
+        public override bool CanExecute(object parameter)
+        {
+            if (Vbe.ActiveCodePane == null)
+            {
+                return false;
+            }
+
+            var selection = Vbe.ActiveCodePane.GetSelection();
+            var target = _state.AllDeclarations.FindSelectedDeclaration(selection, DeclarationExtensions.ProcedureTypes, d => ((ParserRuleContext)d.Context.Parent).GetSelection());
+            return _state.Status == ParserState.Ready && target != null;
+        }
+
         public override void Execute(object parameter)
         {
             var factory = new ExtractMethodPresenterFactory(Editor, _state.AllDeclarations);
             var refactoring = new ExtractMethodRefactoring(factory, Editor);
             refactoring.InvalidSelection += HandleInvalidSelection;
             refactoring.Refactor();
         }
-
-        public RubberduckHotkey Hotkey { get {return RubberduckHotkey.RefactorExtractMethod; } }
     }
 }
diff --git a/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs b/Rubberduck.Parsing/Symbols/ReferencedDeclarationsCollector.cs
@@ -98,12 +98,23 @@ public IEnumerable<Declaration> GetDeclarationsForReference(Reference reference)
 
             ITypeLib typeLibrary;
             LoadTypeLibEx(path, REGKIND.REGKIND_NONE, out typeLibrary);
+            if (typeLibrary == null)
+            {
+                yield break;
+            }
 
             var typeCount = typeLibrary.GetTypeInfoCount();
             for (var i = 0; i < typeCount; i++)
             {
                 ITypeInfo info;
-                typeLibrary.GetTypeInfo(i, out info);
+                try
+                {
+                    typeLibrary.GetTypeInfo(i, out info);
+                }
+                catch(NullReferenceException)
+                {
+                    yield break;
+                }
 
                 if (info == null)
                 {
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -158,7 +158,7 @@ private void ParseAll()
                 var references = projects.SelectMany(p => p.References.Cast<Reference>()).ToList();
                 foreach (var reference in references)
                 {
-                    var items = _comReflector.GetDeclarationsForReference(reference);
+                    var items = _comReflector.GetDeclarationsForReference(reference).ToList();
                     foreach (var declaration in items)
                     {
                         _state.AddDeclaration(declaration);

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public Func<string> Caption`
`36`	`36`	`/// <remarks>Returns <c>true</c> if not overridden.</remarks>`
`37`	`37`	`public virtual bool EvaluateCanExecute(RubberduckParserState state)`
`38`	`38`	`{`
`39`		`- return true;`
	`39`	`+ return _command.CanExecute(state);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`public virtual bool BeginGroup { get { return false; } }`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using System.Windows.Input;`
`2`		`-using Rubberduck.Parsing.VBA;`
`3`	`2`	`using Rubberduck.UI.Command.MenuItems.ParentMenus;`
`4`	`3`
`5`	`4`	`namespace Rubberduck.UI.Command.MenuItems`
`@@ -13,10 +12,5 @@ public ProjectExplorerRefactorRenameCommandMenuItem(ICommand command)`
`13`	`12`
`14`	`13`	`public override string Key { get { return "RefactorMenu_Rename"; } }`
`15`	`14`	`public override int DisplayOrder { get { return (int)RefactoringsMenuItemDisplayOrder.RenameIdentifier; } }`
`16`		`-`
`17`		`- public override bool EvaluateCanExecute(RubberduckParserState state)`
`18`		`- {`
`19`		`- return state.Status == ParserState.Ready;`
`20`		`- }`
`21`	`15`	`}`
`22`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,11 @@ public FormDesignerRefactorRenameCommand(VBE vbe, RubberduckParserState state, I`
`24`	`24`	`_wrapperWrapperFactory = wrapperWrapperFactory;`
`25`	`25`	`}`
`26`	`26`
	`27`	`+ public override bool CanExecute(object parameter)`
	`28`	`+ {`
	`29`	`+ return _state.Status == ParserState.Ready;`
	`30`	`+ }`
	`31`	`+`
`27`	`32`	`public override void Execute(object parameter)`
`28`	`33`	`{`
`29`	`34`	`using (var view = new RenameDialog())`