Add Worksheet provider

Start work on improved Watchers

Author: govert

Source/ExcelDna.IntelliSense/FormattedText.cs

@@ -1,9 +1,6 @@
-using System;
-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using System.Drawing;
-using System.Linq;
-using System.Text;
 
 namespace ExcelDna.IntelliSense
 {

Source/ExcelDna.IntelliSense/IntelliSenseDisplay.cs

@@ -20,7 +20,7 @@ public class ArgumentInfo
         public string FunctionName;
         public string Description;
         public List<ArgumentInfo> ArgumentList;
-        public string XllPath;
+        public string SourcePath; // XllPath for .xll, Workbook Name for Workbook
     }
 
     // CONSIDER: Revisit UI Automation Threading: http://msdn.microsoft.com/en-us/library/windows/desktop/ee671692(v=vs.85).aspx
@@ -39,6 +39,7 @@ class IntelliSenseDisplay : MarshalByRefObject, IDisposable
         WindowWatcher _windowWatcher;
         FormulaEditWatcher _formulaEditWatcher;
         PopupListWatcher _popupListWatcher;
+        SelectDataSourceWatcher _selectDataSourceWatcher;
 
         // Need to make these late ...?
         ToolTipForm _descriptionToolTip;
@@ -62,6 +63,7 @@ public IntelliSenseDisplay()
         public void SetXllOwner(string xllPath)
         {
             _threadAuto = new Thread(() => RunUIAutomation(xllPath));
+            _threadAuto.SetApartmentState(ApartmentState.MTA);
             _threadAuto.Start();
         }
 
@@ -80,6 +82,7 @@ void RunUIAutomation(string xllPath)
             _windowWatcher = new WindowWatcher(xllPath);
             _formulaEditWatcher = new FormulaEditWatcher(_windowWatcher, _syncContextAuto);
             _popupListWatcher = new PopupListWatcher(_windowWatcher, _syncContextAuto);
+            _selectDataSourceWatcher = new SelectDataSourceWatcher(_windowWatcher, _syncContextAuto);
 
             _windowWatcher.MainWindowChanged += OnMainWindowChanged;
             _popupListWatcher.SelectedItemChanged += OnSelectedItemChanged;
@@ -318,7 +321,7 @@ public void AddReference(string xllName)
         public void RemoveReference(string xllName)
         {
             List<string> functionsToRemove =
-                _functionInfoMap.Where(p => p.Value.XllPath == xllName).Select(p => p.Key).ToList();
+                _functionInfoMap.Where(p => p.Value.SourcePath == xllName).Select(p => p.Key).ToList();
 
             foreach (string func in functionsToRemove)
             {

Source/ExcelDna.IntelliSense/IntelliSenseProvider.cs

@@ -3,19 +3,21 @@
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Text;
 using ExcelDna.Integration;
 
 namespace ExcelDna.IntelliSense
 {
-    // An IntelliSenseProvider is a part of an IntelliSenseServer that provides IntelliSense info to the server.
-    // The providers are built in to the ExcelDna.IntelliSense assembly - there are complications in making this a part that can be extended 
+    // An IntelliSenseProvider is the part of an IntelliSenseServer that provides the IntelliSense info gathered from add-ins to the server.
+    // These providers are built in to the ExcelDna.IntelliSense assembly - there are complications in making this a part that can be extended 
     // by a specific add-in (server activation, cross AppDomain loading etc.).
+    //
     // Higher versions of the ExcelDna.IntelliSenseServer are expected to increase the number of providers
     // and/or the scope of some provider (e.g. add support for enums).
+    // No provision is made at the moment for user-created providers or an external provider API.
 
     // The server, upon activation and at other times (when? when ExcelDna.IntelliSense.Refresh is called ?) will call the provider to get the IntelliSense info.
-    // Maybe the provider can also raise an Invalidate event, to prod the server into reloading the IntelliSense info for that provider.
+    // Maybe the provider can also raise an Invalidate event, to prod the server into reloading the IntelliSense info for that provider
+    // (a bit like the ribbon Invalidate works).
     // E.g. the XmlProvider might read from a file, and put a FileWatcher on the file so that whenever the file changes, 
     // the server calls back to get the updated info.
 
@@ -116,7 +118,7 @@ public IEnumerable<IntelliSenseFunctionInfo> GetFunctionInfos()
                             FunctionName = functionName,
                             Description = description,
                             ArgumentList = argumentInfos,
-                            XllPath = _xllPath
+                            SourcePath = _xllPath
                         };
                     }
                 }
