¿Cómo puedo registrar una tecla rápida global para decir CTRL + MAYÚS + (LETRA) usando WPF y .NET 3.5?

Question

Estoy construyendo una aplicación en C# usando WPF. ¿Cómo puedo enlazar algunas teclas?

Además, ¿cómo puedo vincularme al Windows key?

Answer 1

No estoy seguro de lo que quiere decir con "global" aquí, pero aquí va (supongo que quiere decir un comando en el nivel de aplicación, por ejemplo, Guardar todo que se puede activar desde cualquier lugar por Ctrl +Shift +S.)

usted encuentra el mundial UIElement de su elección, por ejemplo, la ventana de nivel superior, que es el padre de todos los controles donde se necesita esta unión. Debido al "burbujeo" de los eventos WPF, los eventos en los elementos secundarios burbujearán hasta la raíz del árbol de control.

Ahora, primero que hay

1. para unir el Key-Combo con un comando usando un InputBinding como esto
2. a continuación, puede conexión el comando para el controlador (por ejemplo, código que se llama por SaveAll) a través de CommandBinding.

Para el clave de Windows, se utiliza el miembro enumerado derecho Key, Key.LWin o Key.RWin

public WindowMain() 
    { 
     InitializeComponent(); 
     // Bind Key 
     InputBinding ib = new InputBinding(
      MyAppCommands.SaveAll, 
      new KeyGesture(Key.S, ModifierKeys.Shift | ModifierKeys.Control)); 
     this.InputBindings.Add(ib); 
     // Bind handler 
     CommandBinding cb = new CommandBinding(MyAppCommands.SaveAll); 
     cb.Executed += new ExecutedRoutedEventHandler(HandlerThatSavesEverthing); 
     this.CommandBindings.Add (cb); 
    } 

    private void HandlerThatSavesEverthing (object obSender, ExecutedRoutedEventArgs e) 
    { 
     // Do the Save All thing here. 
    } 

Answer 2

No estoy seguro acerca de WPF, pero esto puede ayudar. Utilicé la solución descrita en (modificada para mis necesidades, por supuesto) para una aplicación C# Windows Forms para asignar una combinación CTRL-KEY dentro de Windows para mostrar un formulario C#, y funcionó maravillosamente (incluso en Windows Vista). ¡Espero que ayude y buena suerte!

Answer 3

RegisterHotKey() sugerido por John podría funcionar - la única pega es que requiere un HWND (usando PresentationSource.FromVisual(), y emitiendo el resultado a un HwndSource).

Sin embargo, también deberá responder al mensaje WM_HOTKEY - No estoy seguro de si hay una manera de obtener acceso al WndProc de una ventana WPF o no (lo que se puede hacer para las ventanas de Windows Forms) .

Answer 4

Un compañero de trabajo escribió una muestra sobre cómo crear un bajo nivel gancho de teclado para ser utilizado con WPF.

http://blogs.vertigo.com/personal/ralph/Blog/Lists/Posts/Post.aspx?ID=8

Answer 5

Si usted va a mezclar Win32 y WPF, así es como lo hice:

using System; 
using System.Runtime.InteropServices; 
using System.Windows.Interop; 
using System.Windows.Media; 
using System.Threading; 
using System.Windows; 
using System.Windows.Input; 

namespace GlobalKeyboardHook 
{ 
    public class KeyboardHandler : IDisposable 
    { 

     public const int WM_HOTKEY = 0x0312; 
     public const int VIRTUALKEYCODE_FOR_CAPS_LOCK = 0x14; 

     [DllImport("user32.dll")] 
     [return: MarshalAs(UnmanagedType.Bool)] 
     public static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vlc); 

     [DllImport("user32.dll")] 
     [return: MarshalAs(UnmanagedType.Bool)] 
     public static extern bool UnregisterHotKey(IntPtr hWnd, int id); 

     private readonly Window _mainWindow; 
     WindowInteropHelper _host; 

     public KeyboardHandler(Window mainWindow) 
     { 
      _mainWindow = mainWindow; 
      _host = new WindowInteropHelper(_mainWindow); 

      SetupHotKey(_host.Handle); 
      ComponentDispatcher.ThreadPreprocessMessage += ComponentDispatcher_ThreadPreprocessMessage; 
     } 

     void ComponentDispatcher_ThreadPreprocessMessage(ref MSG msg, ref bool handled) 
     { 
      if (msg.message == WM_HOTKEY) 
      { 
       //Handle hot key kere 
      } 
     } 

     private void SetupHotKey(IntPtr handle) 
     { 
      RegisterHotKey(handle, GetType().GetHashCode(), 0, VIRTUALKEYCODE_FOR_CAPS_LOCK); 
     } 

     public void Dispose() 
     { 
      UnregisterHotKey(_host.Handle, GetType().GetHashCode()); 
     } 
    } 
} 

Puede obtener el código de tecla virtual de la tecla de acceso directo que desea registrar aquí: http://msdn.microsoft.com/en-us/library/ms927178.aspx

