Come selezionare le voci del menu File utilizzando la tastiera in WPF e C #?

Question

Sto sviluppando un'applicazione UI WPF.

Ho un menu nella parte superiore dello schermo, che ha File, menu Aiuto.

Nel file - > Funzionalità di back-end (tasto di scelta rapida ctrl + B), voci di sottomenu Exit (Ctrl + x).

quando si fa clic su una voce di sottomenu, si apre la finestra corrispondente.

Quindi, senza usare il mouse, premendo ctrl + B o Ctrl + x, come si può aprire la finestra ??

Inoltre, come posso visualizzare una piccola riga sotto la " F " nel file in modo che quando l'utente preme Alt + F, il menu File dovrebbe essere visibile.

Sto lavorando su WPF usando C #.

Answer 1

Ti consigliamo di esaminare ICommand, RoutedUICommand, InputGestureCollection e CommandManager. Funziona un po 'più in anticipo dell'infrastruttura, ma il modello di comando WPF ti consente di condividere un comando tra menu principale, menu di scelta rapida, clic sui pulsanti, ecc. Con le tue azioni scritte come Comandi, tutti i luoghi nella tua applicazione che utilizzano il comando consentiranno / disabilita costantemente e aggiunge un ulteriore livello di riferimento indiretto per ridurre la ripetizione del codice.

Il seguente esempio è in VB.Net (scusate, ma spero che dovrebbe essere facile da tradurre).

Implementa ciascuna delle tue azioni richieste come una classe che implementa ICommand:

Public Class OpenWindowCommand
  Implements ICommand

  Public Function CanExecute(parameter as Object) As Boolean Implements System.Windows.Input.ICommand.CanExecute
    'enter code that determines whether this command should be enabled or not
    'if you are listening to some backend logic that changes this state, you can
    'raise a CanExecuteChanged event
  End Function

  Public Sub Execute(parameter as Object) Implements System.Windows.Input.ICommand.Execute
     'code that you want to run for the action
  End Sub
 End Class

Crea una classe che memorizza le istanze condivise di ciascuno dei tuoi comandi.

Public Class MyCommands
  Private Shared ReadyOnly openWindowCmd As ICommand = New OpenWindowCommand()
  Private Shared _openWindow as RoutedUICommand

  Shared Sub New()
    'static constructor
    Dim shortcut = New KeyGesture(Key.W, ModifierKeys.Control)
    RegisterCommand(_openWindow, "OpenWindow", "Open...", shortcut, AddressOf ExecuteOpenWindow, AddressOf CanExecuteOpenWindow)
    'add more commands as needed
  End Sub

  Private Shared Sub RegisterCommand(ByRef command as RoutedUICommand, ByVal name as String, ByVal text as String, ByVal gesture as KeyGesture, ByVal executeHandler as ExecutedRoutedEventHandler, ByVal canExecuteHandler as CanExecuteRoutedEventHandler)
    Dim inputs = New InputGestureCollection()
    If gesture IsNot Nothing Then inputs.Add(gesture)
    command = New RoutedUICommand(text, name, GetType(MyCommands), inputs)
    Dim binding = New CommandBinding(command, executeHandler, canExecuteHandler)
    Application.Current.MainWindow.CommandBindings.Add(binding)
    CommandManager.RegisterClassCommandBinding(GetType(Window),binding)
  End Sub

  Public Shared ReadOnly Property OpenWindow() as RoutedUICommand
    Get
      Return _openWindow
    End Get
  End Property
  Public Shared Sub ExecuteOpenWindow(sender as Object, e as ExecutedRoutedEventArgs)
    openCmd.Execute(e.Parameter)
  End Sub
  Public Shared Sub CanExecuteSave(sender as Object, e as CanExecuteRoutedEventArgs)
    e.CanExecute = openCmd.CanExecute(e.Parameter)
    e.Handled = True
  End Sub

End Class

Ora nella tua XAML per il tuo menu puoi associare questo comando:

<Window.Resources>
  <local:MyCommands x:Key="commands"/>
</Window.Resources>
...
<MenuItem Name="mnuOpenWindow" Command="{Binding Path=OpenWindow}"/>

Questo è un po 'più del requisito minimo per usare i Comandi, ma in un'applicazione ragionevolmente grande ho trovato questa infrastruttura aggiuntiva piuttosto utile. Una volta che i comandi sono stati scritti e registrati, legarli ad essi in qualsiasi documento XAML è banale ed esponendo le proprietà condivise per ogni azione attraverso la classe MyCommands è possibile accedere ai comandi puramente nel codice, se necessario.

Answer 2

Per aggiungere la piccola riga che rappresenta l'acceleratore della voce di menu, utilizzare un trattino basso in XAML:

<MenuItem Header="_File">
    <MenuItem Header="_Backend Features" />
    <MenuItem Header="E_xit" />
</MenuItem>

Per quanto riguarda i tasti di scelta rapida, prima di tutto consiglierei di non usare Ctrl + X per Exit, poiché generalmente viene usato per Cut. Normalmente exit non ha un tasto di scelta rapida, ma premere Alt + F4 per chiudere la finestra principale avrà lo stesso effetto.

Per quanto riguarda la tua vera domanda, hai un paio di opzioni, ma per entrambi devi usare i Comandi per implementare gestire i tuoi MenuItems piuttosto che l'evento Click .

La prima opzione è impostare un InputBinding per ciascun tasto di scelta rapida. Si farebbe qualcosa del genere sulla finestra principale:                   

Per l'attributo Command , dovresti specificare un'espressione che rappresenti il ??comando per quel collegamento (per definire il Command > MenuItem , anche). Se hai una classe Comandi , potresti fare qualcosa del tipo:

static class Commands
{
    public static ICommand BackendFeaturesCommand = ...;
}

E poi in XAML:

<KeyBinding Key="B" Modifiers="Control"
    Command="{x:Static Commands.BackendFeaturesCommand}" />

L'altra opzione è definire il comando come RoutedUICommand e specifica un InputGesture . Questo si occuperà del cablaggio del tasto di scelta rapida per te.

Answer 3

Potresti dare un'occhiata all'esempio ShortCutKey del WPF Application Framework (WAF) . È abbastanza semplice da capire.