// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.Runtime.InteropServices; namespace System.Windows.Forms.PropertyGridInternal; internal partial class PropertyGridView { internal partial class MouseHook { private readonly PropertyGridView _gridView; private readonly Control _control; private readonly IMouseHookClient _client; private uint _thisProcessId; private HOOKPROC? _callBack; private HHOOK _mouseHookHandle; private bool _hookDisable; private bool _processing; private readonly Lock _lock = new(); public MouseHook(Control control, IMouseHookClient client, PropertyGridView gridView) { _control = control; _gridView = gridView; _client = client; #if DEBUG _callingStack = Environment.StackTrace; #endif } #if DEBUG private readonly string _callingStack; ~MouseHook() { if (!_mouseHookHandle.IsNull) { throw new InvalidOperationException($"Finalizing an active mouse hook. This will crash the process. Calling stack: {_callingStack}"); } } #endif public bool DisableMouseHook { set { _hookDisable = value; if (value) { UnhookMouse(); } } } public virtual bool HookMouseDown { get => !_mouseHookHandle.IsNull; set { if (value && !_hookDisable) { HookMouse(); } else { UnhookMouse(); } } } public void Dispose() => UnhookMouse(); /// <summary> /// Sets up the needed windows hooks to catch messages. /// </summary> private unsafe void HookMouse() { lock (_lock) { if (!_mouseHookHandle.IsNull) { return; } if (_thisProcessId == 0) { PInvoke.GetWindowThreadProcessId(_control, out _thisProcessId); } _callBack = MouseHookProc; IntPtr hook = Marshal.GetFunctionPointerForDelegate(_callBack); _mouseHookHandle = PInvoke.SetWindowsHookEx( WINDOWS_HOOK_ID.WH_MOUSE, (delegate* unmanaged[Stdcall]<int, WPARAM, LPARAM, LRESULT>)hook, (HINSTANCE)0, PInvokeCore.GetCurrentThreadId()); Debug.Assert(!_mouseHookHandle.IsNull, "Failed to install mouse hook"); } } /// <summary> /// HookProc used for catch mouse messages. /// </summary> private unsafe LRESULT MouseHookProc(int nCode, WPARAM wparam, LPARAM lparam) { if (nCode == PInvoke.HC_ACTION) { var mhs = (MOUSEHOOKSTRUCT*)(nint)lparam; if (mhs is not null) { switch ((uint)wparam) { case PInvokeCore.WM_LBUTTONDOWN: case PInvokeCore.WM_MBUTTONDOWN: case PInvokeCore.WM_RBUTTONDOWN: case PInvokeCore.WM_NCLBUTTONDOWN: case PInvokeCore.WM_NCMBUTTONDOWN: case PInvokeCore.WM_NCRBUTTONDOWN: case PInvokeCore.WM_MOUSEACTIVATE: if (ProcessMouseDown(mhs->hwnd)) { return (LRESULT)1; } break; } } } return PInvoke.CallNextHookEx(_mouseHookHandle, nCode, wparam, lparam); } /// <summary> /// Removes the windowshook that was installed. /// </summary> private void UnhookMouse() { lock (_lock) { if (!_mouseHookHandle.IsNull) { PInvoke.UnhookWindowsHookEx(_mouseHookHandle); _mouseHookHandle = default; } } } private bool ProcessMouseDown(HWND hwnd) { // If we put up the "invalid" message box, it appears this method is getting called reentrantly // when it shouldn't be. This prevents us from recursing. if (_processing) { return false; } IntPtr handle = _control.HandleInternal; // If it is us or one of our children just process as normal. if (hwnd != handle && FromHandle(hwnd) is Control targetControl && !_control.Contains(targetControl)) { Debug.Assert(_thisProcessId != 0, "Didn't get our process id!"); // Make sure the window is in our process. PInvoke.GetWindowThreadProcessId(hwnd, out uint pid); // If this isn't our process, unhook the mouse. if (pid != _thisProcessId) { HookMouseDown = false; return false; } // If this a sibling control (e.g. the drop down or buttons), just forward the message and skip the commit bool needCommit = targetControl is null || !IsSiblingControl(_control, targetControl); try { _processing = true; if (needCommit && _client.OnClickHooked()) { return true; // there was an error, so eat the mouse } } finally { _processing = false; } // Cancel our hook at this point. HookMouseDown = false; } return false; } } } |