/// <summary>
/// Installs the global hook
/// </summary>
public void hook()
{
IntPtr hInstance = LoadLibrary("User32");
_hookProc = new KeyboardHookProc(hookProc);
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, hInstance, 0);
}
public void Hook()
{
var hInstance = LoadLibrary("User32");
SAFE_delegate_callback = HookProc;
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, SAFE_delegate_callback, hInstance, 0);
}
public virtual void Hook()
{
hookDelegate = new KeyboardHookProc(HookProc);
IntPtr hInstance = User32.LoadLibrary("User32");
hhook = User32.SetWindowsHookEx(13, hookDelegate, hInstance, 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="GlobalKeyHook"/> class and installs the keyboard hook.
/// </summary>
/// <param name="AutoHook">Should keyhook be initialized</param>
public GlobalKeyHook(bool AutoHook)
{
_keyboardGlobalHookCallback = HookProc;
if (AutoHook)
{
Hook();
}
}
public bool Start(string moduleName, IList <MenuItem> menuItems)
{
_menuItems = menuItems;
_hookProc = HookProc;
var moduleHandle = GetModuleHandle(moduleName);
_hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, moduleHandle, 0);
var hookStarted = _hookHandle != IntPtr.Zero;
return(hookStarted);
}
//#############################################################
#region [# Hooks #]
public virtual void Hook()
{
hookDelegate = _hookProc;
//Get library instance
IntPtr hInstance = LoadLibrary("User32");
//Call library hook function
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookDelegate, hInstance, 0);
//Set bHooked to true if successful.
bHooked = (hhook != null);
}
public void Hook()
{
IntPtr hInstance = LoadLibrary("User32");
_callbackDelegate = CaptureKeySinglePress;
_hHook = SetWindowsHookEx(WH_KEYBOARD_LL, _callbackDelegate, hInstance, 0);
if (_hHook == IntPtr.Zero)
{
throw new Win32Exception();
}
}
public void hook()
{
_hookProc = new KeyboardHookProc(hookProc);
IntPtr hInstance = LoadLibrary("user32");
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, GetModuleHandle(curModule.ModuleName), 0);
}
}
public void HookInput()
{
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
KeyboardHookDelegate = new KeyboardHookProc(KeyboardHook);
Hook = SetWindowsHookEx(13, KeyboardHookDelegate, GetModuleHandle(curModule.ModuleName), 0);
}
Application.Run();
}
/// <summary>
/// Uninstalls the global hook
/// </summary>
public void Unhook()
{
if (callbackDelegate == null)
{
return;
}
if (UnhookWindowsHookEx(hhook))
{
callbackDelegate = null;
}
}
/// <summary>
/// Installs the global hook
/// </summary>
public void Hook()
{
if (_installed)
{
return;
}
_installed = true;
HInstance = LoadLibrary("User32");
_keyboardHookProc = HookProc;
_hhook = SetWindowsHookEx(WhKeyboardLl, _keyboardHookProc, HInstance, 0);
KeyDown += Kernel.KeyDown;
KeyUp += Kernel.KeyUp;
}
public bool Start(int key1, int key2, int key3)
{
_key1 = key1;
_key2 = key2;
_key3 = key3;
_hookProc = HookProc;
var moduleHandle = NativeMethods.GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
_hookHandle = NativeMethods.SetWindowsHookEx(NativeConstants.WH_KEYBOARD_LL, _hookProc, moduleHandle, 0);
var hookStarted = _hookHandle != IntPtr.Zero;
return(hookStarted);
}
public void UnHook()
{
if (_callbackDelegate == null)
{
return;
}
bool ok = UnhookWindowsHookEx(_hHook);
if (!ok)
{
throw new Win32Exception();
}
_callbackDelegate = null;
}
public static void SetHook()
{
if (callbackDelegate != null)
{
throw new InvalidOperationException("Can't hook more than once");
}
IntPtr hInstance = LoadLibrary("User32");
callbackDelegate = new KeyboardHookProc(HookProc);
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, callbackDelegate, hInstance, 0);
if (hhook == IntPtr.Zero)
{
throw new Win32Exception();
}
}
public void StartHook()
{
try
{
if (keyboardHookDelegate == null)
{
keyboardHookDelegate = ConfigHook;
}
keyboardHookHandler = ApiFunctions.SetWindowsHookEx(HookType.WH_KEYBOARD_LL, keyboardHookDelegate, hookInstance, 0);
logger.Info("Keyboard hook started");
}
catch (Exception ex)
{
logger.Error($"START KEBOARD HOOK ERROR: {ex.StackTrace}");
}
}
public Hook(int keyCode)
{
_key = keyCode;
_proc = HookProc;
}
internal static extern IntPtr KeyboardHookSetWindowsHookEx(int idHook, KeyboardHookProc lpfn, IntPtr hMod, uint dwThreadId);
public static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hModule, uint threadId);
/// <summary>
/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
/// </summary>
private GlobalKeyboardHook()
{
keyboardHookProc = new KeyboardHookProc(hookProc);
Hook();
}
private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hInstance, uint threadId);
static extern IntPtr SetWindowsHookEx(int hookID, KeyboardHookProc callback, IntPtr hInstance, uint threadID);
/// <summary>
/// Initializes a new instance of the <see cref="GlobalKeyboardHook" /> class and installs the keyboard hook.
/// </summary>
public GlobalKeyboardHook()
{
hookProcDelegate = hookProc;
hook();
}
public static extern IntPtr SetWindowsHookEx(HookType hookType, KeyboardHookProc lpfn, IntPtr hMod, uint dwThreadId);
public static extern IntPtr SetWindowsHookEx(WinAPI.HookType code, KeyboardHookProc callback, IntPtr hInstance, int threadId);
/// <summary>
/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard Hook.
/// </summary>
public GlobalKeyboardHook()
{
khp = new KeyboardHookProc(HookProc);
Hook();
}
/// <summary>
/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
/// </summary>
public GlobalKeyboardHook()
{
_callback = new KeyboardHookProc(HookProc);
Hook();
}
/// <summary>
/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
/// </summary>
private GlobalKeyboardHook()
{
keyboardHookProc = new KeyboardHookProc(hookProc);
Hook();
}
private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc lpfn, IntPtr hmod, uint dwThreadId);
private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hInstance, uint threadId);
/// <summary>
/// Installs the global window hook.
/// </summary>
/// <returns>Whether the initialization is successful.</returns>
public bool InitializeHook()
{
_callback = OnHookCall;
_currentHook = SetWindowsHookEx(WH_KEYBOARD_LL, _callback, IntPtr.Zero, 0);
return(_currentHook != IntPtr.Zero);
}
static extern IntPtr SetWindowsHookEx(int hookID, KeyboardHookProc callback, IntPtr hInstance, uint threadID);
public void hook()
{
_hookProc = new KeyboardHookProc(hookProc);
IntPtr hInstance = LoadLibrary("user32");
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
hookHandle = SetWindowsHookEx(WH_KEYBOARD_LL, _hookProc, GetModuleHandle(curModule.ModuleName), 0);
}
}
public GlobalKeyboardHook()
{
HookedKeys = new List<Keys>();
hookedKeyboardProc = (KeyboardHookProc)hookProc;
Hook();
}
public Hook()
{
_proc = HookProc;
SetHook();
}
private bool _hookHandler()
{
_keyboardHookProc = new KeyboardHookProc(_wmHandler);
_hHook = SetWindowsHookEx(WH_KEYBOARD_LL, _keyboardHookProc, LoadLibrary("User32"), 0);
return(_hHook.ToInt32() != 0);
}
/// <summary>
/// Set up the hook into Windows
/// </summary>
protected void Hook()
{
if (m_hook == IntPtr.Zero)
{
// We have to store the HookProc, so that it is not garbage collected during runtime
m_hookedProc = HookProc;
// need instance handle to module to create a system-wide hook
IntPtr instance = WinAPI.LoadLibrary("User32");
m_hook = SetWindowsHookEx(WinAPI.HookType.WH_KEYBOARD_LL, m_hookedProc, instance, 0);
m_hookedAsync = new KeyboardHookAsync(KeyCallback);
}
}
public KeyboardHook()
{
this.callback = this.keyboardHookCallback;
this.hook = SetWindowsHookEx(WH_KEYBOARD_LL, this.callback, GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);
}
public KeyboardHook(string name)
{
Name = name;
_hookProc = HookCallback;
}
[DllImport("user32.dll")] public static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookProc callback, IntPtr hInstance, uint threadId);
/// <summary>
/// Unhook from windows
/// </summary>
public void UnHook()
{
if (m_hook != IntPtr.Zero)
{
WinAPI.UnhookWindowsHookEx(m_hook);
m_hook = IntPtr.Zero;
// clear the forced references for GC
m_hookedAsync = null;
m_hookedProc = null;
}
}
public Hook(int keyCode)
{
_key = keyCode;
_proc = HookProc;
}
