C#钩子类 几乎捕获键盘鼠标所有事件

2022-05-29 15:36:23

  1. using System;  
  2. using System.Text;  
  3. using System.Runtime.InteropServices;  
  4. using System.Reflection;  
  5. using System.Windows.Forms;  
  6.   
  7. namespace MouseKeyboardLibrary  
  8. {  
  9.   
  10.     /// <summary>  
  11.     /// Abstract base class for Mouse and Keyboard hooks  
  12.     /// </summary>  
  13.     public abstract class GlobalHook  
  14.     {  
  15.  
  16.         #region Windows API Code  
  17.   
  18.         [StructLayout(LayoutKind.Sequential)]  
  19.         protected class POINT  
  20.         {  
  21.             public int x;  
  22.             public int y;  
  23.         }  
  24.   
  25.         [StructLayout(LayoutKind.Sequential)]  
  26.         protected class MouseHookStruct  
  27.         {  
  28.             public POINT pt;  
  29.             public int hwnd;  
  30.             public int wHitTestCode;  
  31.             public int dwExtraInfo;  
  32.         }  
  33.   
  34.         [StructLayout(LayoutKind.Sequential)]  
  35.         protected class MouseLLHookStruct  
  36.         {  
  37.             public POINT pt;  
  38.             public int mouseData;  
  39.             public int flags;  
  40.             public int time;  
  41.             public int dwExtraInfo;  
  42.         }  
  43.   
  44.         [StructLayout(LayoutKind.Sequential)]  
  45.         protected class KeyboardHookStruct  
  46.         {  
  47.             public int vkCode;  
  48.             public int scanCode;  
  49.             public int flags;  
  50.             public int time;  
  51.             public int dwExtraInfo;  
  52.         }  
  53.   
  54.         [DllImport("user32.dll", CharSet = CharSet.Auto,  
  55.            CallingConvention = CallingConvention.StdCall, SetLastError = true)]  
  56.         protected static extern int SetWindowsHookEx(  
  57.             int idHook,  
  58.             HookProc lpfn,  
  59.             IntPtr hMod,  
  60.             int dwThreadId);  
  61.   
  62.         [DllImport("user32.dll", CharSet = CharSet.Auto,  
  63.             CallingConvention = CallingConvention.StdCall, SetLastError = true)]  
  64.         protected static extern int UnhookWindowsHookEx(int idHook);  
  65.   
  66.   
  67.         [DllImport("user32.dll", CharSet = CharSet.Auto,  
  68.              CallingConvention = CallingConvention.StdCall)]  
  69.         protected static extern int CallNextHookEx(  
  70.             int idHook,  
  71.             int nCode,  
  72.             int wParam,  
  73.             IntPtr lParam);  
  74.   
  75.         [DllImport("user32")]  
  76.         protected static extern int ToAscii(  
  77.             int uVirtKey,  
  78.             int uScanCode,  
  79.             byte[] lpbKeyState,  
  80.             byte[] lpwTransKey,  
  81.             int fuState);  
  82.   
  83.         [DllImport("user32")]  
  84.         protected static extern int GetKeyboardState(byte[] pbKeyState);  
  85.   
  86.         [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]  
  87.         protected static extern short GetKeyState(int vKey);  
  88.   
  89.         protected delegate int HookProc(int nCode, int wParam, IntPtr lParam);  
  90.   
  91.         protected const int WH_MOUSE_LL = 14;  
  92.         protected const int WH_KEYBOARD_LL = 13;  
  93.   
  94.         protected const int WH_MOUSE = 7;  
  95.         protected const int WH_KEYBOARD = 2;  
  96.         protected const int WM_MOUSEMOVE = 0x200;  
  97.         protected const int WM_LBUTTONDOWN = 0x201;  
  98.         protected const int WM_RBUTTONDOWN = 0x204;  
  99.         protected const int WM_MBUTTONDOWN = 0x207;  
  100.         protected const int WM_LBUTTONUP = 0x202;  
  101.         protected const int WM_RBUTTONUP = 0x205;  
  102.         protected const int WM_MBUTTONUP = 0x208;  
  103.         protected const int WM_LBUTTONDBLCLK = 0x203;  
  104.         protected const int WM_RBUTTONDBLCLK = 0x206;  
  105.         protected const int WM_MBUTTONDBLCLK = 0x209;  
  106.         protected const int WM_MOUSEWHEEL = 0x020A;  
  107.         protected const int WM_KEYDOWN = 0x100;  
  108.         protected const int WM_KEYUP = 0x101;  
  109.         protected const int WM_SYSKEYDOWN = 0x104;  
  110.         protected const int WM_SYSKEYUP = 0x105;  
  111.   
  112.         protected const byte VK_SHIFT = 0x10;  
  113.         protected const byte VK_CAPITAL = 0x14;  
  114.         protected const byte VK_NUMLOCK = 0x90;  
  115.   
  116.         protected const byte VK_LSHIFT = 0xA0;  
  117.         protected const byte VK_RSHIFT = 0xA1;  
  118.         protected const byte VK_LCONTROL = 0xA2;  
  119.         protected const byte VK_RCONTROL = 0x3;  
  120.         protected const byte VK_LALT = 0xA4;  
  121.         protected const byte VK_RALT = 0xA5;  
  122.   
  123.         protected const byte LLKHF_ALTDOWN = 0x20;  
  124.  
  125.         #endregion  
  126.  
  127.         #region Private Variables  
  128.   
  129.         protected int _hookType;  
  130.         protected int _handleToHook;  
  131.         protected bool _isStarted;  
  132.         protected HookProc _hookCallback;  
  133.  
  134.         #endregion  
  135.  
  136.         #region Properties  
  137.   
  138.         public bool IsStarted  
  139.         {  
  140.             get  
  141.             {  
  142.                 return _isStarted;  
  143.             }  
  144.         }  
  145.  
  146.         #endregion  
  147.  
  148.         #region Constructor  
  149.   
  150.         public GlobalHook()  
  151.         {  
  152.   
  153.             Application.ApplicationExit += new EventHandler(Application_ApplicationExit);  
  154.   
  155.         }  
  156.  
  157.         #endregion  
  158.  
  159.         #region Methods  
  160.   
  161.         public void Start()  
  162.         {  
  163.   
  164.             if (!_isStarted &&  
  165.                 _hookType != 0)  
  166.             {  
  167.   
  168.                 // Make sure we keep a reference to this delegate!  
  169.                 // If not, GC randomly collects it, and a NullReference exception is thrown  
  170.                 _hookCallback = new HookProc(HookCallbackProcedure);  
  171.   
  172.                 _handleToHook = SetWindowsHookEx(  
  173.                     _hookType,  
  174.                     _hookCallback,  
  175.                     Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),  
  176.                     0);  
  177.   
  178.                 // Were we able to sucessfully start hook?  
  179.                 if (_handleToHook != 0)  
  180.                 {  
  181.                     _isStarted = true;  
  182.                 }  
  183.   
  184.             }  
  185.   
  186.         }  
  187.   
  188.         public void Stop()  
  189.         {  
  190.   
  191.             if (_isStarted)  
  192.             {  
  193.   
  194.                 UnhookWindowsHookEx(_handleToHook);  
  195.   
  196.                 _isStarted = false;  
  197.   
  198.             }  
  199.   
  200.         }  
  201.   
  202.         protected virtual int HookCallbackProcedure(int nCode, Int32 wParam, IntPtr lParam)  
  203.         {  
  204.              
  205.             // This method must be overriden by each extending hook  
  206.             return 0;  
  207.   
  208.         }  
  209.   
  210.         protected void Application_ApplicationExit(object sender, EventArgs e)  
  211.         {  
  212.   
  213.             if (_isStarted)  
  214.             {  
  215.                 Stop();  
  216.             }  
  217.   
  218.         }  
  219.  
  220.         #endregion  
  221.   
  222.     }  
  223.   
  224. }  
