Merge pull request #1144 from rubberduck-vba/CodeExplorer

merge latest changes

RetailCoder.VBE/App.cs

@@ -1,22 +1,23 @@
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.InteropServices.ComTypes;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using Microsoft.Vbe.Interop;
 using NLog;
-using Rubberduck.AutoSave;
 using Rubberduck.Common;
-using Rubberduck.Inspections;
 using Rubberduck.Parsing;
 using Rubberduck.Parsing.VBA;
 using Rubberduck.Settings;
 using Rubberduck.SmartIndenter;
 using Rubberduck.UI;
 using Rubberduck.UI.Command.MenuItems;
-using Rubberduck.UI.ParserErrors;
 using Rubberduck.VBEditor.Extensions;
 using Infralution.Localization.Wpf;
+using Rubberduck.Common.Dispatch;
 
 namespace Rubberduck
 {
@@ -36,6 +37,12 @@ public class App : IDisposable
 
         private Configuration _config;
 
+        private readonly IConnectionPoint _projectsEventsConnectionPoint;
+        private readonly int _projectsEventsCookie;
+
+        private readonly IDictionary<VBComponents, Tuple<IConnectionPoint, int>>  _componentsEventsConnectionPoints = 
+            new Dictionary<VBComponents, Tuple<IConnectionPoint, int>>(); 
+
         public App(VBE vbe, IMessageBox messageBox,
             IRubberduckParser parser,
             IGeneralConfigService configService,
@@ -60,9 +67,99 @@ public class App : IDisposable
             _parser.State.StateChanged += Parser_StateChanged;
             _stateBar.Refresh += _stateBar_Refresh;
 
+            var sink = new VBProjectsEventsSink();
+            var connectionPointContainer = (IConnectionPointContainer)_vbe.VBProjects;
+            Guid interfaceId = typeof (_dispVBProjectsEvents).GUID;
+            connectionPointContainer.FindConnectionPoint(ref interfaceId, out _projectsEventsConnectionPoint);
+
+            sink.ProjectAdded += sink_ProjectAdded;
+            sink.ProjectRemoved += sink_ProjectRemoved;
+            sink.ProjectActivated += sink_ProjectActivated;
+            sink.ProjectRenamed += sink_ProjectRenamed;
+
+            _projectsEventsConnectionPoint.Advise(sink, out _projectsEventsCookie);
+
             UiDispatcher.Initialize();
         }
 
+        void sink_ProjectRemoved(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            Tuple<IConnectionPoint, int> value;
+            if (_componentsEventsConnectionPoints.TryGetValue(e.Item.VBComponents, out value))
+            {
+                value.Item1.Unadvise(value.Item2);
+                _componentsEventsConnectionPoints.Remove(e.Item.VBComponents);
+
+                _parser.State.ClearDeclarations(e.Item);
+            }
+        }
+
+        void sink_ProjectAdded(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            var connectionPointContainer = (IConnectionPointContainer)e.Item.VBComponents;
+            Guid interfaceId = typeof(_dispVBComponentsEvents).GUID;
+
+            IConnectionPoint connectionPoint;
+            connectionPointContainer.FindConnectionPoint(ref interfaceId, out connectionPoint);
+
+            var sink = new VBComponentsEventsSink();
+            sink.ComponentActivated += sink_ComponentActivated;
+            sink.ComponentAdded += sink_ComponentAdded;
+            sink.ComponentReloaded += sink_ComponentReloaded;
+            sink.ComponentRemoved += sink_ComponentRemoved;
+            sink.ComponentRenamed += sink_ComponentRenamed;
+            sink.ComponentSelected += sink_ComponentSelected;
+
+            int cookie;
+            connectionPoint.Advise(sink, out cookie);
+
+            _componentsEventsConnectionPoints.Add(e.Item.VBComponents, Tuple.Create(connectionPoint, cookie));
+            _parser.State.OnParseRequested();
+        }
+
+        void sink_ComponentSelected(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            // do something?
+        }
+
+        void sink_ComponentRenamed(object sender, DispatcherRenamedEventArgs<VBComponent> e)
+        {
+            _parser.State.ClearDeclarations(e.Item);
+            _parser.State.OnParseRequested(e.Item);
+        }
+
+        void sink_ComponentRemoved(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            _parser.State.ClearDeclarations(e.Item);
+        }
+
+        void sink_ComponentReloaded(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            _parser.State.ClearDeclarations(e.Item);
+            _parser.State.OnParseRequested(e.Item);
+        }
+
+        void sink_ComponentAdded(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            _parser.State.OnParseRequested(e.Item);
+        }
+
+        void sink_ComponentActivated(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            // do something?
+        }
+
+        void sink_ProjectRenamed(object sender, DispatcherRenamedEventArgs<VBProject> e)
+        {
+            _parser.State.ClearDeclarations(e.Item);
+            _parser.State.OnParseRequested();
+        }
+
+        void sink_ProjectActivated(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            // do something?
+        }
+
         private Keys _firstStepHotKey;
         private bool _isAwaitingTwoStepKey;
         private bool _skipKeyUp;
@@ -156,7 +253,7 @@ public void Startup()
             Task.Delay(1000).ContinueWith(t =>
             {
                 _parser.State.AddBuiltInDeclarations(_vbe.HostApplication());
-                _parser.State.OnParseRequested();
+                //_parser.State.OnParseRequested();
             });
 
             //_hooks.AddHook(new LowLevelKeyboardHook(_vbe));
@@ -197,11 +294,17 @@ private void LoadConfig()
 
         public void Dispose()
         {
-            //_hooks.MessageReceived -= hooks_MessageReceived;
             _configService.LanguageChanged -= ConfigServiceLanguageChanged;
             _parser.State.StateChanged -= Parser_StateChanged;
             _autoSave.Dispose();
 
+            _projectsEventsConnectionPoint.Unadvise(_projectsEventsCookie);
+            foreach (var item in _componentsEventsConnectionPoints)
+            {
+                item.Value.Item1.Unadvise(item.Value.Item2);
+            }
+
+            //_hooks.MessageReceived -= hooks_MessageReceived;
             //_hooks.Dispose();
         }
     }

