public MouseListener(GlobalHooker hooker, bool blockLocalInput = false, bool blockRemoteInput = true) { if (hooker == null) { throw new ArgumentNullException("invalid mouse hooker"); } h = hooker; MouseListener.blockLocalInput = blockLocalInput; MouseListener.blockRemoteInput = blockRemoteInput; HookCallbackReference = new HookCallback(HookCallback); try { HookHandle = h.Subscribe(GetHookId(), HookCallbackReference); } catch (Exception) { HookCallbackReference = null; HookHandle = IntPtr.Zero; throw; } mouseTypeMovement = Form1.getForm().mouseTypeMovement; System.Drawing.Rectangle rect = Form1.getForm().getScreenSize(); _screenSize.x = rect.Width; _screenSize.y = rect.Height; }
public MRecorder() { KBCallback = new HookCallback(KeyboardEventCallback); MCallback = new HookCallback(MouseEventCallback); CaptureMouseMovements = true; MouseMovementCaptureDelay = 10; }
// ctor runs from within a lock, and should be as quick as is possible public HookLifetimeManager(HookCallback callback) { Contract.Requires(callback != null); this.pGetMessageHook_Callback = GetMessageHook_Callback; this.pSendMessageHook_Callback = SendMessageHook_Callback; this.Callback = callback; this.GetMessageHook = SetWindowsHookEx(WH_GETMESSAGE, pGetMessageHook_Callback, IntPtr.Zero, GetCurrentThreadId()); if (this.GetMessageHook.IsInvalid) { throw new Win32Exception(); } try { this.SendMessageHook = SetWindowsHookEx(WH_CALLWNDPROCRET, pSendMessageHook_Callback, IntPtr.Zero, GetCurrentThreadId()); if (this.SendMessageHook.IsInvalid) { throw new Win32Exception(); } } catch { GetMessageHook.Dispose(); throw; } }
public static HotKeyManager hkm = new HotKeyManager();//modified only by Main Thread public KeyboardListener(GlobalHooker hooker, HotKeySuite HKCollection, bool blockLocalInput = false, bool blockRemoteInput = true) { if (hooker == null) { throw new ArgumentNullException("invalid keyboard hooker"); } h = hooker; //hkc = HKCollection; //hkm=new HotKeyManager(); Hotkeys.HotKeyHelper.fullfillHotKeys(); KeyboardListener.blockLocalInput = blockLocalInput; KeyboardListener.blockRemoteInput = blockRemoteInput; HookCallbackReference = new HookCallback(HookCallback); try { HookHandle = h.Subscribe(GetHookId(), HookCallbackReference); } catch (Exception) { HookCallbackReference = null; HookHandle = IntPtr.Zero; throw; } }
/* Required methods to be implemented */ public void Initialize() { Console.WriteLine("Hello from TestModule!"); HookCallback cb = new HookCallback(ProcessFile); this._Host.RegisterHook("request.rawfile.process", cb); }
public void RegisterCallback(string hook, HookCallback method) { LoadedCallback cb = new LoadedCallback(); cb.hook = hook; cb.method = method; callbacks.Add(cb); }
internal Hook(int hookAddr, HookCallback callback, int newCodeAddr, uint newCodeLen, int oldInNewAddr, byte[] oldCode) { this.hookAddr = hookAddr; this.callback = callback; this.newCodeAddr = newCodeAddr; this.newCodeLen = newCodeLen; this.oldInNewAddr = oldInNewAddr; this.oldCode = oldCode; }
public HookServer(HookCallback hulkCallback) { Running = false; Handle = IntPtr.Zero; cts = new CancellationTokenSource(); taskFactory = new TaskFactory(cts.Token); hookCallback = new HookCallback(hulkCallback); windowCallback = new WindowCallback(WndProc); }
private static IntPtr SetKeyboardHook(HookCallback callback) { using (Process curProcess = Process.GetCurrentProcess()) { using (ProcessModule curModule = curProcess.MainModule) { return(SetWindowsHookEx(WH_KEYBOARD_LL, callback, GetModuleHandle(curModule.ModuleName), 0)); } } }
/// <summary> /// グローバルフック初期化 /// </summary> /// <param name="callback">フックプロシージャ</param> public KeyboardUtil(MainWindowViewModel vm) { this.IsShiftPress = false; this.CallbackFunc = KeyboardHookProc; //フックIDの取得 this.HookId = SetWindowsHookEx(HookType.WH_KEYBOARD_LL, this.CallbackFunc, IntPtr.Zero, 0); }
/// <summary> /// Unsubscribes from the hook and stops firing events. /// </summary> /// <exception cref="System.ComponentModel.Win32Exception"></exception> public void Stop() { try { m_Hooker.Unsubscribe(HookHandle); } finally { HookCallbackReferenceKeeper = null; HookHandle = 0; } }
public void DeregisterCallback(string hook, HookCallback method) { int i = 0; foreach (LoadedCallback callback in callbacks) { if (callback.hook == hook && callback.method == method) { callbacks.RemoveAt(i); } i++; } }
internal virtual IntPtr Callback(int nCode, IntPtr wParam, IntPtr lParam) { HookCallback?.Invoke(nCode, wParam, lParam); if (CallNextHook) { return(CallNextHookEx(hhk, nCode, wParam, lParam)); } else { return((IntPtr)1); } }
public void Dispose() { try { h.Unsubscribe(HookHandle); } finally { HookCallbackReference = null; HookHandle = IntPtr.Zero; } GC.SuppressFinalize(this); }
internal override int Subscribe(int hookId, HookCallback hookCallback) { int hookHandle = SetWindowsHookEx( hookId, hookCallback, IntPtr.Zero, GetCurrentThreadId()); if (hookHandle == 0) { ThrowLastUnmanagedErrorAsException(); } return hookHandle; }
internal override int Subscribe(int hookId, HookCallback hookCallback) { int hookHandle = SetWindowsHookEx( hookId, hookCallback, Process.GetCurrentProcess().MainModule.BaseAddress, 0); if (hookHandle == 0) { ThrowLastUnmanagedErrorAsException(); } return(hookHandle); }
internal override int Subscribe(int hookId, HookCallback hookCallback) { int hookHandle = SetWindowsHookEx( hookId, hookCallback, Process.GetCurrentProcess().MainModule.BaseAddress, 0); if (hookHandle == 0) { ThrowLastUnmanagedErrorAsException(); } return hookHandle; }
internal /*int*/ IntPtr Subscribe(int hookId, HookCallback hookCallback) { /*int*/ IntPtr hookHandle = Win32NativeMethods.SetWindowsHookEx( hookId, hookCallback, Process.GetCurrentProcess().MainModule.BaseAddress, 0); if (hookHandle == IntPtr.Zero) { ThrowLastUnmanagedErrorAsException(); } return(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); }
public int HookProc(int nCode, IntPtr wParam, IntPtr lParam, HookCallback callback) { if (nCode < 0) { return(CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam)); } HookData hookData; hookData.wParam = wParam; hookData.lParam = lParam; callback(hookData); return(CallNextHookEx(IntPtr.Zero, nCode, wParam, lParam)); }
/// <summary> /// Subscribes to the hook and starts firing events. /// </summary> /// <exception cref="System.ComponentModel.Win32Exception"></exception> public void Start() { if (Enabled) { throw new InvalidOperationException("Hook listener is already started. Call Stop() method first or use Enabled property."); } HookCallbackReferenceKeeper = new HookCallback(HookCallback); try { HookHandle = m_Hooker.Subscribe(GetHookId(), HookCallbackReferenceKeeper); } catch (Exception) { HookCallbackReferenceKeeper = null; HookHandle = 0; throw; } }
internal override int Subscribe(int hookId, HookCallback hookCallback) { //if (hMod == IntPtr.Zero || dwThreadId == 0) { // throw new HookException(String.Format("Missing Values hMod: {0} or dwThreadId: {1}", hMod, dwThreadId)); //} int hookHandle = SetWindowsHookEx( hookId, hookCallback, hMod, dwThreadId); if (hookHandle == 0) { ThrowLastUnmanagedErrorAsException(); } return(hookHandle); }
private void StartTrackingMouseEvents() { if (_mouseHookHandle != 0) { return; } _mouseEventCallback = OnMouseInputEvent; _mouseHookHandle = NativeMethods.SetWindowsHookEx(_mouseHookId, _mouseEventCallback, IntPtr.Zero, 0); if (_mouseHookHandle != 0) { return; } throw new Win32Exception(Marshal.GetLastWin32Error()); }
private void StopTrackingMouseEvents() { if (_mouseHookHandle == 0) { return; } int result = NativeMethods.UnhookWindowsHookEx(_mouseHookHandle); _mouseHookHandle = 0; _mouseEventCallback = null; if (result != 0) { return; } throw new Win32Exception(Marshal.GetLastWin32Error()); }
public static void Start(HookCallback keyboardCallback, HookCallback mouseCallback) { OSHelper.Os os = OSHelper.GetOsVersion(); if (os.System != OSHelper.Platform.Windows) { throw new InvalidOperatingSystemException("Windowhook can only be run on windows machines!"); } if (Running) { throw new InvalidCastException("Windowhook already running"); } ISLogger.Write("Starting Windowhook on " + os); KeyboardProcPtr = SetKeyboardHook(keyboardCallback); if (KeyboardProcPtr == IntPtr.Zero) { throw new Win32Exception("An error occurred while installing keyboard hook. Win32 error code " + Marshal.GetLastWin32Error()); } else { ISLogger.Write("Installed keyboard hook"); } MouseProcPtr = SetMouseHook(mouseCallback); if (MouseProcPtr == IntPtr.Zero) { throw new Win32Exception("An error occurred while installing mouse hook. Win32 error code " + Marshal.GetLastWin32Error()); } else { ISLogger.Write("Installed Mouse hook"); } Running = true; }
public void HookGlobalKeyboard(HookCallback callback) { HookGlobal(WindowsHookType.WH_KEYBOARD_LL, callback); }
public void HookAppMouse(HookCallback callback) { HookApp(WindowsHookType.WH_MOUSE, callback); }
public void HookAppKeyboard(HookCallback callback) { HookApp(WindowsHookType.WH_KEYBOARD, callback); }
extern static public IntPtr GenCreateHook(IntPtr address, HookCallback callback, int stackBytes);
internal static extern int SetWindowsHookEx( int idHook, HookCallback lpfn, IntPtr hMod, int dwThreadId);
private void HookGlobal(WindowsHookType hookType, HookCallback callback) { m_GlobalHookProc = (int nCode, IntPtr wParam, IntPtr lParam) => HookProc(nCode, wParam, lParam, callback); SafeHookHandle handle = SetWindowsHookEx(hookType, m_GlobalHookProc, Process.GetCurrentProcess().MainModule.BaseAddress, 0); }
/// <summary> /// Creates a new hook and hooks it. /// </summary> public Hook(HookType type, HookCallback callback, bool wrapCallback, bool global) : this(type, wrapCallback, global) { this.Callback += callback; StartHook(); }
public void HookGlobalMouse(HookCallback callback) { HookGlobal(WindowsHookType.WH_MOUSE_LL, callback); }
internal abstract int Subscribe(int hookId, HookCallback hookCallback);
public void RegisterHook(string hook, HookCallback method) { cbSystem.RegisterCallback(hook, method); }
private void StartTrackingKeyboardEvents() { if (_keyboardHookHandle != 0) { return; } _keyboardEventCallback = OnKeyboardInputEvent; _keyboardHookHandle = NativeMethods.SetWindowsHookEx( _keyboardHookId, _keyboardEventCallback, IntPtr.Zero, 0); if (_keyboardHookHandle != 0) { return; } throw new Win32Exception(Marshal.GetLastWin32Error()); }
private void HookApp(WindowsHookType hookType, HookCallback callback) { m_AppHookProc = (int nCode, IntPtr wParam, IntPtr lParam) => HookProc(nCode, wParam, lParam, callback); SafeHookHandle handle = SetWindowsHookEx(hookType, m_AppHookProc, IntPtr.Zero, GetCurrentThreadId()); }
public KeyboardFilter() { this.hookCallback = new HookCallback(_hookCallBack); }
/// <summary> /// Creates a new hook and hooks it. /// </summary> public Hook(HookType type, HookCallback callback, bool global) : this(type, global) { this.Callback += callback; StartHook(); }
public static extern IntPtr SetWindowsHookEx(int idHook, HookCallback lpfn, IntPtr hMod, uint dwThreadId);
/// <summary> /// Subscribes to the hook and starts firing events. /// </summary> /// <exception cref="System.ComponentModel.Win32Exception"></exception> public void Start() { if (Enabled) { throw new InvalidOperationException("Hook listener is already started. Call Stop() method firts or use Enabled property."); } HookCallbackReferenceKeeper = new HookCallback(HookCallback); try { HookHandle = m_Hooker.Subscribe(GetHookId(), HookCallbackReferenceKeeper); } catch (Exception) { HookCallbackReferenceKeeper = null; HookHandle = 0; throw; } }