Merge pull request #1323 from retailcoder/next

retailcoder · retailcoder · commit eb79c9ca741e · 2016-04-14T02:37:13.000-04:00
added "current selection" to Rubberduck command bar
diff --git a/RetailCoder.VBE/App.cs b/RetailCoder.VBE/App.cs
@@ -85,7 +85,7 @@ public App(VBE vbe, IMessageBox messageBox,
             _hookActions = new Dictionary<Type, Action>
             {
                 { typeof(MouseHook), HandleMouseMessage },
-                //{ typeof(KeyboardHook), HandleKeyboardMessage },
+                { typeof(KeyboardHook), HandleKeyboardMessage },
             };
             
             
@@ -104,17 +104,18 @@ private void _hooks_MessageReceived(object sender, HookEventArgs e)
 
         private void HandleMouseMessage()
         {
-            _appMenus.EvaluateCanExecute(_parser.State);
+            RefreshSelection();
         }
 
         private void HandleKeyboardMessage()
         {
-            var pane = _vbe.ActiveCodePane;
-            if (pane == null)
-            {
-                return;
-            }
-            _parser.State.OnParseRequested(this, pane.CodeModule.Parent);
+            RefreshSelection();
+        }
+
+        private void RefreshSelection()
+        {
+            _stateBar.SetSelectionText(_parser.State.FindSelectedDeclaration(_vbe.ActiveCodePane));
+            _appMenus.EvaluateCanExecute(_parser.State);
         }
 
         private void _configService_SettingsChanged(object sender, EventArgs e)
diff --git a/RetailCoder.VBE/Common/KeyboardHook.cs b/RetailCoder.VBE/Common/KeyboardHook.cs
@@ -1,6 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
 using Microsoft.Vbe.Interop;
 using Rubberduck.Common.WinAPI;
 
@@ -19,13 +23,29 @@ public KeyboardHook(VBE vbe)
             _callback = HookCallback;
         }
 
+        // keys that don't modify anything in the code pane but the current selection
+        private static readonly IReadOnlyList<Keys> NavigationKeys = new[]
+        {
+            Keys.Down,
+            Keys.Up,
+            Keys.Left,
+            Keys.Right,
+            Keys.PageDown,
+            Keys.PageUp,
+            Keys.Home,
+            Keys.End,
+        };
+
         private int _lastLineIndex;
         private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
         {
             try
             {
                 var pane = _vbe.ActiveCodePane;
-                if (User32.IsVbeWindowActive((IntPtr)_vbe.MainWindow.HWnd) && pane != null && (WM)wParam == WM.KEYUP)
+                if ((WM)wParam == WM.KEYDOWN
+                    && pane != null
+                    && NavigationKeys.Contains((Keys)Marshal.ReadInt32(lParam)) 
+                    && User32.IsVbeWindowActive((IntPtr)_vbe.MainWindow.HWnd))
                 {
                     int startLine;
                     int endLine;
@@ -36,11 +56,9 @@ private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
                     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)
                         {
-                            //var key = (Keys)Marshal.ReadInt32(lParam);
                             OnMessageReceived();
                         }
                     }
diff --git a/RetailCoder.VBE/Common/MouseHook.cs b/RetailCoder.VBE/Common/MouseHook.cs
@@ -41,7 +41,7 @@ private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
                 Debug.WriteLine(exception);
             }
 
-            return IntPtr.Zero;
+            return User32.CallNextHookEx(_hookId, nCode, wParam, lParam);
         }
 
         private void OnMessageReceived()
@@ -85,12 +85,14 @@ public void Detach()
                 return;
             }
 
+            IsAttached = false;
             if (!User32.UnhookWindowsHookEx(_hookId))
             {
+                _hookId = IntPtr.Zero;
                 throw new Win32Exception();
             }
 
-            IsAttached = false;
+            _hookId = IntPtr.Zero;
             Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");
         }
     }