RetailCoder.VBE/Common/Dispatch/DispatcherEventArgs.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace Rubberduck.Common.Dispatch
+{
+    public class DispatcherEventArgs<T> : EventArgs 
+        where T : class
+    {
+        private readonly T _item;
+
+        public DispatcherEventArgs(T item)
+        {
+            _item = item;
+        }
+
+        public T Item { get { return _item; } }
+    }
+}

RetailCoder.VBE/Common/Dispatch/DispatcherRenamedEventArgs.cs

@@ -0,0 +1,16 @@
+namespace Rubberduck.Common.Dispatch
+{
+    public class DispatcherRenamedEventArgs<T> : DispatcherEventArgs<T>
+        where T : class
+    {
+        private readonly string _oldName;
+
+        public DispatcherRenamedEventArgs(T item, string oldName)
+            : base(item)
+        {
+            _oldName = oldName;
+        }
+
+        public string OldName { get { return _oldName; } }
+    }
+}

RetailCoder.VBE/Common/Dispatch/ReferencesEventsSink.cs

@@ -0,0 +1,29 @@
+using System;
+using Microsoft.Vbe.Interop;
+
+namespace Rubberduck.Common.Dispatch
+{
+    public class ReferencesEventsSink : _dispReferencesEvents
+    {
+        public event EventHandler<DispatcherEventArgs<Reference>> ReferenceAdded;
+        public void ItemAdded(Reference Reference)
+        {
+            OnDispatch(ReferenceAdded, Reference);
+        }
+
+        public event EventHandler<DispatcherEventArgs<Reference>> ReferenceRemoved;
+        public void ItemRemoved(Reference Reference)
+        {
+            OnDispatch(ReferenceRemoved, Reference);
+        }
+
+        private void OnDispatch(EventHandler<DispatcherEventArgs<Reference>> dispatched, Reference reference)
+        {
+            var handler = dispatched;
+            if (handler != null)
+            {
+                handler.Invoke(this, new DispatcherEventArgs<Reference>(reference));
+            }
+        }
+    }
+}

RetailCoder.VBE/Common/Dispatch/VBComponentsEventsSink.cs