@@ -163,15 +165,130 @@ IEnumerable<string> GetLoadedXllPaths()
         }
     }
 
-    // VBA might be easy, since the functions are scoped to the Workbook or add-in, and so might have the right name?
-    //         Excel4v(xlcRun, &xlRes, 1, TempStr(" myVBAAddin.xla!myFunc"));
+    // For VBA code, (either in a regular workbook that is open, or in an add-in)
+    // we allow the IntelliSense info to be put into a worksheet (possibly hidden or very hidden)
+    // In the Workbook that contains the VBA.
+    // Initially we won't scope the IntelliSense to the Workbook where the UDFs are defined, 
+    // but we should consider that.
 
-    class VbaIntelliSenseProvider
+    class WorkbookIntelliSenseProvider : IIntelliSenseProvider
     {
+        const string intelliSenseWorksheetName = "_IntelliSense_FunctionInfo_";
+        class WorkbookRegistrationInfo
+        {
+            readonly string _name;
+            DateTime _lastUpdate;               // Version indicator to enumerate from scratch
+            object[,] _regInfo = null;          // Default value
+
+            public WorkbookRegistrationInfo(string name)
+            {
+                _name = name;
+            }
+
+            // Called in a macro context
+            public void Refresh()
+            {
+                dynamic app = ExcelDnaUtil.Application;
+                var wb = app.Workbooks[_name];
+
+                try
+                {
+                    var ws = wb.Sheets[intelliSenseWorksheetName];
+                    var info = ws.UsedRange.Value;
+                    _regInfo = info as object[,];
+                }
+                catch (Exception ex)
+                {
+                    // We expect this if there is no sheet.
+                    // Another approach would be xlSheetNm
+                    Debug.Print("WorkbookIntelliSenseProvider.Refresh Error : " + ex.Message);
+                    _regInfo = null;
+                }
+                _lastUpdate = DateTime.Now;
+            }
+
+            // Not in macro context - don't call Excel, could be any thread.
+            public IEnumerable<IntelliSenseFunctionInfo> GetFunctionInfos()
+            {
+                // to avoid worries about locking and this being updated from another thread, we take a copy of _regInfo
+                var regInfo = _regInfo;
+                /*
+                    result[0, 0] = XlAddIn.PathXll;
+                    result[0, 1] = registrationInfoVersion;
+                 */
+
+                if (regInfo == null)
+                    yield break;
+
+                // regInfo is 1-based: object[1..x, 1..y].
+                for (int i = 1; i <= regInfo.GetLength(0); i++)
+                {
+                    string functionName = regInfo[i, 1] as string;
+                    string description = regInfo[i, 2] as string;
+
+                    List<IntelliSenseFunctionInfo.ArgumentInfo> argumentInfos = new List<IntelliSenseFunctionInfo.ArgumentInfo>();
+                    for (int j = 3; j <= regInfo.GetLength(1) - 1; j += 2)
+                    {
+                        var arg = regInfo[i, j] as string;
+                        var argDesc = regInfo[i, j + 1] as string;
+                        if (!string.IsNullOrEmpty(arg))
+                        {
+                            argumentInfos.Add(new IntelliSenseFunctionInfo.ArgumentInfo
+                            {
+                                ArgumentName = arg,
+                                Description = argDesc
+                            });
+                        }
+                    }
+
+                    yield return new IntelliSenseFunctionInfo
+                    {
+                        FunctionName = functionName,
+                        Description = description,
+                        ArgumentList = argumentInfos,
+                        SourcePath = _name
+                    };
+                }
+            }
+        }
+
+        Dictionary<string, WorkbookRegistrationInfo> _workbookRegistrationInfos = new Dictionary<string, WorkbookRegistrationInfo>();
+
+        public void Refresh()
+        {
+            foreach (var name in GetLoadedWorkbookNames())
+            {
+                WorkbookRegistrationInfo regInfo;
+                if (!_workbookRegistrationInfos.TryGetValue(name, out regInfo))
+                {
+                    regInfo = new WorkbookRegistrationInfo(name);
+                    _workbookRegistrationInfos[name] = regInfo;
+                }
+                regInfo.Refresh();
+            }
+        }
+
+        public IEnumerable<IntelliSenseFunctionInfo> GetFunctionInfos()
+        {
+            return _workbookRegistrationInfos.Values.SelectMany(ri => ri.GetFunctionInfos());
+        }
+
+        // Called in macro context
+        // Might be implemented by tracking Application events
+        // Remember this changes when a workbook is saved, and can refer to the wrong workbook as they are closed / opened
+        IEnumerable<string> GetLoadedWorkbookNames()
+        {
+            // TODO: Implement properly...
+            dynamic app = ExcelDnaUtil.Application;
+            foreach (var wb in app.Workbooks)
+            {
+                yield return wb.Name; 
+            }
+        }
     }
 
     // The idea is that other add-in tools like XLW or XLL+ could provide IntelliSense info with an xml file.
