Wire up references event handlers.

Rubberduck.Core/AddRemoveReferences/ReferenceReconciler.cs

@@ -14,7 +14,7 @@ namespace Rubberduck.AddRemoveReferences
 {
     public interface IReferenceReconciler
     {
-        void ReconcileReferences(IAddRemoveReferencesModel model);
+        List<ReferenceModel> ReconcileReferences(IAddRemoveReferencesModel model);
         List<ReferenceModel> ReconcileReferences(IAddRemoveReferencesModel model, List<ReferenceModel> allReferences);
         ReferenceModel TryAddReference(IVBProject project, string path);
         ReferenceModel TryAddReference(IVBProject project, ReferenceModel reference);
@@ -35,14 +35,14 @@ public ReferenceReconciler(IMessageBox messageBox, IConfigProvider<ReferenceSett
             _tlbProvider = tlbProvider;
         }
 
-        public void ReconcileReferences(IAddRemoveReferencesModel model)
+        public List<ReferenceModel> ReconcileReferences(IAddRemoveReferencesModel model)
         {
             if (model?.NewReferences is null || !model.NewReferences.Any())
             {
-                return;
+                return null;
             }
 
-            ReconcileReferences(model, model.NewReferences.ToList());
+            return ReconcileReferences(model, model.NewReferences.ToList());
         }
 
         //TODO test for simple adds.

Rubberduck.Core/Settings/ReferenceConfigProvider.cs

@@ -1,22 +1,38 @@
 using System;
 using System.IO;
 using System.Reflection;
+using System.Windows.Forms;
 using Rubberduck.Resources.Registration;
 using Rubberduck.SettingsProvider;
 using Rubberduck.UI;
 using Rubberduck.VBEditor;
+using Rubberduck.VBEditor.Events;
+using Rubberduck.VBEditor.SafeComWrappers;
 
 namespace Rubberduck.Settings
 {
-    public class ReferenceConfigProvider : IConfigProvider<ReferenceSettings>
+    public class ReferenceConfigProvider : IConfigProvider<ReferenceSettings>, IDisposable
     {
+        private static readonly string HostApplication = Path.GetFileName(Application.ExecutablePath).ToUpperInvariant();
+
         private readonly IPersistanceService<ReferenceSettings> _persister;
         private readonly IEnvironmentProvider _environment;
+        private readonly IVBEEvents _events;
+        private bool _listening;
 
-        public ReferenceConfigProvider(IPersistanceService<ReferenceSettings> persister, IEnvironmentProvider environment)
+        public ReferenceConfigProvider(IPersistanceService<ReferenceSettings> persister, IEnvironmentProvider environment, IVBEEvents events)
         {
             _persister = persister;
             _environment = environment;
+            _events = events;
+
+
+            var settings = Create();
+            _listening = settings.AddToRecentOnReferenceEvents;
+            if (_listening)
+            {
+                _events.ProjectReferenceAdded += ReferenceAddedHandler;
+            }
         }
 
         public ReferenceSettings Create()
@@ -63,7 +79,53 @@ public ReferenceSettings CreateDefaults()
 
         public void Save(ReferenceSettings settings)
         {
+            if (_listening && !settings.AddToRecentOnReferenceEvents)
+            {
+                _events.ProjectReferenceAdded -= ReferenceAddedHandler;
+                _listening = false;
+            }
+
+            if (_listening && !settings.AddToRecentOnReferenceEvents)
+            {
+                _events.ProjectReferenceAdded += ReferenceAddedHandler;
+                _listening = true;
+            }
+
             _persister.Save(settings);
         }
+
+        private void ReferenceAddedHandler(object sender, ReferenceEventArgs e)
+        {
+            if (e is null || e.Reference.Equals(ReferenceInfo.Empty))
+            {
+                return;
+            }
+
+            var settings = Create();
+            settings.TrackUsage(e.Reference, e.Type == ReferenceKind.Project ? HostApplication : null);
+            _persister.Save(settings);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private bool _disposed;
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing && _listening)
+            {
+                _events.ProjectReferenceAdded -= ReferenceAddedHandler;
+            }
+
+            _disposed = true;
+        }
     }
 }

Rubberduck.Core/UI/AddRemoveReferences/AddRemoveReferencesViewModel.cs

@@ -32,11 +32,11 @@ public class AddRemoveReferencesViewModel : ViewModelBase
             { "WINWORD.EXE", new [] {"docm","dotm","doc","dot"} },
             { "MSACCESS.EXE", new [] {"accdb","mdb","mda","mde","accde"} },
             { "POWERPNT.EXE", new [] {"ppam","ppa"} },
-            // TODO
-            //{ "OUTLOOK.EXE", new [] {"?"} },
+            { "OUTLOOK.EXE", new [] {"otm"} },
+            { "MSPUB.EXE",  new [] {"pub"} },
+            { "VISIO.EXE",  new [] {"vsd","vdx","vss","vst","vtx","vsw","vdw","vsdx","vsdm"} },
+            // TODO           
             //{ "WINPROJ.EXE",  new [] {"?"} },
-            //{ "MSPUB.EXE",  new [] {"?"} },
-            //{ "VISIO.EXE",  new [] {"?"} },
             //{ "ACAD.EXE",  new [] {"?"} },
             //{ "CORELDRW.EXE",  new [] {"?"} }
         };
