First attempt at shutdown / unload improvements

govert · govert · commit 19a70fa16791 · 2016-05-11T01:39:06.000+02:00
diff --git a/Source/ExcelDna.IntelliSense.Host/ExcelDna.IntelliSense.Host.csproj b/Source/ExcelDna.IntelliSense.Host/ExcelDna.IntelliSense.Host.csproj
@@ -73,7 +73,7 @@ xcopy "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn.dna*" "$(TargetDir)ExcelDna.
 xcopy "$(SolutionDir)\packages\ExcelDna.AddIn.0.33.9\tools\ExcelDna64.xll" "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn64.xll*" /C /Y
 "$(SolutionDir)\packages\ExcelDna.AddIn.0.33.9\tools\ExcelDnaPack.exe" "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn.dna" /Y /O "$(TargetDir)ExcelDna.IntelliSense.xll"
 "$(SolutionDir)\packages\ExcelDna.AddIn.0.33.9\tools\ExcelDnaPack.exe" "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn64.dna" /Y /O "$(TargetDir)ExcelDna.IntelliSense64.xll"
-xcopy "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn.xll.config" "$(TargetDir)ExcelDna.IntelliSense.xll.config*"</PostBuildEvent>
+xcopy "$(TargetDir)ExcelDna.IntelliSense.Host-AddIn.xll.config" "$(TargetDir)ExcelDna.IntelliSense.xll.config*" /C /Y</PostBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Source/ExcelDna.IntelliSense/IntelliSenseDisplay.cs b/Source/ExcelDna.IntelliSense/IntelliSenseDisplay.cs
@@ -420,22 +420,22 @@ TextLine GetArgumentDescription(IntelliSenseFunctionInfo.ArgumentInfo argumentIn
 
         public void Dispose()
         {
-            // TODO: How to interact with the pending event callbacks?
-            _syncContextMain.Send(delegate
-                {
-                    if (_descriptionToolTip != null)
-                    {
-                        _descriptionToolTip.Dispose();
-                        _descriptionToolTip = null;
-                    }
-                    if (_argumentsToolTip != null)
-                    {
-                        _argumentsToolTip.Dispose();
-                        _argumentsToolTip = null;
-                    }
-                    _uiMonitor.Dispose();
-                }, null);
-
+            _uiMonitor.StateUpdatePreview -= StateUpdatePreview;
+            _uiMonitor.StateUpdate -= StateUpdate;
+            //// TODO: How to interact with the pending event callbacks?
+            //_syncContextMain.Send(delegate
+            //    {
+            //        if (_descriptionToolTip != null)
+            //        {
+            //            _descriptionToolTip.Dispose();
+            //            _descriptionToolTip = null;
+            //        }
+            //        if (_argumentsToolTip != null)
+            //        {
+            //            _argumentsToolTip.Dispose();
+            //            _argumentsToolTip = null;
+            //        }
+            //    }, null);
             _syncContextMain = null;
         }
 
diff --git a/Source/ExcelDna.IntelliSense/IntelliSenseProvider.cs b/Source/ExcelDna.IntelliSense/IntelliSenseProvider.cs
@@ -277,6 +277,7 @@ void OnInvalidate(object _unused_)
 
         public void Dispose()
         {
+            Logger.Provider.Info("ExcelDnaIntelliSenseProvider.Dispose");
             _loaderNotification.Dispose();
         }
     }
@@ -481,6 +482,10 @@ void OnInvalidate()
 
         public void Dispose()
         {
+            Logger.Provider.Info("WorkbookIntelliSenseProvider.Dispose");
+            var xlApp = (Application)ExcelDnaUtil.Application;
+            xlApp.WorkbookOpen -= Excel_WorkbookOpen;
+            xlApp.WorkbookBeforeClose -= Excel_WorkbookBeforeClose;
         }
     }
 
