public WindowHook()
{
filterMsgs = new List <int>();
mHookCB = null;
msgCallback = null;
hookWndHandle = IntPtr.Zero;
if (null == win32Callback)
{
win32Callback = new Win32.HookProc((nCode, wparam, lparam) =>
{
if (nCode >= 0)
{
Win32.MSG msg = (Win32.MSG)Marshal.PtrToStructure(lparam, typeof(Win32.MSG));
System.Diagnostics.Debug.WriteLine("hook message: " + Convert.ToString(msg.message, 16));
foreach (var m in filterMsgs)
{
if (m == msg.message && msgCallback != null)
{
msgCallback(msg.wParam);
break;
}
}
}
return(Win32.CallNextHookEx(null, nCode, wparam, lparam));
});
}
}
Win32.MyWndProc subWndProc; // Delegate of type MyWndProc - needed to subclass the window
#endregion Fields
#region Constructors
public FlatMenuForm()
{
hookProc = new Win32.HookProc(Hooked);
subWndProc = new Win32.MyWndProc(SubclassWndProc);
hookHandle = Win32.SetWindowsHookEx(4, hookProc, IntPtr.Zero,
Win32.GetWindowThreadProcessId(Handle,0));
}
public void WindowsHook(Win32.HookType type, Win32.HookProc hook)
{
var hMod = Win32.GetModuleHandle(
Process.GetCurrentProcess().MainModule.ModuleName);
Win32.SetWindowsHookEx(type, hook, hMod, 0);
}
DateTime _lastRefresh; // not monotonic, but hopefully not a problem.
public KeyHookManager()
{
_keyboardState = new HashSet <Keys>();
_keyboardHookProcedure = KeyboardHookProc;
_keyboardHookProcPin = GCHandle.Alloc(_keyboardHookProcedure);
Start();
}
public void Initialize()
{
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_OBJECT_DESTROY, Win32.EVENT_CONSTANTS.EVENT_OBJECT_SHOW, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_OBJECT_CLOAKED, Win32.EVENT_CONSTANTS.EVENT_OBJECT_UNCLOAKED, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_SYSTEM_MINIMIZESTART, Win32.EVENT_CONSTANTS.EVENT_SYSTEM_MINIMIZEEND, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_SYSTEM_MOVESIZESTART, Win32.EVENT_CONSTANTS.EVENT_SYSTEM_MOVESIZEEND, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_SYSTEM_FOREGROUND, Win32.EVENT_CONSTANTS.EVENT_SYSTEM_FOREGROUND, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_OBJECT_NAMECHANGE, Win32.EVENT_CONSTANTS.EVENT_OBJECT_NAMECHANGE, IntPtr.Zero, _hookDelegate, 0, 0, 0);
Win32.SetWinEventHook(Win32.EVENT_CONSTANTS.EVENT_OBJECT_LOCATIONCHANGE, Win32.EVENT_CONSTANTS.EVENT_OBJECT_LOCATIONCHANGE, IntPtr.Zero, _hookDelegate, 0, 0, 0);
_mouseHook = MouseHook;
Win32.EnumWindows((handle, param) =>
{
if (Win32Helper.IsAppWindow(handle))
{
RegisterWindow(handle, false);
}
return(true);
}, IntPtr.Zero);
var thread = new Thread(() =>
{
Win32.SetWindowsHookEx(Win32.WH_MOUSE_LL, _mouseHook, Process.GetCurrentProcess().MainModule.BaseAddress, 0);
Application.Run();
});
thread.Name = "WindowsManager";
thread.Start();
}
DateTime _lastRefresh; // not monotonic, but hopefully not a problem.
#endregion Fields
#region Constructors
public KeyHookManager()
{
_keyboardState = new HashSet<Keys>();
_keyboardHookProcedure = KeyboardHookProc;
_keyboardHookProcPin = GCHandle.Alloc(_keyboardHookProcedure);
Start();
}
IntPtr hookHandle = IntPtr.Zero; // Pointer to hookProc
public FlatMenuForm()
{
hookProc = new Win32.HookProc(Hooked);
subWndProc = new Win32.MyWndProc(SubclassWndProc);
hookHandle = Win32.SetWindowsHookEx(4, hookProc, IntPtr.Zero,
Win32.GetWindowThreadProcessId(Handle, 0));
}
public bool HookWindow(IntPtr handle, int [] msgs, MsgCallBack callback)
{
hookWndHandle = handle;
msgCallback = callback;
foreach (var i in msgs)
{
filterMsgs.Add(i);
}
try
{
// int trdId = Win32.GetWindowThreadProcessId(this.hookWndHandle,out procId);
int trdId = Win32.GetCurrentThreadId();
mHookCB = Win32.SetWindowsHookEx(4, win32Callback, IntPtr.Zero, trdId);
if (mHookCB == null)
{
int err = Win32.GetLastError();
string errstr = string.Format("hook message failed:{0}!", err);
Log.Logger.Instance.WriteLog(errstr);
}
}
catch { }
return(true);
}
protected override void EnableHookInternal()
{
_callback = HookCallback;
if (_mousehookId == IntPtr.Zero)
{
_mousehookId = Win32.SetWindowsHookEx(Win32.HookType.WH_MOUSE_LL, _callback, Win32.GetModule(), 0);
}
}
// Win32 Hooking
// ===================================================================================
public static void HookRegister()
{
if (c_hook == 0)
{
MouseHookProcedure = new Win32.HookProc(HookCallBack);
c_hook = Win32.SetWindowsHookEx(Win32.WH_MOUSE_LL, MouseHookProcedure, IntPtr.Zero, 0);
}
}
protected override void EnableHookInternal()
{
_callback = HookCallback;
if (_keyboardHookId == IntPtr.Zero)
{
_keyboardHookId =
Win32.SetWindowsHookEx(Win32.HookType.WH_KEYBOARD_LL, _callback, Win32.GetModule(), 0);
}
}
protected override void DisableHookInternal()
{
if (_keyboardHookId != IntPtr.Zero)
{
Win32.UnhookWindowsHookEx(_keyboardHookId);
_keyboardHookId = IntPtr.Zero;
_callback = null;
}
}
//-------------------------------------
// 생성자
//-------------------------------------
public GlobalHook()
{
this.HookCallBack = new Win32.HookProc(this.CallBack);
System.Windows.Forms.Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
MessageThread = new Thread(MessageThreadStart)
{
Name = "GlobalHook", IsBackground = true
};
MessageThread.Start();
}
public GlobalHook(bool isAll)
{
this.isAll = isAll;
HookCallBack = new Win32.HookProc(CallBack);
MessageThread = new Thread(MessageThreadStart)
{
Name = "GlobalHook", IsBackground = true
};
MessageThread.Start();
}
public void SetHook()
{
KeyboardHookDelegate = new Win32.HookProc(KeyboardHookProc);
Process cProcess = Process.GetCurrentProcess();
ProcessModule cModule = cProcess.MainModule;
var mh = Win32.GetModuleHandle(cModule.ModuleName);
hHook = Win32.SetWindowsHookEx(Win32.WH_KEYBOARD_LL, KeyboardHookDelegate, mh, 0);
}
private static Win32.HookProc m_keyboard_hook_proc; // To prevent the GC collecting the delegate
private static void EnsureSubscribedToGlobalKeyboardEvents()
{
if (m_keyboard_hook_handle != 0)
{
return;
}
m_keyboard_hook_proc = KeyboardHookProc;
m_keyboard_hook_handle = Win32.SetWindowsHookEx((int)Win32.WH_KEYBOARD_LL, m_keyboard_hook_proc, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
if (m_keyboard_hook_handle == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
public IntPtr SetHook()
{
if (hHook == IntPtr.Zero)
{
Win32.HookProc keyCallBack = new Win32.HookProc(KeyHookProcedure);
hHook = Win32.SetWindowsHookEx(
WH_KEYBOARD_LL, keyCallBack,
Win32.GetModuleHandle(System.Diagnostics.Process.GetCurrentProcess().MainModule.ModuleName),
0);
gc = GCHandle.Alloc(keyCallBack);
}
return(hHook);
}
ImageGrabImageDialog(NEVariables variables)
{
Variables = variables;
hookProc = MouseHook;
InitializeComponent();
Loaded += (s, e) =>
{
using (var process = Process.GetCurrentProcess())
using (var module = process.MainModule)
hook = Win32.SetWindowsHookEx(Win32.HookType.WH_MOUSE_LL, hookProc, Win32.GetModuleHandle(module.ModuleName), 0);
};
}
// Remove the keyboard hook
private static void ForceUnsunscribeFromGlobalKeyboardEvents()
{
if (m_keyboard_hook_handle == 0)
{
return;
}
int result = Win32.UnhookWindowsHookEx(m_keyboard_hook_handle);
m_keyboard_hook_handle = 0;
m_keyboard_hook_proc = null;
if (result == 0)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
}
public InteractionWatcher(HookManager hookMgr)
{
_hookMgr = hookMgr;
_keyboardCallback = KeyboardCallback;
_mouseCallback = MouseCallback;
_hookMgr.WindowsHook(Win32.HookType.WH_KEYBOARD_LL, _keyboardCallback);
_hookMgr.WindowsHook(Win32.HookType.WH_MOUSE_LL, _mouseCallback);
_timer = new Timer(1000)
{
AutoReset = true
};
_timer.Elapsed += TimerCallback;
_interaction = false;
_timer.Start();
}
/*** Keyboard Hook ***/
/*** Each class will have it's own overriding function as callback ***/
protected void ApplyKeyboardHook()
{
_KeyboardHookProc = new Win32.HookProc(KeyboardHookCallback);
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
_KeyboardHookID = Win32.SetWindowsHookEx(Win32.WH_KEYBOARD_LL, _KeyboardHookProc, Win32.GetModuleHandle(curModule.ModuleName), 0);
if (_KeyboardHookID == IntPtr.Zero)
{
WriteLog("KeyboardHook Error : " + Marshal.GetLastWin32Error());
}
else
{
WriteLog("LowLevel-KeyboardHook installed !");
}
}
// Installs both or one of mouse and/or keyboard hooks and starts rasing events
public void Start(bool InstallMouseHook, bool InstallKeyboardHook)
{
// Install Mouse hook only if it is not installed and must be installed
if (m_hMouseHook == 0 && InstallMouseHook)
{
// Create an instance of HookProc.
m_MouseHookProcedure = new Win32.HookProc(MouseHookProc);
// Install hook
m_hMouseHook = Win32.SetWindowsHookEx(Win32.WH_MOUSE_LL, m_MouseHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
// If SetWindowsHookEx fails.
if (m_hMouseHook == 0)
{
// Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set.
int errorCode = Marshal.GetLastWin32Error();
// Do cleanup
Stop(true, false, false);
// Initializes and throws a new instance of the Win32Exception class with the specified error.
//throw new Win32Exception(errorCode);
}
}
// Install Keyboard hook only if it is not installed and must be installed
if (m_hKeyboardHook == 0 && InstallKeyboardHook)
{
// Create an instance of HookProc.
m_KeyboardHookProcedure = new Win32.HookProc(KeyboardHookProc);
// Install hook
m_hKeyboardHook = Win32.SetWindowsHookEx(Win32.WH_KEYBOARD_LL, m_KeyboardHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
// If SetWindowsHookEx fails.
if (m_hKeyboardHook == 0)
{
//Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set.
int errorCode = Marshal.GetLastWin32Error();
// Do cleanup
Stop(false, true, false);
// Initializes and throws a new instance of the Win32Exception class with the specified error.
throw new Win32Exception(errorCode);
}
}
}
//设置Hook
public bool SetHook()
{
if (hHook != IntPtr.Zero)
{
return(false);
}
Win32.HookProc mouseCallBack = new Win32.HookProc(MouseHookProcedure);
hHook = Win32.SetWindowsHookEx(WH_MOUSE_LL, mouseCallBack,
Win32.GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName), 0);
if (hHook != IntPtr.Zero)
{
gc = GCHandle.Alloc(mouseCallBack);
return(true);
}
return(false);
}
/// <summary>Stops the application from listening to all keyboard messages.
/// </summary>
public void KeyBoardUnHook()
{
try
{
if (!hooked)
{
return;
}
Win32.UnhookWindowsHookEx(hookId);
callback = null;
hooked = false;
}
catch (MarshalDirectiveException)
{
//if (!SuppressException) throw (e);
}
}
public KeybindManager(IConfigContext context)
{
_context = context;
_kbdHook = KbdHook;
_mouseHook = MouseHook;
_kbdSubs = new Dictionary <Sub, NamedBind <KeybindHandler> >();
_mouseSubs = new Dictionary <MouseEvent, NamedBind <MouseHandler> >();
SubscribeDefaults();
var thread = new Thread(() =>
{
Win32.SetWindowsHookEx(Win32.WH_KEYBOARD_LL, _kbdHook, Process.GetCurrentProcess().MainModule.BaseAddress, 0);
Win32.SetWindowsHookEx(Win32.WH_MOUSE_LL, _mouseHook, Process.GetCurrentProcess().MainModule.BaseAddress, 0);
Application.Run();
});
thread.Name = "KeybindManager";
thread.Start();
}
public void Start()
{
if (!_isStarted && _hookType != 0)
{
//确保_hookCallback不是一个空的引用,如果是，GC会随机回收它，并且一个空的引用会爆出异常
_hookCallback = new Win32.HookProc(HookCallbackProcedure);
using (Process curPro = Process.GetCurrentProcess())
{
using (ProcessModule curMod = curPro.MainModule)
{
_handleToHook = (int)Win32.SetWindowsHookExW(_hookType, _hookCallback, Win32.GetModuleHandle(curMod.ModuleName), 0);
}
}
// 钩成功
if (_handleToHook != 0)
{
_isStarted = true;
}
}
}
public void Initialize()
{
if (hMouseHook == IntPtr.Zero)
{
// Create an instance of HookProc.
MouseHookProcedure = new Win32.HookProc(MouseHookProc);
//install hook
hMouseHook = Win32.SetWindowsHookEx(
Win32.HookType.WH_MOUSE_LL,
MouseHookProcedure,
IntPtr.Zero,
0);
//If SetWindowsHookEx fails.
if (hMouseHook == IntPtr.Zero)
{
int errorCode = Marshal.GetLastWin32Error();
throw new Win32Exception(errorCode);
}
}
}
public KeyboardHook(Action <Key> cb)
{
OnKeyPress = cb;
cbDel = new Win32.HookProc((nCode, wParam, lParam) =>
{
if (nCode >= 0 && wParam == (IntPtr)Win32.WM_KEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
var keyPressed = KeyInterop.KeyFromVirtualKey(vkCode);
if (OnKeyPress != null)
{
OnKeyPress(keyPressed);
}
}
return(Win32.CallNextHookEx(hookId, nCode, wParam, lParam));
});
using (var curProcess = Process.GetCurrentProcess())
using (var curModule = curProcess.MainModule)
{
hookId = Win32.SetWindowsHookEx(Win32.WH_KEYBOARD_LL, cbDel,
Win32.GetModuleHandle(curModule.ModuleName), 0);
}
}
public Form1()
{
InitializeComponent();
// Create an instance of HookProc.
m_MouseHookProcedure = new Win32.HookProc(MouseHookProc);
// Install hook
m_hMouseHook = Win32.SetWindowsHookEx(Win32.WH_CALLWNDPROC /*WH_MOUSE_LL*/, m_MouseHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]), 0);
// If SetWindowsHookEx fails.
if (m_hMouseHook == 0)
{
// Returns the error code returned by the last unmanaged function called using platform invoke that has the DllImportAttribute.SetLastError flag set.
int errorCode = Marshal.GetLastWin32Error();
}
// Uninstall hook
//int retMouse = Win32.UnhookWindowsHookEx(m_hMouseHook);
// Reset invalid handle
//m_hMouseHook = 0;
}
public static extern IntPtr SetWindowsHookEx(Win32.HookTypes hookType, Win32.HookProc hookProc, IntPtr hInstance, int nThreadId);
private static void HookUnregister()
{
Win32.UnhookWindowsHookEx(c_hook);
c_hook = 0;
MouseHookProcedure = null;
}
/// <summary>Allows the application to listen to all keyboard messages.
/// </summary>
public void KeyBoardHook()
{
callback = KeyboardHookCallback;
hookId = Win32.SetWindowsHook((int)KeyboardHookEnum.KeyboardHook, callback);
hooked = true;
}
/// <summary>Stops the application from listening to all keyboard messages.
/// </summary>
public void KeyBoardUnHook()
{
try
{
if (!hooked) return;
Win32.UnhookWindowsHookEx(hookId);
callback = null;
hooked = false;
}
catch (MarshalDirectiveException)
{
//if (!SuppressException) throw (e);
}
}
public int SetHook()
{
hProc = new Win32.HookProc(MouseHookProc);
hHook = Win32.SetWindowsHookEx(WH_MOUSE_LL, hProc, IntPtr.Zero, 0);
return(hHook);
}