[csharp] view plaincopyprint?C#钩子类 几乎捕获键盘鼠标所有事件C#钩子类 几乎捕获键盘鼠标所有事件
 
  1. using System;  
  2. using System.Text;  
  3. using System.Windows.Forms;  
  4. using System.Runtime.InteropServices;  
  5.   
  6. namespace MouseKeyboardLibrary  
  7. {  
  8.   
  9.     /// <summary>  
  10.     /// Captures global keyboard events  
  11.     /// </summary>  
  12.     public class KeyboardHook : GlobalHook  
  13.     {  
  14.  
  15.         #region Events  
  16.   
  17.         public event KeyEventHandler KeyDown;  
  18.         public event KeyEventHandler KeyUp;  
  19.         public event KeyPressEventHandler KeyPress;  
  20.  
  21.         #endregion  
  22.  
  23.         #region Constructor  
  24.   
  25.         public KeyboardHook()  
  26.         {  
  27.   
  28.             _hookType = WH_KEYBOARD_LL;  
  29.   
  30.         }  
  31.  
  32.         #endregion  
  33.  
  34.         #region Methods  
  35.   
  36.         protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)  
  37.         {  
  38.   
  39.             bool handled = false;  
  40.   
  41.             if (nCode > -1 && (KeyDown != null || KeyUp != null || KeyPress != null))  
  42.             {  
  43.   
  44.                 KeyboardHookStruct keyboardHookStruct =  
  45.                     (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));  
  46.   
  47.                 // Is Control being held down?  
  48.                 bool control = ((GetKeyState(VK_LCONTROL) & 0x80) != 0) ||  
  49.                                ((GetKeyState(VK_RCONTROL) & 0x80) != 0);  
  50.   
  51.                 // Is Shift being held down?  
  52.                 bool shift = ((GetKeyState(VK_LSHIFT) & 0x80) != 0) ||  
  53.                              ((GetKeyState(VK_RSHIFT) & 0x80) != 0);  
  54.   
  55.                 // Is Alt being held down?  
  56.                 bool alt = ((GetKeyState(VK_LALT) & 0x80) != 0) ||  
  57.                            ((GetKeyState(VK_RALT) & 0x80) != 0);  
  58.   
  59.                 // Is CapsLock on?  
  60.                 bool capslock = (GetKeyState(VK_CAPITAL) != 0);  
  61.   
  62.                 // Create event using keycode and control/shift/alt values found above  
  63.                 KeyEventArgs e = new KeyEventArgs(  
  64.                     (Keys)(  
  65.                         keyboardHookStruct.vkCode |  
  66.                         (control ? (int)Keys.Control : 0) |  
  67.                         (shift ? (int)Keys.Shift : 0) |  
  68.                         (alt ? (int)Keys.Alt : 0)  
  69.                         ));  
  70.   
  71.                 // Handle KeyDown and KeyUp events  
  72.                 switch (wParam)  
  73.                 {  
  74.   
  75.                     case WM_KEYDOWN:  
  76.                     case WM_SYSKEYDOWN:  
  77.                         if (KeyDown != null)  
  78.                         {  
  79.                             KeyDown(this, e);  
  80.                             handled = handled || e.Handled;  
  81.                         }  
  82.                         break;  
  83.                     case WM_KEYUP:  
  84.                     case WM_SYSKEYUP:  
  85.                         if (KeyUp != null)  
  86.                         {  
  87.                             KeyUp(this, e);  
  88.                             handled = handled || e.Handled;  
  89.                         }  
  90.                         break;  
  91.   
  92.                 }  
  93.   
  94.                 // Handle KeyPress event  
  95.                 if (wParam == WM_KEYDOWN &&  
  96.                    !handled &&  
  97.                    !e.SuppressKeyPress &&  
  98.                     KeyPress != null)  
  99.                 {  
  100.   
  101.                     byte[] keyState = new byte[256];  
  102.                     byte[] inBuffer = new byte[2];  
  103.                     GetKeyboardState(keyState);  
  104.   
  105.                     if (ToAscii(keyboardHookStruct.vkCode,  
  106.                               keyboardHookStruct.scanCode,  
  107.                               keyState,  
  108.                               inBuffer,  
  109.                               keyboardHookStruct.flags) == 1)  
  110.                     {  
  111.   
  112.                         char key = (char)inBuffer[0];  
  113.                         if ((capslock ^ shift) && Char.IsLetter(key))  
  114.                             key = Char.ToUpper(key);  
  115.                         KeyPressEventArgs e2 = new KeyPressEventArgs(key);  
  116.                         KeyPress(this, e2);  
  117.                         handled = handled || e.Handled;  
  118.   
  119.                     }  
  120.   
  121.                 }  
  122.   
  123.             }  
  124.   
  125.             if (handled)  
  126.             {  
  127.                 return 1;  
  128.             }  
  129.             else  
  130.             {  
  131.                 return CallNextHookEx(_handleToHook, nCode, wParam, lParam);  
  132.             }  
  133.   
  134.         }  
  135.  
  136.         #endregion  
  137.   
  138.     }  
  139.   
  140. }  
[csharp] view plaincopyprint?C#钩子类 几乎捕获键盘鼠标所有事件C#钩子类 几乎捕获键盘鼠标所有事件
 
  1. using System;  
  2. using System.Text;  
  3. using System.Runtime.InteropServices;  
  4. using System.Windows.Forms;  
  5.   
  6. namespace MouseKeyboardLibrary  
  7. {  
  8.   
  9.     /// <summary>  
  10.     /// Standard Keyboard Shortcuts used by most applications  
  11.     /// </summary>  
  12.     public enum StandardShortcut  
  13.     {  
  14.         Copy,  
  15.         Cut,  
  16.         Paste,  
  17.         SelectAll,  
  18.         Save,  
  19.         Open,  
  20.         New,  
  21.         Close,  
  22.         Print  
  23.     }  
  24.   
  25.     /// <summary>  
  26.     /// Simulate keyboard key presses  
  27.     /// </summary>  
  28.     public static class KeyboardSimulator  
  29.     {  
  30.  
  31.         #region Windows API Code  
  32.   
  33.         const int KEYEVENTF_EXTENDEDKEY = 0x1;  
  34.         const int KEYEVENTF_KEYUP = 0x2;  
  35.   
  36.         [DllImport("user32.dll")]  
  37.         static extern void keybd_event(byte key, byte scan, int flags, int extraInfo);   
  38.  
  39.         #endregion  
  40.  
  41.         #region Methods  
  42.   
  43.         public static void KeyDown(Keys key)  
  44.         {  
  45.             keybd_event(ParseKey(key), 0, 0, 0);  
  46.         }  
  47.   
  48.         public static void KeyUp(Keys key)  
  49.         {  
  50.             keybd_event(ParseKey(key), 0, KEYEVENTF_KEYUP, 0);  
  51.         }  
  52.   
  53.         public static void KeyPress(Keys key)  
  54.         {  
  55.             KeyDown(key);  
  56.             KeyUp(key);  
  57.         }  
  58.   
  59.         public static void SimulateStandardShortcut(StandardShortcut shortcut)  
  60.         {  
  61.             switch (shortcut)  
  62.             {  
  63.                 case StandardShortcut.Copy:  
  64.                     KeyDown(Keys.Control);  
  65.                     KeyPress(Keys.C);  
  66.                     KeyUp(Keys.Control);  
  67.                     break;  
  68.                 case StandardShortcut.Cut:  
  69.                     KeyDown(Keys.Control);  
  70.                     KeyPress(Keys.X);  
  71.                     KeyUp(Keys.Control);  
  72.                     break;  
  73.                 case StandardShortcut.Paste:  
  74.                     KeyDown(Keys.Control);  
  75.                     KeyPress(Keys.V);  
  76.                     KeyUp(Keys.Control);  
  77.                     break;  
  78.                 case StandardShortcut.SelectAll:  
  79.                     KeyDown(Keys.Control);  
  80.                     KeyPress(Keys.A);  
  81.                     KeyUp(Keys.Control);  
  82.                     break;  
  83.                 case StandardShortcut.Save:  
  84.                     KeyDown(Keys.Control);  
  85.                     KeyPress(Keys.S);  
  86.                     KeyUp(Keys.Control);  
  87.                     break;  
  88.                 case StandardShortcut.Open:  
  89.                     KeyDown(Keys.Control);  
  90.                     KeyPress(Keys.O);  
  91.                     KeyUp(Keys.Control);  
  92.                     break;  
  93.                 case StandardShortcut.New:  
  94.                     KeyDown(Keys.Control);  
  95.                     KeyPress(Keys.N);  
  96.                     KeyUp(Keys.Control);  
  97.                     break;  
  98.                 case StandardShortcut.Close:  
  99.                     KeyDown(Keys.Alt);  
  100.                     KeyPress(Keys.F4);  
  101.                     KeyUp(Keys.Alt);  
  102.                     break;  
  103.                 case StandardShortcut.Print:  
  104.                     KeyDown(Keys.Control);  
  105.                     KeyPress(Keys.P);  
  106.                     KeyUp(Keys.Control);  
  107.                     break;  
  108.             }  
  109.         }  
  110.   
  111.         static byte ParseKey(Keys key)  
  112.         {  
  113.   
  114.             // Alt, Shift, and Control need to be changed for API function to work with them  
  115.             switch (key)  
  116.             {  
  117.                 case Keys.Alt:  
  118.                     return (byte)18;  
  119.                 case Keys.Control:  
  120.                     return (byte)17;  
  121.                 case Keys.Shift:  
  122.                     return (byte)16;  
  123.                 default:  
  124.                     return (byte)key;  
  125.             }  
  126.   
  127.         }   
  128.  
  129.         #endregion  
  130.   
  131.     }  
  132.   
  133. }  
[csharp] view plaincopyprint?C#钩子类 几乎捕获键盘鼠标所有事件C#钩子类 几乎捕获键盘鼠标所有事件
 
  1. using System;  
  2. using System.Text;  
  3. using System.Windows.Forms;  
  4. using System.Runtime.InteropServices;  
  5.   
  6. namespace MouseKeyboardLibrary  
  7. {  
  8.   
  9.     /// <summary>  
  10.     /// Captures global mouse events  
  11.     /// </summary>  
  12.     public class MouseHook : GlobalHook  
  13.     {  
  14.  
  15.         #region MouseEventType Enum  
  16.   
  17.         private enum MouseEventType  
  18.         {  
  19.             None,  
  20.             MouseDown,  
  21.             MouseUp,  
  22.             DoubleClick,  
  23.             MouseWheel,  
  24.             MouseMove  
  25.         }  
  26.  
  27.         #endregion  
  28.  
  29.         #region Events  
  30.   
  31.         public event MouseEventHandler MouseDown;  
  32.         public event MouseEventHandler MouseUp;  
  33.         public event MouseEventHandler MouseMove;  
  34.         public event MouseEventHandler MouseWheel;  
  35.   
  36.         public event EventHandler Click;  
  37.         public event EventHandler DoubleClick;  
  38.  
  39.         #endregion  
  40.  
  41.         #region Constructor  
  42.   
  43.         public MouseHook()  
  44.         {  
  45.   
  46.             _hookType = WH_MOUSE_LL;  
  47.   
  48.         }  
  49.  
  50.         #endregion  
  51.  
  52.         #region Methods  
  53.   
  54.         protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)  
  55.         {  
  56.               
  57.             if (nCode > -1 && (MouseDown != null || MouseUp != null || MouseMove != null))  
  58.             {  
  59.   
  60.                 MouseLLHookStruct mouseHookStruct =  
  61.                     (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));  
  62.   
  63.                 MouseButtons button = GetButton(wParam);  
  64.                 MouseEventType eventType = GetEventType(wParam);  
  65.   
  66.                 MouseEventArgs e = new MouseEventArgs(  
  67.                     button,  
  68.                     (eventType == MouseEventType.DoubleClick ? 2 : 1),  
  69.                     mouseHookStruct.pt.x,  
  70.                     mouseHookStruct.pt.y,  
  71.                     (eventType == MouseEventType.MouseWheel ? (short)((mouseHookStruct.mouseData >> 16) & 0xffff) : 0));  
  72.   
  73.                 // Prevent multiple Right Click events (this probably happens for popup menus)  
  74.                 if (button == MouseButtons.Right && mouseHookStruct.flags != 0)  
  75.                 {  
  76.                     eventType = MouseEventType.None;  
  77.                 }  
  78.   
  79.                 switch (eventType)  
  80.                 {  
  81.                     case MouseEventType.MouseDown:  
  82.                         if (MouseDown != null)  
  83.                         {  
  84.                             MouseDown(this, e);  
  85.                         }  
  86.                         break;  
  87.                     case MouseEventType.MouseUp:  
  88.                         if (Click != null)  
  89.                         {  
  90.                             Click(this, new EventArgs());  
  91.                         }  
  92.                         if (MouseUp != null)  
  93.                         {  
  94.                             MouseUp(this, e);  
  95.                         }  
  96.                         break;  
  97.                     case MouseEventType.DoubleClick:  
  98.                         if (DoubleClick != null)  
  99.                         {  
  100.                             DoubleClick(this, new EventArgs());  
  101.                         }  
  102.                         break;  
  103.                     case MouseEventType.MouseWheel:  
  104.                         if (MouseWheel != null)  
  105.                         {  
  106.                             MouseWheel(this, e);  
  107.                         }  
  108.                         break;  
  109.                     case MouseEventType.MouseMove:  
  110.                         if (MouseMove != null)  
  111.                         {  
  112.                             MouseMove(this, e);  
  113.                         }  
  114.                         break;  
  115.                     default:  
  116.                         break;  
  117.                 }  
  118.                   
  119.             }  
  120.   
  121.             return CallNextHookEx(_handleToHook, nCode, wParam, lParam);  
  122.   
  123.         }  
  124.   
  125.         private MouseButtons GetButton(Int32 wParam)  
  126.         {  
  127.   
  128.             switch (wParam)  
  129.             {  
  130.   
  131.                 case WM_LBUTTONDOWN:  
  132.                 case WM_LBUTTONUP:  
  133.                 case WM_LBUTTONDBLCLK:  
  134.                     return MouseButtons.Left;  
  135.                 case WM_RBUTTONDOWN:  
  136.                 case WM_RBUTTONUP:  
  137.                 case WM_RBUTTONDBLCLK:  
  138.                     return MouseButtons.Right;  
  139.                 case WM_MBUTTONDOWN:  
  140.                 case WM_MBUTTONUP:  
  141.                 case WM_MBUTTONDBLCLK:  
  142.                     return MouseButtons.Middle;  
  143.                 default:  
  144.                     return MouseButtons.None;  
  145.   
  146.             }  
  147.   
  148.         }  
  149.   
  150.         private MouseEventType GetEventType(Int32 wParam)  
  151.         {  
  152.   
  153.             switch (wParam)  
  154.             {  
  155.   
  156.                 case WM_LBUTTONDOWN:  
  157.                 case WM_RBUTTONDOWN:  
  158.                 case WM_MBUTTONDOWN:  
  159.                     return MouseEventType.MouseDown;  
  160.                 case WM_LBUTTONUP:  
  161.                 case WM_RBUTTONUP:  
  162.                 case WM_MBUTTONUP:  
  163.                     return MouseEventType.MouseUp;  
  164.                 case WM_LBUTTONDBLCLK:  
  165.                 case WM_RBUTTONDBLCLK:  
  166.                 case WM_MBUTTONDBLCLK:  
  167.                     return MouseEventType.DoubleClick;  
  168.                 case WM_MOUSEWHEEL:  
  169.                     return MouseEventType.MouseWheel;  
  170.                 case WM_MOUSEMOVE:  
  171.                     return MouseEventType.MouseMove;  
  172.                 default:  
  173.                     return MouseEventType.None;  
  174.   
  175.             }  
  176.         }  
  177.  
  178.         #endregion  
  179.           
  180.     }  
  181.   
  182. }  
[csharp] view plaincopyprint?C#钩子类 几乎捕获键盘鼠标所有事件C#钩子类 几乎捕获键盘鼠标所有事件
 
  1. using System;  
  2. using System.Text;  
  3. using System.Runtime.InteropServices;  
  4. using System.Drawing;  
  5. using System.Windows.Forms;  
  6.   
  7. namespace MouseKeyboardLibrary  
  8. {  
  9.   
  10.     /// <summary>  
  11.     /// And X, Y point on the screen  
  12.     /// </summary>  
  13.     public struct MousePoint  
  14.     {  
  15.   
  16.         public MousePoint(Point p)  
  17.         {  
  18.             X = p.X;  
  19.             Y = p.Y;  
  20.         }  
  21.   
  22.         public int X;  
  23.         public int Y;  
  24.   
  25.         public static implicit operator Point(MousePoint p)  
  26.         {  
  27.             return new Point(p.X, p.Y);  
  28.         }  
  29.   
  30.     }  
  31.   
  32.     /// <summary>  
  33.     /// Mouse buttons that can be pressed  
  34.     /// </summary>  
  35.     public enum MouseButton  
  36.     {  
  37.         Left = 0x2,  
  38.         Right = 0x8,  
  39.         Middle = 0x20  
  40.     }  
  41.   
  42.     /// <summary>  
  43.     /// Operations that simulate mouse events  
  44.     /// </summary>  
  45.     public static class MouseSimulator  
  46.     {  
  47.  
  48.         #region Windows API Code  
  49.   
  50.         [DllImport("user32.dll")]  
  51.         static extern int ShowCursor(bool show);  
  52.   
  53.         [DllImport("user32.dll")]  
  54.         static extern void mouse_event(int flags, int dX, int dY, int buttons, int extraInfo);  
  55.   
  56.         const int MOUSEEVENTF_MOVE = 0x1;  
  57.         const int MOUSEEVENTF_LEFTDOWN = 0x2;  
  58.         const int MOUSEEVENTF_LEFTUP = 0x4;  
  59.         const int MOUSEEVENTF_RIGHTDOWN = 0x8;  
  60.         const int MOUSEEVENTF_RIGHTUP = 0x10;  
  61.         const int MOUSEEVENTF_MIDDLEDOWN = 0x20;  
  62.         const int MOUSEEVENTF_MIDDLEUP = 0x40;  
  63.         const int MOUSEEVENTF_WHEEL = 0x800;  
  64.         const int MOUSEEVENTF_ABSOLUTE = 0x8000;   
  65.  
  66.         #endregion  
  67.  
  68.         #region Properties  
  69.   
  70.         /// <summary>  
  71.         /// Gets or sets a structure that represents both X and Y mouse coordinates  
  72.         /// </summary>  
  73.         public static MousePoint Position  
  74.         {  
  75.             get  
  76.             {  
  77.                 return new MousePoint(Cursor.Position);  
  78.             }  
  79.             set  
  80.             {  
  81.                 Cursor.Position = value;  
  82.             }  
  83.         }  
  84.   
  85.         /// <summary>  
  86.         /// Gets or sets only the mouse‘s x coordinate  
  87.         /// </summary>  
  88.         public static int X  
  89.         {  
  90.             get  
  91.             {  
  92.                 return Cursor.Position.X;  
  93.             }  
  94.             set  
  95.             {  
  96.                 Cursor.Position = new Point(value, Y);  
  97.             }  
  98.         }  
  99.   
  100.         /// <summary>  
  101.         /// Gets or sets only the mouse‘s y coordinate  
  102.         /// </summary>  
  103.         public static int Y  
  104.         {  
  105.             get  
  106.             {  
  107.                 return Cursor.Position.Y;  
  108.             }  
  109.             set  
  110.             {  
  111.                 Cursor.Position = new Point(X, value);  
  112.             }  
  113.         }   
  114.  
  115.         #endregion  
  116.  
  117.         #region Methods  
  118.   
  119.         /// <summary>  
  120.         /// Press a mouse button down  
  121.         /// </summary>  
  122.         /// <param name="button"></param>  
  123.         public static void MouseDown(MouseButton button)  
  124.         {  
  125.             mouse_event(((int)button), 0, 0, 0, 0);  
  126.         }  
  127.   
  128.         public static void MouseDown(MouseButtons button)  
  129.         {  
  130.             switch (button)  
  131.             {  
  132.                 case MouseButtons.Left:  
  133.                     MouseDown(MouseButton.Left);  
  134.                     break;  
  135.                 case MouseButtons.Middle:  
  136.                     MouseDown(MouseButton.Middle);  
  137.                     break;  
  138.                 case MouseButtons.Right:  
  139.                     MouseDown(MouseButton.Right);  
  140.                     break;  
  141.             }  
  142.         }  
  143.   
  144.         /// <summary>  
  145.         /// Let a mouse button up  
  146.         /// </summary>  
  147.         /// <param name="button"></param>  
  148.         public static void MouseUp(MouseButton button)  
  149.         {  
  150.             mouse_event(((int)button) * 2, 0, 0, 0, 0);  
  151.         }  
  152.   
  153.         public static void MouseUp(MouseButtons button)  
  154.         {  
  155.             switch (button)  
  156.             {  
  157.                 case MouseButtons.Left:  
  158.                     MouseUp(MouseButton.Left);  
  159.                     break;  
  160.                 case MouseButtons.Middle:  
  161.                     MouseUp(MouseButton.Middle);  
  162.                     break;  
  163.                 case MouseButtons.Right:  
  164.                     MouseUp(MouseButton.Right);  
  165.                     break;  
  166.             }  
  167.         }  
  168.   
  169.         /// <summary>  
  170.         /// Click a mouse button (down then up)  
  171.         /// </summary>  
  172.         /// <param name="button"></param>  
  173.         public static void Click(MouseButton button)  
  174.         {  
  175.             MouseDown(button);  
  176.             MouseUp(button);  
  177.         }  
  178.   
  179.         public static void Click(MouseButtons button)  
  180.         {  
  181.             switch (button)  
  182.             {  
  183.                 case MouseButtons.Left:  
  184.                     Click(MouseButton.Left);  
  185.                     break;  
  186.                 case MouseButtons.Middle:  
  187.                     Click(MouseButton.Middle);  
  188.                     break;  
  189.                 case MouseButtons.Right:  
  190.                     Click(MouseButton.Right);  
  191.                     break;  
  192.             }  
  193.         }  
  194.   
  195.         /// <summary>  
  196.         /// Double click a mouse button (down then up twice)  
  197.         /// </summary>  
  198.         /// <param name="button"></param>  
  199.         public static void DoubleClick(MouseButton button)  
  200.         {  
  201.             Click(button);  
  202.             Click(button);  
  203.         }  
  204.   
  205.         public static void DoubleClick(MouseButtons button)  
  206.         {  
  207.             switch (button)  
  208.             {  
  209.                 case MouseButtons.Left:  
  210.                     DoubleClick(MouseButton.Left);  
  211.                     break;  
  212.                 case MouseButtons.Middle:  
  213.                     DoubleClick(MouseButton.Middle);  
  214.                     break;  
  215.                 case MouseButtons.Right:  
  216.                     DoubleClick(MouseButton.Right);  
  217.                     break;  
  218.             }  
  219.         }  
  220.   
  221.         /// <summary>  
  222.         /// Show a hidden current on currently application  
  223.         /// </summary>  
  224.         public static void Show()  
  225.         {  
  226.             ShowCursor(true);  
  227.         }  
  228.   
  229.         /// <summary>  
  230.         /// Hide mouse cursor only on current application‘s forms  
  231.         /// </summary>  
  232.         public static void Hide()  
  233.         {  
  234.             ShowCursor(false);  
  235.         }   
  236.  
  237.         #endregion  
  238.   
  239.     }  
  240.   
  241. }  