diff --git a/Source/ExcelDna.IntelliSense/IntelliSenseServer.cs b/Source/ExcelDna.IntelliSense/IntelliSenseServer.cs
@@ -119,8 +119,9 @@ public static void Register()
         // We don't expect DomainUnload to run when Excel is shutting down.
         static void CurrentDomain_DomainUnload(object sender, EventArgs e)
         {
-            // Early shutdown notification
-            XlCall.ShutdownStarted();
+            Logger.Initialization.Info("IntelliSenseServer DomainUnload");
+            //// Early shutdown notification
+            //XlCall.ShutdownStarted();
 
             UnpublishRegistration();
             if (_isActive)
@@ -167,9 +168,10 @@ internal static bool Deactivate()
                 ClearActiveRegistrationInfo();
                 return true;
             }
-            catch (Exception /*ex*/)
+            catch (Exception ex)
             {
                 // TODO: Log
+                Logger.Initialization.Error($"IntelliSenseServer.Deactivate error: {ex}");
                 return false;
             }
         }
diff --git a/Source/ExcelDna.IntelliSense/IntellisenseHelper.cs b/Source/ExcelDna.IntelliSense/IntellisenseHelper.cs
@@ -70,11 +70,16 @@ void UpdateDisplay(IIntelliSenseProvider provider)
 
         public void Dispose()
         {
+            Logger.Initialization.Verbose("IntelliSenseHelper Dispose Start");
+
             foreach (var provider in _providers)
             {
                 provider.Dispose();
             }
+            _uiMonitor.Dispose();
             _display.Dispose();
+
+            Logger.Initialization.Verbose("IntelliSenseHelper Dispose End");
         }
     }
 }
diff --git a/Source/ExcelDna.IntelliSense/LoaderNotification.cs b/Source/ExcelDna.IntelliSense/LoaderNotification.cs
@@ -89,6 +89,7 @@ public LoaderNotification()
         }
 
         // WARNING! LoaderLock danger here
+        //          LoadNotification event handler must be very careful, not load any other managed library etc...
         void Notification(Reason notificationReason, IntPtr pNotificationData, IntPtr context)
         {
             IntPtr pFullDllName = Marshal.ReadIntPtr(pNotificationData, 4);
@@ -112,6 +113,7 @@ protected virtual void Dispose(bool disposing)
                 }
 
                 var status = LdrUnregisterDllNotification(_cookie);
+                Logger.Initialization.Verbose($"LoaderNotification LdrUnregisterDllNotification Result: {status}");
                 disposedValue = true;
             }
         }
@@ -127,7 +129,7 @@ public void Dispose()
         {
             // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             Dispose(true);
-             GC.SuppressFinalize(this);
+            GC.SuppressFinalize(this);
         }
         #endregion
 
diff --git a/Source/ExcelDna.IntelliSense/UIMonitor/FormulaEditWatcher.cs b/Source/ExcelDna.IntelliSense/UIMonitor/FormulaEditWatcher.cs
@@ -246,13 +246,13 @@ void InstallTextChangeMonitor(AutomationElement element)
 
             if (isTextPatternAvailable)
             {
-                Logger.WindowWatcher.Info("FormulaEdit TextPattern adding change handler");
+                Logger.WindowWatcher.Info("FormulaEdit/InCellEdit TextPattern adding change handler");
                 Automation.AddAutomationEventHandler(TextPattern.TextChangedEvent, element, TreeScope.Element, TextChanged);
                 _enableFormulaPolling = false;
             }
             else
             {
-                Logger.WindowWatcher.Info("FormulaEdit TextPattern not available - enabling polling");
+                Logger.WindowWatcher.Info("FormulaEdit/InCellEdit TextPattern not available - enabling polling");
                 _enableFormulaPolling = true;   // Has an effect when focus changes
                 UpdateFormulaPolling();
             }
@@ -263,9 +263,15 @@ void UninstallTextChangeMonitor(AutomationElement element)
             bool isTextPatternAvailable = (bool)element.GetCurrentPropertyValue(AutomationElement.IsTextPatternAvailableProperty);
             if (isTextPatternAvailable)
             {
-                Logger.WindowWatcher.Info("FormulaEdit TextPattern removing change handler");
+                Logger.WindowWatcher.Info("FormulaEdit/InCellEdit removing text change handler");
                 Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, element, TextChanged);
             }
+            else
+            {
+                Logger.WindowWatcher.Info("FormulaEdit/InCellEdit disabling polling");
+                _enableFormulaPolling = false;
+                UpdateFormulaPolling();
+            }
         }
 
         // Breaks the PopupList SelectedItemChange event handler ... !?
