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

  1. using System;
  2. using System.Text;
  3. using System.Runtime.InteropServices;
  4. using System.Reflection;
  5. using System.Windows.Forms;
  6. namespace MouseKeyboardLibrary
  7. {
  8. /// <summary>
  9. /// Abstract base class for Mouse and Keyboard hooks
  10. /// </summary>
  11. public abstract class GlobalHook
  12. {
  13. #region Windows API Code
  14. [StructLayout(LayoutKind.Sequential)]
  15. protected class POINT
  16. {
  17. public int x;
  18. public int y;
  19. }
  20. [StructLayout(LayoutKind.Sequential)]
  21. protected class MouseHookStruct
  22. {
  23. public POINT pt;
  24. public int hwnd;
  25. public int wHitTestCode;
  26. public int dwExtraInfo;
  27. }
  28. [StructLayout(LayoutKind.Sequential)]
  29. protected class MouseLLHookStruct
  30. {
  31. public POINT pt;
  32. public int mouseData;
  33. public int flags;
  34. public int time;
  35. public int dwExtraInfo;
  36. }
  37. [StructLayout(LayoutKind.Sequential)]
  38. protected class KeyboardHookStruct
  39. {
  40. public int vkCode;
  41. public int scanCode;
  42. public int flags;
  43. public int time;
  44. public int dwExtraInfo;
  45. }
  46. [DllImport("user32.dll", CharSet = CharSet.Auto,
  47. CallingConvention = CallingConvention.StdCall, SetLastError = true)]
  48. protected static extern int SetWindowsHookEx(
  49. int idHook,
  50. HookProc lpfn,
  51. IntPtr hMod,
  52. int dwThreadId);
  53. [DllImport("user32.dll", CharSet = CharSet.Auto,
  54. CallingConvention = CallingConvention.StdCall, SetLastError = true)]
  55. protected static extern int UnhookWindowsHookEx(int idHook);
  56. [DllImport("user32.dll", CharSet = CharSet.Auto,
  57. CallingConvention = CallingConvention.StdCall)]
  58. protected static extern int CallNextHookEx(
  59. int idHook,
  60. int nCode,
  61. int wParam,
  62. IntPtr lParam);
  63. [DllImport("user32")]
  64. protected static extern int ToAscii(
  65. int uVirtKey,
  66. int uScanCode,
  67. byte[] lpbKeyState,
  68. byte[] lpwTransKey,
  69. int fuState);
  70. [DllImport("user32")]
  71. protected static extern int GetKeyboardState(byte[] pbKeyState);
  72. [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
  73. protected static extern short GetKeyState(int vKey);
  74. protected delegate int HookProc(int nCode, int wParam, IntPtr lParam);
  75. protected const int WH_MOUSE_LL = 14;
  76. protected const int WH_KEYBOARD_LL = 13;
  77. protected const int WH_MOUSE = 7;
  78. protected const int WH_KEYBOARD = 2;
  79. protected const int WM_MOUSEMOVE = 0x200;
  80. protected const int WM_LBUTTONDOWN = 0x201;
  81. protected const int WM_RBUTTONDOWN = 0x204;
  82. protected const int WM_MBUTTONDOWN = 0x207;
  83. protected const int WM_LBUTTONUP = 0x202;
  84. protected const int WM_RBUTTONUP = 0x205;
  85. protected const int WM_MBUTTONUP = 0x208;
  86. protected const int WM_LBUTTONDBLCLK = 0x203;
  87. protected const int WM_RBUTTONDBLCLK = 0x206;
  88. protected const int WM_MBUTTONDBLCLK = 0x209;
  89. protected const int WM_MOUSEWHEEL = 0x020A;
  90. protected const int WM_KEYDOWN = 0x100;
  91. protected const int WM_KEYUP = 0x101;
  92. protected const int WM_SYSKEYDOWN = 0x104;
  93. protected const int WM_SYSKEYUP = 0x105;
  94. protected const byte VK_SHIFT = 0x10;
  95. protected const byte VK_CAPITAL = 0x14;
  96. protected const byte VK_NUMLOCK = 0x90;
  97. protected const byte VK_LSHIFT = 0xA0;
  98. protected const byte VK_RSHIFT = 0xA1;
  99. protected const byte VK_LCONTROL = 0xA2;
  100. protected const byte VK_RCONTROL = 0x3;
  101. protected const byte VK_LALT = 0xA4;
  102. protected const byte VK_RALT = 0xA5;
  103. protected const byte LLKHF_ALTDOWN = 0x20;
  104. #endregion
  105. #region Private Variables
  106. protected int _hookType;
  107. protected int _handleToHook;
  108. protected bool _isStarted;
  109. protected HookProc _hookCallback;
  110. #endregion
  111. #region Properties
  112. public bool IsStarted
  113. {
  114. get
  115. {
  116. return _isStarted;
  117. }
  118. }
  119. #endregion
  120. #region Constructor
  121. public GlobalHook()
  122. {
  123. Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
  124. }
  125. #endregion
  126. #region Methods
  127. public void Start()
  128. {
  129. if (!_isStarted &&
  130. _hookType != 0)
  131. {
  132. // Make sure we keep a reference to this delegate!
  133. // If not, GC randomly collects it, and a NullReference exception is thrown
  134. _hookCallback = new HookProc(HookCallbackProcedure);
  135. _handleToHook = SetWindowsHookEx(
  136. _hookType,
  137. _hookCallback,
  138. Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),
  139. 0);
  140. // Were we able to sucessfully start hook?
  141. if (_handleToHook != 0)
  142. {
  143. _isStarted = true;
  144. }
  145. }
  146. }
  147. public void Stop()
  148. {
  149. if (_isStarted)
  150. {
  151. UnhookWindowsHookEx(_handleToHook);
  152. _isStarted = false;
  153. }
  154. }
  155. protected virtual int HookCallbackProcedure(int nCode, Int32 wParam, IntPtr lParam)
  156. {
  157. // This method must be overriden by each extending hook
  158. return 0;
  159. }
  160. protected void Application_ApplicationExit(object sender, EventArgs e)
  161. {
  162. if (_isStarted)
  163. {
  164. Stop();
  165. }
  166. }
  167. #endregion
  168. }
  169. }

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Text;
  3. using System.Windows.Forms;
  4. using System.Runtime.InteropServices;
  5. namespace MouseKeyboardLibrary
  6. {
  7. /// <summary>
  8. /// Captures global keyboard events
  9. /// </summary>
  10. public class KeyboardHook : GlobalHook
  11. {
  12. #region Events
  13. public event KeyEventHandler KeyDown;
  14. public event KeyEventHandler KeyUp;
  15. public event KeyPressEventHandler KeyPress;
  16. #endregion
  17. #region Constructor
  18. public KeyboardHook()
  19. {
  20. _hookType = WH_KEYBOARD_LL;
  21. }
  22. #endregion
  23. #region Methods
  24. protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)
  25. {
  26. bool handled = false;
  27. if (nCode > -1 && (KeyDown != null || KeyUp != null || KeyPress != null))
  28. {
  29. KeyboardHookStruct keyboardHookStruct =
  30. (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
  31. // Is Control being held down?
  32. bool control = ((GetKeyState(VK_LCONTROL) & 0x80) != 0) ||
  33. ((GetKeyState(VK_RCONTROL) & 0x80) != 0);
  34. // Is Shift being held down?
  35. bool shift = ((GetKeyState(VK_LSHIFT) & 0x80) != 0) ||
  36. ((GetKeyState(VK_RSHIFT) & 0x80) != 0);
  37. // Is Alt being held down?
  38. bool alt = ((GetKeyState(VK_LALT) & 0x80) != 0) ||
  39. ((GetKeyState(VK_RALT) & 0x80) != 0);
  40. // Is CapsLock on?
  41. bool capslock = (GetKeyState(VK_CAPITAL) != 0);
  42. // Create event using keycode and control/shift/alt values found above
  43. KeyEventArgs e = new KeyEventArgs(
  44. (Keys)(
  45. keyboardHookStruct.vkCode |
  46. (control ? (int)Keys.Control : 0) |
  47. (shift ? (int)Keys.Shift : 0) |
  48. (alt ? (int)Keys.Alt : 0)
  49. ));
  50. // Handle KeyDown and KeyUp events
  51. switch (wParam)
  52. {
  53. case WM_KEYDOWN:
  54. case WM_SYSKEYDOWN:
  55. if (KeyDown != null)
  56. {
  57. KeyDown(this, e);
  58. handled = handled || e.Handled;
  59. }
  60. break;
  61. case WM_KEYUP:
  62. case WM_SYSKEYUP:
  63. if (KeyUp != null)
  64. {
  65. KeyUp(this, e);
  66. handled = handled || e.Handled;
  67. }
  68. break;
  69. }
  70. // Handle KeyPress event
  71. if (wParam == WM_KEYDOWN &&
  72. !handled &&
  73. !e.SuppressKeyPress &&
  74. KeyPress != null)
  75. {
  76. byte[] keyState = new byte[256];
  77. byte[] inBuffer = new byte[2];
  78. GetKeyboardState(keyState);
  79. if (ToAscii(keyboardHookStruct.vkCode,
  80. keyboardHookStruct.scanCode,
  81. keyState,
  82. inBuffer,
  83. keyboardHookStruct.flags) == 1)
  84. {
  85. char key = (char)inBuffer[0];
  86. if ((capslock ^ shift) && Char.IsLetter(key))
  87. key = Char.ToUpper(key);
  88. KeyPressEventArgs e2 = new KeyPressEventArgs(key);
  89. KeyPress(this, e2);
  90. handled = handled || e.Handled;
  91. }
  92. }
  93. }
  94. if (handled)
  95. {
  96. return 1;
  97. }
  98. else
  99. {
  100. return CallNextHookEx(_handleToHook, nCode, wParam, lParam);
  101. }
  102. }
  103. #endregion
  104. }
  105. }

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Text;
  3. using System.Runtime.InteropServices;
  4. using System.Windows.Forms;
  5. namespace MouseKeyboardLibrary
  6. {
  7. /// <summary>
  8. /// Standard Keyboard Shortcuts used by most applications
  9. /// </summary>
  10. public enum StandardShortcut
  11. {
  12. Copy,
  13. Cut,
  14. Paste,
  15. SelectAll,
  16. Save,
  17. Open,
  18. New,
  19. Close,
  20. Print
  21. }
  22. /// <summary>
  23. /// Simulate keyboard key presses
  24. /// </summary>
  25. public static class KeyboardSimulator
  26. {
  27. #region Windows API Code
  28. const int KEYEVENTF_EXTENDEDKEY = 0x1;
  29. const int KEYEVENTF_KEYUP = 0x2;
  30. [DllImport("user32.dll")]
  31. static extern void keybd_event(byte key, byte scan, int flags, int extraInfo);
  32. #endregion
  33. #region Methods
  34. public static void KeyDown(Keys key)
  35. {
  36. keybd_event(ParseKey(key), 0, 0, 0);
  37. }
  38. public static void KeyUp(Keys key)
  39. {
  40. keybd_event(ParseKey(key), 0, KEYEVENTF_KEYUP, 0);
  41. }
  42. public static void KeyPress(Keys key)
  43. {
  44. KeyDown(key);
  45. KeyUp(key);
  46. }
  47. public static void SimulateStandardShortcut(StandardShortcut shortcut)
  48. {
  49. switch (shortcut)
  50. {
  51. case StandardShortcut.Copy:
  52. KeyDown(Keys.Control);
  53. KeyPress(Keys.C);
  54. KeyUp(Keys.Control);
  55. break;
  56. case StandardShortcut.Cut:
  57. KeyDown(Keys.Control);
  58. KeyPress(Keys.X);
  59. KeyUp(Keys.Control);
  60. break;
  61. case StandardShortcut.Paste:
  62. KeyDown(Keys.Control);
  63. KeyPress(Keys.V);
  64. KeyUp(Keys.Control);
  65. break;
  66. case StandardShortcut.SelectAll:
  67. KeyDown(Keys.Control);
  68. KeyPress(Keys.A);
  69. KeyUp(Keys.Control);
  70. break;
  71. case StandardShortcut.Save:
  72. KeyDown(Keys.Control);
  73. KeyPress(Keys.S);
  74. KeyUp(Keys.Control);
  75. break;
  76. case StandardShortcut.Open:
  77. KeyDown(Keys.Control);
  78. KeyPress(Keys.O);
  79. KeyUp(Keys.Control);
  80. break;
  81. case StandardShortcut.New:
  82. KeyDown(Keys.Control);
  83. KeyPress(Keys.N);
  84. KeyUp(Keys.Control);
  85. break;
  86. case StandardShortcut.Close:
  87. KeyDown(Keys.Alt);
  88. KeyPress(Keys.F4);
  89. KeyUp(Keys.Alt);
  90. break;
  91. case StandardShortcut.Print:
  92. KeyDown(Keys.Control);
  93. KeyPress(Keys.P);
  94. KeyUp(Keys.Control);
  95. break;
  96. }
  97. }
  98. static byte ParseKey(Keys key)
  99. {
  100. // Alt, Shift, and Control need to be changed for API function to work with them
  101. switch (key)
  102. {
  103. case Keys.Alt:
  104. return (byte)18;
  105. case Keys.Control:
  106. return (byte)17;
  107. case Keys.Shift:
  108. return (byte)16;
  109. default:
  110. return (byte)key;
  111. }
  112. }
  113. #endregion
  114. }
  115. }

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Text;
  3. using System.Windows.Forms;
  4. using System.Runtime.InteropServices;
  5. namespace MouseKeyboardLibrary
  6. {
  7. /// <summary>
  8. /// Captures global mouse events
  9. /// </summary>
  10. public class MouseHook : GlobalHook
  11. {
  12. #region MouseEventType Enum
  13. private enum MouseEventType
  14. {
  15. None,
  16. MouseDown,
  17. MouseUp,
  18. DoubleClick,
  19. MouseWheel,
  20. MouseMove
  21. }
  22. #endregion
  23. #region Events
  24. public event MouseEventHandler MouseDown;
  25. public event MouseEventHandler MouseUp;
  26. public event MouseEventHandler MouseMove;
  27. public event MouseEventHandler MouseWheel;
  28. public event EventHandler Click;
  29. public event EventHandler DoubleClick;
  30. #endregion
  31. #region Constructor
  32. public MouseHook()
  33. {
  34. _hookType = WH_MOUSE_LL;
  35. }
  36. #endregion
  37. #region Methods
  38. protected override int HookCallbackProcedure(int nCode, int wParam, IntPtr lParam)
  39. {
  40. if (nCode > -1 && (MouseDown != null || MouseUp != null || MouseMove != null))
  41. {
  42. MouseLLHookStruct mouseHookStruct =
  43. (MouseLLHookStruct)Marshal.PtrToStructure(lParam, typeof(MouseLLHookStruct));
  44. MouseButtons button = GetButton(wParam);
  45. MouseEventType eventType = GetEventType(wParam);
  46. MouseEventArgs e = new MouseEventArgs(
  47. button,
  48. (eventType == MouseEventType.DoubleClick ? 2 : 1),
  49. mouseHookStruct.pt.x,
  50. mouseHookStruct.pt.y,
  51. (eventType == MouseEventType.MouseWheel ? (short)((mouseHookStruct.mouseData >> 16) & 0xffff) : 0));
  52. // Prevent multiple Right Click events (this probably happens for popup menus)
  53. if (button == MouseButtons.Right && mouseHookStruct.flags != 0)
  54. {
  55. eventType = MouseEventType.None;
  56. }
  57. switch (eventType)
  58. {
  59. case MouseEventType.MouseDown:
  60. if (MouseDown != null)
  61. {
  62. MouseDown(this, e);
  63. }
  64. break;
  65. case MouseEventType.MouseUp:
  66. if (Click != null)
  67. {
  68. Click(this, new EventArgs());
  69. }
  70. if (MouseUp != null)
  71. {
  72. MouseUp(this, e);
  73. }
  74. break;
  75. case MouseEventType.DoubleClick:
  76. if (DoubleClick != null)
  77. {
  78. DoubleClick(this, new EventArgs());
  79. }
  80. break;
  81. case MouseEventType.MouseWheel:
  82. if (MouseWheel != null)
  83. {
  84. MouseWheel(this, e);
  85. }
  86. break;
  87. case MouseEventType.MouseMove:
  88. if (MouseMove != null)
  89. {
  90. MouseMove(this, e);
  91. }
  92. break;
  93. default:
  94. break;
  95. }
  96. }
  97. return CallNextHookEx(_handleToHook, nCode, wParam, lParam);
  98. }
  99. private MouseButtons GetButton(Int32 wParam)
  100. {
  101. switch (wParam)
  102. {
  103. case WM_LBUTTONDOWN:
  104. case WM_LBUTTONUP:
  105. case WM_LBUTTONDBLCLK:
  106. return MouseButtons.Left;
  107. case WM_RBUTTONDOWN:
  108. case WM_RBUTTONUP:
  109. case WM_RBUTTONDBLCLK:
  110. return MouseButtons.Right;
  111. case WM_MBUTTONDOWN:
  112. case WM_MBUTTONUP:
  113. case WM_MBUTTONDBLCLK:
  114. return MouseButtons.Middle;
  115. default:
  116. return MouseButtons.None;
  117. }
  118. }
  119. private MouseEventType GetEventType(Int32 wParam)
  120. {
  121. switch (wParam)
  122. {
  123. case WM_LBUTTONDOWN:
  124. case WM_RBUTTONDOWN:
  125. case WM_MBUTTONDOWN:
  126. return MouseEventType.MouseDown;
  127. case WM_LBUTTONUP:
  128. case WM_RBUTTONUP:
  129. case WM_MBUTTONUP:
  130. return MouseEventType.MouseUp;
  131. case WM_LBUTTONDBLCLK:
  132. case WM_RBUTTONDBLCLK:
  133. case WM_MBUTTONDBLCLK:
  134. return MouseEventType.DoubleClick;
  135. case WM_MOUSEWHEEL:
  136. return MouseEventType.MouseWheel;
  137. case WM_MOUSEMOVE:
  138. return MouseEventType.MouseMove;
  139. default:
  140. return MouseEventType.None;
  141. }
  142. }
  143. #endregion
  144. }
  145. }

