Capture des frappes sans mise au point

Question

E.g. avec winamp (sous Windows au moins), vous pouvez jouer en mode plein écran avec winamp en arrière-plan, et utiliser les boutons média * pour contrôler le son. Winamp n'a pas besoin de se concentrer, permettant au jeu de continuer en plein écran. Je préférerais écrire ceci en Java mais ça ne marchera probablement pas (capturer des frappes sans focus est déjà difficile dans Java afaik), donc n'importe quelle solution C# est aussi bien. Donc, la question fondamentale est: comment capturer des frappes sans focus? *) Je crois que les boutons «Précédent/Suivant/Arrêter/Courrier/Recherche/Favoris/Web/Maison» sont appelés boutons médias, mais un meilleur nom serait le bienvenu :).

Answer 1

Les crochets de fenêtre de bas niveau sont une façon de le faire. Voici un article et voici un peu plus d'informations de MSDN.

Ceci est une vue partielle de ce que le code peut ressembler à:

private IntPtr LowLevelKeyboardHook(int nCode, WindowsMessages wParam, [In] KBDLLHOOKSTRUCT lParam) 
    { 
     bool callNext = true; 

     bool isKeyDown = (wParam == WindowsMessages.KEYDOWN || wParam == WindowsMessages.SYSKEYDOWN); 
     bool isKeyUp = (wParam == WindowsMessages.KEYUP || wParam == WindowsMessages.SYSKEYUP); 

     if ((nCode >= 0) && (isKeyDown || isKeyUp)) 
     { 
      // the virtual key codes and the winforms Keys have the same enumeration 
      // so we can freely cast back and forth between them 
      Keys key = (Keys)lParam.vkCode; 

      // Do your other processing here... 
     } 

     // if any handler returned false, trap the message 
     return (callNext) ? User32.CallNextHookEx(_mainHook, nCode, wParam, lParam) : _nullNext; 
    } 


    /// <summary> 
    /// Registers the user's LowLevelKeyboardProc with the system in order to 
    /// intercept any keyboard events before processed in the regular fashion. 
    /// This can be used to log all keyboard events or ignore them. 
    /// </summary> 
    /// <param name="hook">Callback function to call whenever a keyboard event occurs.</param> 
    /// <returns>The IntPtr assigned by the Windows's sytem that defines the callback.</returns> 
    private IntPtr RegisterLowLevelHook(LowLevelKeyboardProc hook) 
    { 
     IntPtr handle = IntPtr.Zero; 

     using (Process currentProcess = Process.GetCurrentProcess()) 
     using (ProcessModule currentModule = currentProcess.MainModule) 
     { 
      IntPtr module = Kernel32.GetModuleHandle(currentModule.ModuleName); 
      handle = User32.SetWindowsHookEx(HookType.KEYBOARD_LL, hook, module, 0); 
     } 

     return handle; 
    } 

    /// <summary> 
    /// Unregisters a previously registered callback from the low-level chain. 
    /// </summary> 
    /// <param name="hook">IntPtr previously assigned to the low-level chain. 
    /// Users should have stored the value given by 
    /// <see cref="Drs.Interop.Win32.LowLevelKeyboard.RegisterLowLevelHook"/>, 
    /// and use that value as the parameter into this function.</param> 
    /// <returns>True if the hook was removed, false otherwise.</returns> 
    private bool UnregisterLowLevelHook(IntPtr hook) 
    { 
     return User32.UnhookWindowsHookEx(hook); 
    } 

Tout mettre en œuvre toutes les déclarations P/Invoke nécessaire, et cela devrait fonctionner. J'utilise cette approche dans mon application et cela fonctionne très bien.

Answer 2

En Java, il y a deux bibliothèques qui peuvent le faire:

• JIntellitype (Windows)
• JXGrabKey (X11)