@@ -0,0 +1,57 @@
+using System;
+using Microsoft.Vbe.Interop;
+
+namespace Rubberduck.Common.Dispatch
+{
+    public class VBComponentsEventsSink : _dispVBComponentsEvents
+    {
+        public event EventHandler<DispatcherEventArgs<VBComponent>> ComponentAdded;
+        public void ItemAdded(VBComponent VBComponent)
+        {
+            OnDispatch(ComponentAdded, VBComponent);
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBComponent>> ComponentRemoved;
+        public void ItemRemoved(VBComponent VBComponent)
+        {
+            OnDispatch(ComponentRemoved, VBComponent);
+        }
+
+        public event EventHandler<DispatcherRenamedEventArgs<VBComponent>> ComponentRenamed;
+        public void ItemRenamed(VBComponent VBComponent, string OldName)
+        {
+            var handler = ComponentRenamed;
+            if (handler != null)
+            {
+                handler.Invoke(this, new DispatcherRenamedEventArgs<VBComponent>(VBComponent, OldName));
+            }
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBComponent>> ComponentSelected;
+        public void ItemSelected(VBComponent VBComponent)
+        {
+            OnDispatch(ComponentSelected, VBComponent);
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBComponent>> ComponentActivated;
+        public void ItemActivated(VBComponent VBComponent)
+        {
+            OnDispatch(ComponentActivated, VBComponent);
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBComponent>> ComponentReloaded;
+        public void ItemReloaded(VBComponent VBComponent)
+        {
+            OnDispatch(ComponentReloaded, VBComponent);
+        }
+
+        private void OnDispatch(EventHandler<DispatcherEventArgs<VBComponent>> dispatched, VBComponent component)
+        {
+            var handler = dispatched;
+            if (handler != null)
+            {
+                handler.Invoke(this, new DispatcherEventArgs<VBComponent>(component));
+            }
+        }
+    }
+}

RetailCoder.VBE/Common/Dispatch/VBProjectsEventsSink.cs

@@ -0,0 +1,45 @@
+using System;
+using Microsoft.Vbe.Interop;
+
+namespace Rubberduck.Common.Dispatch
+{
+    public class VBProjectsEventsSink : _dispVBProjectsEvents
+    {
+        public event EventHandler<DispatcherEventArgs<VBProject>> ProjectAdded;
+        public void ItemAdded(VBProject VBProject)
+        {
+            OnDispatch(ProjectAdded, VBProject);
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBProject>> ProjectRemoved;
+        public void ItemRemoved(VBProject VBProject)
+        {
+            OnDispatch(ProjectRemoved, VBProject);
+        }
+
+        public event EventHandler<DispatcherRenamedEventArgs<VBProject>> ProjectRenamed;
+        public void ItemRenamed(VBProject VBProject, string OldName)
+        {
+            var handler = ProjectRenamed;
+            if (handler != null)
+            {
+                handler.Invoke(this, new DispatcherRenamedEventArgs<VBProject>(VBProject, OldName));
+            }
+        }
+
+        public event EventHandler<DispatcherEventArgs<VBProject>> ProjectActivated;
+        public void ItemActivated(VBProject VBProject)
+        {
+            OnDispatch(ProjectActivated, VBProject);
+        }
+
+        private void OnDispatch(EventHandler<DispatcherEventArgs<VBProject>> dispatched, VBProject project)
+        {
+            var handler = dispatched;
+            if (handler != null)
+            {
+                handler.Invoke(this, new DispatcherEventArgs<VBProject>(project));
+            }
+        }
+    }
+}

RetailCoder.VBE/Common/Dispatch/VBProjectsEventsWrapper.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Rubberduck.Common.Dispatch
+{
+    public class VBProjectsEventsWrapper
+    {
+
+    }
+}

RetailCoder.VBE/Inspections/ImplicitVariantReturnTypeInspection.cs

@@ -31,8 +31,7 @@ public override IEnumerable<InspectionResultBase> GetInspectionResults()
                                where !item.IsInspectionDisabled(AnnotationName)
                                 && ProcedureTypes.Contains(item.DeclarationType)
                                 && !item.IsTypeSpecified()
-                               let issue = new {Declaration = item, QualifiedContext = new QualifiedContext<ParserRuleContext>(item.QualifiedName, item.Context)}
-                               select new ImplicitVariantReturnTypeInspectionResult(this, string.Format(Description, issue.Declaration.IdentifierName), issue.QualifiedContext);
+                               select new ImplicitVariantReturnTypeInspectionResult(this, item);
             return issues;
         }
     }