Métodos abreviados de teclado en WPF

Question

Sé acerca de usar _ en lugar de &, lo que estoy viendo es todos los Ctrl + accesos directos de tipo.

Ctrl +Z para deshacer, Ctrl +S para salvar etc.

¿Hay una manera 'estándar' para la implementación de estos en las aplicaciones de WPF? ¿O se trata de un rollo propio y conectarlos a cualquier comando/control?

Answer 1

Entiendo que la forma estándar es crear Comandos y luego agregar sus teclas de método abreviado como InputGestures. Esto permite que las teclas de método abreviado funcionen incluso si no están conectadas a ningún control. Y dado que los elementos del menú comprenden los gestos del teclado, mostrarán automáticamente su tecla de acceso directo en el texto de los elementos del menú, si lo conecta con su elemento de menú.

A. Crear atributo estático para tener mando (preferiblemente como una propiedad de la clase estática se crea para los comandos - pero por ejemplo sencillo, simplemente usando el atributo estático en Cs ventana):

public static RoutedCommand MyCommand = new RoutedCommand(); 

B. Añadir el tecla de acceso directo (s) que debe invocar el método:

MyCommand.InputGestures.Add(new KeyGesture(Key.S , ModifierKeys.Control)); 

C. comando Crear enlace que apunta a su método a llamar a ejecutar, poner estos en los enlaces de comandos para el elemento de la interfaz de usuario en las que debe trabajar para (por ejemplo, , la ventana) & el método:

<Window.CommandBindings> 
    <CommandBinding Command="{x:Static local:MyWindow.MyCommand}" Executed="MyCommandExecuted"/> 
</Window.CommandBindings> 

private void MyCommandExecuted(object sender, ExecutedRoutedEventArgs e) { ... } 

Answer 2

Depende de dónde desee utilizarlos. TextBoxBase controles derivados ya implementan esos accesos directos. Si desea utilizar atajos de teclado personalizados, debe echar un vistazo a los comandos y gestos de entrada. Aquí hay un pequeño tutorial de Cambiar el Código: WPF Tutorial - Command Bindings and Custom Commands

Espero que esto ayude.

Answer 3

Me pareció que esto era exactamente lo que estaba buscando relacionado con el enlace de claves en WPF.

<Window.InputBindings> 
     <KeyBinding Modifiers="Control" 
        Key="N" 
        Command="{Binding CreateCustomerCommand}" /> 
</Window.InputBindings> 

http://joyfulwpf.blogspot.com/2009/05/mvvm-commandreference-and-keybinding.html

Answer 4

VB.Net:

Public Shared SaveCommand_AltS As New RoutedCommand 

Dentro evento cargado:

SaveCommand_AltS.InputGestures.Add(New KeyGesture(Key.S, ModifierKeys.Control)) 

Me.CommandBindings.Add(New CommandBinding(SaveCommand_AltS, AddressOf Me.save)) 

Sin xaml necesario.

Espero que esto ayude.

Answer 5

cómo asociar el comando con un MenuItem:

<MenuItem Header="My command" Command="{x:Static local:MyWindow.MyCommand}"/> 

Answer 6

probar este Código ...

En primer lugar crear un objeto RoutedComand

RoutedCommand newCmd = new RoutedCommand(); 
    newCmd.InputGestures.Add(new KeyGesture(Key.N, ModifierKeys.Control)); 
    CommandBindings.Add(new CommandBinding(newCmd, btnNew_Click)); 

Answer 7

La documentación de esta respuesta para los demás, ya que hay una manera mucho más simple de hacer esto que pocas veces se hace referencia, y no necesita tocar el XAML en absoluto.

Para vincular un atajo de teclado, en el constructor de Windows simplemente agregue un nuevo enlace de clave a la colección InputBindings. Como comando, pase su clase de comando arbitraria que implementa ICommand. Para el método de ejecución, simplemente implemente la lógica que necesite. En mi ejemplo a continuación, mi clase de WindowCommand toma un delegado que ejecutará siempre que se invoque. Cuando construyo el nuevo WindowCommand para pasar con mi enlace, simplemente indico en mi inicializador, el método que quiero que WindowCommand ejecute.

Puede usar este patrón para crear sus propios atajos rápidos de teclado.

public YourWindow() //inside any WPF Window constructor 
{ 
    ... 
    //add this one statement to bind a new keyboard command shortcut 
    InputBindings.Add(new KeyBinding(//add a new key-binding, and pass in your command object instance which contains the Execute method which WPF will execute 
     new WindowCommand(this) 
     { 
     ExecuteDelegate = TogglePause //REPLACE TogglePause with your method delegate 
     }, new KeyGesture(Key.P, ModifierKeys.Control))); 
    ... 
} 

Crea una clase simple de WindowCommand que toma un delegado de ejecución para disparar cualquier método establecido en él.

public class WindowCommand : ICommand 
{ 
    private MainWindow _window; 

    //Set this delegate when you initialize a new object. This is the method the command will execute. You can also change this delegate type if you need to. 
    public Action ExecuteDelegate { get; set; } 

    //You don't have to add a parameter that takes a constructor. I've just added one in case I need access to the window directly. 
    public WindowCommand(MainWindow window) 
    { 
     _window = window; 
    } 

    //always called before executing the command, mine just always returns true 
    public bool CanExecute(object parameter) 
    { 
     return true; //mine always returns true, yours can use a new CanExecute delegate, or add custom logic to this method instead. 
    } 

    public event EventHandler CanExecuteChanged; //i'm not using this, but it's required by the interface 

    //the important method that executes the actual command logic 
    public void Execute(object parameter) 
    { 
     if (ExecuteDelegate != null) 
     { 
      ExecuteDelegate(); 
     } 
     else 
     { 
      throw new InvalidOperationException(); 
     } 
    } 
} 

Answer 8

tuve un problema similar, y se encontró respuesta de @ Aliwa a ser la solución más útil y más elegante; sin embargo, necesitaba una combinación de teclas específica, Ctrl + 1. Por desgracia me dieron el siguiente error:

'1' cannot be used as a value for 'Key'. Numbers are not valid enumeration values.

Con un poco de la búsqueda, he modificado respuesta de @ Aliwa a lo siguiente:

<Window.InputBindings> 
    <KeyBinding Gesture="Ctrl+1" Command="{Binding MyCommand}"/> 
</Window.InputBindings> 

Me pareció que este es un gran trabajo para bastante bien cualquier combinación que necesitaba .