Merge pull request #1259 from retailcoder/next

Hotkeys work

Author: retailcoder

RetailCoder.VBE/API/ParserState.cs

@@ -9,29 +9,33 @@
 namespace Rubberduck.API
 {
     [ComVisible(true)]
-    [InterfaceType(ComInterfaceType.InterfaceIsDual)]
     public interface IParserState
     {
         void Initialize(VBE vbe);
 
         void Parse();
         void BeginParse();
 
-        Declaration[] AllDeclarations 
-        {
-            get; 
-        }
+        Declaration[] AllDeclarations { get; }
+        Declaration[] UserDeclarations { get; }
+    }
 
-        Declaration[] UserDeclarations
-        {
-            get;
-        }
+    [ComVisible(true)]
+    [Guid("3D8EAA28-8983-44D5-83AF-2EEC4C363079")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
+    public interface IParserStateEvents
+    {
+        void OnParsed();
+        void OnReady();
+        void OnError();
     }
 
     [ComVisible(true)]
     [Guid(ClassId)]
     [ProgId(ProgId)]
+    [ClassInterface(ClassInterfaceType.AutoDual)]
     [ComDefaultInterface(typeof(IParserState))]
+    [ComSourceInterfaces(typeof(IParserStateEvents))]
     [EditorBrowsable(EditorBrowsableState.Always)]
     public class ParserState : IParserState
     {
@@ -73,6 +77,10 @@ public void BeginParse()
             _state.OnParseRequested(this);
         }
 
+        public event Action OnParsed;
+        public event Action OnReady;
+        public event Action OnError;
+
         private void _state_StateChanged(object sender, System.EventArgs e)
         {
             _allDeclarations = _state.AllDeclarations
@@ -82,6 +90,24 @@ private void _state_StateChanged(object sender, System.EventArgs e)
             _userDeclarations = _state.AllUserDeclarations
                                      .Select(item => new Declaration(item))
                                      .ToArray();
+
+            var errorHandler = OnError;
+            if (_state.Status == Parsing.VBA.ParserState.Error && errorHandler != null)
+            {
+                errorHandler.Invoke();
+            }
+
+            var parsedHandler = OnParsed;
+            if (_state.Status == Parsing.VBA.ParserState.Parsed && parsedHandler != null)
+            {
+                parsedHandler.Invoke();
+            }
+
+            var readyHandler = OnReady;
+            if (_state.Status == Parsing.VBA.ParserState.Ready && readyHandler != null)
+            {
+                readyHandler.Invoke();
+            }
         }
 
         private Declaration[] _allDeclarations;

RetailCoder.VBE/App.cs

@@ -6,6 +6,7 @@
 using System.Runtime.InteropServices.ComTypes;
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using System.Windows.Input;
 using Microsoft.Vbe.Interop;
 using NLog;
 using Rubberduck.Common;
@@ -17,6 +18,9 @@
 using Rubberduck.UI.Command.MenuItems;
 using Infralution.Localization.Wpf;
 using Rubberduck.Common.Dispatch;
+using Rubberduck.Common.Hotkeys;
+using Rubberduck.UI.Command;
+using Hotkey = Rubberduck.Common.Hotkeys.Hotkey;
 
 namespace Rubberduck
 {
@@ -31,6 +35,7 @@ public class App : IDisposable
         private readonly RubberduckCommandBar _stateBar;
         private readonly IIndenter _indenter;
         private readonly IRubberduckHooks _hooks;
+        private readonly IEnumerable<ICommand> _appCommands;
 
         private readonly Logger _logger;
 
@@ -40,15 +45,21 @@ public class App : IDisposable
         private readonly int _projectsEventsCookie;
 
         private readonly IDictionary<VBComponents, Tuple<IConnectionPoint, int>>  _componentsEventsConnectionPoints = 
-            new Dictionary<VBComponents, Tuple<IConnectionPoint, int>>(); 
+            new Dictionary<VBComponents, Tuple<IConnectionPoint, int>>();
+
+        private IReadOnlyDictionary<string, RubberduckHotkey> _hotkeyNameMap;
+
+        private IReadOnlyDictionary<RubberduckHotkey, ICommand> _hotkeyActions;
+        private IReadOnlyDictionary<string, ICommand> _secondKeyActions;
 
         public App(VBE vbe, IMessageBox messageBox,
             IRubberduckParser parser,
             IGeneralConfigService configService,
             IAppMenu appMenus,
             RubberduckCommandBar stateBar,
-            IIndenter indenter/*
-            IRubberduckHooks hooks*/)
+            IIndenter indenter,
+            IRubberduckHooks hooks,
+            IEnumerable<ICommand> appCommands)
         {
             _vbe = vbe;
             _messageBox = messageBox;
@@ -58,10 +69,11 @@ IIndenter indenter/*
             _appMenus = appMenus;
             _stateBar = stateBar;
             _indenter = indenter;
-            //_hooks = hooks;
+            _hooks = hooks;
+            _appCommands = appCommands;
             _logger = LogManager.GetCurrentClassLogger();
 
-            //_hooks.MessageReceived += hooks_MessageReceived;
+            _hooks.MessageReceived += hooks_MessageReceived;
             _configService.LanguageChanged += ConfigServiceLanguageChanged;
             _parser.State.StateChanged += Parser_StateChanged;
             _stateBar.Refresh += _stateBar_Refresh;
@@ -81,6 +93,18 @@ IIndenter indenter/*
             UiDispatcher.Initialize();
         }
 
+        public void Startup()
+        {
+            CleanReloadConfig();
+
+            _appMenus.Initialize();
+            _appMenus.Localize();
+
+            //_hooks.AddHook(new LowLevelKeyboardHook(_vbe));
+            HookHotkeys();
+            _hooks.Attach();
+        }
+
         async void sink_ProjectRemoved(object sender, DispatcherEventArgs<VBProject> e)
         {
             Debug.WriteLine(string.Format("Project '{0}' was removed.", e.Item.Name));
@@ -220,56 +244,68 @@ async void sink_ProjectActivated(object sender, DispatcherEventArgs<VBProject> e
         private bool _isAwaitingTwoStepKey;
         private bool _skipKeyUp;
 
-        private async void hooks_MessageReceived(object sender, HookEventArgs e)
+        private void hooks_MessageReceived(object sender, HookEventArgs e)
         {
             if (sender is LowLevelKeyboardHook)
             {
-                if (_skipKeyUp)
-                {
-                    _skipKeyUp = false;
-                    return;
-                }
-
-                if (_isAwaitingTwoStepKey)
-                {
-                    // todo: use _firstStepHotKey and e.Key to run 2-step hotkey action
-                    if (_firstStepHotKey == Keys.I && e.Key == Keys.M)
-                    {
-                        _indenter.IndentCurrentModule();
-                    }
-
-                    AwaitNextKey();
-                    return;
-                }
-
-                var component = _vbe.ActiveCodePane.CodeModule.Parent;
-                _parser.ParseComponent(component);
-
-                AwaitNextKey();
+                HandleLowLevelKeyhook(e);
                 return;
             }
-
-            var hotKey = sender as IHotKey;
-            if (hotKey == null)
+            
+            var hotKey = sender as IHotkey;
+            if (hotKey != null)
+            {
+                HandleHotkey(hotKey);
+            }
+            else
             {
                 AwaitNextKey();
-                return;
             }
+        }
 
-            if (hotKey.IsTwoStepHotKey)
+        private void HandleHotkey(IHotkey hotkey)
+        {
+            if (hotkey.IsTwoStepHotkey)
             {
-                _firstStepHotKey = hotKey.HotKeyInfo.Keys;
-                AwaitNextKey(true, hotKey.HotKeyInfo);
+                _firstStepHotKey = hotkey.HotkeyInfo.Keys;
+                AwaitNextKey(true, hotkey.HotkeyInfo);
             }
             else
             {
-                // todo: use e.Key to run 1-step hotkey action
                 _firstStepHotKey = Keys.None;
+                _hotkeyActions[_hotkeyNameMap[hotkey.Key]].Execute(null);
+                AwaitNextKey();
+            }
+        }
+
+        private void HandleLowLevelKeyhook(HookEventArgs e)
+        {
+            if (_skipKeyUp)
+            {
+                _skipKeyUp = false;
+                return;
+            }
+
+            if (_isAwaitingTwoStepKey)
+            {
+                // todo: use _firstStepHotKey and e.Key to run 2-step hotkey action
+                if (_firstStepHotKey == Keys.I && e.Key == Keys.M)
+                {
+                    _indenter.IndentCurrentModule();
+                }
+
                 AwaitNextKey();
+                return;
             }
+
+            var component = _vbe.ActiveCodePane.CodeModule.Parent;
+            _parser.ParseComponent(component);
+
+            AwaitNextKey();
+            return;
         }
 
-        private void AwaitNextKey(bool eatNextKey = false, HotKeyInfo info = default(HotKeyInfo))
+        private void AwaitNextKey(bool eatNextKey = false, HotkeyInfo info = default(HotkeyInfo))
         {
             _isAwaitingTwoStepKey = eatNextKey;
             foreach (var hook in _hooks.Hooks.OfType<ILowLevelKeyboardHook>())
@@ -299,22 +335,42 @@ private void Parser_StateChanged(object sender, EventArgs e)
             _appMenus.EvaluateCanExecute(_parser.State);
         }
 
-        public void Startup()
+        private void HookHotkeys()
         {
-            CleanReloadConfig();
-
-            _appMenus.Initialize();
-            _appMenus.Localize();
-
-            //_hooks.AddHook(new LowLevelKeyboardHook(_vbe));
-            //_hooks.AddHook(new HotKey((IntPtr)_vbe.MainWindow.HWnd, "%^R", Keys.R));
-            //_hooks.AddHook(new HotKey((IntPtr)_vbe.MainWindow.HWnd, "%^I", Keys.I));
-            //_hooks.Attach();
+            var settings = _config.UserSettings.GeneralSettings.HotkeySettings;
+            foreach (var hotkey in settings.Where(hotkey => hotkey.IsEnabled))
+            {
+                _hooks.AddHook(new Hotkey((IntPtr)_vbe.MainWindow.HWnd, hotkey.ToString()));
+            }
         }
 
         private void CleanReloadConfig()
         {
             LoadConfig();
+            var hotkeys = _config.UserSettings.GeneralSettings.HotkeySettings
+                .Where(hotkey => hotkey.IsEnabled).ToList();
+
+            _hotkeyNameMap = hotkeys
+                .ToDictionary(
+                    hotkey => hotkey.ToString(),
+                    hotkey => (RubberduckHotkey)Enum.Parse(typeof(RubberduckHotkey), hotkey.Name));
+
+            _hotkeyActions = (from hotkey in hotkeys
+                             let value = (RubberduckHotkey)Enum.Parse(typeof(RubberduckHotkey),hotkey.Name)
+                             where string.IsNullOrEmpty(hotkey.Key2)
+                             select new
+                             {
+                                 Hotkey = value, 
+                                 Command = _appCommands.OfType<IHotkeyCommand>()
+                                 .SingleOrDefault(command => command.Hotkey == (RubberduckHotkey)Enum.Parse(typeof(RubberduckHotkey),hotkey.Name))
+                             })
+                             .ToDictionary(kvp => kvp.Hotkey, kvp => (ICommand)kvp.Command);
+                             
+            _secondKeyActions = hotkeys
+                .Where(hotkey => !string.IsNullOrEmpty(hotkey.Key2))
+                .ToDictionary(
+                    hotkey => hotkey.Key2,
+                    hotkey => hotkey.Command);
         }
 
         private void ConfigServiceLanguageChanged(object sender, EventArgs e)
@@ -354,8 +410,8 @@ public void Dispose()
                 item.Value.Item1.Unadvise(item.Value.Item2);
             }
 
-            //_hooks.MessageReceived -= hooks_MessageReceived;
-            //_hooks.Dispose();
+            _hooks.MessageReceived -= hooks_MessageReceived;
+            _hooks.Dispose();
         }
     }
 }

RetailCoder.VBE/Common/HotKey.cs renamed to RetailCoder.VBE/Common/Hotkeys/Hotkey.cs

@@ -1,32 +1,31 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
 using System.Windows.Forms;
 using Rubberduck.Common.WinAPI;
 
-namespace Rubberduck.Common
+namespace Rubberduck.Common.Hotkeys
 {
-    public class HotKey : IHotKey
+    public class Hotkey : IHotkey
     {
         private readonly string _key;
         private readonly IntPtr _hWndVbe;
 
-        public HotKey(IntPtr hWndVbe, string key, Keys secondKey = Keys.None)
+        public Hotkey(IntPtr hWndVbe, string key, Keys secondKey = Keys.None)
         {
             _hWndVbe = hWndVbe;
 
-            IsTwoStepHotKey = secondKey != Keys.None;
+            IsTwoStepHotkey = secondKey != Keys.None;
             _key = key;
             Combo = GetCombo(key);
             SecondKey = secondKey;
         }
 
-        public HotKeyInfo HotKeyInfo { get; private set; }
+        public string Key { get { return _key; } }
+        public HotkeyInfo HotkeyInfo { get; private set; }
         public Keys Combo { get; private set; }
         public Keys SecondKey { get; private set; }
-        public bool IsTwoStepHotKey { get; private set; }
+        public bool IsTwoStepHotkey { get; private set; }
         public bool IsAttached { get; private set; }
 
         public void Attach()
@@ -50,8 +49,8 @@ public void Detach()
                 throw new InvalidOperationException("Hook is already detached.");
             }
 
-            User32.UnregisterHotKey(_hWndVbe, HotKeyInfo.HookId);
-            Kernel32.GlobalDeleteAtom(HotKeyInfo.HookId);
+            User32.UnregisterHotKey(_hWndVbe, HotkeyInfo.HookId);
+            Kernel32.GlobalDeleteAtom(HotkeyInfo.HookId);
 
             IsAttached = false;
         }
@@ -70,7 +69,7 @@ private void HookKey(Keys key, uint shift)
                 throw new Win32Exception("HotKey was not registered.");
             }
 
-            HotKeyInfo = new HotKeyInfo(hookId, Combo);
+            HotkeyInfo = new HotkeyInfo(hookId, Combo);
             IsAttached = true;
         }
 
@@ -111,9 +110,7 @@ private static uint GetModifierValue(ref string key)
 
         private static Keys GetCombo(string key)
         {
-            var combo = key;
-            var modifiers = GetModifierValue(ref combo);
-            return (Keys)Enum.Parse(typeof(Keys), combo) // will break with special keys, e.g. {f12}
+            return (Keys)Enum.Parse(typeof(Keys), key.Trim('%', '^', '+')) // will break with special keys, e.g. {f12}
                    | (key.Contains("%") ? Keys.Alt : Keys.None)
                    | (key.Contains("^") ? Keys.Control : Keys.None)
                    | (key.Contains("+") ? Keys.Shift : Keys.None);