private IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0 && !Ignore(wParam.ToInt32())) { var mouseData = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)); var button = GetButton(wParam.ToInt32()); var state = GetState(wParam.ToInt32()); var info = GetInfo(mouseData); if (callback(button, state, info)) { return((IntPtr)1); } } return(User32.CallNextHookEx(handle, nCode, wParam, lParam)); }
private static int KeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { int vkCode = Marshal.ReadInt32(lParam); if ((Keys)vkCode == Keys.LControlKey || (Keys)vkCode == Keys.RControlKey) { if (wParam == (IntPtr)User32.WindowMessage.WM_KEYDOWN) { UnclipCursor(); } else if (wParam == (IntPtr)User32.WindowMessage.WM_KEYUP) { ClipCursorToCurrentScreen(); } } return(User32.CallNextHookEx(_keyboardHook.DangerousGetHandle(), nCode, wParam, lParam)); }
// Default filter function public int CoreHookProc(int code, IntPtr wParam, IntPtr lParam) { if (code < 0) { return(User32.CallNextHookEx(m_hHook, code, wParam, lParam)); } // Let clients determine what to do HookEventArgs e = new HookEventArgs(); e.HookCode = code; e.wParam = wParam; e.lParam = lParam; OnHookInvoked(e); // Yield to the next hook in the chain return(User32.CallNextHookEx(m_hHook, code, wParam, lParam)); }
public static IntPtr JournalRecordProc(int nCode, IntPtr wParam, IntPtr lParam) { //throw new Exception("checking"); if (nCode < 0) { return(User32.CallNextHookEx(journalHook, nCode, wParam, lParam)); } EventMsg msg = (EventMsg)Marshal.PtrToStructure(lParam, typeof(EventMsg)); //do what you like to save the events using (StreamWriter sw = new StreamWriter("tempfile.txt", true)) { sw.WriteLine(msg); } return(User32.CallNextHookEx(journalHook, nCode, wParam, lParam)); }
/// <summary>Hook callback to process <see cref="WM.WM_MOUSEMOVE" /> messages to highlight/un-highlight the close button on each tab.</summary> /// <param name="nCode">The message being received.</param> /// <param name="wParam">Additional information about the message.</param> /// <param name="lParam">Additional information about the message.</param> /// <returns>A zero value if the procedure processes the message; a nonzero value if the procedure ignores the message.</returns> protected IntPtr MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { MouseEvent mouseEvent = new MouseEvent { nCode = nCode, wParam = wParam, lParam = lParam }; if (nCode >= 0 && (int)WM.WM_MOUSEMOVE == (int)wParam) { mouseEvent.MouseData = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)); } _mouseEvents.Add(mouseEvent); return(User32.CallNextHookEx(_hookId, nCode, wParam, lParam)); }
/// <summary>Hook callback to process <see cref="WM.WM_MOUSEMOVE" /> messages to move the thumbnail along with the cursor.</summary> /// <param name="nCode">The message being received.</param> /// <param name="wParam">Additional information about the message.</param> /// <param name="lParam">Additional information about the message.</param> /// <returns>A zero value if the procedure processes the message; a nonzero value if the procedure ignores the message.</returns> protected IntPtr MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { switch ((WM)wParam) { case WM.WM_MOUSEMOVE: MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)); Point cursorPosition = new Point(hookStruct.pt.x, hookStruct.pt.y); SetWindowPosition(cursorPosition); { var msg = new Message() { HWnd = Handle, LParam = lParam, WParam = wParam, Msg = (int)WM.WM_MOUSEMOVE, }; Invoke(new Action(() => m_messageFilter.PreFilterMessage(ref msg))); } break; case WM.WM_LBUTTONUP: { var msg = new Message() { HWnd = Handle, LParam = lParam, WParam = wParam, Msg = (int)WM.WM_LBUTTONUP, }; Invoke(new Action(() => m_messageFilter.PreFilterMessage(ref msg))); } break; default: break; } } return(User32.CallNextHookEx(m_hookId, nCode, wParam, lParam)); }
private IntPtr KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) { // it was ok and someone listens to events if ((nCode >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null)) { KBDLLHOOKSTRUCT MyKeyboardHookStruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT)); // KeyDown if ((KeyDown != null) && (wParam == (IntPtr)WinUser.WM_KEYDOWN || wParam == (IntPtr)WinUser.WM_SYSKEYDOWN)) { Keys keyData = (Keys)MyKeyboardHookStruct.vkCode; KeyEventArgs e = new KeyEventArgs(keyData); this.KeyDown(this, e); } // KeyPress if ((KeyPress != null) && (wParam == (IntPtr)WinUser.WM_KEYDOWN)) { byte[] keyState = new byte[256]; User32.GetKeyboardState(keyState); byte[] inBuffer = new byte[2]; if (User32.ToAscii(MyKeyboardHookStruct.vkCode, MyKeyboardHookStruct.scanCode, keyState, inBuffer, MyKeyboardHookStruct.flags == 1) == 1) { KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]); KeyPress(this, e); } } // KeyUp if ((KeyUp != null) && (wParam == (IntPtr)WinUser.WM_KEYUP || wParam == (IntPtr)WinUser.WM_SYSKEYUP)) { Keys keyData = (Keys)MyKeyboardHookStruct.vkCode; KeyEventArgs e = new KeyEventArgs(keyData); KeyUp(this, e); } } return(User32.CallNextHookEx(m_keyboardHook, nCode, wParam, lParam)); }
/// <summary> /// <inheritdoc cref="User32.WindowsHookDelegate"/> /// </summary> private static int MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { var msg = (User32.WindowMessage)wParam; if (msg == User32.WindowMessage.WM_LBUTTONDOWN || msg == User32.WindowMessage.WM_RBUTTONDOWN) { var input = Marshal.PtrToStructure <User32.MOUSEINPUT>(lParam); MouseChanged?.Invoke(null, new MouseMessageArg { Msg = (int)msg, X = input.dx, Y = input.dy }); } } return(User32.CallNextHookEx(MouseHook.DangerousGetHandle(), nCode, wParam, lParam)); }
private int HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0 && wParam == (IntPtr)User32.WindowMessage.WM_KEYDOWN) { int vkCode = Marshal.ReadInt32(lParam); if (KeyCode.Count > 0) { if (KeyCode.Any(x => x == vkCode)) { Callback?.Invoke(vkCode); } } else { Callback?.Invoke(vkCode); } } return(User32.CallNextHookEx(handle, nCode, wParam, lParam)); }
private unsafe IntPtr LowLevelMouseAction(int nCode, IntPtr wParam, IntPtr lParam) { var state = (MouseState)(wParam.ToInt32() - 1); // fix for MouseMove 0x200 mask if ((MouseState.All & state) == state) { var p = Unsafe.Read <LowLevelMouseInputEvent>(lParam.ToPointer()); var args = new GlobalMouseHookEventArgs(p, state); MousePressed?.Invoke(this, args); if (args.Handled) { return((IntPtr)1); } } return(User32.CallNextHookEx(MouseHookHandle, nCode, wParam, lParam)); }
public IntPtr MouseHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { var mouseStructure = Marshal.PtrToStructure <MouseLowLevelHookStruct>(lParam); var mouseMessage = (MouseMessage)wParam; var exists = MouseMessages.TryGetValue(mouseMessage, out var eventMethod); if (exists) { eventMethod(mouseStructure.pt, mouseMessage); } } if (!StealthyMouseHook) { return(User32.CallNextHookEx(MouseHook.HookHandle, nCode, wParam, lParam)); } return(IntPtr.Zero); }
private IntPtr KeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { var keyboardStructure = Marshal.PtrToStructure <KeyboardLowLevelHookStruct>(lParam); var keyboardMessage = (KeyboardMessage)wParam; var exists = KeyboardMessages.TryGetValue((Keys)keyboardStructure.vkCode, out var eventMethod); if (exists) { Console.WriteLine(keyboardStructure.vkCode); eventMethod((Keys)keyboardStructure.vkCode, keyboardMessage); } } if (!StealthyKeyboardHook) { return(User32.CallNextHookEx(KeyboardHook.HookHandle, nCode, wParam, lParam)); } return(IntPtr.Zero); }
/// <summary> /// Called whenever the mouse moves. This routine leans entirely on the /// CheckJumpCursor() routine to see if there is any need to "mess with" the cursor /// position, to make it jump from one monitor to another. /// </summary> private IntPtr LLMouseHookCallback(int nCode, uint wParam, IntPtr lParam) { if (!(nCode < 0 || wParam != User32.WM_MOUSEMOVE || _updatingDisplaySettings)) { var mouse = ((MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT))).pt; // If we jump the cursor, then we return 1 here to tell the OS that we // have handled the message, so it doesn't call SetCursorPos() right // after we do, and "undo" our call to SetCursorPos(). if (User32.GetCursorPos(out var cursor) && _screenSet.CheckJumpCursor(cursor, mouse, out var newCursor)) { newCursor.SetCursorPos(); return((IntPtr)1); } // Default is to let the OS handle the mouse events, when "return" does not happen in // if() clause above. } return(User32.CallNextHookEx(_llMouseHookhand, nCode, wParam, lParam)); }
private unsafe IntPtr LowLevelKeyboardAction(int nCode, IntPtr wParam, IntPtr lParam) { var wparamTyped = (KeyboardState)wParam.ToInt32(); if ((KeyboardState.All & wparamTyped) == wparamTyped) { var p = Unsafe.Read <LowLevelKeyboardInputEvent>(lParam.ToPointer()); if (KeyBinding.TryGet(p.VirtualCode, out _)) { var args = new GlobalKeyboardHookEventArgs(p, wparamTyped); KeyboardPressed?.Invoke(this, args); if (args.Handled) { return((IntPtr)1); } } } return(User32.CallNextHookEx(KeyboardHookHandle, nCode, wParam, lParam)); }
private unsafe static IntPtr LLKeyboardCallback(int nCode, KeyboardButtonsState wParam, KeyBoardLowlevelHookStruct *lParam) { if (nCode > -1) { KeyBoardLowlevelHookStruct hookStruct = *lParam; VirtualKey key = hookStruct.VkCode; if (key == VirtualKey.LShift) { LShiftPress = (wParam == KeyboardButtonsState.WM_KEYDOWN); } if (key == VirtualKey.RShift) { RShiftPress = (wParam == KeyboardButtonsState.WM_KEYDOWN); } if (key == VirtualKey.CapsLock) { CapsPressed = (wParam == KeyboardButtonsState.WM_KEYDOWN); } string v = (LShiftPress || RShiftPress || CapsPressed) ? key.ToString() : key.ToString().ToLower(); KeyboardEvent.Invoke(v, wParam, hookStruct); } return(User32.CallNextHookEx(KBHook, nCode, (IntPtr)wParam, (IntPtr)lParam)); }
private IntPtr ReceiveCallback(int code, IntPtr wParam, IntPtr lParam) { if (code == 0) { var hookStruct = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT)); var keys = (Keys)hookStruct.vkCode; if ((hookStruct.flags & KBDLLHOOKSTRUCTFlags.LLKHF_UP) == KBDLLHOOKSTRUCTFlags.LLKHF_UP) { if (KeyUp != null) { KeyUp(this, new KeyEventArgs(keys | Control.ModifierKeys)); } } else { if (KeyDown != null) { KeyDown(this, new KeyEventArgs(keys | Control.ModifierKeys)); } } } return(User32.CallNextHookEx(IntPtr.Zero, code, wParam, lParam)); }
public int HookProc(int code, IntPtr wParam, IntPtr lParam) { switch (code) { case 9: FocusChanged?.Invoke(this, new FocusChangeEventArgs(wParam, lParam)); break; case 5: if (_insideActivateEvent.CanEnter) { using (_insideActivateEvent.Enter()) { //if (Activate != null) // Activate(this, new WindowActivateEventArgs(wParam)); } } break; } return(User32.CallNextHookEx(_windowHook, code, wParam, lParam)); }
private IntPtr LowLevelKeyboardProc(int nCode, UIntPtr wParam, IntPtr lParam) { if (nCode < 0) { return(User32.CallNextHookEx(hookId, nCode, wParam, lParam)); } if (wParam.ToUInt32() == (int)User32.KeyEvent.WM_KEYDOWN || wParam.ToUInt32() == (int)User32.KeyEvent.WM_KEYUP || wParam.ToUInt32() == (int)User32.KeyEvent.WM_SYSKEYDOWN || wParam.ToUInt32() == (int)User32.KeyEvent.WM_SYSKEYUP) { bool handled = hookedKeyboardCallback.Invoke((User32.KeyEvent)wParam.ToUInt32(), Marshal.ReadInt32(lParam)); if (handled) { return((IntPtr)1); } } return(User32.CallNextHookEx(hookId, nCode, wParam, lParam)); }
private int HookProc(int code, int wParam, ref User32.KeyboardHookStruct lParam) { if (code >= 0) { var key = (Keys)lParam.vkCode; if (HookedKeys.Contains(key)) { var kea = new KeyEventArgs(key); if (wParam == User32.WM_KEYDOWN || wParam == User32.WM_SYSKEYDOWN) { KeyDown?.Invoke(this, kea); } if (wParam == User32.WM_KEYUP || wParam == User32.WM_SYSKEYUP) { KeyUp?.Invoke(this, kea); } if (kea.Handled) { return(1); } } } return(User32.CallNextHookEx(_hhook, code, wParam, ref lParam)); }
private static int KeyboardHookProc(int nCode, int wParam, IntPtr lParam) { if (nCode >= 0) { var khs = (User32.KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(User32.KeyboardHookStruct)); if (khs.ExtraInfo != AppEventFlag && khs.VirtualKeyCode != PacketKey) { switch (wParam) { case User32.WM_KEYDOWN: case User32.WM_SYSKEYDOWN: for (var i = Subscribed.Count - 1; i >= 0; i--) { if (Subscribed[i].RaiseKeyDown(khs.VirtualKeyCode)) { return(-1); } } break; case User32.WM_KEYUP: case User32.WM_SYSKEYUP: for (var i = Subscribed.Count - 1; i >= 0; i--) { if (Subscribed[i].RaiseKeyUp(khs.VirtualKeyCode)) { return(-1); } } break; } } } return(User32.CallNextHookEx(_hookHandle, nCode, wParam, lParam)); }
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { bool handled = false; if (nCode >= 0) { if (((wParam == (IntPtr)WM.WM_KEYDOWN) || (wParam == (IntPtr)WM.WM_SYSKEYDOWN))) { handled = OnKeyDown(lParam); } if (((wParam == (IntPtr)WM.WM_KEYUP) || (wParam == (IntPtr)WM.WM_SYSKEYUP))) { handled = OnKeyUp(lParam); } } if (!handled) { return(User32.CallNextHookEx(hookId, nCode, wParam, lParam)); } return(IntPtr.Zero); }
private unsafe IntPtr MouseHookProc(User32.HC nCode, IntPtr wparam, IntPtr lparam) { if (_isHooked && nCode == User32.HC.ACTION && lparam != IntPtr.Zero) { User32.MOUSEHOOKSTRUCT *mhs = (User32.MOUSEHOOKSTRUCT *)lparam; try { if (ProcessMouseMessage(mhs->hWnd, unchecked ((int)(long)wparam), mhs->pt.X, mhs->pt.Y)) { return((IntPtr)1); } } catch (Exception ex) { _currentAdornerWindow.Capture = false; if (ex != CheckoutException.Canceled) { _currentAdornerWindow._behaviorService.ShowError(ex); } if (ClientUtils.IsCriticalException(ex)) { throw; } } finally { _currentAdornerWindow = null; } } Debug.Assert(_isHooked, "How did we get here when we are disposed?"); return(User32.CallNextHookEx(new HandleRef(this, _mouseHookHandle), nCode, wparam, lparam)); }
/// <summary> /// CBT callback called when a form is activated. /// If the newly activated form is modal and matches any registered names, /// invoke the appropriate hander. /// </summary> private int Callback_ModalListener(int code, IntPtr wParam, IntPtr lParam) { if (code == HCBT_ACTIVATE) { // Some controls sends an HCBT_ACTIVATE when changed for example tabPages. We do not // want our handler to be called when a tabPage is changed. This is a problem in Modal // modal windows. if (!hwndList.Contains(wParam)) { hwndList.Add(wParam); FindWindowNameAndInvokeHandler(wParam); } } if (code == HCBT_DESTROYWND) { // Need to remove the handle when the window is destroyed. if (hwndList.Contains(wParam)) { hwndList.Remove(wParam); } } return(User32.CallNextHookEx(handleToHook, code, wParam, lParam)); }
private IntPtr MsgHookCallBack(int nCode, IntPtr wParam, ref MSG lParam) { if (nCode < 0) { return(User32.CallNextHookEx(m_gmHookHandle, nCode, wParam, ref lParam)); } if (true) //(wParam.ToInt32() == PM_NOREMOVE) { bool isMsgHandled = false; if (lParam.hwnd == this.m_windowHandle) { Msgs wmMessage = (Msgs)lParam.message; // check for the messages that should be handled (, and ignored). if (hndldMsgType != Msgs.WM_NULL) { if (lParam.wParam == hndldMsgWP) { switch (hndldMsgType) { case Msgs.WM_KEYUP: case Msgs.WM_SYSKEYUP: hndldMsgType = Msgs.WM_NULL; break; case Msgs.WM_KEYDOWN: case Msgs.WM_SYSKEYDOWN: hndldMsgType = Msgs.WM_CHAR; break; case Msgs.WM_CHAR: case Msgs.WM_SYSCHAR: hndldMsgType = Msgs.WM_KEYUP; break; default: hndldMsgType = Msgs.WM_NULL; break; } lParam.message = (uint)Msgs.WM_NULL; lParam.wParam = 0; lParam.lParam = 0; isMsgHandled = true; } else { hndldMsgType = Msgs.WM_NULL; } } if (!isMsgHandled && !(lParam.message == prevMsgType && lParam.time == prevMsgTime)) { WindowListenerEventArgs eventArgs = new WindowListenerEventArgs(); eventArgs.handled = false; eventArgs.message = (int)lParam.message; eventArgs.lparam = lParam.lParam; eventArgs.wparam = lParam.wParam; prevMsgType = (int)lParam.message; prevMsgTime = lParam.time; switch (wmMessage) { case Msgs.WM_KEYUP: case Msgs.WM_SYSKEYUP: if (KeyUp != null) { KeyUp(this, eventArgs); } break; case Msgs.WM_KEYDOWN: case Msgs.WM_SYSKEYDOWN: if (KeyDown != null) { KeyDown(this, eventArgs); } break; case Msgs.WM_CHAR: case Msgs.WM_SYSCHAR: if (KeyPressed != null) { KeyPressed(this, eventArgs); } break; default: if (OtherMessage != null) { OtherMessage(this, eventArgs); } break; } if (eventArgs.handled) { hndldMsgTime = lParam.time; hndldMsgType = wmMessage; hndldMsgWP = lParam.time; lParam.message = (uint)Msgs.WM_NULL; lParam.lParam = 0; lParam.wParam = 0; } } if (!isMsgHandled && CheckIgnoreCodes) { if (wmMessage == Msgs.WM_KEYDOWN || wmMessage == Msgs.WM_KEYUP || wmMessage == Msgs.WM_CHAR || wmMessage == Msgs.WM_SYSKEYDOWN || wmMessage == Msgs.WM_SYSKEYUP || wmMessage == Msgs.WM_SYSCHAR) { if (m_setKeyboardIgnoreCodes.Contains(lParam.wParam)) { lParam.message = (uint)Msgs.WM_NULL; lParam.lParam = 0; lParam.wParam = 0; } } } } if (lParam.message == (uint)Msgs.WM_NULL && lParam.lParam == 0 && lParam.wParam == 0) { return((IntPtr)1); } } return(User32.CallNextHookEx(m_gmHookHandle, nCode, wParam, ref lParam)); }
private IntPtr CwpHookCallBack(int nCode, IntPtr wParam, ref CWPSTRUCT lParam) { if (nCode < 0) { return(User32.CallNextHookEx(m_gmHookHandle, nCode, wParam, ref lParam)); } if (true) //(wParam.ToInt32() == PM_NOREMOVE) { if (lParam.hwnd == this.m_windowHandle) { WindowListenerEventArgs eventArgs = new WindowListenerEventArgs(); eventArgs.handled = false; eventArgs.message = (int)lParam.message; eventArgs.lparam = lParam.lParam; eventArgs.wparam = lParam.wParam; Msgs wmMessage = (Msgs)lParam.message; switch (wmMessage) { case Msgs.WM_KILLFOCUS: if (LostFocus != null) { LostFocus(this, eventArgs); } break; case Msgs.WM_SETFOCUS: if (GetFocus != null) { GetFocus(this, eventArgs); } break; case Msgs.WM_WINDOWPOSCHANGING: if (PositionChanging != null) { PositionChanging(this, eventArgs); } break; case Msgs.WM_PAINT: if (this.Paint != null) { Paint(this, eventArgs); } break; default: if (OtherMessage != null) { OtherMessage(this, eventArgs); } break; } if (eventArgs.handled) { lParam.message = (uint)Msgs.WM_NULL; lParam.lParam = 0; lParam.wParam = 0; return((IntPtr)1); } } } return(User32.CallNextHookEx(m_cwpHookHandle, nCode, wParam, ref lParam)); }
private int test(int c, IntPtr a, IntPtr b) { return(User32.CallNextHookEx(new IntPtr(hKeyboardHook), c, a, b)); }
private int WindowsHookProc(int nCode, IntPtr wParam, IntPtr lParam) { //Something... return(User32.CallNextHookEx(new IntPtr(wHookId), nCode, wParam, lParam)); }
/// <summary> /// A callback function which will be called every Time a mouse activity detected. /// </summary> /// <param name="nCode"> /// [in] Specifies whether the hook procedure must process the message. /// If nCode is HC_ACTION, the hook procedure must process the message. /// If nCode is less than zero, the hook procedure must pass the message to the /// CallNextHookEx function without further processing and must return the /// value returned by CallNextHookEx. /// </param> /// <param name="wParam"> /// [in] Specifies whether the message was sent by the current thread. /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. /// </param> /// <param name="lParam"> /// [in] Pointer to a CWPSTRUCT structure that contains details about the message. /// </param> /// <returns> /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook /// procedure does not call CallNextHookEx, the return value should be zero. /// </returns> private static int MouseHookProc(int nCode, IntPtr wParam, IntPtr lParam) { if (nCode >= 0) { //Marshall the data from callback. MSLLHOOKSTRUCT mouseHookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT)); //detect button clicked MouseButtons button = MouseButtons.None; short mouseDelta = 0; int clickCount = 0; bool mouseDown = false; bool mouseUp = false; WM command = (WM)wParam; switch (command) { case WM.WM_LBUTTONDOWN: mouseDown = true; button = MouseButtons.Left; clickCount = 1; break; case WM.WM_LBUTTONUP: mouseUp = true; button = MouseButtons.Left; clickCount = 1; break; case WM.WM_LBUTTONDBLCLK: button = MouseButtons.Left; clickCount = 2; break; case WM.WM_RBUTTONDOWN: mouseDown = true; button = MouseButtons.Right; clickCount = 1; break; case WM.WM_RBUTTONUP: mouseUp = true; button = MouseButtons.Right; clickCount = 1; break; case WM.WM_RBUTTONDBLCLK: button = MouseButtons.Right; clickCount = 2; break; case WM.WM_MOUSEWHEEL: //If the message is WM_MOUSEWHEEL, the high-order word of MouseData member is the wheel delta. //One wheel click is defined as WHEEL_DELTA, which is 120. //(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value mouseDelta = (short)((mouseHookStruct.MouseData >> 16) & 0xffff); //TODO: X BUTTONS (I havent them so was unable to test) //If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP, //or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released, //and the low-order word is reserved. This value can be one or more of the following values. //Otherwise, MouseData is not used. break; } //generate event MouseEventExtArgs e = new MouseEventExtArgs( button, clickCount, mouseHookStruct.Point.X, mouseHookStruct.Point.Y, mouseDelta); //Mouse up if (s_MouseUp != null && mouseUp) { s_MouseUp.Invoke(null, e); } //Mouse down if (s_MouseDown != null && mouseDown) { s_MouseDown.Invoke(null, e); } //If someone listens to click and a click is heppened if (s_MouseClick != null && clickCount > 0) { s_MouseClick.Invoke(null, e); } //If someone listens to click and a click is heppened if (s_MouseClickExt != null && clickCount > 0) { s_MouseClickExt.Invoke(null, e); } //If someone listens to double click and a click is heppened if (s_MouseDoubleClick != null && clickCount == 2) { s_MouseDoubleClick.Invoke(null, e); } //Wheel was moved if (s_MouseWheel != null && mouseDelta != 0) { s_MouseWheel.Invoke(null, e); } //If someone listens to move and there was a change in coordinates raise move event if ((s_MouseMove != null || s_MouseMoveExt != null) && (m_OldX != mouseHookStruct.Point.X || m_OldY != mouseHookStruct.Point.Y)) { m_OldX = mouseHookStruct.Point.X; m_OldY = mouseHookStruct.Point.Y; if (s_MouseMove != null) { s_MouseMove.Invoke(null, e); } if (s_MouseMoveExt != null) { s_MouseMoveExt.Invoke(null, e); } } if (e.Handled) { return(-1); } } //call next hook return(User32.CallNextHookEx(s_MouseHookHandle, nCode, wParam, lParam)); }
/// <summary> /// A callback function which will be called every Time a keyboard activity detected. /// </summary> /// <param name="nCode"> /// [in] Specifies whether the hook procedure must process the message. /// If nCode is HC_ACTION, the hook procedure must process the message. /// If nCode is less than zero, the hook procedure must pass the message to the /// CallNextHookEx function without further processing and must return the /// value returned by CallNextHookEx. /// </param> /// <param name="wParam"> /// [in] Specifies whether the message was sent by the current thread. /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero. /// </param> /// <param name="lParam"> /// [in] Pointer to a CWPSTRUCT structure that contains details about the message. /// </param> /// <returns> /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx. /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook /// procedure does not call CallNextHookEx, the return value should be zero. /// </returns> private static int KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) { //indicates if any of underlaing events set e.Handled flag bool handled = false; if (nCode >= 0) { WM command = (WM)wParam; //read structure KeyboardHookStruct at lParam KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct)); //raise KeyDown if (s_KeyDown != null && (command == WM.WM_KEYDOWN || command == WM.WM_SYSKEYDOWN)) { Keys keyData = (Keys)MyKeyboardHookStruct.VirtualKeyCode; KeyEventArgs e = new KeyEventArgs(keyData); s_KeyDown.Invoke(null, e); handled = e.Handled; } // raise KeyPress if (s_KeyPress != null && command == WM.WM_KEYDOWN) { bool isDownShift = ((User32.GetKeyState((int)VK.VK_SHIFT) & 0x80) == 0x80 ? true : false); bool isDownCapslock = (User32.GetKeyState((int)VK.VK_CAPITAL) != 0 ? true : false); byte[] keyState = new byte[256]; User32.GetKeyboardState(keyState); byte[] inBuffer = new byte[2]; if (User32.ToAscii(MyKeyboardHookStruct.VirtualKeyCode, MyKeyboardHookStruct.ScanCode, keyState, inBuffer, MyKeyboardHookStruct.Flags) == 1) { char key = (char)inBuffer[0]; if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) { key = Char.ToUpper(key); } KeyPressEventArgs e = new KeyPressEventArgs(key); s_KeyPress.Invoke(null, e); handled = handled || e.Handled; } } // raise KeyUp if (s_KeyUp != null && (command == WM.WM_KEYUP || command == WM.WM_SYSKEYUP)) { Keys keyData = (Keys)MyKeyboardHookStruct.VirtualKeyCode; KeyEventArgs e = new KeyEventArgs(keyData); s_KeyUp.Invoke(null, e); handled = handled || e.Handled; } } //if event handled in application do not handoff to other listeners if (handled) { return(-1); } //forward to other application return(User32.CallNextHookEx(s_KeyboardHookHandle, nCode, wParam, lParam)); }
/// <summary> /// Processes shortcut keys. /// </summary> /// <param name="nCode">Code indicating if we should process this message.</param> /// <param name="wParam"><see cref="WM"/> enumeration value which is the message that's being passed to us.</param> /// <param name="lParam">Virtual key code of the key being pressed.</param> /// <returns>The result of the next hook in the queue (<see cref="User32.CallNextHookEx"/>).</returns> protected IntPtr KeyboardHookCallback(int nCode, IntPtr wParam, IntPtr lParam) { // Only process the key press if our window is active if (nCode >= 0 && User32.GetActiveWindow() == Handle) { // Get the key that was pressed Key key = KeyInterop.KeyFromVirtualKey(Marshal.ReadInt32(lParam)); switch ((WM)wParam.ToInt32()) { case WM.WM_KEYDOWN: case WM.WM_SYSKEYDOWN: switch (key) { case Key.RightCtrl: case Key.LeftCtrl: _ctrlDown = true; break; case Key.RightShift: case Key.LeftShift: _shiftDown = true; break; // Ctrl+T creates a new tab case Key.T: if (_ctrlDown) { AddNewTab(); } break; // Ctrl+Tab cycles forward in the tab list, while Ctrl+Shift+Tab cycles backward case Key.Tab: if (Tabs.Count > 1) { if (_ctrlDown && _shiftDown) { if (SelectedTabIndex == 0) { SelectedTabIndex = Tabs.Count - 1; } else { SelectedTabIndex--; } } else if (_ctrlDown) { if (SelectedTabIndex == Tabs.Count - 1) { SelectedTabIndex = 0; } else { SelectedTabIndex++; } } } break; } break; case WM.WM_KEYUP: case WM.WM_SYSKEYUP: switch (key) { case Key.RightCtrl: case Key.LeftCtrl: _ctrlDown = false; break; case Key.RightShift: case Key.LeftShift: _shiftDown = false; break; } break; } } // Call the next hook in the queue return(User32.CallNextHookEx(_hookId, nCode, wParam, lParam)); }