Ensure call to LPenHelper is made from the main thread and add inactivity timeout of 100ms before calling it

gmichaud · gmichaud · commit c9e20eebb9a2 · 2020-09-02T10:11:02.000-04:00
diff --git a/Source/ExcelDna.IntelliSense/ExcelDna.IntelliSense.csproj b/Source/ExcelDna.IntelliSense/ExcelDna.IntelliSense.csproj
@@ -88,6 +88,7 @@
     <Compile Include="UIMonitor\UIState.cs" />
     <Compile Include="UIMonitor\WindowLocationWatcher.cs" />
     <Compile Include="UIMonitor\WindowWatcher.cs" />
+    <Compile Include="Util\RenewableDelayExecutor.cs" />
     <Compile Include="Win32Helper.cs" />
     <Compile Include="Providers\LoaderNotification.cs" />
     <Compile Include="UIMonitor\WinEvents.cs" />
diff --git a/Source/ExcelDna.IntelliSense/UIMonitor/FormulaEditWatcher.cs b/Source/ExcelDna.IntelliSense/UIMonitor/FormulaEditWatcher.cs
@@ -1,4 +1,5 @@
-﻿using System;
+﻿using ExcelDna.IntelliSense.Util;
+using System;
 using System.Diagnostics;
 using System.Threading;
 using System.Windows;
@@ -71,11 +72,15 @@ public IntPtr FormulaEditWindow
         readonly SynchronizationContext _syncContextMain;
 
         readonly WindowWatcher _windowWatcher;          // Passed in
-        WindowLocationWatcher  _windowLocationWatcher;  // Managed here
 
