Wie wählen Sie Menüelemente Datei mithilfe der Tastatur in WPF und C#aus?

Question

Ich entwickle eine WPF -UI -Anwendung.

Ich habe ein Menü oben auf dem Bildschirm, in dem Dateien mit Hilfsmenuitems geholfen werden.

In Datei -> Backend -Funktionen (Abkürzungstaste ist Strg + B), beenden (Strg + x) Sub -Menüelemente.

Wenn Sie auf einen Sub -Menüelement klicken, wird das entsprechende Fenster geöffnet.

Wie kann das Fenster geöffnet werden?

Wie kann ich auch eine kleine Zeile unterhalb der "F" in der Datei anzeigen, damit das Dateimenü beim Drücken von Alt + F sichtbar ist.

Ich arbeite an WPF mit C#.

Answer 1

Sie möchten Icommand, Routeduicommand, InputgestureCollection und CommandManager untersuchen. Es funktioniert ein wenig mehr im Voraus Infrastruktur. Mit dem WPF -Befehlsmuster können Sie einen Befehl über das Hauptmenü, das Kontextmenü, die Schaltflächenklicks usw. freigeben /Deaktivieren Sie konsequent und fügen Sie eine weitere Indirektionschicht hinzu, um die Wiederholung der Code zu verringern.

Das folgende Beispiel ist in VB.NET (sorry, aber hoffentlich sollte es leicht zu übersetzen sein).

Implementieren Sie jede Ihrer erforderlichen Aktionen als Klasse, die Icommand implementiert:

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

Erstellen Sie eine Klasse, in der gemeinsame Instanzen jeder Ihrer Befehle gespeichert sind.

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

Jetzt können Sie in Ihrem XAML für Ihr Menü an diesen Befehl binden:

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

Dies ist ein bisschen mehr als die minimale Anforderung, Befehle zu verwenden, aber in einer einigermaßen großen Anwendung habe ich diese zusätzliche Infrastruktur ziemlich nützlich gefunden. Sobald die Befehle geschrieben und registriert sind, ist die Bindung an sie in einem XAML -Dokument trivial. Durch die Freigabe gemeinsamer Eigenschaften für jede Aktion über die MyCommands -Klasse können Sie bei Bedarf nur in Code auf die Befehle in Code zugreifen.

Answer 2

Um die kleine Zeile hinzuzufügen, die den Beschleuniger des Menüelements darstellt, verwenden Sie einen Unterstrich im XAML:

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

Was die Verknüpfungsschlüssel betrifft, empfehle ich zunächst, nicht zu verwenden Strg + X Für den Ausgang, da dies im Allgemeinen zum Schneiden verwendet wird. Normalerweise hat der Beenden keine Abkürzungstaste, sondern drückt aber Alt + F4 Das Hauptfenster hat den gleichen Einfluss.

In Bezug auf Ihre tatsächliche Frage haben Sie einige Optionen, aber für beide müssen Sie Befehle verwenden, um Ihre Menuitems zu verarbeiten als die Click Veranstaltung.

Die erste Möglichkeit besteht darin, eine festzulegen InputBinding Für jeden Abkürzungschlüssel. Es würde so etwas in Ihrem Hauptfenster getan werden:

Für die Command Das Attribut müssten einen Ausdruck angeben, der den Befehl für diese Verknüpfung darstellt (Sie würden dasselbe verwenden Command Beim Definieren der MenuItem, zu). Wenn Sie eine haben Commands Klasse, Sie könnten so etwas wie Folgendes tun:

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

Und dann in xaml:

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

Die andere Möglichkeit besteht darin, Ihren Befehl als zu definieren RoutedUICommand, und angeben eine InputGesture dafür. Dies wird sich um die Verkabelung des Verknüpfungsschlüssels für Sie kümmern.

Answer 3

Möglicherweise werfen Sie einen Blick auf die Verknüpfungsprobe des WPF Application Framework (WAF). Es ist ganz einfach zu verstehen.