Comme vous l'avez mentionné, vous pouvez le faire en utilisant une crochet de souris de bas niveau ( WH_MOUSE_LL) mais de manière quelque peu erronée. Ce qui se passe lorsque vous définissez un crochet, c'est que vous recevrez des notifications à chaque événement de saisie de la souris ( WM_MOUSEMOVE , WM_LBUTTONDOWN , WM_RBUTTONDOWN , WM_MBUTTONDOWN , WM_XBUTTONDOWN , WM_NCXBUTTONDOWN les événements équivalents pour chacun d'entre eux, WM_MOUSEWHEEL y WM_MOUSEHWHEEL ). Une fois que vous avez fini de traiter chaque événement, vous supposée pour appeler le CallNextHookEx fonction qui transmet les informations sur l'événement à l'application suivante dans la chaîne de crochets. Cependant, si vous voulez empêcher tout autre programme d'obtenir des informations sur l'entrée de la souris, vous pouvez simplement ne pas appeler cette fonction à la fin de votre procédure d'accrochage. La section "Remarques" de la documentation mentionnée ci-dessus l'explique ainsi :
Appel à CallNextHookEx est facultatif, mais elle est fortement recommandée ; sinon, les autres applications qui qui ont installé des hooks ne recevront pas notifications de hook et peuvent se comporter comportement incorrect. Vous devez appeler CallNextHookEx à moins que vous absolument nécessaire d'empêcher la notification d'être vue par d'autres autres applications.
Et il s'avère que les crochets de souris de bas niveau ne sont pas si difficiles à réaliser en C#. Je viens juste d'en coder un moi-même, en fait. Mais plutôt que de mettre en ligne cette bibliothèque monstrueuse, je vous renvoie à l'extrait de code plus simple publié sur Le blog de Stephen Toub que j'ai réimprimé ici avec la coloration syntaxique pour plus de commodité :
class InterceptMouse
{
private static LowLevelMouseProc _proc = HookCallback;
private static IntPtr _hookID = IntPtr.Zero;
public static void Main()
{
_hookID = SetHook(_proc);
Application.Run();
UnhookWindowsHookEx(_hookID);
}
private static IntPtr SetHook(LowLevelMouseProc proc)
{
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
return SetWindowsHookEx(WH_MOUSE_LL, proc,
GetModuleHandle(curModule.ModuleName), 0);
}
}
private delegate IntPtr LowLevelMouseProc(int nCode, IntPtr wParam, IntPtr lParam);
private static IntPtr HookCallback(
int nCode, IntPtr wParam, IntPtr lParam)
{
if (nCode >= 0 &&
MouseMessages.WM_LBUTTONDOWN == (MouseMessages)wParam)
{
MSLLHOOKSTRUCT hookStruct = (MSLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(MSLLHOOKSTRUCT));
Console.WriteLine(hookStruct.pt.x + ", " + hookStruct.pt.y);
}
return CallNextHookEx(_hookID, nCode, wParam, lParam);
}
private const int WH_MOUSE_LL = 14;
private enum MouseMessages
{
WM_LBUTTONDOWN = 0x0201,
WM_LBUTTONUP = 0x0202,
WM_MOUSEMOVE = 0x0200,
WM_MOUSEWHEEL = 0x020A,
WM_RBUTTONDOWN = 0x0204,
WM_RBUTTONUP = 0x0205
}
[StructLayout(LayoutKind.Sequential)]
private struct POINT
{
public int x;
public int y;
}
[StructLayout(LayoutKind.Sequential)]
private struct MSLLHOOKSTRUCT
{
public POINT pt;
public uint mouseData;
public uint flags;
public uint time;
public IntPtr dwExtraInfo;
}
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr SetWindowsHookEx(int idHook,
LowLevelMouseProc lpfn, IntPtr hMod, uint dwThreadId);
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
IntPtr wParam, IntPtr lParam);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);
}
Comme je l'ai expliqué ci-dessus, vous voudrez modifier son HookCallback de ne pas appeler la méthode CallNextHookEx une fois que vous avez fini de traiter l'événement de la souris, mais renvoyez quelque chose comme new IntPtr(1) à la place.
EDIT : Et oui, comme d'autres l'ont mentionné, il y a probablement d'autres solutions plus simples et plus propres à ce problème. Les pilotes de votre trackpad sont un bon endroit pour rechercher une option comme "Ignorer les saisies accidentelles de la souris pendant la frappe". Si vous n'avez pas cette option, vous utilisez probablement les pilotes de souris standard de Windows. Essayez de télécharger les pilotes du fabricant de votre trackpad depuis le site Web du fabricant de l'ordinateur portable (pour ce que ça vaut, la plupart des trackpads non-Apple que j'ai vus sont des pilotes de souris standard). Synaptics ).