[csharp] view plaincopyprint?C#钩子类 几乎捕获键盘鼠标所有事件C#钩子类 几乎捕获键盘鼠标所有事件
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.ComponentModel;  
  4. using System.Data;  
  5. using System.Drawing;  
  6. using System.Linq;  
  7. using System.Text;  
  8. using System.Windows.Forms;  
  9.   
  10. using MouseKeyboardLibrary;  
  11.   
  12. namespace SampleApplication  
  13. {  
  14.     /* 
  15.       上面的5个类编译成Dll引用,使用例子 
  16.      */  
  17.     public partial class HookTestForm : Form  
  18.     {  
  19.   
  20.         MouseHook mouseHook = new MouseHook();  
  21.         KeyboardHook keyboardHook = new KeyboardHook();  
  22.   
  23.         public HookTestForm()  
  24.         {  
  25.             InitializeComponent();  
  26.         }  
  27.   
  28.         private void TestForm_Load(object sender, EventArgs e)  
  29.         {  
  30.   
  31.             mouseHook.MouseMove += new MouseEventHandler(mouseHook_MouseMove);  
  32.             mouseHook.MouseDown += new MouseEventHandler(mouseHook_MouseDown);  
  33.             mouseHook.MouseUp += new MouseEventHandler(mouseHook_MouseUp);  
  34.             mouseHook.MouseWheel += new MouseEventHandler(mouseHook_MouseWheel);  
  35.   
  36.             keyboardHook.KeyDown += new KeyEventHandler(keyboardHook_KeyDown);  
  37.             keyboardHook.KeyUp += new KeyEventHandler(keyboardHook_KeyUp);  
  38.             keyboardHook.KeyPress += new KeyPressEventHandler(keyboardHook_KeyPress);  
  39.   
  40.             mouseHook.Start();  
  41.             keyboardHook.Start();  
  42.   
  43.             SetXYLabel(MouseSimulator.X, MouseSimulator.Y);  
  44.   
  45.         }  
  46.   
  47.         void keyboardHook_KeyPress(object sender, KeyPressEventArgs e)  
  48.         {  
  49.   
  50.             AddKeyboardEvent(  
  51.                 "KeyPress",  
  52.                 "",  
  53.                 e.KeyChar.ToString(),  
  54.                 "",  
  55.                 "",  
  56.                 ""  
  57.                 );  
  58.   
  59.         }  
  60.   
  61.         void keyboardHook_KeyUp(object sender, KeyEventArgs e)  
  62.         {  
  63.   
  64.             AddKeyboardEvent(  
  65.                 "KeyUp",  
  66.                 e.KeyCode.ToString(),  
  67.                 "",  
  68.                 e.Shift.ToString(),  
  69.                 e.Alt.ToString(),  
  70.                 e.Control.ToString()  
  71.                 );  
  72.   
  73.         }  
  74.   
  75.         void keyboardHook_KeyDown(object sender, KeyEventArgs e)  
  76.         {  
  77.   
  78.   
  79.             AddKeyboardEvent(  
  80.                 "KeyDown",  
  81.                 e.KeyCode.ToString(),  
  82.                 "",  
  83.                 e.Shift.ToString(),  
  84.                 e.Alt.ToString(),  
  85.                 e.Control.ToString()  
  86.                 );  
  87.   
  88.         }  
  89.   
  90.         void mouseHook_MouseWheel(object sender, MouseEventArgs e)  
  91.         {  
  92.   
  93.             AddMouseEvent(  
  94.                 "MouseWheel",  
  95.                 "",  
  96.                 "",  
  97.                 "",  
  98.                 e.Delta.ToString()  
  99.                 );  
  100.   
  101.         }  
  102.   
  103.         void mouseHook_MouseUp(object sender, MouseEventArgs e)  
  104.         {  
  105.   
  106.   
  107.             AddMouseEvent(  
  108.                 "MouseUp",  
  109.                 e.Button.ToString(),  
  110.                 e.X.ToString(),  
  111.                 e.Y.ToString(),  
  112.                 ""  
  113.                 );  
  114.   
  115.         }  
  116.   
  117.         void mouseHook_MouseDown(object sender, MouseEventArgs e)  
  118.         {  
  119.   
  120.   
  121.             AddMouseEvent(  
  122.                 "MouseDown",  
  123.                 e.Button.ToString(),  
  124.                 e.X.ToString(),  
  125.                 e.Y.ToString(),  
  126.                 ""  
  127.                 );  
  128.   
  129.   
  130.         }  
  131.   
  132.         void mouseHook_MouseMove(object sender, MouseEventArgs e)  
  133.         {  
  134.   
  135.             SetXYLabel(e.X, e.Y);  
  136.   
  137.         }  
  138.   
  139.         void SetXYLabel(int x, int y)  
  140.         {  
  141.   
  142.             curXYLabel.Text = String.Format("Current Mouse Point: X={0}, y={1}", x, y);  
  143.   
  144.         }  
  145.   
  146.         void AddMouseEvent(string eventType, string button, string x, string y, string delta)  
  147.         {  
  148.   
  149.             listView1.Items.Insert(0,  
  150.                 new ListViewItem(  
  151.                     new string[]{  
  152.                         eventType,   
  153.                         button,  
  154.                         x,  
  155.                         y,  
  156.                         delta  
  157.                     }));  
  158.   
  159.         }  
  160.   
  161.         void AddKeyboardEvent(string eventType, string keyCode, string keyChar, string shift, string alt, string control)  
  162.         {  
  163.   
  164.             listView2.Items.Insert(0,  
  165.                  new ListViewItem(  
  166.                      new string[]{  
  167.                         eventType,   
  168.                         keyCode,  
  169.                         keyChar,  
  170.                         shift,  
  171.                         alt,  
  172.                         control  
  173.                 }));  
  174.   
  175.         }  
  176.   
  177.         private void TestForm_FormClosed(object sender, FormClosedEventArgs e)  
  178.         {  
  179.   
  180.             // Not necessary anymore, will stop when application exits  
  181.   
  182.             //mouseHook.Stop();  
  183.             //keyboardHook.Stop();  
  184.   
  185.         }  
  186.   
  187.   
  188.     }  
  189. }  

C#钩子类 几乎捕获键盘鼠标所有事件

上一篇：WPF命令参数CommandParameter


下一篇：WPF对象级资源的定义与查找