程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> .NET網頁編程 >> C# >> 關於C# >> VC#利用鉤子控制鼠標

VC#利用鉤子控制鼠標

編輯:關於C#

工作中有這樣的需求,某個控件panel的子控件textbox要實現只留鼠標右鍵copy,注意同時還不能影響其它panel的子控件textbox,怎麼辦?

答案是只有用鉤子,在codeporject上找到這麼一個鉤子。

如圖所示,第一個文本框只有copy功能。

UserActivityHook.cs
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);
 }
}
}
Form1.cs
using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;
namespace WindowsApplication2
{
/// <summary>
/// Form1 的摘要說明。清清月兒主頁:http://blog.csdn.net/21aspnet/ 
/// </summary>
public class Form1 : System.Windows.Forms.Form
{
 private System.Windows.Forms.TextBox textBox1;
 private System.Windows.Forms.TextBox textBox2;
 private System.Windows.Forms.Panel panel1;
 /// <summary>
 /// 必需的設計器變量。
 /// </summary>
 private System.ComponentModel.Container components = null;
 public Form1()
 {
  //
  // Windows 窗體設計器支持所必需的
  //
  InitializeComponent();
  //
  // TODO: 在 InitializeComponent 調用後添加任何構造函數代碼
  //
 }
 /// <summary>
 /// 清理所有正在使用的資源。
 /// </summary>
 protected override void Dispose( bool disposing )
 {
  if( disposing )
  {
  if (components != null)
  {
   components.Dispose();
  }
  }
  base.Dispose( disposing );
 }
 #region Windows 窗體設計器生成的代碼
 /// <summary>
 /// 設計器支持所需的方法 - 不要使用代碼編輯器修改
 /// 此方法的內容。
 /// </summary>
 private void InitializeComponent()
 {
  this.textBox1 = new System.Windows.Forms.TextBox();
  this.textBox2 = new System.Windows.Forms.TextBox();
  this.panel1 = new System.Windows.Forms.Panel();
  this.panel1.SuspendLayout();
  this.SuspendLayout();
  //
  // textBox1
  //
  this.textBox1.Location = new System.Drawing.Point(0, 8);
  this.textBox1.Name = "textBox1";
  this.textBox1.Size = new System.Drawing.Size(256, 20);
  this.textBox1.Tab, Index = 1;
  this.textBox1.Text = "111";
  //
  // textBox2
  //
  this.textBox2.Location = new System.Drawing.Point(8, 48);
  this.textBox2.Multiline = true;
  this.textBox2.Name = "textBox2";
  this.textBox2.Size = new System.Drawing.Size(256, 176);
  this.textBox2.TabIndex = 2;
  this.textBox2.Text = "textBox2";
  //
  // panel1
  //
  this.panel1.Controls.Add(this.textBox1);
  this.panel1.Location = new System.Drawing.Point(8, 0);
  this.panel1.Name = "panel1";
  this.panel1.Size = new System.Drawing.Size(280, 40);
  this.panel1.TabIndex = 3;
  //
  // Form1
  //
  this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
  this.ClientSize = new System.Drawing.Size(272, 229);
  this.Controls.Add(this.panel1);
  this.Controls.Add(this.textBox2);
  this.Name = "Form1";
  this.Text = "Form1";
  this.Load += new System.EventHandler(this.Form1_Load);
  this.panel1.ResumeLayout(false);
  this.ResumeLayout(false);
 }
 #endregion
 /// <summary>
 /// 應用程序的主入口點。
 /// </summary>
 [STAThread]
 static void Main()
 {
  Application.Run(new Form1());
 }
 public void MyKeyDown(object sender, KeyEventArgs e)
 {
 }
 public void MyKeyPress(object sender, KeyPressEventArgs e)
 {
 }
 public void MyKeyUp(object sender, KeyEventArgs e)
 {
 }
 void choose_OnMouseActivity(object sender, MouseEventArgs e)
 {
  //自定義右鍵---www.bianceng.cn
  //if (ActiveControl.Parent == panel1) 備用
  //if (ActiveControl.Parent is System.Windows.Forms.Panel) 備用
  if (ActiveControl == textBox1)
  {
  MenuItem copy = new MenuItem("copy");
  copy.Click += new EventHandler(copy_Click);      
  MenuItem[] menuItems = new MenuItem[] { copy };
  ContextMenu buttonMenu = new ContextMenu(menuItems);     
  textBox1.ContextMenu = buttonMenu;
  //this.ActiveControl.ContextMenu = buttonMenu; 備用
  }
 }
 private void copy_Click(object sender, EventArgs e)
 {
  Clipboard.SetDataObject(textBox1.SelectedText) ; //復制到剪切板
 }
 private void Form1_Load(object sender, System.EventArgs e)
 {
  //初始化
  gma.System.Windows.UserActivityHook choosesc=new gma.System.Windows.UserActivityHook();
  choosesc.OnMouseActivity += new MouseEventHandler(choose_OnMouseActivity);
//  choosesc.KeyDown += new KeyEventHandler(MyKeyDown);
//  choosesc.KeyPress += new KeyPressEventHandler(MyKeyPress);
//  choosesc.KeyUp += new KeyEventHandler(MyKeyUp);
 }
}
}

說明:這個鉤子有點問題,就是一次只能打開一個窗口(如果該窗口使用鉤子),打開後一定要關閉否則出問題,後果很嚴重!!!

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved