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;
}
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);
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 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);
}
internal abstract int Subscribe(int hookId, 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();
}
internal static extern int SetWindowsHookEx(
int idHook,
HookCallback lpfn,
IntPtr hMod,
int dwThreadId);
public static extern IntPtr SetWindowsHookEx(int idHook, HookCallback lpfn, IntPtr hMod, uint dwThreadId);
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;
}
}
