Merge pull request #4833 from bclothier/ComDisconnect

Introducing ComCommand classes

Author: retailcoder

Rubberduck.API/VBA/Parser.cs

@@ -70,7 +70,7 @@ public sealed class Parser : IParser, IDisposable
         private readonly RubberduckParserState _state;
         private readonly SynchronousParseCoordinator _parser;
         private readonly IVBE _vbe;
-        private readonly IVBEEvents _vbeEvents;
+        private readonly IVbeEvents _vbeEvents;
         private readonly IUiDispatcher _dispatcher;
         private readonly CancellationTokenSource _tokenSource;
 
@@ -91,7 +91,7 @@ internal Parser(object vbe) : this()
             }
 
             _vbe = RootComWrapperFactory.GetVbeWrapper(vbe);
-            _vbeEvents = VBEEvents.Initialize(_vbe);
+            _vbeEvents = VbeEvents.Initialize(_vbe);
             var declarationFinderFactory = new ConcurrentlyConstructedDeclarationFinderFactory();
             var projectRepository = new ProjectsRepository(_vbe);
             var projectsToBeLoadedFromComSelector = new ProjectsToResolveFromComProjectsSelector(projectRepository);

Rubberduck.Core/App.cs

@@ -12,6 +12,7 @@
 using System.Linq;
 using Rubberduck.Parsing.UIContext;
 using Rubberduck.Resources;
+using Rubberduck.Runtime;
 using Rubberduck.UI.Command;
 using Rubberduck.VBEditor.Utility;
 using Rubberduck.VersionCheck;

Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairCompletionService.cs

