Merge branch 'CodeExplorer' of https://github.com/retailcoder/Rubberduck.git

Author: retailcoder

README.md

@@ -105,6 +105,16 @@ LibGit2Sharp is the library that has allowed us to integrate Git right into the
 
 Which basically means it's a reimplementation of Git in C. It also [happens to be the technology Microsoft uses for their own Git integration with Visual Studio](http://www.hanselman.com/blog/GitSupportForVisualStudioGitTFSAndVSPutIntoContext.aspx).
 
+###[Smart Indenter](http://www.oaltd.co.uk/Indenter/)
+
+**What is Smart Indenter?**
+
+> *The Smart Indenter is a utility to tidy up VBA code by rebuilding the indentation of each line. Most developers naturally indent code within control structures, such as For...Next, If...End If, etc. Many developers also indent all the code within a procedure, to ease identification of line labels, error handling blocks etc. From that point on, there is much more variety in indenting styles, ranging from how to treat declaration lines to handling end-of-line comments.*
+
+The Rubberduck project was graciously offered the source code for this formidable tool by Stephen Bullen and Rob Bovey. We've translated the VB6 source code to C# and embedded a managed indenting API that Rubberduck calls into, while decoupling the indenter logic from the Windows Registry so we could store indenter options together with the Rubberduck settings, and configure the indenter from Rubberduck's options dialog.
+
+If you're already using Smart Indenter, Rubberduck's options dialog allow importing the settings from the registry. If we did our part well, you can uninstall Smart Indenter after installing Rubberduck 2.0, and still benefit from the smartest indenting tool available for VBA.
+
 ##Icons
 
 We didn't come up with these icons ourselves! Here's who did what:

RetailCoder.VBE/App.cs

@@ -1,9 +1,7 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
-using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
@@ -13,6 +11,7 @@
 using Rubberduck.Inspections;
 using Rubberduck.Parsing;
 using Rubberduck.Settings;
+using Rubberduck.SmartIndenter;
 using Rubberduck.UI;
 using Rubberduck.UI.Command.MenuItems;
 using Rubberduck.UI.ParserErrors;
@@ -30,7 +29,8 @@ public class App : IDisposable
         private readonly IGeneralConfigService _configService;
         private readonly IAppMenu _appMenus;
         private readonly ParserStateCommandBar _stateBar;
-        private readonly IKeyHook _hook;
+        private readonly IIndenter _indenter;
+        private readonly IRubberduckHooks _hooks;
 
         private readonly Logger _logger;
 
@@ -46,7 +46,8 @@ public App(VBE vbe, IMessageBox messageBox,
             IGeneralConfigService configService,
             IAppMenu appMenus,
             ParserStateCommandBar stateBar,
-            IKeyHook hook)
+            IIndenter indenter,
+            IRubberduckHooks hooks)
         {
             _vbe = vbe;
             _messageBox = messageBox;
@@ -56,36 +57,104 @@ public App(VBE vbe, IMessageBox messageBox,
             _configService = configService;
             _appMenus = appMenus;
             _stateBar = stateBar;
-            _hook = hook;
+            _indenter = indenter;
+            _hooks = hooks;
             _logger = LogManager.GetCurrentClassLogger();
 
-            _hook.KeyPressed += _hook_KeyPressed;
+            _hooks.MessageReceived += hooks_MessageReceived;
             _configService.SettingsChanged += _configService_SettingsChanged;
             _parser.State.StateChanged += Parser_StateChanged;
             _stateBar.Refresh += _stateBar_Refresh;
         }
 
-        private void _stateBar_Refresh(object sender, EventArgs e)
+        private Keys _firstStepHotKey;
+        private bool _isAwaitingTwoStepKey;
+        private bool _skipKeyUp;
+
+        private async 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;
+                ParseComponentAsync(component);
+
+                AwaitNextKey();
+                return;
+            }
+
+            var hotKey = sender as IHotKey;
+            if (hotKey == null)
+            {
+                AwaitNextKey();
+                return;
+            }
+
+            if (hotKey.IsTwoStepHotKey)
+            {
+                _firstStepHotKey = hotKey.HotKeyInfo.Keys;
+                AwaitNextKey(true, hotKey.HotKeyInfo);
+            }
+            else
+            {
+                // todo: use e.Key to run 1-step hotkey action
+                _firstStepHotKey = Keys.None;
+                AwaitNextKey();
+            }
+        }
+
+        private void AwaitNextKey(bool eatNextKey = false, HotKeyInfo info = default(HotKeyInfo))
         {
-            Task.Run(() => ParseAll());
+            _isAwaitingTwoStepKey = eatNextKey;
+            foreach (var hook in _hooks.Hooks.OfType<ILowLevelKeyboardHook>())
+            {
+                hook.EatNextKey = eatNextKey;
+            }
+
+            _skipKeyUp = eatNextKey;
+            if (eatNextKey)
+            {
+                _stateBar.SetStatusText("(" + info + ") was pressed. Waiting for second key...");
+            }
+            else
+            {
+                _stateBar.SetStatusText(_parser.State.Status.ToString());
+            }
         }
 
