public void Install()
{
_hookProc = KeyboardHookProc;
_hookHandle = SetupHook(_hookProc);
if (_hookHandle == IntPtr.Zero)
throw new Win32Exception(Marshal.GetLastWin32Error());
}
internal void CreateHook()
{
_khd = new KeyboardHookDelegate(KeyboardHookCallback);
GC.KeepAlive(_khd);
_kbHandle = SetWindowsHookEx(13, _khd, Marshal.GetHINSTANCE(System.Reflection.Assembly.GetExecutingAssembly().GetModules()[0]), 0);
GlobalVariables.GlobalVariables.KHookStatus = (_kbHandle != IntPtr.Zero);
}
///<summary>
///新しいインスタンスを作成する。
///</summary>
public KeyboardHook()
{
KeyboardHookDelegate callback = CallNextHook;
this._hookDelegate = GCHandle.Alloc(callback);
IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
this._hook = SetWindowsHookEx(KEYBOARD_HOOK_TYPE, callback, module, 0);
}
///<summary>
///新しいインスタンスを作成する。
///</summary>
public KeyboardHook()
{
KeyboardHookDelegate callback = new KeyboardHookDelegate(CallNextHook);
hookDelegate = GCHandle.Alloc(callback);
IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
hook = SetWindowsHookEx(KeyboardHookType, callback, module, 0);
}
public void Install()
{
_hookProc = KeyboardHookProc;
_hookHandle = SetupHook(_hookProc);
if (_hookHandle == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
static IntPtr SetHook(KeyboardHookDelegate hook)
{
using (var currentProcess = Process.GetCurrentProcess())
using (var currentModule = currentProcess.MainModule)
{
return(SetWindowsHookEx(WH_KEYBOARD_LL, hook,
GetModuleHandle(currentModule.ModuleName), 0));
}
}
public void HookKeyboard()
{
callback = new KeyboardHookDelegate(LowLevelKeyboardProc);
KeyboardHandle = SetWindowsHookEx(WH_KEYBOARD_LL, callback,
Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), (uint)0);
if ((int)KeyboardHandle == 0)
{
throw new Exception("Hook Falhou");
}
}
public void Install()
{
_hookProc = KeyboardHookProc;
_hookHandle = SetupHook(_hookProc);
if (_hookHandle == IntPtr.Zero)
{
MessageBox.Show("Lỗi cài đặt hook");
}
}
///<summary>
///新しいインスタンスを作成する。
///</summary>
public KeyboardHook()
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
throw new PlatformNotSupportedException("Windows 98/Meではサポートされていません。");
}
this.hookDelegate = new KeyboardHookDelegate(CallNextHook);
IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
hook = SetWindowsHookEx(KeyboardHookType, hookDelegate, module, 0);
}
///<summary>
///新しいインスタンスを作成する。
///</summary>
public KeyboardHook()
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
throw new PlatformNotSupportedException("Windows 98/Meではサポートされていません。");
}
this.callback = new KeyboardHookDelegate(CallNextHook);
this.hookDelegate = GCHandle.Alloc(callback);
this.module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
}
/// <summary>
/// Creates global keyboard listener.
/// </summary>
public KeyboardListener()
{
// We have to store the HookCallback, so that it is not garbage collected runtime
_hookedKeyboardHook = LowLevelKeyboardProc;
// Set the hook
_hookId = SetHook(_hookedKeyboardHook);
// Assign the asynchronous callback event
_hookedKeyboardCallback = KeyboardListener_KeyboardCallbackAsync;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
public void Install()
{
_hookProc = KeyboardHookProc;
_hookHandle = SetupHook(_hookProc);
if (_hookHandle == IntPtr.Zero)
{
MessageBox.Show("Error when hook keyboard: " + Marshal.GetLastWin32Error().ToString());
}
MouseEventArgs a;
}
///<summary>
/// インスタンスを初期化する。
///</summary>
public KeyboardHook()
{
KeyboardHookDelegate callback = new KeyboardHookDelegate(CallNextHook);
hookDelegate = GCHandle.Alloc(callback);
string moduleName = Process.GetCurrentProcess().MainModule?.ModuleName ?? "";
IntPtr hModule = string.IsNullOrEmpty(moduleName)
? IntPtr.Zero
: WindowsAPI.GetModuleHandle(moduleName);
hook = SetWindowsHookEx(KeyboardHookType, callback, hModule, 0);
}
public void Connect()
{
if (IsConnected)
{
throw new InvalidOperationException("The keyboard hook is already connected.");
}
_hookedKeyboardHook = LowLevelKeyboardProc;
_hookId = SetHook(_hookedKeyboardHook);
_hookedKeyboardCallback = KeyboardListener_KeyboardCallbackAsync;
IsConnected = true;
}
public void Install()
{
_hookProc = KeyboardHookProc;
_hookHandle = SetupHook(_hookProc);
currentWindow = GetActiveWindowsTXT();
textBoxWindowName.Text = currentWindow;
this.TopMost = true;
if (_hookHandle == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
public void Disconnect()
{
if (!IsConnected)
{
throw new InvalidOperationException("The keyboard hook is already disconnected.");
}
UnhookWindowsHookEx(_hookId);
_hookedKeyboardHook = null;
_hookedKeyboardCallback = null;
_hookId = default(IntPtr);
}
public void Start()
{
if (!Enabled)
{
KeyboardHookDelegate callback = new KeyboardHookDelegate(CallNextHook);
this.hookDelegate = GCHandle.Alloc(callback);
IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
this.hook = NativeMethod.SetWindowsHookEx(GlobalHookTypes.KeyBoard_Global, callback, module, 0);
if (this.hook != IntPtr.Zero)
{
Enabled = true;
}
}
}
public void Connect()
{
if (!IsConnected)
{
using (var currentProcess = Process.GetCurrentProcess())
using (var currentModule = currentProcess.MainModule)
{
hookDelegate = LowLevelKeyboardCallback;
hookId = SetWindowsHookEx(
WH_KEYBOARD_LL,
hookDelegate,
GetModuleHandle(currentModule.ModuleName),
0);
}
}
}
private IntPtr SetupHook(KeyboardHookDelegate hookProc)
{
IntPtr hInstance = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]);
return(SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0));
}
///<summary>
///�V�����C���X�^���X��쐬����B
///</summary>
public KeyboardHook()
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
throw new PlatformNotSupportedException("Windows 98/Me�ł̓T�|�[�g����Ă��܂���B");
KeyboardHookDelegate callback = new KeyboardHookDelegate(CallNextHook);
this.hookDelegate = GCHandle.Alloc(callback);
IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
this.hook = SetWindowsHookEx(KeyboardHookType, callback, module, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
private IntPtr SetupHook(KeyboardHookDelegate hookProc)
{
IntPtr hInstance = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
return(SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0));
}
/// <summary>
/// Installs the global hook
/// </summary>
public static void Hook()
{
IntPtr hInstance = LoadLibrary("User32");
keyeventHandler = hookProc;
GC.KeepAlive(keyeventHandler);
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, keyeventHandler, hInstance, 0);
KeyUp += Native_KeyUp;
}
private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookDelegate lpfn, IntPtr hMod, uint dwThreadId);
public IntPtr SetWindowsHookExOverride(int idHook, KeyboardHookDelegate lpfn, IntPtr hMod, uint dwThreadId)
{
_interface.DebugWriteLine("Hook install intercepted and overriden.");
var result = originalSetWindowsHookExW(
idHook,
(nCode, wParam, lParam) =>
{
var vkCode = Marshal.ReadInt32(lParam);
var currentKey = KeyInterop.KeyFromVirtualKey(vkCode);
var keyEvent = (KeyEvent)wParam.ToUInt32();
var isCurrentKeyDown = keyEvent == KeyEvent.WM_KEYDOWN;
var shouldIgnoreHook = _interface.GetShouldIgnoreHook();
var shouldOverride = ctrlIsDown &&
(currentKey == Key.V) &&
!shouldIgnoreHook;
switch (currentKey)
{
case Key.LeftCtrl:
case Key.RightCtrl:
ctrlIsDown = isCurrentKeyDown;
break;
case Key.V:
vIsDown = isCurrentKeyDown;
break;
}
var fetchOriginalResult = new Lazy <IntPtr>(() => lpfn(nCode, wParam, lParam));
if (!shouldOverride)
{
var value = fetchOriginalResult.Value.ToInt32();
_interface.DebugWriteLine($"Original call for {currentKey} {(isCurrentKeyDown ? "down" : "up")} returned {value}.");
if ((value != 1) && (value != -1))
{
return(fetchOriginalResult.Value);
}
}
switch (currentKey)
{
case Key.LeftCtrl:
case Key.RightCtrl:
shouldOverride = true;
break;
case Key.V:
shouldOverride = ctrlIsDown;
break;
case Key.Down:
case Key.Up:
case Key.Left:
case Key.Right:
shouldOverride = ctrlIsDown && vIsDown;
break;
}
if (shouldOverride || shouldIgnoreHook)
{
return(CallNextHookEx(
new IntPtr(idHook), nCode, wParam, lParam));
}
return(fetchOriginalResult.Value);
},
hMod,
dwThreadId);
return(result);
}
public static extern IntPtr SetWindowsHookEx(GlobalHookTypes hookType, KeyboardHookDelegate hookDelegate, IntPtr hInstance, uint threadId);
private IntPtr SetHook(KeyboardHookDelegate hook)
{
using (Process currentProcess = Process.GetCurrentProcess())
{
using (ProcessModule curModule = currentProcess.MainModule)
{
_dispatcher = Dispatcher.CurrentDispatcher;
return SetWindowsHookEx(WH_KEYBOARD_LL, hook,
GetModuleHandle(curModule.ModuleName), 0);
}
}
}
private static extern IntPtr SetWindowsHookEx(int hookType, KeyboardHookDelegate hookDelegate, IntPtr hInstance, uint threadId);
///<summary>
///新しいインスタンスを作成する。
///</summary>
public KeyboardHook()
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
throw new PlatformNotSupportedException("Windows 98/Meではサポートされていません。");
KeyboardHookDelegate callback = new KeyboardHookDelegate(CallNextHook);
this.hookDelegate = GCHandle.Alloc(callback);
//IntPtr module = Marshal.GetHINSTANCE(typeof(KeyboardHook).Assembly.GetModules()[0]);
IntPtr module = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
this.hook = SetWindowsHookEx(KeyboardHookType, callback, module, 0);
}
public KeyboardListener(FirstKey firstKey)
{
FirstKey = firstKey;
KeyboardHookInstance = new KeyboardHookDelegate(KeyboardHook);
Install();
}
private static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookDelegate lpfn, IntPtr hMod, uint dwThreadId);
private IntPtr SetupHook(KeyboardHookDelegate hookProc)
{
IntPtr hInstance = Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]);
return SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
}
private static extern IntPtr SetWindowsHookEx(int hookType, KeyboardHookDelegate hookDelegate, IntPtr hInstance, uint threadId);
static extern IntPtr SetWindowsHookEx(int idHook, KeyboardHookDelegate callback, IntPtr hInstance, uint threadId);
