Merge pull request #4331 from mansellan/Firehose

WM Firehose improvements (debug builds only)

Author: retailcoder

Rubberduck.VBEEditor/Events/VBENativeServices.cs

@@ -80,11 +80,21 @@ public static void VbeEventCallback(IntPtr hWinEventHook, uint eventType, IntPtr
         {
             if (Suspend || hwnd == IntPtr.Zero || _vbe.IsWrappingNullReference) { return; }
 
-#if THIRSTY_DUCK && DEBUG
+            var windowType = hwnd.ToWindowType();
+
+#if (DEBUG && (THIRSTY_DUCK || THIRSTY_DUCK_EVT))            
+
             //This is an output window firehose, viewer discretion is advised.
-            if (idObject != (int)ObjId.Cursor) { Debug.WriteLine("Hwnd: {0:X4} - EventType {1:X4}, idObject {2}, idChild {3}", (int)hwnd, eventType, idObject, idChild); }
+            if (idObject != (int)ObjId.Cursor)
+            {
+                var windowClassName = hwnd.ToClassName();
+                if (!WinEventMap.Lookup.TryGetValue((int)eventType, out var eventName))
+                {
+                    eventName = "Unknown";
+                }
+                Debug.WriteLine($"EVT: 0x{eventType:X4} ({eventName}) Hwnd 0x{(int)hwnd:X4} ({windowClassName}), idObject {idObject}, idChild {idChild}");
+            }
 #endif
-            var windowType = hwnd.ToWindowType();
 
             if (windowType == WindowType.IntelliSense)
             {

Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj

@@ -98,6 +98,7 @@
     <Compile Include="SafeComWrappers\SafeRedirectedEventedComWrapper.cs" />
     <Compile Include="SafeComWrappers\VB\Abstract\IHostApplication.cs" />
     <Compile Include="SafeComWrappers\VB\Enums\VBEKind.cs" />
+    <Compile Include="Utility\EnumHelper.cs" />
     <Compile Include="Utility\UiContext.cs" />
     <Compile Include="VBERuntime\IVBERuntime.cs" />
     <Compile Include="VBERuntime\Settings\IVBESettings.cs" />

Rubberduck.VBEEditor/Utility/EnumHelper.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+namespace Rubberduck.VBEditor.Utility
+{
+    public static class EnumHelper
+    {
+        public static Dictionary<TUnderlying, string> ToDictionary<TEnum, TUnderlying>()
+        {
+            var enumType = typeof(TEnum);
+            var underlyingType = typeof(TUnderlying);
+            var actualUnderlyingType = Enum.GetUnderlyingType(enumType);
+
+            Debug.Assert(enumType.IsEnum, $"Type '{enumType.Name}' is not an enum");
+            Debug.Assert(actualUnderlyingType == underlyingType, $"Underlying type parameter '{underlyingType.Name}' does not match actual underlying type for enum '{enumType.Name}' ('{actualUnderlyingType.Name}')");
+            
+            var dictionary = new Dictionary<TUnderlying, string>();
+
+            foreach (var fieldInfo in enumType.GetFields().Where(fi => fi.FieldType.IsEnum))
+            {
+                if (fieldInfo.GetCustomAttributes(typeof(ReflectionIgnoreAttribute), false).Any())
+                {
+                    continue;
+                }
+
+                var key = (TUnderlying) fieldInfo.GetRawConstantValue();
+
+                dictionary[key] = dictionary.ContainsKey(key)
+                    ? $"{dictionary[key]} / {fieldInfo.Name}"
+                    : fieldInfo.Name;
+            }
+
+            return dictionary;
+        }
+    }
+
+    public class ReflectionIgnoreAttribute : Attribute
+    {
+    }
+}

Rubberduck.VBEEditor/WindowsApi/DesignerWindowSubclass.cs

@@ -20,10 +20,6 @@ public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr
                 DispatchFocusEvent(FocusType.GotFocus);
             }
 
-#if THIRSTY_DUCK && DEBUG
-            //This is an output window firehose kind of like spy++. Prepare for some spam.
-            Debug.WriteLine("WM: {0:X4}, wParam {1}, lParam {2}", msg, wParam, lParam);
-#endif
             return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData);
         }
     }