-        IntPtr            _hwndFormulaBar;
-        IntPtr            _hwndInCellEdit;
-        FormulaEditFocus  _formulaEditFocus;
+        WindowLocationWatcher _windowLocationWatcher;  // Managed here
+        readonly RenewableDelayExecutor _updateEditStateAfterTimeout;
+
+        IntPtr _hwndFormulaBar;
+        IntPtr _hwndInCellEdit;
+        FormulaEditFocus _formulaEditFocus;
+
+        const int DelayBeforeStateUpdateMilliseconds = 100;
 
         public FormulaEditWatcher(WindowWatcher windowWatcher, SynchronizationContext syncContextAuto, SynchronizationContext syncContextMain)
         {
@@ -84,6 +89,7 @@ public FormulaEditWatcher(WindowWatcher windowWatcher, SynchronizationContext sy
             _windowWatcher = windowWatcher;
             _windowWatcher.FormulaBarWindowChanged += _windowWatcher_FormulaBarWindowChanged;
             _windowWatcher.InCellEditWindowChanged += _windowWatcher_InCellEditWindowChanged;
+            _updateEditStateAfterTimeout = new RenewableDelayExecutor(DelayBeforeStateUpdateMilliseconds, () => UpdateEditState());
         }
 
         // Runs on the Automation thread
@@ -95,13 +101,13 @@ void _windowWatcher_FormulaBarWindowChanged(object sender, WindowWatcher.WindowC
                     if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Self)
                     {
                         SetEditWindow(e.WindowHandle, ref _hwndFormulaBar);
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)
                     {
                         // We expect this on every text change
                         // NOTE: Not anymore after some Excel / Windows update
-                        UpdateEditStateDelayed();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else
                     {
@@ -126,29 +132,29 @@ void _windowWatcher_FormulaBarWindowChanged(object sender, WindowWatcher.WindowC
                             SetEditWindow(e.WindowHandle, ref _hwndFormulaBar);
                         }
                         _formulaEditFocus = FormulaEditFocus.FormulaBar;
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.Unfocus:
                     if (_formulaEditFocus == FormulaEditFocus.FormulaBar)
                     {
                         Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Unfocus");
                         _formulaEditFocus = FormulaEditFocus.None;
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.Show:
-                        Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Show");
+                    Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Show");
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.Hide:
-                        Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Hide");
+                    Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Hide");
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.LocationChange:
                     if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)
                     {
                         // We expect this on every text change in newer Excel versions
                         Debug.Print($"-#-#-#- Text Changed ... ");
-                        UpdateEditStateDelayed();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else
                     {
@@ -172,14 +178,14 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC
                     if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Self)
                     {
                         SetEditWindow(e.WindowHandle, ref _hwndInCellEdit);
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)
                     {
                         // We expect this on every text change 
                         // NOTE: Not anymore after some Excel / Windows update
                         Debug.Print($"-#-#-#- Text Changed ... ");
-                        UpdateEditStateDelayed();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else
                     {
@@ -206,15 +212,15 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC
                         Logger.WindowWatcher.Verbose($"FormulaEdit - InCellEdit Focus");
 
                         _formulaEditFocus = FormulaEditFocus.InCellEdit;
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.Unfocus:
                     if (_formulaEditFocus == FormulaEditFocus.InCellEdit)
                     {
                         Logger.WindowWatcher.Verbose($"FormulaEdit - InCellEdit Unfocus");
                         _formulaEditFocus = FormulaEditFocus.None;
-                        UpdateEditState();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     break;
                 case WindowWatcher.WindowChangedEventArgs.ChangeType.Show:
@@ -228,7 +234,7 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC
                     {
                         // We expect this on every text change in newer Excel versions
                         Debug.Print($"-#-#-#- Text Changed ... ");
-                        UpdateEditStateDelayed();
+                        _updateEditStateAfterTimeout.Signal();
                     }
                     else
                     {
@@ -313,22 +319,20 @@ void _windowLocationWatcher_LocationChanged(object sender, EventArgs e)
         //    UpdateFormula(textChangedOnly: true);
         //}
 
-        // TODO: Get rid of this somehow - added to make the mouse clicks in the in-cell editing work, by delaying the call to the PenHelper
-        void UpdateEditStateDelayed()
+        void UpdateEditState(bool moveOnly = false)
         {
-            _syncContextAuto.Post(_ =>
-           {
-               Thread.Sleep(100);
-               UpdateEditState();
-           }, null);
+            // Switches to our Main UI thread, updates current state and raises StateChanged event
+            _syncContextMain.Post(_ =>
+            {
+                UpdateEditStateImpl(moveOnly);
+            }, null);
         }
 
-        // Switches to our Automation thread, updates current state and raises StateChanged event
-        void UpdateEditState(bool moveOnly = false)
+        void UpdateEditStateImpl(bool moveOnly = false)
         {
             Logger.WindowWatcher.Verbose($"> FormulaEdit UpdateEditState - Thread {Thread.CurrentThread.ManagedThreadId}");
             Logger.WindowWatcher.Verbose($"FormulaEdit UpdateEditState - Focus: {_formulaEditFocus} Window: {(_formulaEditFocus == FormulaEditFocus.FormulaBar ? _hwndFormulaBar : _hwndInCellEdit)}");
-            
+
             IntPtr hwnd = IntPtr.Zero;
             bool prefixChanged = false;
             if (_formulaEditFocus == FormulaEditFocus.FormulaBar)
@@ -410,6 +414,9 @@ public void Dispose()
             Debug.Assert(Thread.CurrentThread.ManagedThreadId == 1);
 
             Logger.WindowWatcher.Verbose("FormulaEdit Dispose Begin");
+
+            _updateEditStateAfterTimeout.Dispose();
+
             _windowWatcher.FormulaBarWindowChanged -= _windowWatcher_FormulaBarWindowChanged;
             _windowWatcher.InCellEditWindowChanged -= _windowWatcher_InCellEditWindowChanged;
 
@@ -419,7 +426,8 @@ public void Dispose()
             {
                 tempWatcher.Dispose();
             }
+
             Logger.WindowWatcher.Verbose("FormulaEdit Dispose End");
         }
     }
-}
+}
diff --git a/Source/ExcelDna.IntelliSense/Util/RenewableDelayExecutor.cs b/Source/ExcelDna.IntelliSense/Util/RenewableDelayExecutor.cs
@@ -0,0 +1,67 @@
+﻿using System;
+using System.Timers;
+
+namespace ExcelDna.IntelliSense.Util
+{
+    /// <summary>
+    /// Upon a signal, executes the specified action after the specified delay.
+    /// If any other signal arrives during the waiting period, the delay interval begins anew.
+    /// </summary>
+    internal class RenewableDelayExecutor : IDisposable
+    {
+        private readonly Timer _timer;
+        private readonly Action _action;
+        private readonly int _debounceIntervalMilliseconds;
+
+        public bool IsDisposed { get; private set; }
+
+        public RenewableDelayExecutor(int debounceIntervalMilliseconds, Action action)
+        {
+            _action = action;
+            _debounceIntervalMilliseconds = debounceIntervalMilliseconds;
+            _timer = new Timer
+            {
+                AutoReset = false,
+                Interval = _debounceIntervalMilliseconds,
+            };
+
+            _timer.Elapsed += OnTimerElapsed;
+        }
+
+        private void OnTimerElapsed(object sender, ElapsedEventArgs e)
+        {
+            if (IsDisposed)
+            {
+                return;
+            }
+
+            _action();
+        }
+
+        public void Signal()
+        {
+            _timer.Stop();
+            _timer.Start();
+        }
+
+        private void Dispose(bool isDisposing)
+        {
+            IsDisposed = true;
+
+            _timer.Elapsed -= OnTimerElapsed;
+            _timer.Dispose();
+
+            if (isDisposing)
+            {
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        public void Dispose() => Dispose(true);
+
+        ~RenewableDelayExecutor()
+        {
+            Dispose(false);
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System;`
	`1`	`+using ExcelDna.IntelliSense.Util;`
	`2`	`+using System;`
`2`	`3`	`using System.Diagnostics;`
`3`	`4`	`using System.Threading;`
`4`	`5`	`using System.Windows;`
`@@ -71,11 +72,15 @@ public IntPtr FormulaEditWindow`
`71`	`72`	`readonly SynchronizationContext _syncContextMain;`
`72`	`73`
`73`	`74`	`readonly WindowWatcher _windowWatcher; // Passed in`
`74`		`- WindowLocationWatcher _windowLocationWatcher; // Managed here`
`75`	`75`
`76`		`- IntPtr _hwndFormulaBar;`
`77`		`- IntPtr _hwndInCellEdit;`
`78`		`- FormulaEditFocus _formulaEditFocus;`
	`76`	`+ WindowLocationWatcher _windowLocationWatcher; // Managed here`
	`77`	`+ readonly RenewableDelayExecutor _updateEditStateAfterTimeout;`
	`78`	`+`
	`79`	`+ IntPtr _hwndFormulaBar;`
	`80`	`+ IntPtr _hwndInCellEdit;`
	`81`	`+ FormulaEditFocus _formulaEditFocus;`
	`82`	`+`
	`83`	`+ const int DelayBeforeStateUpdateMilliseconds = 100;`
`79`	`84`
`80`	`85`	`public FormulaEditWatcher(WindowWatcher windowWatcher, SynchronizationContext syncContextAuto, SynchronizationContext syncContextMain)`
`81`	`86`	`{`
`@@ -84,6 +89,7 @@ public FormulaEditWatcher(WindowWatcher windowWatcher, SynchronizationContext sy`
`84`	`89`	`_windowWatcher = windowWatcher;`
`85`	`90`	`_windowWatcher.FormulaBarWindowChanged += _windowWatcher_FormulaBarWindowChanged;`
`86`	`91`	`_windowWatcher.InCellEditWindowChanged += _windowWatcher_InCellEditWindowChanged;`
	`92`	`+ _updateEditStateAfterTimeout = new RenewableDelayExecutor(DelayBeforeStateUpdateMilliseconds, () => UpdateEditState());`
`87`	`93`	`}`
`88`	`94`
`89`	`95`	`// Runs on the Automation thread`
`@@ -95,13 +101,13 @@ void _windowWatcher_FormulaBarWindowChanged(object sender, WindowWatcher.WindowC`
`95`	`101`	`if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Self)`
`96`	`102`	`{`
`97`	`103`	`SetEditWindow(e.WindowHandle, ref _hwndFormulaBar);`
`98`		`- UpdateEditState();`
	`104`	`+ _updateEditStateAfterTimeout.Signal();`
`99`	`105`	`}`
`100`	`106`	`else if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)`
`101`	`107`	`{`
`102`	`108`	`// We expect this on every text change`
`103`	`109`	`// NOTE: Not anymore after some Excel / Windows update`
`104`		`- UpdateEditStateDelayed();`
	`110`	`+ _updateEditStateAfterTimeout.Signal();`
`105`	`111`	`}`
`106`	`112`	`else`
`107`	`113`	`{`
`@@ -126,29 +132,29 @@ void _windowWatcher_FormulaBarWindowChanged(object sender, WindowWatcher.WindowC`
`126`	`132`	`SetEditWindow(e.WindowHandle, ref _hwndFormulaBar);`
`127`	`133`	`}`
`128`	`134`	`_formulaEditFocus = FormulaEditFocus.FormulaBar;`
`129`		`- UpdateEditState();`
	`135`	`+ _updateEditStateAfterTimeout.Signal();`
`130`	`136`	`}`
`131`	`137`	`break;`
`132`	`138`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.Unfocus:`
`133`	`139`	`if (_formulaEditFocus == FormulaEditFocus.FormulaBar)`
`134`	`140`	`{`
`135`	`141`	`Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Unfocus");`
`136`	`142`	`_formulaEditFocus = FormulaEditFocus.None;`
`137`		`- UpdateEditState();`
	`143`	`+ _updateEditStateAfterTimeout.Signal();`
`138`	`144`	`}`
`139`	`145`	`break;`
`140`	`146`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.Show:`
`141`		`- Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Show");`
	`147`	`+ Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Show");`
`142`	`148`	`break;`
`143`	`149`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.Hide:`
`144`		`- Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Hide");`
	`150`	`+ Logger.WindowWatcher.Verbose($"FormulaEdit - FormulaBar Hide");`
`145`	`151`	`break;`
`146`	`152`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.LocationChange:`
`147`	`153`	`if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)`
`148`	`154`	`{`
`149`	`155`	`// We expect this on every text change in newer Excel versions`
`150`	`156`	`Debug.Print($"-#-#-#- Text Changed ... ");`
`151`		`- UpdateEditStateDelayed();`
	`157`	`+ _updateEditStateAfterTimeout.Signal();`
`152`	`158`	`}`
`153`	`159`	`else`
`154`	`160`	`{`
`@@ -172,14 +178,14 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC`
`172`	`178`	`if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Self)`
`173`	`179`	`{`
`174`	`180`	`SetEditWindow(e.WindowHandle, ref _hwndInCellEdit);`
`175`		`- UpdateEditState();`
	`181`	`+ _updateEditStateAfterTimeout.Signal();`
`176`	`182`	`}`
`177`	`183`	`else if (e.ObjectId == WindowWatcher.WindowChangedEventArgs.ChangeObjectId.Caret)`
`178`	`184`	`{`
`179`	`185`	`// We expect this on every text change`
`180`	`186`	`// NOTE: Not anymore after some Excel / Windows update`
`181`	`187`	`Debug.Print($"-#-#-#- Text Changed ... ");`
`182`		`- UpdateEditStateDelayed();`
	`188`	`+ _updateEditStateAfterTimeout.Signal();`
`183`	`189`	`}`
`184`	`190`	`else`
`185`	`191`	`{`
`@@ -206,15 +212,15 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC`
`206`	`212`	`Logger.WindowWatcher.Verbose($"FormulaEdit - InCellEdit Focus");`
`207`	`213`
`208`	`214`	`_formulaEditFocus = FormulaEditFocus.InCellEdit;`
`209`		`- UpdateEditState();`
	`215`	`+ _updateEditStateAfterTimeout.Signal();`
`210`	`216`	`}`
`211`	`217`	`break;`
`212`	`218`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.Unfocus:`
`213`	`219`	`if (_formulaEditFocus == FormulaEditFocus.InCellEdit)`
`214`	`220`	`{`
`215`	`221`	`Logger.WindowWatcher.Verbose($"FormulaEdit - InCellEdit Unfocus");`
`216`	`222`	`_formulaEditFocus = FormulaEditFocus.None;`
`217`		`- UpdateEditState();`
	`223`	`+ _updateEditStateAfterTimeout.Signal();`
`218`	`224`	`}`
`219`	`225`	`break;`
`220`	`226`	`case WindowWatcher.WindowChangedEventArgs.ChangeType.Show:`
`@@ -228,7 +234,7 @@ void _windowWatcher_InCellEditWindowChanged(object sender, WindowWatcher.WindowC`
`228`	`234`	`{`
`229`	`235`	`// We expect this on every text change in newer Excel versions`
`230`	`236`	`Debug.Print($"-#-#-#- Text Changed ... ");`
`231`		`- UpdateEditStateDelayed();`
	`237`	`+ _updateEditStateAfterTimeout.Signal();`
`232`	`238`	`}`
`233`	`239`	`else`
`234`	`240`	`{`
`@@ -313,22 +319,20 @@ void _windowLocationWatcher_LocationChanged(object sender, EventArgs e)`
`313`	`319`	`// UpdateFormula(textChangedOnly: true);`
`314`	`320`	`//}`
`315`	`321`
`316`		`- // TODO: Get rid of this somehow - added to make the mouse clicks in the in-cell editing work, by delaying the call to the PenHelper`
`317`		`- void UpdateEditStateDelayed()`
	`322`	`+ void UpdateEditState(bool moveOnly = false)`
`318`	`323`	`{`
`319`		`- _syncContextAuto.Post(_ =>`
`320`		`- {`
`321`		`- Thread.Sleep(100);`
`322`		`- UpdateEditState();`
`323`		`- }, null);`
	`324`	`+ // Switches to our Main UI thread, updates current state and raises StateChanged event`
	`325`	`+ _syncContextMain.Post(_ =>`
	`326`	`+ {`
	`327`	`+ UpdateEditStateImpl(moveOnly);`
	`328`	`+ }, null);`
`324`	`329`	`}`
`325`	`330`
`326`		`- // Switches to our Automation thread, updates current state and raises StateChanged event`
`327`		`- void UpdateEditState(bool moveOnly = false)`
	`331`	`+ void UpdateEditStateImpl(bool moveOnly = false)`
`328`	`332`	`{`
`329`	`333`	`Logger.WindowWatcher.Verbose($"> FormulaEdit UpdateEditState - Thread {Thread.CurrentThread.ManagedThreadId}");`
`330`	`334`	`Logger.WindowWatcher.Verbose($"FormulaEdit UpdateEditState - Focus: {_formulaEditFocus} Window: {(_formulaEditFocus == FormulaEditFocus.FormulaBar ? _hwndFormulaBar : _hwndInCellEdit)}");`
`331`		`-`
	`335`	`+`
`332`	`336`	`IntPtr hwnd = IntPtr.Zero;`
`333`	`337`	`bool prefixChanged = false;`
`334`	`338`	`if (_formulaEditFocus == FormulaEditFocus.FormulaBar)`
`@@ -410,6 +414,9 @@ public void Dispose()`
`410`	`414`	`Debug.Assert(Thread.CurrentThread.ManagedThreadId == 1);`
`411`	`415`
`412`	`416`	`Logger.WindowWatcher.Verbose("FormulaEdit Dispose Begin");`
	`417`	`+`
	`418`	`+ _updateEditStateAfterTimeout.Dispose();`
	`419`	`+`
`413`	`420`	`_windowWatcher.FormulaBarWindowChanged -= _windowWatcher_FormulaBarWindowChanged;`
`414`	`421`	`_windowWatcher.InCellEditWindowChanged -= _windowWatcher_InCellEditWindowChanged;`
`415`	`422`
`@@ -419,7 +426,8 @@ public void Dispose()`
`419`	`426`	`{`
`420`	`427`	`tempWatcher.Dispose();`
`421`	`428`	`}`
	`429`	`+`
`422`	`430`	`Logger.WindowWatcher.Verbose("FormulaEdit Dispose End");`
`423`	`431`	`}`
`424`	`432`	`}`
`425`		`-}`
	`433`	`+}`