Jak przechwycić wszystkie zdarzenia na klawiaturze i zapobiec utracie ostrości w aplikacji WinForm?

Question

Mój przyjaciel jest ślepy i mam pomysł opracowania programu, który pozwoliłby mu korzystać z komputera przy pomocy ślepej metody pisania i audialnego sprzężenia zwrotnego. Doświadczenie byłoby znacznie bogatsze (dzięki zastosowaniu większej liczby klawiszy dla poszczególnych funkcji) i bezbłędne (np. Zapobieganie sporadycznemu utracie ostrości), jeśli moja aplikacja mogłaby w sposób wymuszony przejąć całkowitą kontrolę nad całym wprowadzeniem z klawiatury zaraz po jej uruchomieniu (powiedziałabym to w rozruchu dla niego). Jestem programistą WinForms C# .Net, więc chciałbym zaimplementować to w aplikacji używającej tej konkretnej struktury i języka (nie zważaj jednak na zawijane wywołania WinAPI).

PS: Nie mam nic przeciwko systemowi utrzymującemu kontrolę nad kombinacją Ctrl + Ald + Del, ale chciałbym przejąć kontrolę nad wszystkimi pozostałymi kluczami i kombinacjami, łącznie z logo Windows i standardowymi przyciskami uruchamiania aplikacji.

Answer 1

Można użyć implementacji haka niskiego poziomu posted here. Nie powinien kraść ognisk z dala od jakichkolwiek programów, ale twój program może zostać powiadomiony po naciśnięciu klawiszy. To jest kod z postu na wypadek, gdyby link przestał działać.

using System; 
using System.Diagnostics; 
using System.Windows.Forms; 
using System.Runtime.InteropServices; 

class InterceptKeys 
{ 
    private const int WH_KEYBOARD_LL = 13; 
    private const int WM_KEYDOWN = 0x0100; 
    private static LowLevelKeyboardProc _proc = HookCallback; 
    private static IntPtr _hookID = IntPtr.Zero; 

    public static void Main() 
    { 
     _hookID = SetHook(_proc); 
     Application.Run(); 
     UnhookWindowsHookEx(_hookID); 
    } 

    private static IntPtr SetHook(LowLevelKeyboardProc proc) 
    { 
     using (Process curProcess = Process.GetCurrentProcess()) 
     using (ProcessModule curModule = curProcess.MainModule) 
     { 
      return SetWindowsHookEx(WH_KEYBOARD_LL, proc, 
       GetModuleHandle(curModule.ModuleName), 0); 
     } 
    } 

    private delegate IntPtr LowLevelKeyboardProc(
     int nCode, IntPtr wParam, IntPtr lParam); 

    private static IntPtr HookCallback(
     int nCode, IntPtr wParam, IntPtr lParam) 
    { 
     if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) 
     { 
      int vkCode = Marshal.ReadInt32(lParam); 
      Console.WriteLine((Keys)vkCode); 
     } 
     return CallNextHookEx(_hookID, nCode, wParam, lParam); 
    } 

    [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)] 
    private static extern IntPtr SetWindowsHookEx(int idHook, 
     LowLevelKeyboardProc 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); 
} 

można obsługiwać naciśnięcia przycisków w przypadku HookCallback (lub dalszych abstrakcyjnych głównych części do osobnej klasy i podnieść zdarzenie).

Answer 2

Wiem, że ten temat jest stary, ale znalazłem możliwe rozwiązanie. Można użyć ostatnią odpowiedź i edytować go trochę:

zamiast dzwonić następny hak

private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { 
    if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) 
    { 
     int vkCode = Marshal.ReadInt32(lParam); 
     Console.WriteLine((Keys)vkCode); 
    } 
    return CallNextHookEx(_hookID, nCode, wParam, lParam); 
} 

tylko zwracają -1 do zatrzymania proceding dowolny uchwyt do innych kontroli

private static IntPtr HookCallback(
    int nCode, IntPtr wParam, IntPtr lParam) 
{ 
    if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN) 
    { 
     int vkCode = Marshal.ReadInt32(lParam); 
     Console.WriteLine((Keys)vkCode); 
    } 
    return -1; 
} 

ten nie jest ładny, ale działa. Ostrożnie z tym!