diff --git a/RetailCoder.VBE/Common/RubberduckHooks.cs b/RetailCoder.VBE/Common/RubberduckHooks.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -44,7 +45,7 @@ public void HookHotkeys()
             var config = _config.LoadConfiguration();
             var settings = config.UserSettings.GeneralSettings.HotkeySettings;
 
-            //AddHook(new KeyboardHook(_vbe));
+            AddHook(new KeyboardHook(_vbe));
             AddHook(new MouseHook(_vbe));
             foreach (var hotkey in settings.Where(hotkey => hotkey.IsEnabled))
             {
@@ -91,7 +92,7 @@ public void Attach()
 
                 IsAttached = true;
             }
-            catch (Exception exception)
+            catch (Win32Exception exception)
             {
                 Debug.WriteLine(exception);
             }
@@ -111,13 +112,12 @@ public void Detach()
                     hook.Detach();
                     hook.MessageReceived -= hook_MessageReceived;
                 }
-
-                IsAttached = false;
             }
-            catch (Exception exception)
+            catch (Win32Exception exception)
             {
                 Debug.WriteLine(exception);
             }
+            IsAttached = false;
         }
 
         private void hook_MessageReceived(object sender, HookEventArgs e)
@@ -166,9 +166,9 @@ private IntPtr WindowProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam)
                             suppress = HandleHotkeyMessage(wParam);
                             break;
 
-                        //case WM.ACTIVATEAPP:
-                        //    HandleActivateAppMessage(wParam);
-                        //    break;
+                        case WM.ACTIVATEAPP:
+                            HandleActivateAppMessage(wParam);
+                            break;
                     }
                 }
 
diff --git a/RetailCoder.VBE/UI/Command/MenuItems/RubberduckCommandBar.cs b/RetailCoder.VBE/UI/Command/MenuItems/RubberduckCommandBar.cs
@@ -2,9 +2,13 @@
 using System.Diagnostics;
 using Microsoft.Office.Core;
 using Microsoft.Vbe.Interop;
+using Rubberduck.Parsing.Symbols;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Properties;
 using Rubberduck.UI.Command.MenuItems.ParentMenus;
+using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.VBEInterfaces.RubberduckCodePane;
+using ParserState = Rubberduck.Parsing.VBA.ParserState;
 
 namespace Rubberduck.UI.Command.MenuItems
 {
@@ -16,6 +20,7 @@ public class RubberduckCommandBar
 
         private CommandBarButton _refreshButton;
         private CommandBarButton _statusButton;
+        private CommandBarButton _selectionButton;
 
         public RubberduckCommandBar(RubberduckParserState state, VBE vbe, IShowParserErrorsCommand command)
         {
@@ -36,13 +41,38 @@ private void _statusButton_Click(CommandBarButton Ctrl, ref bool CancelDefault)
 
         public void SetStatusText(string value = null)
         {
-            _statusButton.Caption = value ?? RubberduckUI.ResourceManager.GetString("ParserState_" + _state.Status);
+            UiDispatcher.Invoke(() => _statusButton.Caption = value ?? RubberduckUI.ResourceManager.GetString("ParserState_" + _state.Status));
+        }
+
+        public void SetSelectionText(Declaration declaration)
+        {
+            UiDispatcher.Invoke(() =>
+            {
+                if (declaration == null && _vbe.ActiveCodePane != null)
+                {
+                    var selection = _vbe.ActiveCodePane.GetSelection();
+                    SetSelectionText(selection);
+                }
+                else if (declaration != null)
+                {
+                    _selectionButton.Caption = string.Format("{0} ({1}): {2} ({3})", 
+                        declaration.QualifiedName.QualifiedModuleName,
+                        declaration.QualifiedSelection.Selection,
+                        declaration.IdentifierName,
+                        RubberduckUI.ResourceManager.GetString("DeclarationType_" + declaration.DeclarationType));
+                }
+            });
+        }
+
+        private void SetSelectionText(QualifiedSelection selection)
+        {
+            UiDispatcher.Invoke(() => _selectionButton.Caption = selection.ToString());
         }
 
         private void State_StateChanged(object sender, EventArgs e)
         {
             Debug.WriteLine("RubberduckCommandBar handles StateChanged...");
-            UiDispatcher.Invoke(() => SetStatusText(RubberduckUI.ResourceManager.GetString("ParserState_" + _state.Status)));
+            SetStatusText(RubberduckUI.ResourceManager.GetString("ParserState_" + _state.Status));
         }
 
         public event EventHandler Refresh;
@@ -72,6 +102,11 @@ public void Initialize()
             _statusButton.Tag = "Status";
             _statusButton.Click += _statusButton_Click;
 
+            _selectionButton = (CommandBarButton)commandbar.Controls.Add(MsoControlType.msoControlButton);
+            _selectionButton.Style = MsoButtonStyle.msoButtonCaption;
+            _selectionButton.BeginGroup = true;
+            _selectionButton.Enabled = false;
+
             commandbar.Visible = true;
         }
 
diff --git a/RetailCoder.VBE/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs b/RetailCoder.VBE/UI/Command/Refactorings/CodePaneRefactorRenameCommand.cs
@@ -33,7 +33,7 @@ public override bool CanExecute(object parameter)
             }
 
             var target = _state.FindSelectedDeclaration(Vbe.ActiveCodePane);