@@ -47,6 +47,9 @@ public class AddRemoveReferencesViewModel : ViewModelBase
             { "WINWORD.EXE", string.Format(RubberduckUI.References_BrowseFilterWord, string.Join(";", HostFileFilters["WINWORD.EXE"].Select(_ => $"*.{_}"))) }, 
             { "MSACCESS.EXE", string.Format(RubberduckUI.References_BrowseFilterAccess, string.Join(";", HostFileFilters["MSACCESS.EXE"].Select(_ => $"*.{_}"))) },
             { "POWERPNT.EXE", string.Format(RubberduckUI.References_BrowseFilterPowerPoint, string.Join(";", HostFileFilters["POWERPNT.EXE"].Select(_ => $"*.{_}"))) },
+            { "OUTLOOK.EXE", string.Format(RubberduckUI.References_BrowseFilterOutlook, string.Join(";", HostFileFilters["OUTLOOK.EXE"].Select(_ => $"*.{_}"))) },
+            { "MSPUB.EXE", string.Format(RubberduckUI.References_BrowseFilterOutlook, string.Join(";", HostFileFilters["MSPUB.EXE"].Select(_ => $"*.{_}"))) },
+            { "VISIO.EXE", string.Format(RubberduckUI.References_BrowseFilterVisio, string.Join(";", HostFileFilters["VISIO.EXE"].Select(_ => $"*.{_}"))) },
         };
 
         private static readonly List<string> FileFilters = new List<string>

Rubberduck.Resources/RubberduckUI.resx

@@ -1422,4 +1422,16 @@ NOTE: Restart is required for the setting to take effect.</value>
   <data name="ReferenceSettings_TrackHostReferences" xml:space="preserve">
     <value>Track references not added by Rubberduck</value>
   </data>
+  <data name="References_BrowseFilterOutlook" xml:space="preserve">
+    <value>Outlook VBA Files ({0})|{0}</value>
+    <comment>{0} = semi-colon delimited extension list in the format of *.ext</comment>
+  </data>
+  <data name="References_BrowseFilterPublisher" xml:space="preserve">
+    <value>Publisher Files ({0}|{0}</value>
+    <comment>{0} = semi-colon delimited extension list in the format of *.ext</comment>
+  </data>
+  <data name="References_BrowseFilterVisio" xml:space="preserve">
+    <value>All Visio Files ({0})|{0}</value>
+    <comment>{0} = semi-colon delimited extension list in the format of *.ext</comment>
+  </data>
 </root>

Rubberduck.VBEEditor/Events/IVbeEvents.cs

@@ -1,4 +1,5 @@
 using System;
+using Rubberduck.VBEditor.SafeComWrappers;
 
 namespace Rubberduck.VBEditor.Events
 {
@@ -14,6 +15,8 @@ public interface IVBEEvents
         event EventHandler<ComponentEventArgs> ComponentSelected;
         event EventHandler<ComponentEventArgs> ComponentActivated;
         event EventHandler<ComponentEventArgs> ComponentReloaded;
+        event EventHandler<ReferenceEventArgs> ProjectReferenceAdded;
+        event EventHandler<ReferenceEventArgs> ProjectReferenceRemoved;
         event EventHandler EventsTerminated;
     }
 }

Rubberduck.VBEEditor/Events/VbeEvents.cs

@@ -12,6 +12,7 @@ public sealed class VBEEvents : IVBEEvents
         private static readonly object Lock = new object();
         private readonly IVBProjects _projects;
         private readonly Dictionary<string, IVBComponents> _components;