Puede haber una manera mejor, pero esto es lo que tengo hasta ahora.

¡Salud!

Answer 6

Aunque RegisterHotKey a veces es precisamente lo que desea, en la mayoría de los casos probablemente no quiera utilizar teclas de acceso directo en todo el sistema. Terminé usando código como el siguiente:

 
using System.Windows; 
using System.Windows.Interop; 

namespace WpfApp 
{ 
    public partial class MainWindow : Window 
    { 
     const int WM_KEYUP = 0x0101; 

     const int VK_RETURN = 0x0D; 
     const int VK_LEFT = 0x25; 

     public MainWindow() 
     { 
      this.InitializeComponent(); 

      ComponentDispatcher.ThreadPreprocessMessage += 
       ComponentDispatcher_ThreadPreprocessMessage; 
     } 

     void ComponentDispatcher_ThreadPreprocessMessage(
      ref MSG msg, ref bool handled) 
     { 
      if (msg.message == WM_KEYUP) 
      { 
       if ((int)msg.wParam == VK_RETURN) 
        MessageBox.Show("RETURN was pressed"); 

       if ((int)msg.wParam == VK_LEFT) 
        MessageBox.Show("LEFT was pressed"); 
      } 
     } 
    } 
} 

Answer 7

Ésta es una solución completa de trabajo, creo que sirve ...

Uso:

_hotKey = new HotKey(Key.F9, KeyModifier.Shift | KeyModifier.Win, OnHotKeyHandler); 

...

private void OnHotKeyHandler(HotKey hotKey) 
{ 
    SystemHelper.SetScreenSaverRunning(); 
} 

Clase:

using System; 
using System.Collections.Generic; 
using System.Diagnostics; 
using System.Linq; 
using System.Net.Mime; 
using System.Runtime.InteropServices; 
using System.Text; 
using System.Windows; 
using System.Windows.Input; 
using System.Windows.Interop; 

namespace UnManaged 
{ 
    public class HotKey : IDisposable 
    { 
     private static Dictionary<int, HotKey> _dictHotKeyToCalBackProc; 

     [DllImport("user32.dll")] 
     private static extern bool RegisterHotKey(IntPtr hWnd, int id, UInt32 fsModifiers, UInt32 vlc); 

     [DllImport("user32.dll")] 
     private static extern bool UnregisterHotKey(IntPtr hWnd, int id); 

     public const int WmHotKey = 0x0312; 

     private bool _disposed = false; 

     public Key Key { get; private set; } 
     public KeyModifier KeyModifiers { get; private set; } 
     public Action<HotKey> Action { get; private set; } 
     public int Id { get; set; } 

     // ****************************************************************** 
     public HotKey(Key k, KeyModifier keyModifiers, Action<HotKey> action, bool register = true) 
     { 
      Key = k; 
      KeyModifiers = keyModifiers; 
      Action = action; 
      if (register) 
      { 
       Register(); 
      } 
     } 

     // ****************************************************************** 
     public bool Register() 
     { 
      int virtualKeyCode = KeyInterop.VirtualKeyFromKey(Key); 
      Id = virtualKeyCode + ((int)KeyModifiers * 0x10000); 
      bool result = RegisterHotKey(IntPtr.Zero, Id, (UInt32)KeyModifiers, (UInt32)virtualKeyCode); 

      if (_dictHotKeyToCalBackProc == null) 
      { 
       _dictHotKeyToCalBackProc = new Dictionary<int, HotKey>(); 
       ComponentDispatcher.ThreadFilterMessage += new ThreadMessageEventHandler(ComponentDispatcherThreadFilterMessage); 
      } 

      _dictHotKeyToCalBackProc.Add(Id, this); 

      Debug.Print(result.ToString() + ", " + Id + ", " + virtualKeyCode); 
      return result; 
     } 

     // ****************************************************************** 
     public void Unregister() 
     { 
      HotKey hotKey; 
      if (_dictHotKeyToCalBackProc.TryGetValue(Id, out hotKey)) 
      { 
       UnregisterHotKey(IntPtr.Zero, Id); 
      } 
     } 

     // ****************************************************************** 
     private static void ComponentDispatcherThreadFilterMessage(ref MSG msg, ref bool handled) 
     { 
      if (!handled) 
      { 
       if (msg.message == WmHotKey) 
       { 
        HotKey hotKey; 

        if (_dictHotKeyToCalBackProc.TryGetValue((int)msg.wParam, out hotKey)) 
        { 
         if (hotKey.Action != null) 
         { 
          hotKey.Action.Invoke(hotKey); 
         } 
         handled = true; 
        } 
       } 
      } 
     } 

     // ****************************************************************** 
     // Implement IDisposable. 
     // Do not make this method virtual. 
     // A derived class should not be able to override this method. 
     public void Dispose() 
     { 
      Dispose(true); 
      // This object will be cleaned up by the Dispose method. 
      // Therefore, you should call GC.SupressFinalize to 
      // take this object off the finalization queue 
      // and prevent finalization code for this object 
      // from executing a second time. 
      GC.SuppressFinalize(this); 
     } 

