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

Author: retailcoder

RetailCoder.VBE/App.cs

@@ -1,32 +1,30 @@
 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
 {
     public class App : IDisposable
     {
         private readonly VBE _vbe;
         private readonly IMessageBox _messageBox;
-        private readonly IParserErrorsPresenterFactory _parserErrorsPresenterFactory;
         private readonly IRubberduckParser _parser;
-        private readonly IInspectorFactory _inspectorFactory;
         private readonly AutoSave.AutoSave _autoSave;
         private readonly IGeneralConfigService _configService;
         private readonly IAppMenu _appMenus;
@@ -38,10 +36,14 @@ 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,
-            IParserErrorsPresenterFactory parserErrorsPresenterFactory,
             IRubberduckParser parser,
-            IInspectorFactory inspectorFactory,
             IGeneralConfigService configService,
             IAppMenu appMenus,
             RubberduckCommandBar stateBar,
@@ -50,25 +52,170 @@ public App(VBE vbe, IMessageBox messageBox,
         {
             _vbe = vbe;
             _messageBox = messageBox;
-            _parserErrorsPresenterFactory = parserErrorsPresenterFactory;
             _parser = parser;
-            _inspectorFactory = inspectorFactory;
-            _autoSave = new AutoSave.AutoSave(_vbe, new AutoSaveSettings());
             _configService = configService;
+            _autoSave = new AutoSave.AutoSave(_vbe, _configService);
             _appMenus = appMenus;
             _stateBar = stateBar;
             _indenter = indenter;
             //_hooks = hooks;
             _logger = LogManager.GetCurrentClassLogger();
 
             //_hooks.MessageReceived += hooks_MessageReceived;
-            _configService.SettingsChanged += _configService_SettingsChanged;
+            _configService.LanguageChanged += ConfigServiceLanguageChanged;
             _parser.State.StateChanged += Parser_StateChanged;
             _stateBar.Refresh += _stateBar_Refresh;
 
+            var sink = new VBProjectsEventsSink();
+            var connectionPointContainer = (IConnectionPointContainer)_vbe.VBProjects;
+            var 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();
         }
 
+        async void sink_ProjectRemoved(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            Debug.WriteLine(string.Format("Project '{0}' was removed.", e.Item.Name));
+            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);
+            }
+        }
+
+        async void sink_ProjectAdded(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                // forces menus to evaluate their CanExecute state:
+                Parser_StateChanged(this, new ParserStateEventArgs(ParserState.Pending));
+                _stateBar.SetStatusText();
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Project '{0}' was added.", e.Item.Name));
+            var connectionPointContainer = (IConnectionPointContainer)e.Item.VBComponents;
+            var 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(sender);
+        }
+
+        async void sink_ComponentSelected(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was selected.", e.Item.Name));
+            // do something?
+        }
+
+        async void sink_ComponentRenamed(object sender, DispatcherRenamedEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was renamed.", e.Item.Name));
+
+            _parser.State.OnParseRequested(sender, e.Item);
+        }
+
+        async void sink_ComponentRemoved(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was removed.", e.Item.Name));
+            _parser.State.ClearDeclarations(e.Item);
+        }
+
+        async void sink_ComponentReloaded(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was reloaded.", e.Item.Name));
+            _parser.State.OnParseRequested(sender, e.Item);
+        }
+
+        async void sink_ComponentAdded(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was added.", e.Item.Name));
+            _parser.State.OnParseRequested(sender, e.Item);
+        }
+
+        async void sink_ComponentActivated(object sender, DispatcherEventArgs<VBComponent> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Component '{0}' was activated.", e.Item.Name));
+            // do something?
+        }
+
+        async void sink_ProjectRenamed(object sender, DispatcherRenamedEventArgs<VBProject> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Project '{0}' was renamed.", e.Item.Name));
+            _parser.State.ClearDeclarations(e.Item);
+            _parser.State.OnParseRequested(sender);
+        }
+
+        async void sink_ProjectActivated(object sender, DispatcherEventArgs<VBProject> e)
+        {
+            if (!_parser.State.AllDeclarations.Any())
+            {
+                return;
+            }
+
+            Debug.WriteLine(string.Format("Project '{0}' was activated.", e.Item.Name));
+            // do something?
+        }
+
         private Keys _firstStepHotKey;
         private bool _isAwaitingTwoStepKey;
         private bool _skipKeyUp;
@@ -143,11 +290,12 @@ private async void hooks_MessageReceived(object sender, HookEventArgs e)
 
         private void _stateBar_Refresh(object sender, EventArgs e)
         {
-            _parser.State.OnParseRequested();
+            _parser.State.OnParseRequested(sender);
         }
 
-        private void Parser_StateChanged(object sender, ParserStateEventArgs e)
+        private void Parser_StateChanged(object sender, EventArgs e)
         {
+            Debug.WriteLine("App handles StateChanged ({0}), evaluating menu states...", _parser.State.Status);
             _appMenus.EvaluateCanExecute(_parser.State);
         }
 
@@ -158,13 +306,6 @@ public void Startup()
             _appMenus.Initialize();
             _appMenus.Localize();
 
-            // delay to allow the VBE to properly load. HostApplication is null until then.
-            Task.Delay(1000).ContinueWith(t =>
-            {
-                _parser.State.AddBuiltInDeclarations(_vbe.HostApplication());
-                _parser.State.OnParseRequested();
-            });
-
             //_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));
@@ -174,10 +315,9 @@ public void Startup()
         private void CleanReloadConfig()
         {
             LoadConfig();
-            Setup();
         }
 
-        private void _configService_SettingsChanged(object sender, EventArgs e)
+        private void ConfigServiceLanguageChanged(object sender, EventArgs e)
         {
             CleanReloadConfig();
         }
@@ -202,19 +342,19 @@ private void LoadConfig()
             }
         }
 