[csharp] view plaincopyprint?

  1. using System;
  2. using System.Text;
  3. using System.Runtime.InteropServices;
  4. using System.Drawing;
  5. using System.Windows.Forms;
  6. namespace MouseKeyboardLibrary
  7. {
  8. /// <summary>
  9. /// And X, Y point on the screen
  10. /// </summary>
  11. public struct MousePoint
  12. {
  13. public MousePoint(Point p)
  14. {
  15. X = p.X;
  16. Y = p.Y;
  17. }
  18. public int X;
  19. public int Y;
  20. public static implicit operator Point(MousePoint p)
  21. {
  22. return new Point(p.X, p.Y);
  23. }
  24. }
  25. /// <summary>
  26. /// Mouse buttons that can be pressed
  27. /// </summary>
  28. public enum MouseButton
  29. {
  30. Left = 0x2,
  31. Right = 0x8,
  32. Middle = 0x20
  33. }
  34. /// <summary>
  35. /// Operations that simulate mouse events
  36. /// </summary>
  37. public static class MouseSimulator
  38. {
  39. #region Windows API Code
  40. [DllImport("user32.dll")]
  41. static extern int ShowCursor(bool show);
  42. [DllImport("user32.dll")]
  43. static extern void mouse_event(int flags, int dX, int dY, int buttons, int extraInfo);
  44. const int MOUSEEVENTF_MOVE = 0x1;
  45. const int MOUSEEVENTF_LEFTDOWN = 0x2;
  46. const int MOUSEEVENTF_LEFTUP = 0x4;
  47. const int MOUSEEVENTF_RIGHTDOWN = 0x8;
  48. const int MOUSEEVENTF_RIGHTUP = 0x10;
  49. const int MOUSEEVENTF_MIDDLEDOWN = 0x20;
  50. const int MOUSEEVENTF_MIDDLEUP = 0x40;
  51. const int MOUSEEVENTF_WHEEL = 0x800;
  52. const int MOUSEEVENTF_ABSOLUTE = 0x8000;
  53. #endregion
  54. #region Properties
  55. /// <summary>
  56. /// Gets or sets a structure that represents both X and Y mouse coordinates
  57. /// </summary>
  58. public static MousePoint Position
  59. {
  60. get
  61. {
  62. return new MousePoint(Cursor.Position);
  63. }
  64. set
  65. {
  66. Cursor.Position = value;
  67. }
  68. }
  69. /// <summary>
  70. /// Gets or sets only the mouse‘s x coordinate
  71. /// </summary>
  72. public static int X
  73. {
  74. get
  75. {
  76. return Cursor.Position.X;
  77. }
  78. set
  79. {
  80. Cursor.Position = new Point(value, Y);
  81. }
  82. }
  83. /// <summary>
  84. /// Gets or sets only the mouse‘s y coordinate
  85. /// </summary>
  86. public static int Y
  87. {
  88. get
  89. {
  90. return Cursor.Position.Y;
  91. }
  92. set
  93. {
  94. Cursor.Position = new Point(X, value);
  95. }
  96. }
  97. #endregion
  98. #region Methods
  99. /// <summary>
  100. /// Press a mouse button down
  101. /// </summary>
  102. /// <param name="button"></param>
  103. public static void MouseDown(MouseButton button)
  104. {
  105. mouse_event(((int)button), 0, 0, 0, 0);
  106. }
  107. public static void MouseDown(MouseButtons button)
  108. {
  109. switch (button)
  110. {
  111. case MouseButtons.Left:
  112. MouseDown(MouseButton.Left);
  113. break;
  114. case MouseButtons.Middle:
  115. MouseDown(MouseButton.Middle);
  116. break;
  117. case MouseButtons.Right:
  118. MouseDown(MouseButton.Right);
  119. break;
  120. }
  121. }
  122. /// <summary>
  123. /// Let a mouse button up
  124. /// </summary>
  125. /// <param name="button"></param>
  126. public static void MouseUp(MouseButton button)
  127. {
  128. mouse_event(((int)button) * 2, 0, 0, 0, 0);
  129. }
  130. public static void MouseUp(MouseButtons button)
  131. {
  132. switch (button)
  133. {
  134. case MouseButtons.Left:
  135. MouseUp(MouseButton.Left);
  136. break;
  137. case MouseButtons.Middle:
  138. MouseUp(MouseButton.Middle);
  139. break;
  140. case MouseButtons.Right:
  141. MouseUp(MouseButton.Right);
  142. break;
  143. }
  144. }
  145. /// <summary>
  146. /// Click a mouse button (down then up)
  147. /// </summary>
  148. /// <param name="button"></param>
  149. public static void Click(MouseButton button)
  150. {
  151. MouseDown(button);
  152. MouseUp(button);
  153. }
  154. public static void Click(MouseButtons button)
  155. {
  156. switch (button)
  157. {
  158. case MouseButtons.Left:
  159. Click(MouseButton.Left);
  160. break;
  161. case MouseButtons.Middle:
  162. Click(MouseButton.Middle);
  163. break;
  164. case MouseButtons.Right:
  165. Click(MouseButton.Right);
  166. break;
  167. }
  168. }
  169. /// <summary>
  170. /// Double click a mouse button (down then up twice)
  171. /// </summary>
  172. /// <param name="button"></param>
  173. public static void DoubleClick(MouseButton button)
  174. {
  175. Click(button);
  176. Click(button);
  177. }
  178. public static void DoubleClick(MouseButtons button)
  179. {
  180. switch (button)
  181. {
  182. case MouseButtons.Left:
  183. DoubleClick(MouseButton.Left);
  184. break;
  185. case MouseButtons.Middle:
  186. DoubleClick(MouseButton.Middle);
  187. break;
  188. case MouseButtons.Right:
  189. DoubleClick(MouseButton.Right);
  190. break;
  191. }
  192. }
  193. /// <summary>
  194. /// Show a hidden current on currently application
  195. /// </summary>
  196. public static void Show()
  197. {
  198. ShowCursor(true);
  199. }
  200. /// <summary>
  201. /// Hide mouse cursor only on current application‘s forms
  202. /// </summary>
  203. public static void Hide()
  204. {
  205. ShowCursor(false);
  206. }
  207. #endregion
  208. }
  209. }