Rubberduck.VBEEditor/WindowsApi/SubclassingWindow.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using System.Text;
 using NLog;
 
 namespace Rubberduck.VBEditor.WindowsApi
@@ -85,6 +86,22 @@ public virtual int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr l
                 return DefSubclassProc(hWnd, msg, wParam, lParam);
             }
 
+#if (DEBUG && (THIRSTY_DUCK || THIRSTY_DUCK_WM))
+            //This is an output window firehose kind of like spy++. Prepare for some spam.
+            var windowClassName = ToClassName(hWnd);
+            if (WM_MAP.Lookup.TryGetValue((uint) msg, out var wmName))
+            {
+                wmName = $"WM_{wmName}";
+            }
+            else
+            {
+                wmName = "Unknown";
+            }
+
+
+            Debug.WriteLine($"MSG: 0x{(uint)msg:X4} ({wmName}), Hwnd 0x{(uint)hWnd:X4} ({windowClassName}), wParam 0x{(uint)wParam:X4}, lParam 0x{(uint)lParam:X4}");
+#endif
+
             if ((uint) msg == (uint) WM.DESTROY)
             {
                 Dispose();
@@ -107,5 +124,12 @@ protected virtual void Dispose(bool disposing)
 
             _disposed = true;
         }
+
+        private static string ToClassName(IntPtr hwnd)
+        {
+            var name = new StringBuilder(User32.MaxGetClassNameBufferSize);
+            User32.GetClassName(hwnd, name, name.Capacity);
+            return name.ToString();
+        }
     }
 }

Rubberduck.VBEEditor/WindowsApi/WM.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using Rubberduck.VBEditor.Utility;
 
 namespace Rubberduck.VBEditor.WindowsApi
 {
@@ -395,6 +397,7 @@ public enum WM : uint
         /// <summary>
         /// This message filters for keyboard messages.
         /// </summary>
+        [ReflectionIgnore]
         KEYFIRST = 0x0100,
         /// <summary>
         /// The WM_KEYDOWN message is posted to the window with the keyboard focus when a nonsystem key is pressed. A nonsystem key is a key that is pressed when the ALT key is not pressed. 
@@ -436,6 +439,7 @@ public enum WM : uint
         /// <summary>
         /// This message filters for keyboard messages.
         /// </summary>
+        [ReflectionIgnore]
         KEYLAST = 0x0109,
         /// <summary>
         /// Sent immediately before the IME generates the composition string as a result of a keystroke. A window receives this message through its WindowProc function. 
@@ -449,6 +453,8 @@ public enum WM : uint
         /// Sent to an application when the IME changes composition status as a result of a keystroke. A window receives this message through its WindowProc function. 
         /// </summary>
         IME_COMPOSITION = 0x010F,
+
+        [ReflectionIgnore]
         IME_KEYLAST = 0x010F,
         /// <summary>
         /// The WM_INITDIALOG message is sent to the dialog box procedure immediately before a dialog box is displayed. Dialog box procedures typically use this message to initialize controls and carry out any other initialization tasks that affect the appearance of the dialog box. 
@@ -557,6 +563,7 @@ public enum WM : uint
         /// <summary>
         /// Use WM_MOUSEFIRST to specify the first mouse message. Use the PeekMessage() Function.
         /// </summary>
+        [ReflectionIgnore]
         MOUSEFIRST = 0x0200,
         /// <summary>
         /// The WM_MOUSEMOVE message is posted to a window when the cursor moves. If the mouse is not captured, the message is posted to the window that contains the cursor. Otherwise, the message is posted to the window that has captured the mouse.
@@ -621,6 +628,7 @@ public enum WM : uint
         /// <summary>
         /// Use WM_MOUSELAST to specify the last mouse message. Used with PeekMessage() Function.
         /// </summary>
+        [ReflectionIgnore]
         MOUSELAST = 0x020E,
         /// <summary>
         /// The WM_PARENTNOTIFY message is sent to the parent of a child window when the child window is created or destroyed, or when the user clicks a mouse button while the cursor is over the child window. When the child window is being created, the system sends WM_PARENTNOTIFY just before the CreateWindow or CreateWindowEx function that creates the window returns. When the child window is being destroyed, the system sends the message before any processing to destroy the window takes place.
@@ -903,10 +911,12 @@ public enum WM : uint
         /// <summary>
         /// The WM_APP constant is used by applications to help define private messages, usually of the form WM_APP+X, where X is an integer value. 
         /// </summary>
+        [ReflectionIgnore]
         APP = 0x8000,
         /// <summary>
         /// The WM_USER constant is used by applications to help define private messages for use by private window classes, usually of the form WM_USER+X, where X is an integer value. 
         /// </summary>
+        [ReflectionIgnore]
         USER = 0x0400,
 
         /// <summary>
@@ -930,51 +940,14 @@ public enum WM : uint
         /// Private message to signal focus RD shutdown. No parameters.
         /// </summary>        
         RUBBERDUCK_SINKING = USER + 0x0D1E,
+    }
 
