Wie abfangen alle Tastaturereignisse und verhindern, den Fokus in einer WinForms-Anwendung zu verlieren?

Question

Ein Freund von mir ist blind und ich habe eine Idee, ein Programm zu entwickeln, das es ihm erlauben würde, einen PC mit Hilfe einer blinden Tippmethode und auditiver Rückmeldung zu benutzen. Die Erfahrung wäre viel reicher (die Verwendung von mehr Tasten für bestimmte Funktionen) und fehlerlos (wie das Verhindern von gelegentlichem Fokusverlust), wenn meine Anwendung gewaltsam die totale Kontrolle über die gesamte Tastatureingabe übernehmen könnte, sobald sie gestartet wird (ich würde es sagen) im Start-up für ihn). Ich bin ein WinForms C# .Net-Entwickler, also möchte ich dies in einer Anwendung implementieren, die dieses spezielle Framework und diese spezielle Sprache verwendet (verwickelte WinAPI-Aufrufe beachten).

PS: Ich habe nichts dagegen, dass das System die Kontrolle über die Kombination Strg + Ald + Entf behält, aber ich möchte die Kontrolle über alle anderen Tasten und Kombinationen übernehmen, einschließlich des Windows-Logos und der Standard-Anwendungsstarter.

Answer 1

Sie können die Low-Level-Tastatur-Hook-Implementierung posted here verwenden. Es sollte nicht Fokus weg von irgendwelchen Programmen stehlen, aber Ihr Programm kann benachrichtigt werden, wenn Schlüssel gedrückt werden. Dies ist der Code aus dem Post, falls die Verbindung nicht mehr funktioniert.

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); 
} 

Sie können die Tastendrücke im HookCallback Ereignis (oder weiter abstrakt die wichtigsten Teile in eine separate Klasse und ein Ereignis auslösen) behandeln.

Answer 2

Ich weiß, dass dieses Thema alt ist, aber ich fand eine mögliche Lösung. Sie können die letzte Antwort verwenden und es ein wenig bearbeiten:

stattdessen den nächsten Haken des Aufrufs

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); 
} 

nur -1 zurück zum Anhalten jeder Handgriff auf andere Kontrollen proceding

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; 
} 

Diese ist nicht nett, aber es funktioniert. Sei vorsichtig damit!