[csharp] view plaincopyprint?

  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. using MouseKeyboardLibrary;
  10. namespace SampleApplication
  11. {
  12. /*
  13. 上面的5个类编译成Dll引用,使用例子
  14. */
  15. public partial class HookTestForm : Form
  16. {
  17. MouseHook mouseHook = new MouseHook();
  18. KeyboardHook keyboardHook = new KeyboardHook();
  19. public HookTestForm()
  20. {
  21. InitializeComponent();
  22. }
  23. private void TestForm_Load(object sender, EventArgs e)
  24. {
  25. mouseHook.MouseMove += new MouseEventHandler(mouseHook_MouseMove);
  26. mouseHook.MouseDown += new MouseEventHandler(mouseHook_MouseDown);
  27. mouseHook.MouseUp += new MouseEventHandler(mouseHook_MouseUp);
  28. mouseHook.MouseWheel += new MouseEventHandler(mouseHook_MouseWheel);
  29. keyboardHook.KeyDown += new KeyEventHandler(keyboardHook_KeyDown);
  30. keyboardHook.KeyUp += new KeyEventHandler(keyboardHook_KeyUp);
  31. keyboardHook.KeyPress += new KeyPressEventHandler(keyboardHook_KeyPress);
  32. mouseHook.Start();
  33. keyboardHook.Start();
  34. SetXYLabel(MouseSimulator.X, MouseSimulator.Y);
  35. }
  36. void keyboardHook_KeyPress(object sender, KeyPressEventArgs e)
  37. {
  38. AddKeyboardEvent(
  39. "KeyPress",
  40. "",
  41. e.KeyChar.ToString(),
  42. "",
  43. "",
  44. ""
  45. );
  46. }
  47. void keyboardHook_KeyUp(object sender, KeyEventArgs e)
  48. {
  49. AddKeyboardEvent(
  50. "KeyUp",
  51. e.KeyCode.ToString(),
  52. "",
  53. e.Shift.ToString(),
  54. e.Alt.ToString(),
  55. e.Control.ToString()
  56. );
  57. }
  58. void keyboardHook_KeyDown(object sender, KeyEventArgs e)
  59. {
  60. AddKeyboardEvent(
  61. "KeyDown",
  62. e.KeyCode.ToString(),
  63. "",
  64. e.Shift.ToString(),
  65. e.Alt.ToString(),
  66. e.Control.ToString()
  67. );
  68. }
  69. void mouseHook_MouseWheel(object sender, MouseEventArgs e)
  70. {
  71. AddMouseEvent(
  72. "MouseWheel",
  73. "",
  74. "",
  75. "",
  76. e.Delta.ToString()
  77. );
  78. }
  79. void mouseHook_MouseUp(object sender, MouseEventArgs e)
  80. {
  81. AddMouseEvent(
  82. "MouseUp",
  83. e.Button.ToString(),
  84. e.X.ToString(),
  85. e.Y.ToString(),
  86. ""
  87. );
  88. }
  89. void mouseHook_MouseDown(object sender, MouseEventArgs e)
  90. {
  91. AddMouseEvent(
  92. "MouseDown",
  93. e.Button.ToString(),
  94. e.X.ToString(),
  95. e.Y.ToString(),
  96. ""
  97. );
  98. }
  99. void mouseHook_MouseMove(object sender, MouseEventArgs e)
  100. {
  101. SetXYLabel(e.X, e.Y);
  102. }
  103. void SetXYLabel(int x, int y)
  104. {
  105. curXYLabel.Text = String.Format("Current Mouse Point: X={0}, y={1}", x, y);
  106. }
  107. void AddMouseEvent(string eventType, string button, string x, string y, string delta)
  108. {
  109. listView1.Items.Insert(0,
  110. new ListViewItem(
  111. new string[]{
  112. eventType,
  113. button,
  114. x,
  115. y,
  116. delta
  117. }));
  118. }
  119. void AddKeyboardEvent(string eventType, string keyCode, string keyChar, string shift, string alt, string control)
  120. {
  121. listView2.Items.Insert(0,
  122. new ListViewItem(
  123. new string[]{
  124. eventType,
  125. keyCode,
  126. keyChar,
  127. shift,
  128. alt,
  129. control
  130. }));
  131. }
  132. private void TestForm_FormClosed(object sender, FormClosedEventArgs e)
  133. {
  134. // Not necessary anymore, will stop when application exits
  135. //mouseHook.Stop();
  136. //keyboardHook.Stop();
  137. }
  138. }
  139. }
