欢迎使用CSDN-markdown编辑器

C#全局鼠标/键盘钩子

using System;using System.Runtime.InteropServices;using System.Reflection;using System.Threading;using System.Windows.Forms;using System.ComponentModel;namespace gma.System.Windows{    /// <summary>    /// This class allows you to tap keyboard and mouse and / or to detect their activity even when an     /// application runes in background or does not have any user interface at all. This class raises     /// common .NET events with KeyEventArgs and MouseEventArgs so you can easily retrieve any information you need.    /// </summary>    public class UserActivityHook    {        #region Windows structure definitions        /// <summary>        /// The POINT structure defines the x- and y- coordinates of a point.         /// </summary>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/gdi/rectangl_0tiq.asp        /// </remarks>        [StructLayout(LayoutKind.Sequential)]        private class POINT        {            /// <summary>            /// Specifies the x-coordinate of the point.             /// </summary>            public int x;            /// <summary>            /// Specifies the y-coordinate of the point.             /// </summary>            public int y;        }        /// <summary>        /// The MOUSEHOOKSTRUCT structure contains information about a mouse event passed to a WH_MOUSE hook procedure, MouseProc.         /// </summary>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookstructures/cwpstruct.asp        /// </remarks>        [StructLayout(LayoutKind.Sequential)]        private class MouseHookStruct        {            /// <summary>            /// Specifies a POINT structure that contains the x- and y-coordinates of the cursor, in screen coordinates.             /// </summary>            public POINT pt;            /// <summary>            /// Handle to the window that will receive the mouse message corresponding to the mouse event.             /// </summary>            public int hwnd;            /// <summary>            /// Specifies the hit-test value. For a list of hit-test values, see the description of the WM_NCHITTEST message.             /// </summary>            public int wHitTestCode;            /// <summary>            /// Specifies extra information associated with the message.             /// </summary>            public int dwExtraInfo;        }        /// <summary>        /// The MSLLHOOKSTRUCT structure contains information about a low-level keyboard input event.         /// </summary>        [StructLayout(LayoutKind.Sequential)]        private class MouseLLHookStruct        {            /// <summary>            /// Specifies a POINT structure that contains the x- and y-coordinates of the cursor, in screen coordinates.             /// </summary>            public POINT pt;            /// <summary>            /// If the message is WM_MOUSEWHEEL, the high-order word of this member is the wheel delta.             /// The low-order word is reserved. A positive value indicates that the wheel was rotated forward,             /// away from the user; a negative value indicates that the wheel was rotated backward, toward the user.             /// One wheel click is defined as WHEEL_DELTA, which is 120.             ///If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP,            /// or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released,             /// and the low-order word is reserved. This value can be one or more of the following values. Otherwise, mouseData is not used.             ///XBUTTON1            ///The first X button was pressed or released.            ///XBUTTON2            ///The second X button was pressed or released.            /// </summary>            public int mouseData;            /// <summary>            /// Specifies the event-injected flag. An application can use the following value to test the mouse flags. Value Purpose             ///LLMHF_INJECTED Test the event-injected flag.              ///0            ///Specifies whether the event was injected. The value is 1 if the event was injected; otherwise, it is 0.            ///1-15            ///Reserved.            /// </summary>            public int flags;            /// <summary>            /// Specifies the time stamp for this message.            /// </summary>            public int time;            /// <summary>            /// Specifies extra information associated with the message.             /// </summary>            public int dwExtraInfo;        }        /// <summary>        /// The KBDLLHOOKSTRUCT structure contains information about a low-level keyboard input event.         /// </summary>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookstructures/cwpstruct.asp        /// </remarks>        [StructLayout(LayoutKind.Sequential)]        private class KeyboardHookStruct        {            /// <summary>            /// Specifies a virtual-key code. The code must be a value in the range 1 to 254.             /// </summary>            public int vkCode;            /// <summary>            /// Specifies a hardware scan code for the key.             /// </summary>            public int scanCode;            /// <summary>            /// Specifies the extended-key flag, event-injected flag, context code, and transition-state flag.            /// </summary>            public int flags;            /// <summary>            /// Specifies the time stamp for this message.            /// </summary>            public int time;            /// <summary>            /// Specifies extra information associated with the message.             /// </summary>            public int dwExtraInfo;        }        #endregion        #region Windows function imports        /// <summary>        /// The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain.         /// You would install a hook procedure to monitor the system for certain types of events. These events         /// are associated either with a specific thread or with all threads in the same desktop as the calling thread.         /// </summary>        /// <param name="idHook">        /// [in] Specifies the type of hook procedure to be installed. This parameter can be one of the following values.        /// </param>        /// <param name="lpfn">        /// [in] Pointer to the hook procedure. If the dwThreadId parameter is zero or specifies the identifier of a         /// thread created by a different process, the lpfn parameter must point to a hook procedure in a dynamic-link         /// library (DLL). Otherwise, lpfn can point to a hook procedure in the code associated with the current process.        /// </param>        /// <param name="hMod">        /// [in] Handle to the DLL containing the hook procedure pointed to by the lpfn parameter.         /// The hMod parameter must be set to NULL if the dwThreadId parameter specifies a thread created by         /// the current process and if the hook procedure is within the code associated with the current process.         /// </param>        /// <param name="dwThreadId">        /// [in] Specifies the identifier of the thread with which the hook procedure is to be associated.         /// If this parameter is zero, the hook procedure is associated with all existing threads running in the         /// same desktop as the calling thread.         /// </param>        /// <returns>        /// If the function succeeds, the return value is the handle to the hook procedure.        /// If the function fails, the return value is NULL. To get extended error information, call GetLastError.        /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp        /// </remarks>        [DllImport("user32.dll", CharSet = CharSet.Auto,           CallingConvention = CallingConvention.StdCall, SetLastError = true)]        private static extern int SetWindowsHookEx(            int idHook,            HookProc lpfn,            IntPtr hMod,            int dwThreadId);        /// <summary>        /// The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function.         /// </summary>        /// <param name="idHook">        /// [in] Handle to the hook to be removed. This parameter is a hook handle obtained by a previous call to SetWindowsHookEx.         /// </param>        /// <returns>        /// If the function succeeds, the return value is nonzero.        /// If the function fails, the return value is zero. To get extended error information, call GetLastError.        /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp        /// </remarks>        [DllImport("user32.dll", CharSet = CharSet.Auto,            CallingConvention = CallingConvention.StdCall, SetLastError = true)]        private static extern int UnhookWindowsHookEx(int idHook);        /// <summary>        /// The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain.         /// A hook procedure can call this function either before or after processing the hook information.         /// </summary>        /// <param name="idHook">Ignored.</param>        /// <param name="nCode">        /// [in] Specifies the hook code passed to the current hook procedure.         /// The next hook procedure uses this code to determine how to process the hook information.        /// </param>        /// <param name="wParam">        /// [in] Specifies the wParam value passed to the current hook procedure.         /// The meaning of this parameter depends on the type of hook associated with the current hook chain.         /// </param>        /// <param name="lParam">        /// [in] Specifies the lParam value passed to the current hook procedure.         /// The meaning of this parameter depends on the type of hook associated with the current hook chain.         /// </param>        /// <returns>        /// This value is returned by the next hook procedure in the chain.         /// The current hook procedure must also return this value. The meaning of the return value depends on the hook type.         /// For more information, see the descriptions of the individual hook procedures.        /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/setwindowshookex.asp        /// </remarks>        [DllImport("user32.dll", CharSet = CharSet.Auto,             CallingConvention = CallingConvention.StdCall)]        private static extern int CallNextHookEx(            int idHook,            int nCode,            int wParam,            IntPtr lParam);        /// <summary>        /// The CallWndProc hook procedure is an application-defined or library-defined callback         /// function used with the SetWindowsHookEx function. The HOOKPROC type defines a pointer         /// to this callback function. CallWndProc is a placeholder for the application-defined         /// or library-defined function name.        /// </summary>        /// <param name="nCode">        /// [in] Specifies whether the hook procedure must process the message.         /// If nCode is HC_ACTION, the hook procedure must process the message.         /// If nCode is less than zero, the hook procedure must pass the message to the         /// CallNextHookEx function without further processing and must return the         /// value returned by CallNextHookEx.        /// </param>        /// <param name="wParam">        /// [in] Specifies whether the message was sent by the current thread.         /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero.         /// </param>        /// <param name="lParam">        /// [in] Pointer to a CWPSTRUCT structure that contains details about the message.         /// </param>        /// <returns>        /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx.         /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx         /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC         /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook         /// procedure does not call CallNextHookEx, the return value should be zero.         /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/windowing/hooks/hookreference/hookfunctions/callwndproc.asp        /// </remarks>        private delegate int HookProc(int nCode, int wParam, IntPtr lParam);        /// <summary>        /// The ToAscii function translates the specified virtual-key code and keyboard         /// state to the corresponding character or characters. The function translates the code         /// using the input language and physical keyboard layout identified by the keyboard layout handle.        /// </summary>        /// <param name="uVirtKey">        /// [in] Specifies the virtual-key code to be translated.         /// </param>        /// <param name="uScanCode">        /// [in] Specifies the hardware scan code of the key to be translated.         /// The high-order bit of this value is set if the key is up (not pressed).         /// </param>        /// <param name="lpbKeyState">        /// [in] Pointer to a 256-byte array that contains the current keyboard state.         /// Each element (byte) in the array contains the state of one key.         /// If the high-order bit of a byte is set, the key is down (pressed).         /// The low bit, if set, indicates that the key is toggled on. In this function,         /// only the toggle bit of the CAPS LOCK key is relevant. The toggle state         /// of the NUM LOCK and SCROLL LOCK keys is ignored.        /// </param>        /// <param name="lpwTransKey">        /// [out] Pointer to the buffer that receives the translated character or characters.         /// </param>        /// <param name="fuState">        /// [in] Specifies whether a menu is active. This parameter must be 1 if a menu is active, or 0 otherwise.         /// </param>        /// <returns>        /// If the specified key is a dead key, the return value is negative. Otherwise, it is one of the following values.         /// Value Meaning         /// 0 The specified virtual key has no translation for the current state of the keyboard.         /// 1 One character was copied to the buffer.         /// 2 Two characters were copied to the buffer. This usually happens when a dead-key character         /// (accent or diacritic) stored in the keyboard layout cannot be composed with the specified         /// virtual key to form a single character.         /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputfunctions/toascii.asp        /// </remarks>        [DllImport("user32")]        private static extern int ToAscii(            int uVirtKey,            int uScanCode,            byte[] lpbKeyState,            byte[] lpwTransKey,            int fuState);        /// <summary>        /// The GetKeyboardState function copies the status of the 256 virtual keys to the         /// specified buffer.         /// </summary>        /// <param name="pbKeyState">        /// [in] Pointer to a 256-byte array that contains keyboard key states.         /// </param>        /// <returns>        /// If the function succeeds, the return value is nonzero.        /// If the function fails, the return value is zero. To get extended error information, call GetLastError.         /// </returns>        /// <remarks>        /// http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardinput/keyboardinputreference/keyboardinputfunctions/toascii.asp        /// </remarks>        [DllImport("user32")]        private static extern int GetKeyboardState(byte[] pbKeyState);        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]        private static extern short GetKeyState(int vKey);        #endregion        #region Windows constants        //values from Winuser.h in Microsoft SDK.        /// <summary>        /// Windows NT/2000/XP: Installs a hook procedure that monitors low-level mouse input events.        /// </summary>        private const int WH_MOUSE_LL = 14;        /// <summary>        /// Windows NT/2000/XP: Installs a hook procedure that monitors low-level keyboard  input events.        /// </summary>        private const int WH_KEYBOARD_LL = 13;        /// <summary>        /// Installs a hook procedure that monitors mouse messages. For more information, see the MouseProc hook procedure.         /// </summary>        private const int WH_MOUSE = 7;        /// <summary>        /// Installs a hook procedure that monitors keystroke messages. For more information, see the KeyboardProc hook procedure.         /// </summary>        private const int WH_KEYBOARD = 2;        /// <summary>        /// The WM_MOUSEMOVE message is posted to a window when the cursor moves.         /// </summary>        private const int WM_MOUSEMOVE = 0x200;        /// <summary>        /// The WM_LBUTTONDOWN message is posted when the user presses the left mouse button         /// </summary>        private const int WM_LBUTTONDOWN = 0x201;        /// <summary>        /// The WM_RBUTTONDOWN message is posted when the user presses the right mouse button        /// </summary>        private const int WM_RBUTTONDOWN = 0x204;        /// <summary>        /// The WM_MBUTTONDOWN message is posted when the user presses the middle mouse button         /// </summary>        private const int WM_MBUTTONDOWN = 0x207;        /// <summary>        /// The WM_LBUTTONUP message is posted when the user releases the left mouse button         /// </summary>        private const int WM_LBUTTONUP = 0x202;        /// <summary>        /// The WM_RBUTTONUP message is posted when the user releases the right mouse button         /// </summary>        private const int WM_RBUTTONUP = 0x205;        /// <summary>        /// The WM_MBUTTONUP message is posted when the user releases the middle mouse button         /// </summary>        private const int WM_MBUTTONUP = 0x208;        /// <summary>        /// The WM_LBUTTONDBLCLK message is posted when the user double-clicks the left mouse button         /// </summary>        private const int WM_LBUTTONDBLCLK = 0x203;        /// <summary>        /// The WM_RBUTTONDBLCLK message is posted when the user double-clicks the right mouse button         /// </summary>        private const int WM_RBUTTONDBLCLK = 0x206;        /// <summary>        /// The WM_RBUTTONDOWN message is posted when the user presses the right mouse button         /// </summary>        private const int WM_MBUTTONDBLCLK = 0x209;        /// <summary>        /// The WM_MOUSEWHEEL message is posted when the user presses the mouse wheel.         /// </summary>        private const int WM_MOUSEWHEEL = 0x020A;        /// <summary>        /// The WM_KEYDOWN message is posted to the window with the keyboard focus when a nonsystem         /// key is pressed. A nonsystem key is a key that is pressed when the ALT key is not pressed.        /// </summary>        private const int WM_KEYDOWN = 0x100;        /// <summary>        /// The WM_KEYUP message is posted to the window with the keyboard focus when a nonsystem         /// key is released. A nonsystem key is a key that is pressed when the ALT key is not pressed,         /// or a keyboard key that is pressed when a window has the keyboard focus.        /// </summary>        private const int WM_KEYUP = 0x101;        /// <summary>        /// The WM_SYSKEYDOWN message is posted to the window with the keyboard focus when the user         /// presses the F10 key (which activates the menu bar) or holds down the ALT key and then         /// presses another key. It also occurs when no window currently has the keyboard focus;         /// in this case, the WM_SYSKEYDOWN message is sent to the active window. The window that         /// receives the message can distinguish between these two contexts by checking the context         /// code in the lParam parameter.         /// </summary>        private const int WM_SYSKEYDOWN = 0x104;        /// <summary>        /// The WM_SYSKEYUP message is posted to the window with the keyboard focus when the user         /// releases a key that was pressed while the ALT key was held down. It also occurs when no         /// window currently has the keyboard focus; in this case, the WM_SYSKEYUP message is sent         /// to the active window. The window that receives the message can distinguish between         /// these two contexts by checking the context code in the lParam parameter.         /// </summary>        private const int WM_SYSKEYUP = 0x105;        private const byte VK_SHIFT = 0x10;        private const byte VK_CAPITAL = 0x14;        private const byte VK_NUMLOCK = 0x90;        #endregion        /// <summary>        /// Creates an instance of UserActivityHook object and sets mouse and keyboard hooks.        /// </summary>        /// <exception cref="Win32Exception">Any windows problem.</exception>        public UserActivityHook()        {            Start();        }        /// <summary>        /// Creates an instance of UserActivityHook object and installs both or one of mouse and/or keyboard hooks and starts rasing events        /// </summary>        /// <param name="InstallMouseHook"><b>true</b> if mouse events must be monitored</param>        /// <param name="InstallKeyboardHook"><b>true</b> if keyboard events must be monitored</param>        /// <exception cref="Win32Exception">Any windows problem.</exception>        /// <remarks>        /// To create an instance without installing hooks call new UserActivityHook(false, false)        /// </remarks>        public UserActivityHook(bool InstallMouseHook, bool InstallKeyboardHook)        {            Start(InstallMouseHook, InstallKeyboardHook);        }        /// <summary>        /// Destruction.        /// </summary>        ~UserActivityHook()        {            //uninstall hooks and do not throw exceptions            Stop(true, true, false);        }        /// <summary>        /// Occurs when the user moves the mouse, presses any mouse button or scrolls the wheel        /// </summary>        public event MouseEventHandler OnMouseActivity;        /// <summary>        /// Occurs when the user presses a key        /// </summary>        public event KeyEventHandler KeyDown;        /// <summary>        /// Occurs when the user presses and releases         /// </summary>        public event KeyPressEventHandler KeyPress;        /// <summary>        /// Occurs when the user releases a key        /// </summary>        public event KeyEventHandler KeyUp;        /// <summary>        /// Stores the handle to the mouse hook procedure.        /// </summary>        private int hMouseHook = 0;        /// <summary>        /// Stores the handle to the keyboard hook procedure.        /// </summary>        private int hKeyboardHook = 0;        /// <summary>        /// Declare MouseHookProcedure as HookProc type.        /// </summary>        private static HookProc MouseHookProcedure;        /// <summary>        /// Declare KeyboardHookProcedure as HookProc type.        /// </summary>        private static HookProc KeyboardHookProcedure;        /// <summary>        /// Installs both mouse and keyboard hooks and starts raising events        /// </summary>        /// <exception cref="Win32Exception">Any windows problem.</exception>        public void Start()        {            this.Start(true, true);        }        /// <summary>        /// Installs both or one of mouse and/or keyboard hooks and starts raising events        /// </summary>        /// <param name="InstallMouseHook"><b>true</b> if mouse events must be monitored</param>        /// <param name="InstallKeyboardHook"><b>true</b> if keyboard events must be monitored</param>        /// <exception cref="Win32Exception">Any windows problem.</exception>        public void Start(bool InstallMouseHook, bool InstallKeyboardHook)        {            // install Mouse hook only if it is not installed and must be installed            if (hMouseHook == 0 && InstallMouseHook)            {                // Create an instance of HookProc.                MouseHookProcedure = new HookProc(MouseHookProc);                //install hook                hMouseHook = SetWindowsHookEx(                    WH_MOUSE_LL,                    MouseHookProcedure,                    Marshal.GetHINSTANCE(                    Assembly.GetExecutingAssembly().GetModules()[0]),                    0);                //If SetWindowsHookEx fails.                if (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 (hKeyboardHook == 0 && InstallKeyboardHook)            {                // Create an instance of HookProc.                KeyboardHookProcedure = new HookProc(KeyboardHookProc);                //install hook                hKeyboardHook = SetWindowsHookEx(                    WH_KEYBOARD_LL,                    KeyboardHookProcedure,                    Marshal.GetHINSTANCE(                    Assembly.GetExecutingAssembly().GetModules()[0]),                    0);                //If SetWindowsHookEx fails.                if (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);                }            }        }        /// <summary>        /// Stops monitoring both mouse and keyboard events and rasing events.        /// </summary>        /// <exception cref="Win32Exception">Any windows problem.</exception>        public void Stop()        {            this.Stop(true, true, true);        }        /// <summary>        /// Stops monitoring both or one of mouse and/or keyboard events and rasing events.        /// </summary>        /// <param name="UninstallMouseHook"><b>true</b> if mouse hook must be uninstalled</param>        /// <param name="UninstallKeyboardHook"><b>true</b> if keyboard hook must be uninstalled</param>        /// <param name="ThrowExceptions"><b>true</b> if exceptions which occured during uninstalling must be thrown</param>        /// <exception cref="Win32Exception">Any windows problem.</exception>        public void Stop(bool UninstallMouseHook, bool UninstallKeyboardHook, bool ThrowExceptions)        {            //if mouse hook set and must be uninstalled            if (hMouseHook != 0 && UninstallMouseHook)            {                //uninstall hook                int retMouse = UnhookWindowsHookEx(hMouseHook);                //reset invalid handle                hMouseHook = 0;                //if failed and exception must be thrown                if (retMouse == 0 && ThrowExceptions)                {                    //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();                    //Initializes and throws a new instance of the Win32Exception class with the specified error.                     throw new Win32Exception(errorCode);                }            }            //if keyboard hook set and must be uninstalled            if (hKeyboardHook != 0 && UninstallKeyboardHook)            {                //uninstall hook                int retKeyboard = UnhookWindowsHookEx(hKeyboardHook);                //reset invalid handle                hKeyboardHook = 0;                //if failed and exception must be thrown                if (retKeyboard == 0 && ThrowExceptions)                {                    //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();                    //Initializes and throws a new instance of the Win32Exception class with the specified error.                     throw new Win32Exception(errorCode);                }            }        }        /// <summary>        /// A callback function which will be called every time a mouse activity detected.        /// </summary>        /// <param name="nCode">        /// [in] Specifies whether the hook procedure must process the message.         /// If nCode is HC_ACTION, the hook procedure must process the message.         /// If nCode is less than zero, the hook procedure must pass the message to the         /// CallNextHookEx function without further processing and must return the         /// value returned by CallNextHookEx.        /// </param>        /// <param name="wParam">        /// [in] Specifies whether the message was sent by the current thread.         /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero.         /// </param>        /// <param name="lParam">        /// [in] Pointer to a CWPSTRUCT structure that contains details about the message.         /// </param>        /// <returns>        /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx.         /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx         /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC         /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook         /// procedure does not call CallNextHookEx, the return value should be zero.         /// </returns>        private int MouseHookProc(int nCode, int wParam, IntPtr lParam)        {            // if ok and someone listens to our events            if ((nCode >= 0) && (OnMouseActivity != null))            {                //Marshall the data from callback.                MouseLLHookStruct mouseHookStruct = (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));                //detect button clicked                MouseButtons button = MouseButtons.None;                short mouseDelta = 0;                switch (wParam)                {                    case WM_LBUTTONDOWN:                        //case WM_LBUTTONUP:                         //case WM_LBUTTONDBLCLK:                         button = MouseButtons.Left;                        break;                    case WM_RBUTTONDOWN:                        //case WM_RBUTTONUP:                         //case WM_RBUTTONDBLCLK:                         button = MouseButtons.Right;                        break;                    case WM_MOUSEWHEEL:                        //If the message is WM_MOUSEWHEEL, the high-order word of mouseData member is the wheel delta.                         //One wheel click is defined as WHEEL_DELTA, which is 120.                         //(value >> 16) & 0xffff; retrieves the high-order word from the given 32-bit value                        mouseDelta = (short)((mouseHookStruct.mouseData >> 16) & 0xffff);                        //TODO: X BUTTONS (I havent them so was unable to test)                        //If the message is WM_XBUTTONDOWN, WM_XBUTTONUP, WM_XBUTTONDBLCLK, WM_NCXBUTTONDOWN, WM_NCXBUTTONUP,                         //or WM_NCXBUTTONDBLCLK, the high-order word specifies which X button was pressed or released,                         //and the low-order word is reserved. This value can be one or more of the following values.                         //Otherwise, mouseData is not used.                         break;                }                //double clicks                int clickCount = 0;                if (button != MouseButtons.None)                    if (wParam == WM_LBUTTONDBLCLK || wParam == WM_RBUTTONDBLCLK) clickCount = 2;                    else clickCount = 1;                //generate event                 MouseEventArgs e = new MouseEventArgs(                                   button,                                   clickCount,                                   mouseHookStruct.pt.x,                                   mouseHookStruct.pt.y,                                   mouseDelta);                //raise it                OnMouseActivity(this, e);            }            //call next hook            return CallNextHookEx(hMouseHook, nCode, wParam, lParam);        }        /// <summary>        /// A callback function which will be called every time a keyboard activity detected.        /// </summary>        /// <param name="nCode">        /// [in] Specifies whether the hook procedure must process the message.         /// If nCode is HC_ACTION, the hook procedure must process the message.         /// If nCode is less than zero, the hook procedure must pass the message to the         /// CallNextHookEx function without further processing and must return the         /// value returned by CallNextHookEx.        /// </param>        /// <param name="wParam">        /// [in] Specifies whether the message was sent by the current thread.         /// If the message was sent by the current thread, it is nonzero; otherwise, it is zero.         /// </param>        /// <param name="lParam">        /// [in] Pointer to a CWPSTRUCT structure that contains details about the message.         /// </param>        /// <returns>        /// If nCode is less than zero, the hook procedure must return the value returned by CallNextHookEx.         /// If nCode is greater than or equal to zero, it is highly recommended that you call CallNextHookEx         /// and return the value it returns; otherwise, other applications that have installed WH_CALLWNDPROC         /// hooks will not receive hook notifications and may behave incorrectly as a result. If the hook         /// procedure does not call CallNextHookEx, the return value should be zero.         /// </returns>        private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)        {            //indicates if any of underlaing events set e.Handled flag            bool handled = false;            //it was ok and someone listens to events            if ((nCode >= 0) && (KeyDown != null || KeyUp != null || KeyPress != null))            {                //read structure KeyboardHookStruct at lParam                KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));                //raise KeyDown                if (KeyDown != null && (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))                {                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;                    KeyEventArgs e = new KeyEventArgs(keyData);                    KeyDown(this, e);                    handled = handled || e.Handled;                }                // raise KeyPress                if (KeyPress != null && wParam == WM_KEYDOWN)                {                    bool isDownShift = ((GetKeyState(VK_SHIFT) & 0x80) == 0x80 ? true : false);                    bool isDownCapslock = (GetKeyState(VK_CAPITAL) != 0 ? true : false);                    byte[] keyState = new byte[256];                    GetKeyboardState(keyState);                    byte[] inBuffer = new byte[2];                    if (ToAscii(MyKeyboardHookStruct.vkCode,                          MyKeyboardHookStruct.scanCode,                          keyState,                          inBuffer,                          MyKeyboardHookStruct.flags) == 1)                    {                        char key = (char)inBuffer[0];                        if ((isDownCapslock ^ isDownShift) && Char.IsLetter(key)) key = Char.ToUpper(key);                        KeyPressEventArgs e = new KeyPressEventArgs(key);                        KeyPress(this, e);                        handled = handled || e.Handled;                    }                }                // raise KeyUp                if (KeyUp != null && (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))                {                    Keys keyData = (Keys)MyKeyboardHookStruct.vkCode;                    KeyEventArgs e = new KeyEventArgs(keyData);                    KeyUp(this, e);                    handled = handled || e.Handled;                }            }            //if event handled in application do not handoff to other listeners            if (handled)                return 1;            else                return CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);        }    }}

原文地址