+        private readonly Dictionary<string, IReferences> _references;
 
         public static VBEEvents Initialize(IVBE vbe)
         {
@@ -43,6 +44,7 @@ public static void Terminate()
         private VBEEvents(IVBE vbe)
         {
             _components = new Dictionary<string, IVBComponents>();
+            _references = new Dictionary<string, IReferences>();
 
             if (_projects != null)
             {
@@ -60,12 +62,12 @@ private VBEEvents(IVBE vbe)
             using (project)
             {
                 {
-                    RegisterComponents(project);
+                    RegisterProjectHandlers(project);
                 }
             }
         }
 
-        private void RegisterComponents(string projectId, string projectName)
+        private void RegisterProjectHandlers(string projectId, string projectName)
         {
             IVBProject project = null;
             foreach (var item in _projects)
@@ -84,10 +86,10 @@ private void RegisterComponents(string projectId, string projectName)
                 return;
             }
 
-            RegisterComponents(project);
+            RegisterProjectHandlers(project);
         }
 
-        private void RegisterComponents(IVBProject project)
+        private void RegisterProjectHandlers(IVBProject project)
         {
             if (project.IsWrappingNullReference || project.Protection != ProjectProtection.Unprotected)
             {
@@ -106,9 +108,15 @@ private void RegisterComponents(IVBProject project)
             components.ComponentActivated += ComponentActivatedHandler;
             components.ComponentSelected += ComponentSelectedHandler;
             components.ComponentReloaded += ComponentReloadedHandler;
+
+            var references = project.References;
+            _references.Add(project.ProjectId, references);
+            references.AttachEvents();
+            references.ItemAdded += ProjectReferenceAddedHandler;
+            references.ItemRemoved += ProjectReferenceRemovedHandler;
         }
 
-        private void UnregisterComponents(string projectId)
+        private void UnregisterProjectHandlers(string projectId)
         {
             if (!_components.ContainsKey(projectId))
             {
@@ -127,22 +135,30 @@ private void UnregisterComponents(string projectId)
 
                 _components.Remove(projectId);
             }
+
+            using (var references = _references[projectId])
+            {
+                references.ItemAdded -= ProjectReferenceAddedHandler;
+                references.ItemRemoved -= ProjectReferenceRemovedHandler;
+                references.DetachEvents();
+                _references.Remove(projectId);
+            }
         }
 
         public event EventHandler<ProjectEventArgs> ProjectAdded;
         private void ProjectAddedHandler(object sender, ProjectEventArgs e)
         {
             if (!_components.ContainsKey(e.ProjectId))
             {
-                RegisterComponents(e.ProjectId, e.ProjectName);
+                RegisterProjectHandlers(e.ProjectId, e.ProjectName);
             }
             ProjectAdded?.Invoke(sender, e);
         }
 
         public event EventHandler<ProjectEventArgs> ProjectRemoved;
         private void ProjectRemovedHandler(object sender, ProjectEventArgs e)
         {
-            UnregisterComponents(e.ProjectId);
+            UnregisterProjectHandlers(e.ProjectId);
             ProjectRemoved?.Invoke(sender, e);
         }
 
@@ -188,12 +204,27 @@ private void ComponentSelectedHandler(object sender, ComponentEventArgs e)
             ComponentSelected?.Invoke(sender, e);
         }
 
-        public event EventHandler<ComponentEventArgs> ComponentReloaded; 
+        public event EventHandler<ComponentEventArgs> ComponentReloaded;
+
         private void ComponentReloadedHandler(object sender, ComponentEventArgs e)
         {
             ComponentReloaded?.Invoke(sender, e);
         }
 
+        public event EventHandler<ReferenceEventArgs> ProjectReferenceAdded;
+
+        private void ProjectReferenceAddedHandler(object sender, ReferenceEventArgs e)
+        {
+            ProjectReferenceAdded?.Invoke(sender, e);
+        }
+
+        public event EventHandler<ReferenceEventArgs> ProjectReferenceRemoved;
+
+        private void ProjectReferenceRemovedHandler(object sender, ReferenceEventArgs e)
+        {
+            ProjectReferenceRemoved?.Invoke(sender, e);
+        }
+
         public event EventHandler EventsTerminated;
 
         #region IDisposable
@@ -214,7 +245,7 @@ private void Dispose(bool disposing)
                 var projectIds = _components.Keys.ToArray();
                 foreach (var projectid in projectIds)
                 {
-                    UnregisterComponents(projectid);
+                    UnregisterProjectHandlers(projectid);
                 }
 
                 _projects.ProjectActivated -= ProjectActivatedHandler;

Rubberduck.VBEEditor/SafeComWrappers/ReferenceEventArgs.cs

@@ -1,15 +1,16 @@
 using System;
-using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 
 namespace Rubberduck.VBEditor.SafeComWrappers
 {
     public class ReferenceEventArgs : EventArgs
     {
-        public ReferenceEventArgs(IReference reference)
+        public ReferenceEventArgs(ReferenceInfo reference, ReferenceKind type)
         {
             Reference = reference;
+            Type = type;
         }
 
-        public IReference Reference { get; }
+        public ReferenceInfo Reference { get; }
+        public ReferenceKind Type { get; }
     }
 }

Rubberduck.VBEEditor/SafeComWrappers/VB/Abstract/IReferences.cs

@@ -2,7 +2,7 @@
 
 namespace Rubberduck.VBEditor.SafeComWrappers.Abstract
 {
-    public interface IReferences : ISafeComWrapper, IComCollection<IReference>, IEquatable<IReferences>
+    public interface IReferences : ISafeEventedComWrapper, IComCollection<IReference>, IEquatable<IReferences>
     {
         event EventHandler<ReferenceEventArgs> ItemAdded;
         event EventHandler<ReferenceEventArgs> ItemRemoved;