protected override IntPtr HookTrigger(int nCode, IntPtr wParam, IntPtr lParam)
{
KeyboardMessages keyboardMessage = (KeyboardMessages)wParam.ToInt32();
KeyboardMessageData keyboardMessageData = (KeyboardMessageData)Marshal.PtrToStructure(lParam, typeof(KeyboardMessageData));
var keyboardEventArgs = new KeyboardEventArgs(keyboardMessage, keyboardMessageData.VkCode);
switch (keyboardMessage)
{
case KeyboardMessages.WM_KEYDOWN:
this.KeyDown?.Invoke(this, keyboardEventArgs);
break;
case KeyboardMessages.WM_KEYUP:
this.KeyUp?.Invoke(this, keyboardEventArgs);
break;
case KeyboardMessages.WM_SYSKEYDOWN:
this.SystemKeyDown?.Invoke(this, keyboardEventArgs);
break;
case KeyboardMessages.WM_SYSKEYUP:
this.SystemKeyUp?.Invoke(this, keyboardEventArgs);
break;
}
this.Action?.Invoke(this, keyboardEventArgs);
return(HookNativeMethods.CallNextHookEx((int)HookId.WH_KEYBOARD_LL, nCode, wParam, lParam));
}
private IntPtr LowLevelHookProc(int nCode, IntPtr wParam, IntPtr lParam)
{
var passThrough = nCode != 0;
if (passThrough)
{
return(HookNativeMethods.CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
}
var callbackData = new InputEventData
{
Message = (int)wParam,
Data = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct))
};
//Debug.WriteLine(
// $@"LowLevelInput {(Keys)callbackData.Data.VirtualKeyCode} {callbackData.Data.ScanCode} {callbackData.Data.Flags} {
// KeyUtils.GetDeviceKey(
// (Keys)callbackData.Data.VirtualKeyCode, callbackData.Data.ScanCode,
// ((ScanCodeFlags)callbackData.Data.Flags).HasFlag(ScanCodeFlags.E0))
// }", "InputEvents");
Input?.Invoke(this, callbackData);
if (callbackData.Intercepted)
{
return(new IntPtr(-1));
}
return(HookNativeMethods.CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
}
internal void Unsubscribe(int handle)
{
int result = HookNativeMethods.UnhookWindowsHookEx(handle);
if (result == 0)
{
ThrowLastUnmanagedErrorAsException();
}
}
protected override bool ReleaseHandle()
{
//NOTE Calling Unhook during processexit causes delay
if (_closing)
{
return(true);
}
return(HookNativeMethods.UnhookWindowsHookEx(handle) != 0);
}
internal void Unsubscribe(int handle)
{
int result = HookNativeMethods.UnhookWindowsHookEx(handle);
// IFREQ: currently taken out as throws an exception at the very end
// if (result == 0)
// {
// ThrowLastUnmanagedErrorAsException();
// }
}
public void Hook()
{
var source = HookNativeMethods.GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
this.hookProcDelegate = new HookProc(this.OnHookCall);
this.hookHandle = HookNativeMethods.SetWindowsHookEx((int)this.hookId, hookProcDelegate, source, 0);
if (this.hookHandle.IsInvalid)
{
var errorCode = Marshal.GetLastWin32Error();
throw new Win32Exception(errorCode);
}
}
/// <summary>
/// Method to be used from Dispose and finalizer.
/// Override this method to release subclass sepcific references.
/// </summary>
protected virtual void Dispose(bool isDisposing)
{
if (isDisposing)
{
Stop();
}
else
{
if (HookHandle != 0)
{
HookNativeMethods.UnhookWindowsHookEx(HookHandle);
}
}
}
internal override int Subscribe(int hookId, HookCallback hookCallback)
{
int hookHandle = HookNativeMethods.SetWindowsHookEx(
hookId,
hookCallback,
IntPtr.Zero,
ThreadNativeMethods.GetCurrentThreadId());
if (hookHandle == 0)
{
ThrowLastUnmanagedErrorAsException();
}
return(hookHandle);
}
internal override int Subscribe(int hookId, HookCallback hookCallback)
{
int hookHandle = HookNativeMethods.SetWindowsHookEx(
hookId,
hookCallback,
Process.GetCurrentProcess().MainModule.BaseAddress,
0);
if (hookHandle == 0)
{
ThrowLastUnmanagedErrorAsException();
}
return(hookHandle);
}
private void MessagePumpInit()
{
using (new ThreadPriorityChanger(ThreadPriority.AboveNormal,
ThreadPriorityChanger.ThreadPriority.THREAD_PRIORITY_TIME_CRITICAL))
using (var lowLevelHookHandle = HookNativeMethods.SetWindowsHookEx(HookIds.WH_KEYBOARD_LL, hookProcedure,
Process.GetCurrentProcess().MainModule.BaseAddress, 0))
{
if (lowLevelHookHandle.IsInvalid)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
thread.EnterMessageLoop();
}
}
private static HookResult HookGlobal(int hookId, Callback callback)
{
_globalHookProc = (code, param, lParam) => HookProcedure(code, param, lParam, callback);
var hookHandle = HookNativeMethods.SetWindowsHookEx(
hookId,
_globalHookProc,
Process.GetCurrentProcess().MainModule.BaseAddress,
0);
if (hookHandle.IsInvalid)
{
ThrowLastUnmanagedErrorAsException();
}
return(new HookResult(hookHandle, _globalHookProc));
}
private static HookResult HookApp(int hookId, Callback callback)
{
_appHookProc = (code, param, lParam) => HookProcedure(code, param, lParam, callback);
var hookHandle = HookNativeMethods.SetWindowsHookEx(
hookId,
_appHookProc,
IntPtr.Zero,
ThreadNativeMethods.GetCurrentThreadId());
if (hookHandle.IsInvalid)
{
ThrowLastUnmanagedErrorAsException();
}
return(new HookResult(hookHandle, _appHookProc));
}
protected override IntPtr HookTrigger(int nCode, IntPtr wParam, IntPtr lParam)
{
var mouseMessage = (MouseMessages)wParam.ToInt32();
MouseMessageData mouseMessageData = (MouseMessageData)Marshal.PtrToStructure(lParam, typeof(MouseMessageData));
var eventArgs = new MouseEventArgs(mouseMessage, mouseMessageData.Point);
switch (mouseMessage)
{
case MouseMessages.WM_LBUTTONDOWN:
this.LeftButtonDown?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_LBUTTONUP:
this.LeftButtonUp?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_MOUSEMOVE:
this.Move?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_MOUSEWHEEL:
this.WheelRotate?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_MOUSEHWHEEL:
this.HorizontalWheelRotate?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_RBUTTONDOWN:
this.RightButtonDown?.Invoke(this, eventArgs);
break;
case MouseMessages.WM_RBUTTONUP:
this.RightButtonUp?.Invoke(this, eventArgs);
break;
}
this.Action?.Invoke(this, eventArgs);
return(HookNativeMethods.CallNextHookEx((int)HookId.WH_MOUSE_LL, nCode, wParam, lParam));
}
private static IntPtr CallNextHookEx(int nCode, IntPtr wParam, IntPtr lParam)
{
return(HookNativeMethods.CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam));
}
private int CallNextHook(int nCode, int wParam, IntPtr lParam)
{
return(HookNativeMethods.CallNextHookEx(HookHandle, nCode, wParam, lParam));
}