-            return _state.Status == ParserState.Ready && target != null;
+            return _state.Status == ParserState.Ready && target != null && !target.IsBuiltIn;
         }
 
         public override void Execute(object parameter)
diff --git a/Rubberduck.Parsing/VBA/RubberduckParser.cs b/Rubberduck.Parsing/VBA/RubberduckParser.cs
@@ -279,15 +279,18 @@ public void Resolve(CancellationToken token)
 
         private void ResolveInternal(CancellationToken token)
         {
-            if (!_state.HasAllParseTrees)
+            var components = _state.Projects
+                .Where(project => project.Protection == vbext_ProjectProtection.vbext_pp_none)
+                .SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();
+            if (!_state.HasAllParseTrees(components))
             {
                 return;
             }
 
             foreach (var kvp in _state.ParseTrees)
             {
                 var qualifiedName = kvp.Key;
-                if (_force || _state.IsModified(qualifiedName))
+                if (/*_force || _state.IsModified(qualifiedName)*/ true)
                 {
                     Debug.WriteLine(string.Format("Module '{0}' is new or was modified since last parse. Walking parse tree for declarations...", kvp.Key.ComponentName));
                     // modified module; walk parse tree and re-acquire all declarations
diff --git a/Rubberduck.Parsing/VBA/RubberduckParserState.cs b/Rubberduck.Parsing/VBA/RubberduckParserState.cs
@@ -415,7 +415,16 @@ public IParseTree GetParseTree(VBComponent component)
 
         public IEnumerable<KeyValuePair<QualifiedModuleName, IParseTree>> ParseTrees { get { return _parseTrees; } }
 
-        public bool HasAllParseTrees { get { return _moduleStates.Count == _parseTrees.Count; } }
+        public bool HasAllParseTrees(IReadOnlyList<VBComponent> expected)
+        {
+            var expectedModules = expected.Select(module => new QualifiedModuleName(module));
+            foreach (var module in _moduleStates.Keys.Where(item => !expectedModules.Contains(item)))
+            {
+                ClearDeclarations(module.Component);
+            }
+
+            return _parseTrees.Count == expected.Count;
+        }        
 
         public TokenStreamRewriter GetRewriter(VBComponent component)
         {
@@ -487,11 +496,19 @@ public Declaration FindSelectedDeclaration(CodePane activeCodePane)
 
             if (!selection.Equals(default(QualifiedSelection)))
             {
-                _selectedDeclaration = AllDeclarations
-                    .SingleOrDefault(item => item.DeclarationType != DeclarationType.Project &&
-                        item.DeclarationType != DeclarationType.ModuleOption &&
-                        (IsSelectedDeclaration(selection, item) ||
-                        item.References.Any(reference => IsSelectedReference(selection, reference))));
+                var matches = AllDeclarations
+                    .Where(item => item.DeclarationType != DeclarationType.Project &&
+                                   item.DeclarationType != DeclarationType.ModuleOption &&
+                                   (IsSelectedDeclaration(selection, item) ||
+                                    item.References.Any(reference => IsSelectedReference(selection, reference))));
+                try
+                {
+                    _selectedDeclaration = matches.SingleOrDefault();
+                }
+                catch (InvalidOperationException exception)
+                {
+                    Debug.WriteLine(exception);
+                }
             }
 
             if (_selectedDeclaration != null)
diff --git a/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs b/RubberduckTests/Inspections/ImplicitPublicMemberInspectionTests.cs
@@ -16,9 +16,10 @@ public class ImplicitPublicMemberInspectionTests
         [TestMethod]
         public void ImplicitPublicMember_ReturnsResult_Sub()
         {
-            const string inputCode =
-@"Sub Foo()
-End Sub";
+            const string inputCode = @"
+Sub Foo()
+End Sub
+";
 
             //Arrange
             var builder = new MockVbeBuilder();

Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public App(VBE vbe, IMessageBox messageBox,`
`85`	`85`	`_hookActions = new Dictionary<Type, Action>`
`86`	`86`	`{`
`87`	`87`	`{ typeof(MouseHook), HandleMouseMessage },`
`88`		`- //{ typeof(KeyboardHook), HandleKeyboardMessage },`
	`88`	`+ { typeof(KeyboardHook), HandleKeyboardMessage },`
`89`	`89`	`};`
`90`	`90`
`91`	`91`
`@@ -104,17 +104,18 @@ private void _hooks_MessageReceived(object sender, HookEventArgs e)`
`104`	`104`
`105`	`105`	`private void HandleMouseMessage()`
`106`	`106`	`{`
`107`		`- _appMenus.EvaluateCanExecute(_parser.State);`
	`107`	`+ RefreshSelection();`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`private void HandleKeyboardMessage()`
`111`	`111`	`{`
`112`		`- var pane = _vbe.ActiveCodePane;`
`113`		`- if (pane == null)`
`114`		`- {`
`115`		`- return;`
`116`		`- }`
`117`		`- _parser.State.OnParseRequested(this, pane.CodeModule.Parent);`
	`112`	`+ RefreshSelection();`
	`113`	`+ }`
	`114`	`+`
	`115`	`+ private void RefreshSelection()`
	`116`	`+ {`
	`117`	`+ _stateBar.SetSelectionText(_parser.State.FindSelectedDeclaration(_vbe.ActiveCodePane));`
	`118`	`+ _appMenus.EvaluateCanExecute(_parser.State);`
`118`	`119`	`}`
`119`	`120`
`120`	`121`	`private void _configService_SettingsChanged(object sender, EventArgs e)`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)`
`41`	`41`	`Debug.WriteLine(exception);`
`42`	`42`	`}`
`43`	`43`
`44`		`- return IntPtr.Zero;`
	`44`	`+ return User32.CallNextHookEx(_hookId, nCode, wParam, lParam);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`private void OnMessageReceived()`
`@@ -85,12 +85,14 @@ public void Detach()`
`85`	`85`	`return;`
`86`	`86`	`}`
`87`	`87`
	`88`	`+ IsAttached = false;`
`88`	`89`	`if (!User32.UnhookWindowsHookEx(_hookId))`
`89`	`90`	`{`
	`91`	`+ _hookId = IntPtr.Zero;`
`90`	`92`	`throw new Win32Exception();`
`91`	`93`	`}`
`92`	`94`
`93`		`- IsAttached = false;`
	`95`	`+ _hookId = IntPtr.Zero;`
`94`	`96`	`Debug.WriteLine("{0}: {1}", GetType().Name, IsAttached ? "Attached" : "Detached");`
`95`	`97`	`}`
`96`	`98`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.ComponentModel;`
`3`	`4`	`using System.Diagnostics;`
`4`	`5`	`using System.Linq;`
`5`	`6`	`using System.Runtime.InteropServices;`
`@@ -44,7 +45,7 @@ public void HookHotkeys()`
`44`	`45`	`var config = _config.LoadConfiguration();`
`45`	`46`	`var settings = config.UserSettings.GeneralSettings.HotkeySettings;`
`46`	`47`
`47`		`- //AddHook(new KeyboardHook(_vbe));`
	`48`	`+ AddHook(new KeyboardHook(_vbe));`
`48`	`49`	`AddHook(new MouseHook(_vbe));`
`49`	`50`	`foreach (var hotkey in settings.Where(hotkey => hotkey.IsEnabled))`
`50`	`51`	`{`
`@@ -91,7 +92,7 @@ public void Attach()`
`91`	`92`
`92`	`93`	`IsAttached = true;`
`93`	`94`	`}`
`94`		`- catch (Exception exception)`
	`95`	`+ catch (Win32Exception exception)`
`95`	`96`	`{`
`96`	`97`	`Debug.WriteLine(exception);`
`97`	`98`	`}`
`@@ -111,13 +112,12 @@ public void Detach()`
`111`	`112`	`hook.Detach();`
`112`	`113`	`hook.MessageReceived -= hook_MessageReceived;`
`113`	`114`	`}`
`114`		`-`
`115`		`- IsAttached = false;`
`116`	`115`	`}`
`117`		`- catch (Exception exception)`
	`116`	`+ catch (Win32Exception exception)`
`118`	`117`	`{`
`119`	`118`	`Debug.WriteLine(exception);`
`120`	`119`	`}`
	`120`	`+ IsAttached = false;`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`private void hook_MessageReceived(object sender, HookEventArgs e)`
`@@ -166,9 +166,9 @@ private IntPtr WindowProc(IntPtr hWnd, uint uMsg, IntPtr wParam, IntPtr lParam)`
`166`	`166`	`suppress = HandleHotkeyMessage(wParam);`
`167`	`167`	`break;`
`168`	`168`
`169`		`- //case WM.ACTIVATEAPP:`
`170`		`- // HandleActivateAppMessage(wParam);`
`171`		`- // break;`
	`169`	`+ case WM.ACTIVATEAPP:`
	`170`	`+ HandleActivateAppMessage(wParam);`
	`171`	`+ break;`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public override bool CanExecute(object parameter)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`var target = _state.FindSelectedDeclaration(Vbe.ActiveCodePane);`
`36`		`- return _state.Status == ParserState.Ready && target != null;`
	`36`	`+ return _state.Status == ParserState.Ready && target != null && !target.IsBuiltIn;`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`public override void Execute(object parameter)`
Original file line number	Diff line number	Diff line change
`@@ -279,15 +279,18 @@ public void Resolve(CancellationToken token)`
`279`	`279`
`280`	`280`	`private void ResolveInternal(CancellationToken token)`
`281`	`281`	`{`
`282`		`- if (!_state.HasAllParseTrees)`
	`282`	`+ var components = _state.Projects`
	`283`	`+ .Where(project => project.Protection == vbext_ProjectProtection.vbext_pp_none)`
	`284`	`+ .SelectMany(p => p.VBComponents.Cast<VBComponent>()).ToList();`
	`285`	`+ if (!_state.HasAllParseTrees(components))`
`283`	`286`	`{`
`284`	`287`	`return;`
`285`	`288`	`}`
`286`	`289`
`287`	`290`	`foreach (var kvp in _state.ParseTrees)`
`288`	`291`	`{`
`289`	`292`	`var qualifiedName = kvp.Key;`
`290`		`- if (_force \|\| _state.IsModified(qualifiedName))`
	`293`	`+ if (/_force \|\| _state.IsModified(qualifiedName)/ true)`
`291`	`294`	`{`
`292`	`295`	`Debug.WriteLine(string.Format("Module '{0}' is new or was modified since last parse. Walking parse tree for declarations...", kvp.Key.ComponentName));`
`293`	`296`	`// modified module; walk parse tree and re-acquire all declarations`