-    // CONSIDER: How to find these files - can't jsut be relative to the IntelliSense add-in. 
+    // CONSIDER: How to find these files - can't just be relative to the IntelliSense add-in. 
     //           (Maybe next to the foreign .xll file (.xllinfo)?)
     class XmlIntelliSenseProvider
     {

Source/ExcelDna.IntelliSense/IntelliSenseServer.cs

@@ -3,8 +3,6 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.Remoting;
-using System.Text;
 using System.Text.RegularExpressions;
 using Microsoft.Win32;
 using ExcelDna.Integration;
@@ -16,12 +14,13 @@ namespace ExcelDna.IntelliSense
     // Among different add-ins that are loaded into an Excel process, at most one IntelliSenseServer can be Active.
     // This should always be the IntelliSenseServer with the greatest version number among those registered.
     // At the moment the bookkeeping for registration and activation in the process is done with environment variables. 
+    // (An attractive alternative is the hidden Excel name space: http://www.cpearson.com/excel/hidden.htm )
     // This prevents cross-AppDomain calls, which are problematic because assemblies are then loaded into multiple AppDomains, and
     // since the mechanism is intended to cater for different assembly versions, this would be a problem. Also, we don't control
     // the CLR hosting configuration, so can't always set the MultiDomain flag on setup. COM mechanisms could work, but are complicated.
     // Another approach would be to use a hidden Excel function that the Active server provides, and have all server register with the active server.
     // When a new server should become active, it then tells the active server, and somehow gets all the other registrations...
-    
+
     // Registered Servers also register a macro with Excel through which control calls are to be made.
     // This is against a unique GUID-based name for every registered server, so that the Activate call can be made on an inactive server.
     // (To be called in a macro context only, e.g. from AutoOpen.)

Source/ExcelDna.IntelliSense/IntellisenseHelper.cs

@@ -1,14 +1,15 @@
 using System;
-using System.Collections.Generic;
 using ExcelDna.Integration;
 
 namespace ExcelDna.IntelliSense
 {
     // TODO: This is to be replaced by the Provider / Server info retrieval mechanism
+    // First version might run on a timer for updates.
     public class IntelliSenseHelper : IDisposable
     {
         private readonly IntelliSenseDisplay _id;
         private readonly IIntelliSenseProvider _excelDnaProvider = new ExcelDnaIntelliSenseProvider();
+        private readonly IIntelliSenseProvider _workbookProvider = new WorkbookIntelliSenseProvider();
         // TODO: Others
 
         public IntelliSenseHelper()
@@ -25,6 +26,12 @@ void RegisterIntellisense()
             {
                 _id.RegisterFunctionInfo(fi);
             }
+
+            _workbookProvider.Refresh();
+            foreach (var fi in _workbookProvider.GetFunctionInfos())
+            {
+                _id.RegisterFunctionInfo(fi);
+            }
         }
 
         public void Dispose()