-        private void Parser_StateChanged(object sender, EventArgs e)
+        private void _stateBar_Refresh(object sender, EventArgs e)
         {
-            _appMenus.EvaluateCanExecute(_parser.State);
+            ParseAll();
         }
 
-        private async void _hook_KeyPressed(object sender, KeyHookEventArgs e)
+        private void Parser_StateChanged(object sender, EventArgs e)
         {
-            await ParseComponentAsync(e.Component);
+            _appMenus.EvaluateCanExecute(_parser.State);
         }
 
-        private async Task ParseComponentAsync(VBComponent component, bool resolve = true)
+        private void ParseComponentAsync(VBComponent component, bool resolve = true)
         {
             var tokenSource = RenewTokenSource(component);
 
             var token = tokenSource.Token;
-            await _parser.ParseAsync(component, token);
+            _parser.ParseAsync(component, token);
 
             if (resolve && !token.IsCancellationRequested)
             {
@@ -102,8 +171,11 @@ private CancellationTokenSource RenewTokenSource(VBComponent component)
             {
                 CancellationTokenSource existingTokenSource;
                 _tokenSources.TryRemove(component, out existingTokenSource);
-                existingTokenSource.Cancel();
-                existingTokenSource.Dispose();
+                if (existingTokenSource != null)
+                {
+                    existingTokenSource.Cancel();
+                    existingTokenSource.Dispose();
+                }
             }
 
             var tokenSource = new CancellationTokenSource();
@@ -124,15 +196,18 @@ public void Startup()
                 ParseAll();
             });
 
-            _hook.Attach();
+            //_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();
         }
 
         private void ParseAll()
         {
             var components = _vbe.VBProjects.Cast<VBProject>()
                 .SelectMany(project => project.VBComponents.Cast<VBComponent>());
 
-            var result = Parallel.ForEach(components, async component => { await ParseComponentAsync(component, false); });
+            var result = Parallel.ForEach(components, component => { ParseComponentAsync(component, false); });
 
             if (result.IsCompleted)
             {
@@ -182,10 +257,12 @@ private void Setup()
 
         public void Dispose()
         {
-            _hook.KeyPressed -= _hook_KeyPressed;
+            _hooks.MessageReceived -= hooks_MessageReceived;
             _configService.SettingsChanged -= _configService_SettingsChanged;
             _parser.State.StateChanged -= Parser_StateChanged;
 
+            _hooks.Dispose();
+
             if (_tokenSources.Any())
             {
                 foreach (var tokenSource in _tokenSources)

RetailCoder.VBE/Common/HookEventArgs.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Windows.Forms;
+
+namespace Rubberduck.Common
+{
+    public class HookEventArgs : EventArgs
+    {
+        private readonly Keys _key;
+        private static readonly Lazy<HookEventArgs> _empty = new Lazy<HookEventArgs>(() => new HookEventArgs(Keys.None));
+
+        public HookEventArgs(Keys key)
+        {
+            _key = key;
+        }
+
+        public Keys Key { get { return _key; } }
+
+        public new static HookEventArgs Empty {get { return _empty.Value; }}
+    }
+}