-        private void Setup()
-        {
-            _inspectorFactory.Create();
-            _parserErrorsPresenterFactory.Create();
-        }
-
         public void Dispose()
         {
-            //_hooks.MessageReceived -= hooks_MessageReceived;
-            _configService.SettingsChanged -= _configService_SettingsChanged;
+            _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/AutoSave/AutoSave.cs

@@ -1,44 +1,45 @@
 using System;
-using System.ComponentModel;
 using System.IO;
 using System.Linq;
 using System.Timers;
 using Microsoft.Vbe.Interop;
+using Rubberduck.Settings;
 
 namespace Rubberduck.AutoSave
 {
     public class AutoSave : IDisposable
     {
         private readonly VBE _vbe;
-        private readonly IAutoSaveSettings _settings;
+        private readonly IGeneralConfigService _configService;
         private readonly Timer _timer = new Timer();
+        private Configuration _config;
 
         private const int VbeSaveCommandId = 3;
 
-        public AutoSave(VBE vbe, IAutoSaveSettings settings)
+        public AutoSave(VBE vbe, IGeneralConfigService configService)
         {
             _vbe = vbe;
-            _settings = settings;
+            _configService = configService;
+            _config = _configService.LoadConfiguration();
 
-            _settings.PropertyChanged += _settings_PropertyChanged;
+            _configService.SettingsChanged += ConfigServiceSettingsChanged;
 
-            _timer.Enabled = _settings.IsEnabled;
-            _timer.Interval = _settings.TimerDelay;
+            _timer.Enabled = _config.UserSettings.GeneralSettings.AutoSaveEnabled 
+                && _config.UserSettings.GeneralSettings.AutoSavePeriod != 0;
 
-            _timer.Elapsed += _timer_Elapsed;
+            if (_config.UserSettings.GeneralSettings.AutoSavePeriod != 0)
+            {
+                _timer.Interval = _config.UserSettings.GeneralSettings.AutoSavePeriod * 1000;
+                _timer.Elapsed += _timer_Elapsed;
+            }
         }
 
-        private void _settings_PropertyChanged(object sender, PropertyChangedEventArgs e)
+        void ConfigServiceSettingsChanged(object sender, EventArgs e)
         {
-            switch (e.PropertyName)
-            {
-                case "IsEnabled":
-                    _timer.Enabled = _settings.IsEnabled;
-                    break;
-                case "TimerDelay":
-                    _timer.Interval = _settings.TimerDelay;
-                    break;
-            }
+            _config = _configService.LoadConfiguration();
+
+            _timer.Enabled = _config.UserSettings.GeneralSettings.AutoSaveEnabled;
+            _timer.Interval = _config.UserSettings.GeneralSettings.AutoSavePeriod * 1000;
         }
 
         private void _timer_Elapsed(object sender, ElapsedEventArgs e)
@@ -61,7 +62,7 @@ private void _timer_Elapsed(object sender, ElapsedEventArgs e)
 
         public void Dispose()
         {
-            _settings.PropertyChanged -= _settings_PropertyChanged;
+            _configService.LanguageChanged -= ConfigServiceSettingsChanged;
             _timer.Elapsed -= _timer_Elapsed;
 
             _timer.Dispose();