时间： 2024-10-11 17:28:14

C#钩子类 几乎捕获键盘鼠标所有事件的相关文章

鼠标在某个控件上按下，然后离开后弹起，如何捕获这个鼠标弹起事件

默认情况下当鼠标移出控件外部后控件将获取不到WM_LBUTTONUP消息.以下通过SetCapture函数实现获取. SetCapture 函数功能: 该函数在属于当前线程的指定窗口里设置鼠标捕获.一旦窗口捕获了鼠标,所有鼠标输入都针对该窗口,无论光标是否在窗口的边界内.同一时刻只能有一个窗口捕获鼠标.如果鼠标光标在另一个线程创建的窗口上,只有当鼠标键按下时系统才将鼠标输入指向指定的窗口. LRESULT CALLBACK TestProc(HWND hwnd, UINT msg, WPARAM

键盘鼠标模拟全知道

http://www.cnblogs.com/bjxsky/p/3656076.html 本文目录如下 一.基于windows 消息机制的鼠标键盘模拟  (一).应用程序级模拟  (二).系统级模拟         1. 用API函数keybd_event 模拟键盘事件         2. SendInput函数模拟全局键盘鼠标事件         3.用全局钩子模拟键盘消息 二.驱动级模拟 ***************************************************

Android自动化测试初探（五）: 再述模拟键盘鼠标事件（adb shell 实现） .

http://blog.csdn.net/roger_ge/article/details/5552740 转自csdn,实现模拟鼠标键盘系列 上一篇博文中讲述了通过Socket编程从外部向Emulator发送键盘鼠标模拟事件,貌似实现细节有点复杂.其实Android还有一种更简单的模拟键盘鼠标事件的方法,那就是通过使用adb shell 命令. 1.     发送键盘事件: 命令格式1:adb shell input keyevent "value" 其中value以及对应的key

WPF 利用键盘钩子来捕获键盘,做一些不为人知的事情...完整实例

键盘钩子是一种可以监控键盘操作的指令. 看到这句话是不是觉得其实键盘钩子可以做很多事情. 场景 当你的程序需要一个全局的快捷键时,可以考虑使用键盘钩子,如大家常用qq的截图快捷键,那么在WPF里怎么去实现呢? 当然不是直接在Window窗体里面去注册MouseLeftButtonDown.MouseLeftButtonUp,这样只有在程序是焦点的情况下才能触发, 我们这里要做的更为强大,即在非焦点下去获取到键盘的事件(要偷偷记录女朋友键盘记录的滚粗,当然我是在开玩笑,程序猿哪里有女朋友,我们只有

c#键盘鼠标钩子

1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using System.Windows.Forms; 6 using System.Runtime.InteropServices; 7 using System.ComponentModel; 8 using System.Reflection; 9 10 namespace Alif.CommonAP

利用钩子函数来捕捉键盘响应的windows应用程序

一:引言: 你也许一直对金山词霸的屏幕抓词的实现原理感到困惑,你也许希望将你的键盘,鼠标的活动适时的记录下来,甚至你想知道木马在windows操作系统是怎样进行木马dll的加载的…..其实这些都是用到了windows的钩子函数.因此本文将对钩子函数的相关知识进行阐述.当然,本文的目的并不是想通过此程序让读者去窃取别人的密码,只是由于钩子函数在windows系统中是一个非常重要的系统接口函数,所以想和大家共同的探讨,当然本文也对怎样建立动态连结库(DLL)作了一些简单的描述.(本文的程序为vc6.

在WebBrowser中通过模拟键盘鼠标操控网页中的文件上传控件

在WebBrowser中通过模拟键盘鼠标操控网页中的文件上传控件 引言 这两天沉迷了Google SketchUp,刚刚玩够,一时兴起,研究了一下WebBrowser. 我在<WebBrowser控件使用技巧分享>一文中曾谈到过"我现在可以通过WebBrowser实现对各种Html元素的操控,唯独无法控制Html的上传控件",出于安全原因,IE没有对上传控件提供操控支持,这使得我们没法像控制其他控件一样用简单的代码进行赋值. 比较实际的解决方案就是模拟操作了,下面我就将演示

java 计算器SWT/RAP(版本3)键盘鼠标兼容

java 计算器SWT/RAP(版本3)键盘鼠标兼容,之前版本也对,但存在线程失效问题,当多人访问时,就容易线程失效,一直犯得一个错误就是一直用static变量和static方法, 之前加了什么js界面控制什么的,都没用,去掉static就好了 package cn.lesaas.nof.rwtswt.ui.dialog; import java.math.BigDecimal; import org.eclipse.swt.SWT;import org.eclipse.swt.events.S

setCapture只能作用于鼠标不可作用于键盘等其它事件

处理的优点非常类似于流媒体的优点.分析能够立即开始,而不是等待所有的数据被处理.而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中.这对于大型文档来说是个巨大的优点.事实上,应用程序甚至不必解析整个文档:它可以在某个条件得到满足时停止解析. 由于需要分别处理不同情况,所以上述代码用多种方式来定义这两个宏.第一个 #if 用于判断编译器是否支持新式枚举,若支持新特性,这一具有功能给我等纠结于屏幕驱动的程序员带来了很大的福音.有经验的读者一定有过这样的经历,用FSMC驱动带由控