@@ -300,13 +306,12 @@ void UpdateFormulaPolling()
                 }
                 else // no focus
                 {
-                    if (_formulaPollingTimer != null)
-                        _formulaPollingTimer.Change(-1, -1);
+                    _formulaPollingTimer?.Change(-1, -1);
                 }
             }
             else if (_formulaPollingTimer != null)
             {
-                _formulaPollingTimer.Dispose();
+                _formulaPollingTimer?.Dispose();
                 _formulaPollingTimer = null;
             }
         }
@@ -425,27 +430,27 @@ void OnStateChanged(StateChangeEventArgs stateChangeEventArgs)
 
         public void Dispose()
         {
-            if (_formulaPollingTimer != null)
-            {
-                _formulaPollingTimer.Dispose();
-            }
+            Logger.WindowWatcher.Verbose("FormulaEdit Disposing");
+            XlCall.ShutdownStarted();
+
             // Not sure we need this:
             _windowWatcher.FormulaBarWindowChanged -= _windowWatcher_FormulaBarWindowChanged;
             _windowWatcher.InCellEditWindowChanged -= _windowWatcher_InCellEditWindowChanged;
 //            _windowWatcher.MainWindowChanged -= _windowWatcher_MainWindowChanged;
 
-            _syncContextAuto.Post(delegate 
+            _formulaPollingTimer?.Dispose();
+            _formulaPollingTimer = null;
+
+            _syncContextAuto.Send(delegate 
             {
-                Debug.Print("Disposing FormulaEditWatcher");
-                //Automation.RemoveAutomationFocusChangedEventHandler(FocusChangedEventHandler);
-                //if (_formulaBar != null)
-                //{
-                //    Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, _formulaBar, TextChanged);
-                //    _formulaBar = null;
-                //}
+                if (_formulaBar != null)
+                {
+                    UninstallTextChangeMonitor(_formulaBar);
+                    _formulaBar = null;
+                }
                 if (_inCellEdit != null)
                 {
-                    Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, _inCellEdit, TextChanged);
+                    UninstallTextChangeMonitor(_inCellEdit);
                     _inCellEdit = null;
                 }
                 //if (_mainWindow != null)
diff --git a/Source/ExcelDna.IntelliSense/UIMonitor/PopupListWatcher.cs b/Source/ExcelDna.IntelliSense/UIMonitor/PopupListWatcher.cs
@@ -313,6 +313,9 @@ void UpdateSelectedItem()
         void UpdateSelectedItem(AutomationElement newSelectedItem)
         {
             // Debug.Print($"POPUPLISTWATCHER WINDOW CURRENT SELECTION {newSelectedItem}");
+
+            // TODO: Sometimes the IsVisble is not updated, but we are visible and the first selection is set
+
             if (!IsVisible || newSelectedItem == null)
             {
                 if (_selectedItem == null &&
@@ -364,7 +367,7 @@ public void Dispose()
             _windowWatcher.PopupListWindowChanged -= _windowWatcher_PopupListWindowChanged;
             _windowWatcher = null;
 
-            _syncContextAuto.Post(delegate
+            _syncContextAuto.Send(delegate
             {
                 Debug.Print("Disposing PopupListWatcher - In Automation context");
                 if (_popupList != null)
diff --git a/Source/ExcelDna.IntelliSense/UIMonitor/UIMonitor.cs b/Source/ExcelDna.IntelliSense/UIMonitor/UIMonitor.cs
@@ -620,12 +620,11 @@ void RaiseStateUpdates(object updates)
 
         public void Dispose()
         {
-
             if (_syncContextAuto == null)
                 return;
 
             // Send is not supported on _syncContextAuto
-            _syncContextAuto.Post(delegate
+            _syncContextAuto.Send(delegate
                 {
                     if (_windowWatcher != null)
                     {
@@ -646,9 +645,16 @@ public void Dispose()
                         _popupListWatcher.Dispose();
                         _popupListWatcher = null;
                     }
-                    _syncContextAuto.Complete();
-                    _syncContextAuto = null;
                 }, null);
+
+            // Let the above delegate and nested calls run, then clean up.
+            // (not sure it makes a difference anymore...)
+            _syncContextAuto.Post(delegate
+            {
+                _syncContextAuto.Complete();
+                _syncContextAuto = null;
+            }, null);
+
         }
     }
 }
diff --git a/Source/ExcelDna.IntelliSense/UIMonitor/WinEvents.cs b/Source/ExcelDna.IntelliSense/UIMonitor/WinEvents.cs
@@ -143,13 +143,13 @@ protected virtual void Dispose(bool disposing)
                 {
                     // TODO: dispose managed state (managed objects).
                 }
-                _syncContextAuto.Post(winEventHook =>
+                _syncContextAuto.Send(winEventHook =>
                 {
                     try
                     {
                         Logger.WinEvents.Info($"UnhookWinEvent called on thread {Thread.CurrentThread.ManagedThreadId}");
                         bool result = UnhookWinEvent((IntPtr)winEventHook);
-                        Logger.WinEvents.Info($"UnhookWinEvent result {result}");
+                        Logger.WinEvents.Info($"UnhookWinEvent success? {result}");
                     }
                     catch (Exception ex)
                     {
@@ -161,18 +161,20 @@ protected virtual void Dispose(bool disposing)
             }
         }
 
-         ~WinEventHook()
-        {
-           // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
-           Dispose(false);
-         }
+        // TODO: Does this make any sense?
+        //       We _have_to_ Unhook from the automation thread...
+        // ~WinEventHook()
+        //{
+        //   // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+        //   Dispose(false);
+        // }
 
         // This code added to correctly implement the disposable pattern.
         public void Dispose()
         {
             // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
             Dispose(true);
-            GC.SuppressFinalize(this);
+            // GC.SuppressFinalize(this);
         }
         #endregion
     }

Original file line number	Diff line number	Diff line change
`@@ -277,6 +277,7 @@ void OnInvalidate(object _unused_)`
`277`	`277`
`278`	`278`	`public void Dispose()`
`279`	`279`	`{`
	`280`	`+ Logger.Provider.Info("ExcelDnaIntelliSenseProvider.Dispose");`
`280`	`281`	`_loaderNotification.Dispose();`
`281`	`282`	`}`
`282`	`283`	`}`
`@@ -481,6 +482,10 @@ void OnInvalidate()`
`481`	`482`
`482`	`483`	`public void Dispose()`
`483`	`484`	`{`
	`485`	`+ Logger.Provider.Info("WorkbookIntelliSenseProvider.Dispose");`
	`486`	`+ var xlApp = (Application)ExcelDnaUtil.Application;`
	`487`	`+ xlApp.WorkbookOpen -= Excel_WorkbookOpen;`
	`488`	`+ xlApp.WorkbookBeforeClose -= Excel_WorkbookBeforeClose;`
`484`	`489`	`}`
`485`	`490`	`}`
`486`	`491`
Original file line number	Diff line number	Diff line change
`@@ -119,8 +119,9 @@ public static void Register()`
`119`	`119`	`// We don't expect DomainUnload to run when Excel is shutting down.`
`120`	`120`	`static void CurrentDomain_DomainUnload(object sender, EventArgs e)`
`121`	`121`	`{`
`122`		`- // Early shutdown notification`
`123`		`- XlCall.ShutdownStarted();`
	`122`	`+ Logger.Initialization.Info("IntelliSenseServer DomainUnload");`
	`123`	`+ //// Early shutdown notification`
	`124`	`+ //XlCall.ShutdownStarted();`
`124`	`125`
`125`	`126`	`UnpublishRegistration();`
`126`	`127`	`if (_isActive)`
`@@ -167,9 +168,10 @@ internal static bool Deactivate()`
`167`	`168`	`ClearActiveRegistrationInfo();`
`168`	`169`	`return true;`
`169`	`170`	`}`
`170`		`- catch (Exception /ex/)`
	`171`	`+ catch (Exception ex)`
`171`	`172`	`{`
`172`	`173`	`// TODO: Log`
	`174`	`+ Logger.Initialization.Error($"IntelliSenseServer.Deactivate error: {ex}");`
`173`	`175`	`return false;`
`174`	`176`	`}`
`175`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -70,11 +70,16 @@ void UpdateDisplay(IIntelliSenseProvider provider)`
`70`	`70`
`71`	`71`	`public void Dispose()`
`72`	`72`	`{`
	`73`	`+ Logger.Initialization.Verbose("IntelliSenseHelper Dispose Start");`
	`74`	`+`
`73`	`75`	`foreach (var provider in _providers)`
`74`	`76`	`{`
`75`	`77`	`provider.Dispose();`
`76`	`78`	`}`
	`79`	`+ _uiMonitor.Dispose();`
`77`	`80`	`_display.Dispose();`
	`81`	`+`
	`82`	`+ Logger.Initialization.Verbose("IntelliSenseHelper Dispose End");`
`78`	`83`	`}`
`79`	`84`	`}`
`80`	`85`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,7 @@ public LoaderNotification()`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`// WARNING! LoaderLock danger here`
	`92`	`+ // LoadNotification event handler must be very careful, not load any other managed library etc...`
`92`	`93`	`void Notification(Reason notificationReason, IntPtr pNotificationData, IntPtr context)`
`93`	`94`	`{`
`94`	`95`	`IntPtr pFullDllName = Marshal.ReadIntPtr(pNotificationData, 4);`
`@@ -112,6 +113,7 @@ protected virtual void Dispose(bool disposing)`
`112`	`113`	`}`
`113`	`114`
`114`	`115`	`var status = LdrUnregisterDllNotification(_cookie);`
	`116`	`+ Logger.Initialization.Verbose($"LoaderNotification LdrUnregisterDllNotification Result: {status}");`
`115`	`117`	`disposedValue = true;`
`116`	`118`	`}`
`117`	`119`	`}`
`@@ -127,7 +129,7 @@ public void Dispose()`
`127`	`129`	`{`
`128`	`130`	`// Do not change this code. Put cleanup code in Dispose(bool disposing) above.`
`129`	`131`	`Dispose(true);`
`130`		`- GC.SuppressFinalize(this);`
	`132`	`+ GC.SuppressFinalize(this);`
`131`	`133`	`}`
`132`	`134`	`#endregion`
`133`	`135`
Original file line number	Diff line number	Diff line change
`@@ -246,13 +246,13 @@ void InstallTextChangeMonitor(AutomationElement element)`
`246`	`246`
`247`	`247`	`if (isTextPatternAvailable)`
`248`	`248`	`{`
`249`		`- Logger.WindowWatcher.Info("FormulaEdit TextPattern adding change handler");`
	`249`	`+ Logger.WindowWatcher.Info("FormulaEdit/InCellEdit TextPattern adding change handler");`
`250`	`250`	`Automation.AddAutomationEventHandler(TextPattern.TextChangedEvent, element, TreeScope.Element, TextChanged);`
`251`	`251`	`_enableFormulaPolling = false;`
`252`	`252`	`}`
`253`	`253`	`else`
`254`	`254`	`{`
`255`		`- Logger.WindowWatcher.Info("FormulaEdit TextPattern not available - enabling polling");`
	`255`	`+ Logger.WindowWatcher.Info("FormulaEdit/InCellEdit TextPattern not available - enabling polling");`
`256`	`256`	`_enableFormulaPolling = true; // Has an effect when focus changes`
`257`	`257`	`UpdateFormulaPolling();`
`258`	`258`	`}`
`@@ -263,9 +263,15 @@ void UninstallTextChangeMonitor(AutomationElement element)`
`263`	`263`	`bool isTextPatternAvailable = (bool)element.GetCurrentPropertyValue(AutomationElement.IsTextPatternAvailableProperty);`
`264`	`264`	`if (isTextPatternAvailable)`
`265`	`265`	`{`
`266`		`- Logger.WindowWatcher.Info("FormulaEdit TextPattern removing change handler");`
	`266`	`+ Logger.WindowWatcher.Info("FormulaEdit/InCellEdit removing text change handler");`
`267`	`267`	`Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, element, TextChanged);`
`268`	`268`	`}`
	`269`	`+ else`
	`270`	`+ {`
	`271`	`+ Logger.WindowWatcher.Info("FormulaEdit/InCellEdit disabling polling");`
	`272`	`+ _enableFormulaPolling = false;`
	`273`	`+ UpdateFormulaPolling();`
	`274`	`+ }`
`269`	`275`	`}`
`270`	`276`
`271`	`277`	`// Breaks the PopupList SelectedItemChange event handler ... !?`
`@@ -300,13 +306,12 @@ void UpdateFormulaPolling()`
`300`	`306`	`}`
`301`	`307`	`else // no focus`
`302`	`308`	`{`
`303`		`- if (_formulaPollingTimer != null)`
`304`		`- _formulaPollingTimer.Change(-1, -1);`
	`309`	`+ _formulaPollingTimer?.Change(-1, -1);`
`305`	`310`	`}`
`306`	`311`	`}`
`307`	`312`	`else if (_formulaPollingTimer != null)`
`308`	`313`	`{`
`309`		`- _formulaPollingTimer.Dispose();`
	`314`	`+ _formulaPollingTimer?.Dispose();`
`310`	`315`	`_formulaPollingTimer = null;`
`311`	`316`	`}`
`312`	`317`	`}`
`@@ -425,27 +430,27 @@ void OnStateChanged(StateChangeEventArgs stateChangeEventArgs)`
`425`	`430`
`426`	`431`	`public void Dispose()`
`427`	`432`	`{`
`428`		`- if (_formulaPollingTimer != null)`
`429`		`- {`
`430`		`- _formulaPollingTimer.Dispose();`
`431`		`- }`
	`433`	`+ Logger.WindowWatcher.Verbose("FormulaEdit Disposing");`
	`434`	`+ XlCall.ShutdownStarted();`
	`435`	`+`
`432`	`436`	`// Not sure we need this:`
`433`	`437`	`_windowWatcher.FormulaBarWindowChanged -= _windowWatcher_FormulaBarWindowChanged;`
`434`	`438`	`_windowWatcher.InCellEditWindowChanged -= _windowWatcher_InCellEditWindowChanged;`
`435`	`439`	`// _windowWatcher.MainWindowChanged -= _windowWatcher_MainWindowChanged;`
`436`	`440`
`437`		`- _syncContextAuto.Post(delegate`
	`441`	`+ _formulaPollingTimer?.Dispose();`
	`442`	`+ _formulaPollingTimer = null;`
	`443`	`+`
	`444`	`+ _syncContextAuto.Send(delegate`
`438`	`445`	`{`
`439`		`- Debug.Print("Disposing FormulaEditWatcher");`
`440`		`- //Automation.RemoveAutomationFocusChangedEventHandler(FocusChangedEventHandler);`
`441`		`- //if (_formulaBar != null)`
`442`		`- //{`
`443`		`- // Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, _formulaBar, TextChanged);`
`444`		`- // _formulaBar = null;`
`445`		`- //}`
	`446`	`+ if (_formulaBar != null)`
	`447`	`+ {`
	`448`	`+ UninstallTextChangeMonitor(_formulaBar);`
	`449`	`+ _formulaBar = null;`
	`450`	`+ }`
`446`	`451`	`if (_inCellEdit != null)`
`447`	`452`	`{`
`448`		`- Automation.RemoveAutomationEventHandler(TextPattern.TextChangedEvent, _inCellEdit, TextChanged);`
	`453`	`+ UninstallTextChangeMonitor(_inCellEdit);`
`449`	`454`	`_inCellEdit = null;`
`450`	`455`	`}`
`451`	`456`	`//if (_mainWindow != null)`
Original file line number	Diff line number	Diff line change
`@@ -313,6 +313,9 @@ void UpdateSelectedItem()`
`313`	`313`	`void UpdateSelectedItem(AutomationElement newSelectedItem)`
`314`	`314`	`{`
`315`	`315`	`// Debug.Print($"POPUPLISTWATCHER WINDOW CURRENT SELECTION {newSelectedItem}");`
	`316`	`+`
	`317`	`+ // TODO: Sometimes the IsVisble is not updated, but we are visible and the first selection is set`
	`318`	`+`
`316`	`319`	`if (!IsVisible \|\| newSelectedItem == null)`
`317`	`320`	`{`
`318`	`321`	`if (_selectedItem == null &&`
`@@ -364,7 +367,7 @@ public void Dispose()`
`364`	`367`	`_windowWatcher.PopupListWindowChanged -= _windowWatcher_PopupListWindowChanged;`
`365`	`368`	`_windowWatcher = null;`
`366`	`369`
`367`		`- _syncContextAuto.Post(delegate`
	`370`	`+ _syncContextAuto.Send(delegate`
`368`	`371`	`{`
`369`	`372`	`Debug.Print("Disposing PopupListWatcher - In Automation context");`
`370`	`373`	`if (_popupList != null)`
Original file line number	Diff line number	Diff line change
`@@ -620,12 +620,11 @@ void RaiseStateUpdates(object updates)`
`620`	`620`
`621`	`621`	`public void Dispose()`
`622`	`622`	`{`
`623`		`-`
`624`	`623`	`if (_syncContextAuto == null)`
`625`	`624`	`return;`
`626`	`625`
`627`	`626`	`// Send is not supported on _syncContextAuto`
`628`		`- _syncContextAuto.Post(delegate`
	`627`	`+ _syncContextAuto.Send(delegate`
`629`	`628`	`{`
`630`	`629`	`if (_windowWatcher != null)`
`631`	`630`	`{`
`@@ -646,9 +645,16 @@ public void Dispose()`
`646`	`645`	`_popupListWatcher.Dispose();`
`647`	`646`	`_popupListWatcher = null;`
`648`	`647`	`}`
`649`		`- _syncContextAuto.Complete();`
`650`		`- _syncContextAuto = null;`
`651`	`648`	`}, null);`
	`649`	`+`
	`650`	`+ // Let the above delegate and nested calls run, then clean up.`
	`651`	`+ // (not sure it makes a difference anymore...)`
	`652`	`+ _syncContextAuto.Post(delegate`
	`653`	`+ {`
	`654`	`+ _syncContextAuto.Complete();`
	`655`	`+ _syncContextAuto = null;`
	`656`	`+ }, null);`
	`657`	`+`
`652`	`658`	`}`
`653`	`659`	`}`
`654`	`660`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,13 +143,13 @@ protected virtual void Dispose(bool disposing)`
`143`	`143`	`{`
`144`	`144`	`// TODO: dispose managed state (managed objects).`
`145`	`145`	`}`
`146`		`- _syncContextAuto.Post(winEventHook =>`
	`146`	`+ _syncContextAuto.Send(winEventHook =>`
`147`	`147`	`{`
`148`	`148`	`try`
`149`	`149`	`{`
`150`	`150`	`Logger.WinEvents.Info($"UnhookWinEvent called on thread {Thread.CurrentThread.ManagedThreadId}");`
`151`	`151`	`bool result = UnhookWinEvent((IntPtr)winEventHook);`
`152`		`- Logger.WinEvents.Info($"UnhookWinEvent result {result}");`
	`152`	`+ Logger.WinEvents.Info($"UnhookWinEvent success? {result}");`
`153`	`153`	`}`
`154`	`154`	`catch (Exception ex)`
`155`	`155`	`{`
`@@ -161,18 +161,20 @@ protected virtual void Dispose(bool disposing)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`- ~WinEventHook()`
`165`		`- {`
`166`		`- // Do not change this code. Put cleanup code in Dispose(bool disposing) above.`
`167`		`- Dispose(false);`
`168`		`- }`
	`164`	`+ // TODO: Does this make any sense?`
	`165`	`+ // We _have_to_ Unhook from the automation thread...`
	`166`	`+ // ~WinEventHook()`
	`167`	`+ //{`
	`168`	`+ // // Do not change this code. Put cleanup code in Dispose(bool disposing) above.`
	`169`	`+ // Dispose(false);`
	`170`	`+ // }`
`169`	`171`
`170`	`172`	`// This code added to correctly implement the disposable pattern.`
`171`	`173`	`public void Dispose()`
`172`	`174`	`{`
`173`	`175`	`// Do not change this code. Put cleanup code in Dispose(bool disposing) above.`
`174`	`176`	`Dispose(true);`
`175`		`- GC.SuppressFinalize(this);`
	`177`	`+ // GC.SuppressFinalize(this);`
`176`	`178`	`}`
`177`	`179`	`#endregion`
`178`	`180`	`}`