Explicitly clear event delegates, more "sane" check COM object checking.

Author: comintern

Rubberduck.VBEEditor/Events/VBENativeServices.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Text;
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.WindowsApi;
@@ -40,6 +39,10 @@ public static void UnhookEvents()
         {
             lock (ThreadLock)
             {
+                SelectionChanged = delegate { };
+                IntelliSenseChanged = delegate { };
+                KeyDown = delegate { };
+                WindowFocusChange = delegate { };
                 User32.UnhookWinEvent(_eventHandle);
                 Subclasses.Dispose();
                 VBEEvents.Terminate();
@@ -92,7 +95,7 @@ public static void VbeEventCallback(IntPtr hWinEventHook, uint eventType, IntPtr
             else if (windowType == WindowType.CodePane && idObject == (int)ObjId.Caret && 
                 (eventType == (uint)WinEvent.ObjectLocationChange || eventType == (uint)WinEvent.ObjectCreate))
             {
-                OnSelectionChanged(hwnd);             
+                OnSelectionChanged(hwnd);
             }
             else if (SubclassManager.IsSubclassable(windowType) && (idObject == (int)ObjId.Window && eventType == (uint)WinEvent.ObjectCreate) ||
                      !Subclasses.IsSubclassed(hwnd))

Rubberduck.VBEEditor/WindowsApi/NativeMethods.cs

@@ -59,6 +59,17 @@ public static class NativeMethods
         [DllImport("user32.dll", CharSet = CharSet.Unicode)]
         public static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, string lclassName, string windowTitle);
 
+        /// <summary>
+        /// Forces the specified region to repaint.
+        /// </summary>
+        /// <param name="hWnd">The window to redraw</param>
+        /// <param name="lprcUpdate">The update region. Ignored if hrgnUpdate is not null.</param>
+        /// <param name="hrgnUpdate">Handle to an update region. Defaults to the entire window if null and lprcUpdate is null</param>
+        /// <param name="flags">Redraw flags.</param>
+        /// <returns></returns>
+        [DllImport("user32.dll")]
+        public static extern bool RedrawWindow(IntPtr hWnd, IntPtr lprcUpdate, IntPtr hrgnUpdate, RedrawWindowFlags flags);
+
         /// <summary>   Gets window caption text by handle. </summary>
         ///
         /// <param name="windowHandle"> Handle of the window to be activated. </param>
@@ -101,4 +112,58 @@ public static void EnumChildWindows(IntPtr parentWindowHandle, EnumChildWindowsD
             }
         }
     }
+
+    [Flags]
+    public enum RedrawWindowFlags : uint
+    {
+        /// <summary>
+        /// Invalidates the rectangle or region that you specify in lprcUpdate or hrgnUpdate.
+        /// You can set only one of these parameters to a non-NULL value. If both are NULL, RDW_INVALIDATE invalidates the entire window.
+        /// </summary>
+        Invalidate = 0x1,
+
+        /// <summary>Causes the OS to post a WM_PAINT message to the window regardless of whether a portion of the window is invalid.</summary>
+        InternalPaint = 0x2,
+
+        /// <summary>
+        /// Causes the window to receive a WM_ERASEBKGND message when the window is repainted.
+        /// Specify this value in combination with the RDW_INVALIDATE value; otherwise, RDW_ERASE has no effect.
+        /// </summary>
+        Erase = 0x4,
+
+        /// <summary>
+        /// Validates the rectangle or region that you specify in lprcUpdate or hrgnUpdate.
+        /// You can set only one of these parameters to a non-NULL value. If both are NULL, RDW_VALIDATE validates the entire window.
+        /// This value does not affect internal WM_PAINT messages.
+        /// </summary>
+        Validate = 0x8,
+
+        NoInternalPaint = 0x10,
+
+        /// <summary>Suppresses any pending WM_ERASEBKGND messages.</summary>
+        NoErase = 0x20,
+
+        /// <summary>Excludes child windows, if any, from the repainting operation.</summary>
+        NoChildren = 0x40,
+
+        /// <summary>Includes child windows, if any, in the repainting operation.</summary>
+        AllChildren = 0x80,
+
+        /// <summary>
+        /// Causes the affected windows, which you specify by setting the RDW_ALLCHILDREN and RDW_NOCHILDREN values, to receive
+        /// WM_ERASEBKGND and WM_PAINT messages before the RedrawWindow returns, if necessary.
+        /// </summary>
+        UpdateNow = 0x100,
+
+        /// <summary>
+        /// Causes the affected windows, which you specify by setting the RDW_ALLCHILDREN and RDW_NOCHILDREN values, to receive WM_ERASEBKGND
+        /// messages before RedrawWindow returns, if necessary.
+        /// The affected windows receive WM_PAINT messages at the ordinary time.
+        /// </summary>
+        EraseNow = 0x200,
+
+        Frame = 0x400,
+
+        NoFrame = 0x800
+    }
 }

Rubberduck.VBEEditor/WindowsApi/VbeAttachableSubclass.cs

@@ -47,20 +47,24 @@ public bool HasValidVbeObject
 
                 try
                 {
-                    if (Marshal.GetIUnknownForObject(_target.Target) != IntPtr.Zero)
+                    var unmanaged = Marshal.GetIUnknownForObject(_target.Target);
+                    if (unmanaged != IntPtr.Zero)
                     {
+                        try
+                        {
+                            Marshal.Release(unmanaged);
+                        }
+                        catch (COMException)
+                        {
+                            // this should be "safe" to hold the reference - it's not like it should go anywhere now... :-/
+                            SubclassLogger.Warn($"{ GetType().Name } failed to dispose of a held { typeof(T).Name } reference.");
+                        }
                         return true;
                     }
-
-                    _target.Dispose();
-                    _target = default;
                 }
-                catch
+                catch (COMException)
                 {
-                    // All paths leading to here mean that we need to ditch the held reference, and there
-                    // isn't jack all that we can do about it.
                     _target = default;
-                    SubclassLogger.Warn($"{ GetType().Name } failed to dispose of a held { typeof(T).Name } reference.");
                 }
                 return false;
             }