@@ -12,16 +12,17 @@ namespace Rubberduck.AutoComplete.SelfClosingPairs
 {
     public class SelfClosingPairCompletionService
     {
-        /*
-         // note: this works... but the VBE makes an annoying DING! when the command isn't available.
-         // todo: implement our own intellisense, then uncomment this code.
-        private readonly IShowIntelliSenseCommand _showIntelliSense;
+        private readonly IShowQuickInfoCommand _showQuickInfo;
 
-        public SelfClosingPairCompletionService(IShowIntelliSenseCommand showIntelliSense)
+        public SelfClosingPairCompletionService(IShowQuickInfoCommand showQuickInfo)
         {
-            _showIntelliSense = showIntelliSense;
+            _showQuickInfo = showQuickInfo;
+        }
+
+        public void ShowIntellisense()
+        {
+            _showQuickInfo.Execute();
         }
-        */
 
         public bool Execute(SelfClosingPair pair, CodeString original, char input, out CodeString result)
         {

Rubberduck.Core/AutoComplete/SelfClosingPairs/SelfClosingPairHandler.cs

@@ -143,6 +143,7 @@ private bool HandleInternal(AutoCompleteEventArgs e, CodeString original, SelfCl
                 {
                     e.Handled = true;
                     result = reprettified;
+                    _scpService.ShowIntellisense();
                     return true;
                 }
 

Rubberduck.Core/AutoComplete/ShowQuickInfoCommand.cs

@@ -0,0 +1,62 @@
+using System.Runtime.InteropServices;
+using Rubberduck.Runtime;
+using Rubberduck.UI.Command.ComCommands;
+using Rubberduck.VBEditor.Events;
+using Rubberduck.VBEditor.SafeComWrappers.Abstract;
+
+namespace Rubberduck.AutoComplete
+{
+    public interface IShowQuickInfoCommand
+    {
+        /// <summary>
+        /// Displays the quick info in the VBE.
+        /// NOTE: By default, it makes an utterly annoying DING! in the VBE if the "QuickInfo" command is unavailable. Hooking is used to suppress the ding.
+        /// </summary>
+        void Execute();
+    }
+
+    public class ShowQuickInfoCommand : ComCommandBase, IShowQuickInfoCommand
+    {
+        private readonly IVBE _vbe;
+        private readonly IBeepInterceptor _beepInterceptor;
+
+        public ShowQuickInfoCommand(IVBE vbe, IVbeEvents vbeEvents, IBeepInterceptor beepInterceptor) : base(vbeEvents)
+        {
+            _vbe = vbe;
+            _beepInterceptor = beepInterceptor;
+            AddToCanExecuteEvaluation(SpecialEvaluateCanExecute);
+        }
+
+        private bool SpecialEvaluateCanExecute(object parameter)
+        {
+            try
+            {
+                return parameter != null || _vbe.ProjectsCount == 1;
+            }
+            catch (COMException)
+            {
+                return false;
+            }
+        }
+
+        public void Execute()
+        {
+            OnExecute(null);
+        }
+
+        protected override void OnExecute(object parameter)
+        {
+            const int showQuickInfoId = 2531;
+            using (var commandBars = _vbe.CommandBars)
+            {
+                using (var command = commandBars.FindControl(showQuickInfoId))
+                {
+                    // Ensures that the queued beep message (if any) is suppressed
+                    _beepInterceptor.SuppressBeep(100);
+
+                    command.Execute();
+                }
+            }
+        }
+    }
+}

Rubberduck.Core/Navigation/CodeExplorer/CodeExplorerViewModel.cs

@@ -16,7 +16,8 @@
 using System.Windows.Input;
 using Rubberduck.Parsing.UIContext;
 using Rubberduck.Templates;
-using Rubberduck.UI.UnitTesting.Commands;
+using Rubberduck.UI.Command.ComCommands;
+using Rubberduck.UI.UnitTesting.ComCommands;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.Navigation.CodeExplorer

Rubberduck.Core/Rubberduck.Core.xml

@@ -0,0 +1,91 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Timers;
+using EasyHook;
+using Rubberduck.VBEditor.VbeRuntime;
+
+namespace Rubberduck.Runtime
+{
+    public class BeepEventArgs : EventArgs
+    {
+        public bool Handled { get; set; }
+    }
+
+    public interface IBeepInterceptor : IDisposable
+    {
+        void SuppressBeep(double millisecondsToSuppress);
+        event EventHandler<BeepEventArgs> Beep;
+    }
+
+    public sealed class BeepInterceptor : IBeepInterceptor
+    {
+        public event EventHandler<BeepEventArgs> Beep;
+
+        private readonly IVbeNativeApi _vbeApi;
+        private readonly LocalHook _hook;
+        private readonly Timer _timer;
+
+        public BeepInterceptor(IVbeNativeApi vbeApi)
+        {
+            _vbeApi = vbeApi;
+            _hook = HookVbaBeep();
+            _timer = new Timer();
+            _timer.Elapsed += TimerElapsed;
+        }
+
+        public void SuppressBeep(double millisecondsToSuppress)
+        {
+            _suppressed = true;
+            _timer.Interval = millisecondsToSuppress;
+            _timer.Enabled = true;
+        }
+
+        private LocalHook HookVbaBeep()
+        {
+            var processAddress = LocalHook.GetProcAddress(_vbeApi.DllName, "rtcBeep");
+            var callbackDelegate = new VbaBeepDelegate(VbaBeepCallback);
+            var hook = LocalHook.Create(processAddress, callbackDelegate, null);
+            hook.ThreadACL.SetInclusiveACL(new[] { 0 });
+            return hook;
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall, SetLastError = true)]
+        private delegate void VbaBeepDelegate();
+
+        private bool _suppressed;
+        private void VbaBeepCallback()
+        {
+            if (_suppressed)
+            {
+                return;
+            }
+            
+            var e = new BeepEventArgs();
+            Beep?.Invoke(this, e);
+
+            if (!e.Handled)
+            {
+                _vbeApi.Beep();
+            }
+        }
+
+        private void TimerElapsed(object sender, ElapsedEventArgs e)
+        {
+            _suppressed = false;
+            _timer.Enabled = false;
+        }
+
+        private bool _disposed;
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _hook?.Dispose();
+            _timer?.Dispose();
+            _disposed = true;
+        }
+    }
+}

Rubberduck.Core/Runtime/BeepInterceptor.cs

@@ -16,10 +16,10 @@ public class ReferenceConfigProvider : ConfigurationServiceBase<ReferenceSetting
         private static readonly string HostApplication = Path.GetFileName(Application.ExecutablePath).ToUpperInvariant();
 
         private readonly IEnvironmentProvider _environment;
-        private readonly IVBEEvents _events;
+        private readonly IVbeEvents _events;
         private bool _listening;
 
-        public ReferenceConfigProvider(IPersistenceService<ReferenceSettings> persister, IEnvironmentProvider environment, IVBEEvents events)
+        public ReferenceConfigProvider(IPersistenceService<ReferenceSettings> persister, IEnvironmentProvider environment, IVbeEvents events)
             : base(persister, new DefaultSettings<ReferenceSettings, Properties.Settings>())
         {
             _environment = environment;

Rubberduck.Core/Settings/ReferenceConfigProvider.cs

@@ -1,13 +1,14 @@
 using System.Collections.Generic;
+using Rubberduck.VBEditor.Events;
 using Rubberduck.VBEditor.SafeComWrappers;
 
 namespace Rubberduck.UI.CodeExplorer.Commands
 {
     public class AddClassModuleCommand : AddComponentCommandBase
     {
-        public AddClassModuleCommand(ICodeExplorerAddComponentService addComponentService) 
-            : base(addComponentService)
-        {}
+        public AddClassModuleCommand(
+            ICodeExplorerAddComponentService addComponentService, IVbeEvents vbeEvents) 
+            : base(addComponentService, vbeEvents) { }
 
         public override IEnumerable<ProjectType> AllowableProjectTypes => ProjectTypes.All;