     // ****************************************************************** 
     // Dispose(bool disposing) executes in two distinct scenarios. 
     // If disposing equals true, the method has been called directly 
     // or indirectly by a user's code. Managed and unmanaged resources 
     // can be _disposed. 
     // If disposing equals false, the method has been called by the 
     // runtime from inside the finalizer and you should not reference 
     // other objects. Only unmanaged resources can be _disposed. 
     protected virtual void Dispose(bool disposing) 
     { 
      // Check to see if Dispose has already been called. 
      if (!this._disposed) 
      { 
       // If disposing equals true, dispose all managed 
       // and unmanaged resources. 
       if (disposing) 
       { 
        // Dispose managed resources. 
        Unregister(); 
       } 

       // Note disposing has been done. 
       _disposed = true; 
      } 
     } 
    } 

    // ****************************************************************** 
    [Flags] 
    public enum KeyModifier 
    { 
     None = 0x0000, 
     Alt = 0x0001, 
     Ctrl = 0x0002, 
     NoRepeat = 0x4000, 
     Shift = 0x0004, 
     Win = 0x0008 
    } 

    // ****************************************************************** 
} 

Answer 8

He encontrado el proyecto Global Hotkeys in WPF en codeproject.com que hace el trabajo por mí. Es relativamente reciente, no necesita una referencia a System.Windows.Forms y funciona "globalmente" en términos de reacción a la tecla presionada incluso si "tu" aplicación no es la ventana activa.

Answer 9

El registro de los accesos directos de nivel de sistema operativo casi nunca es algo bueno: los usuarios no quieren que se meta con su sistema operativo.

Dicho esto, hay una manera mucho más simple y fácil de usar para hacer esto en WPF, si estás bien con la tecla de acceso directo a trabajar dentro de la aplicación única (es decir, el tiempo que su aplicación WPF tiene el foco):

En App.xaml.cs:

protected override void OnStartup(StartupEventArgs e) 
{ 
    EventManager.RegisterClassHandler(typeof(Window), Window.PreviewKeyUpEvent, new KeyEventHandler(OnWindowKeyUp)); 
} 

private void OnWindowKeyUp(object source, KeyEventArgs e)) 
{ 
    //Do whatever you like with e.Key and Keyboard.Modifiers 
} 

Es mejor funciona así de simple solución

Answer 10

de babuino, ya que puede tener múltiples ventanas. Lo modifiqué para que use PreviewKeyDownEvent en lugar de PreviewKeyUpEvent para manejar la repetición con las teclas.

Recomendaría en contra del registro a nivel del sistema operativo a menos que esté escribiendo algo así como una herramienta de recorte o una aplicación de grabación de audio, ya que le permitirá acceder a la funcionalidad cuando la ventana no esté enfocada.

Answer 11

Esto es similar a las respuestas ya dadas, pero me resulta un poco más limpia:

using System; 
using System.Windows.Forms; 

namespace GlobalHotkeyExampleForm 
{ 
    public partial class ExampleForm : Form 
    { 
     [System.Runtime.InteropServices.DllImport("user32.dll")] 
     private static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vk); 
     [System.Runtime.InteropServices.DllImport("user32.dll")] 
     private static extern bool UnregisterHotKey(IntPtr hWnd, int id); 

     enum KeyModifier 
     { 
      None = 0, 
      Alt = 1, 
      Control = 2, 
      Shift = 4, 
      WinKey = 8 
     } 

     public ExampleForm() 
     { 
      InitializeComponent(); 

      int id = 0;  // The id of the hotkey. 
      RegisterHotKey(this.Handle, id, (int)KeyModifier.Shift, Keys.A.GetHashCode());  // Register Shift + A as global hotkey. 
     } 

     protected override void WndProc(ref Message m) 
     { 
      base.WndProc(ref m); 

      if (m.Msg == 0x0312) 
      { 
       /* Note that the three lines below are not needed if you only want to register one hotkey. 
       * The below lines are useful in case you want to register multiple keys, which you can use a switch with the id as argument, or if you want to know which key/modifier was pressed for some particular reason. */ 

       Keys key = (Keys)(((int)m.LParam >> 16) & 0xFFFF);     // The key of the hotkey that was pressed. 
       KeyModifier modifier = (KeyModifier)((int)m.LParam & 0xFFFF);  // The modifier of the hotkey that was pressed. 
       int id = m.WParam.ToInt32();          // The id of the hotkey that was pressed. 


       MessageBox.Show("Hotkey has been pressed!"); 
       // do something 
      } 
     } 

     private void ExampleForm_FormClosing(object sender, FormClosingEventArgs e) 
     { 
      UnregisterHotKey(this.Handle, 0);  // Unregister hotkey with id 0 before closing the form. You might want to call this more than once with different id values if you are planning to register more than one hotkey. 
     } 
    } 
} 

lo he encontrado en fluxbytes.com.