-        /// <summary>
-        /// The accessibility state has changed.
-        /// </summary>
-        HSHELL_ACCESSIBILITYSTATE = 11,
-        /// <summary>
-        /// The shell should activate its main window.
-        /// </summary>
-        HSHELL_ACTIVATESHELLWINDOW = 3,
-        /// <summary>
-        /// The user completed an input event (for example, pressed an application command button on the mouse or an application command key on the keyboard), and the application did not handle the WM_APPCOMMAND message generated by that input.
-        /// If the Shell procedure handles the WM_COMMAND message, it should not call CallNextHookEx. See the Return Value section for more information.
-        /// </summary>
-        HSHELL_APPCOMMAND = 12,
-        /// <summary>
-        /// A window is being minimized or maximized. The system needs the coordinates of the minimized rectangle for the window.
-        /// </summary>
-        HSHELL_GETMINRECT = 5,
-        /// <summary>
-        /// Keyboard language was changed or a new keyboard layout was loaded.
-        /// </summary>
-        HSHELL_LANGUAGE = 8,
-        /// <summary>
-        /// The title of a window in the task bar has been redrawn.
-        /// </summary>
-        HSHELL_REDRAW = 6,
-        /// <summary>
-        /// The user has selected the task list. A shell application that provides a task list should return TRUE to prevent Windows from starting its task list.
-        /// </summary>
-        HSHELL_TASKMAN = 7,
-        /// <summary>
-        /// A top-level, unowned window has been created. The window exists when the system calls this hook.
-        /// </summary>
-        HSHELL_WINDOWCREATED = 1,
-        /// <summary>
-        /// A top-level, unowned window is about to be destroyed. The window still exists when the system calls this hook.
-        /// </summary>
-        HSHELL_WINDOWDESTROYED = 2,
-        /// <summary>
-        /// The activation has changed to a different top-level, unowned window.
-        /// </summary>
-        HSHELL_WINDOWACTIVATED = 4,
-        /// <summary>
-        /// A top-level window is being replaced. The window exists when the system calls this hook.
-        /// </summary>
-        HSHELL_WINDOWREPLACED = 13
+#if (DEBUG && (THIRSTY_DUCK || THIRSTY_DUCK_WM))
+
+    public static class WM_MAP
+    {
+        public static readonly Dictionary<uint, string> Lookup = EnumHelper.ToDictionary<WM, uint>();
     }
+
+#endif
 }

Rubberduck.VBEEditor/WindowsApi/WinEvent.cs

@@ -1,7 +1,11 @@
-namespace Rubberduck.VBEditor.WindowsApi
+using System.Collections.Generic;
+using Rubberduck.VBEditor.Utility;
+
+namespace Rubberduck.VBEditor.WindowsApi
 {
     public enum WinEvent
     {
+        [ReflectionIgnore]
         Min = 0x0001,
         SystemSound = 0x0001,
         SystemAlert = 0x0002,
@@ -64,6 +68,7 @@ public enum WinEvent
         ObjectEnd = 0x80FF,
         AiaStart = 0xA000,
         AiaEnd = 0xAFFF,
+        [ReflectionIgnore]
         Max = 0x7FFFFFFF
     }
 
@@ -85,4 +90,13 @@ public enum ObjId
         QueryClasNameIdx = -12,
         NativeOM = -16     
     }
+
+#if (THIRSTY_DUCK || THIRSTY_DUCK_EVT)
+
+    public static class WinEventMap
+    {
+        public static readonly Dictionary<int, string> Lookup = EnumHelper.ToDictionary<WinEvent, int>();
+    }
+
+#endif
 }