Rework update event filtering to allow multiple listeners

Author: govert

Source/ExcelDna.IntelliSense/IntelliSenseDisplay.cs

@@ -53,31 +53,37 @@ public IntelliSenseDisplay(SynchronizationContext syncContextMain, UIMonitor uiM
 
             _syncContextMain = syncContextMain;
             _uiMonitor = uiMonitor;
-            _uiMonitor.StateUpdateFilter = StateUpdateFilter;
-            _uiMonitor.StateUpdate = StateUpdate;
+            _uiMonitor.StateUpdatePreview += StateUpdatePreview;
+            _uiMonitor.StateUpdate += StateUpdate;
         }
 
         // This runs on the UIMonitor's automation thread
-        bool StateUpdateFilter(UIStateUpdate update)
+        // Allows us to enable the update to be raised on main thread
+        // Might be raised on the main thread even if we don't enable it (other listeners might enable)
+        void StateUpdatePreview(object sender,  UIStateUpdate update)
         {
+            bool enable;
             if (update.Update == UIStateUpdate.UpdateType.FormulaEditTextChange)
             {
                 var fe = (UIState.FormulaEdit)update.NewState;
-                return ShouldProcessFormulaEditTextChange(fe.FormulaPrefix);
+                enable = ShouldProcessFormulaEditTextChange(fe.FormulaPrefix);
             }
             else if (update.Update == UIStateUpdate.UpdateType.FunctionListSelectedItemChange)
             {
                 var fl = (UIState.FunctionList)update.NewState;
-                return ShouldProcessFunctionListSelectedItemChange(fl.SelectedItemText);
+                enable = ShouldProcessFunctionListSelectedItemChange(fl.SelectedItemText);
             }
             else
             {
-                return true; // allow the update event to be raised
+                enable = true; // allow the update event to be raised by default
             }
+
+            if (enable)
+                update.EnableUpdateEvent();
         }
 
         // This runs on the main thread
-        void StateUpdate(UIStateUpdate update)
+        void StateUpdate(object sender, UIStateUpdate update)
         {
             Debug.Print($"STATE UPDATE ({update.Update}): {update.OldState} => {update.NewState}");
 

Source/ExcelDna.IntelliSense/UIMonitor.cs

@@ -329,15 +329,23 @@ public enum UpdateType
                 SelectDataSourceMainWindowChange,
             SelectDataSourceHide
         }
-        public UIState OldState;
-        public UIState NewState;
-        public UpdateType Update;
+        public UIState OldState { get; }
+        public UIState NewState { get; }
+        public UpdateType Update { get; }
+        public bool IsEnabled { get; private set; }  // Should this update be raised on the main thread - allows preview event to filter out some events
 
         public UIStateUpdate(UIState oldState, UIState newState, UpdateType update)
         {
             OldState = oldState;
             NewState = newState;
             Update = update;
+            IsEnabled = false;
+        }
+
+        // Call this to allow the update event (on the main thread) to be raised
+        public void EnableUpdateEvent()
+        {
+            IsEnabled = true;
         }
     }
 
@@ -355,8 +363,8 @@ class UIMonitor : IDisposable
         PopupListWatcher _popupListWatcher;
 
         public UIState CurrentState = UIState.ReadyState;
-        public Func<UIStateUpdate, bool> StateUpdateFilter;   // Always called on the automation thread
-        public Action<UIStateUpdate> StateUpdate;       // Always posted to the main thread
+        public EventHandler<UIStateUpdate> StateUpdatePreview;   // Always called on the automation thread
+        public EventHandler<UIStateUpdate> StateUpdate;       // Always posted to the main thread
 
         public UIMonitor(SynchronizationContext syncContextMain)
         {
@@ -479,17 +487,22 @@ UIState ReadCurrentState()
         }
 
         // Filter the states changes (on the automation thread) and then raise changes (on the main thread)
-        // TODO: We might short-cut the update type too, for the common FormulaEdit and SelectItemChange cases
         void OnStateChanged(UIState newStateOrNull = null)
         {
             var oldState = CurrentState;
             if (newStateOrNull == null)
                 newStateOrNull = ReadCurrentState();
             CurrentState = newStateOrNull;
 
-            var updates = UIState.GetUpdates(oldState, CurrentState)
-                                 .Where(StateUpdateFilter)
-                                 .ToList();
+            var updates = new List<UIStateUpdate>();    // TODO: Improve perf for common single-update case
+            foreach (var update in UIState.GetUpdates(oldState, CurrentState))
+            {
+                // First we raise the preview event on this thread
+                // allowing listeners to enable the main-thread event for this update
+                StateUpdatePreview?.Invoke(this, update);
+                if (update.IsEnabled)
+                    updates.Add(update);
+            }
             if (updates.Count > 0)
                 _syncContextMain.Post(RaiseStateUpdates, updates);
         }
@@ -535,7 +548,7 @@ void RaiseStateUpdates(object updates)
         {
             foreach (var update in (List<UIStateUpdate>)updates)
             {
-                StateUpdate(update);
+                StateUpdate?.Invoke(this, update);
             }
         }