Tastaturbeschleuniger

Zugriffstasten (oder Tastaturkürzel) sind Tastenkombinationen, die die Benutzerfreundlichkeit und Barrierefreiheit Ihrer Windows-Anwendungen verbessern, indem sie Benutzern eine intuitive Möglichkeit bieten, allgemeine Aktionen oder Befehle auszuführen, ohne durch die Benutzeroberfläche der App zu navigieren.

Details zum Navigieren in der Benutzeroberfläche einer Windows-Anwendung mit Tastenkombinationen finden Sie im Thema Access keys.

Informationen zum Erstellen eigener benutzerdefinierter Tastenkombinationen finden Sie im Thema " Tastaturereignisse" .

Überblick

Zugriffstasten bestehen aus zwei Arten von Tasten: Modifizierer und Nichtmodifizierer. Modifiziertasten umfassen die Umschalttaste, die Menütaste, die Strg-Taste und die Windows-Taste, die über VirtualKeyModifiers verfügbar gemacht werden. Nichtmodifizierer schließen jeden VirtualKey ein, wie Delete, F3, Leertaste, Pfeiltasten, Esc und alle alphanumerischen sowie Satzzeichen-Tasten.

Viele XAML-Steuerelemente verfügen über integrierte Tastenkürzel. Beispielsweise unterstützt ListView STRG+A zum Auswählen aller Elemente in der Liste, und RichEditBox unterstützt STRG+TAB zum Einfügen einer Registerkarte in das Textfeld. Diese integrierten Tastenkürzel werden als Steuerungskombinationen bezeichnet und werden nur ausgeführt, wenn sich der Fokus auf dem Element oder einem seiner untergeordneten Elemente befindet. Von Ihnen mithilfe der hier beschriebenen Tastenkombinations-APIs definierte Beschleuniger werden als App-Beschleuniger bezeichnet.

Tastenkürzel sind nicht für jede Aktion verfügbar, sind aber häufig mit Befehlen verknüpft, die in Menüs verfügbar gemacht werden (und sollten mit dem Menüelementinhalt angegeben werden). Tastenkombinationen können auch Aktionen zugeordnet werden, die keinen entsprechenden Menüelementen zugeordnet sind. Da Benutzer jedoch auf die Menüs einer Anwendung angewiesen sind, um den verfügbaren Befehlssatz zu ermitteln und zu erlernen, sollten Sie versuchen, Tastenkombinationen so einfach wie möglich zu ermitteln (die Verwendung von Bezeichnungen oder etablierten Mustern kann ihnen dabei helfen).

Eine Tastenkombination wird automatisch wiederholt (z. B. wenn der Benutzer STRG+UMSCHALT drückt und dann M gedrückt hält, wird die Tastenkombination wiederholt aktiviert, bis M losgelassen wird). Dieses Verhalten kann nicht geändert werden.

Tastenkürzel, die in einer Menüelementbeschriftung beschrieben werden

Verwendung von Tastaturbeschleunigern

Es wird empfohlen, Tastenkürzel an beliebiger Stellen in der Benutzeroberfläche anzugeben und Tastenkombinationen in allen benutzerdefinierten Steuerelementen zu unterstützen.

• Tastaturkürzel verbessern die Zugänglichkeit Ihrer App für Benutzer mit motorischen Beeinträchtigungen, einschließlich derjenigen, die jeweils nur eine Taste drücken können oder Schwierigkeiten beim Nutzen einer Maus haben.

  Eine gut gestaltete Tastaturbenutzeroberfläche ist ein wichtiger Aspekt der Barrierefreiheit der Software. Sie ermöglicht Benutzern mit Sehbehinderungen oder mit bestimmten motorischen Behinderungen, in einer App zu navigieren und mit ihren Features zu interagieren. Solche Benutzer können möglicherweise keine Maus bedienen und verlassen sich stattdessen auf verschiedene Hilfstechnologien wie Tastaturerweiterungstools, Bildschirmtastaturen, Bildschirmvergrößerungsgeräte, Bildschirmsprachausgaben und Spracheingabeprogramme. Für diese Benutzer ist eine umfassende Befehlsabdeckung von entscheidender Bedeutung.

• Tastenkürzel machen Ihre App für fortgeschrittene Benutzer benutzerfreundlicher, die lieber über die Tastatur interagieren.

  Erfahrene Benutzer haben häufig eine starke Vorliebe für die Verwendung der Tastatur, da tastaturbasierte Befehle schneller eingegeben werden können und sie nicht benötigen, um ihre Hände von der Tastatur zu entfernen. Für diese Nutzer sind Effizienz und Konsistenz von entscheidender Bedeutung; Vollständigkeit ist nur für die am häufigsten verwendeten Befehle wichtig.

Tastenkürzel festlegen

Verwenden Sie die KeyboardAccelerator-APIs, um Tastenkombinationen in Windows-Apps zu erstellen. Bei diesen APIs müssen Sie nicht mehrere KeyDown-Ereignisse behandeln, um die gedrückte Tastenkombination zu erkennen, und Sie können Tastenkürzel in den App-Ressourcen lokalisieren.

Es wird empfohlen, für die gängigsten Aktionen in Ihrer App Tastenkürzel festzulegen und diese mithilfe der Menüelementbeschriftung oder der QuickInfo zu dokumentieren. In diesem Beispiel definieren wir Tastenkürzel nur für die Befehle „Umbenennen“ und „Kopieren“.

<CommandBar Margin="0,200" AccessKey="M">
  <AppBarButton 
    Icon="Share" 
    Label="Share" 
    Click="OnShare" 
    AccessKey="S" />
  <AppBarButton 
    Icon="Copy" 
    Label="Copy" 
    ToolTipService.ToolTip="Copy (Ctrl+C)" 
    Click="OnCopy" 
    AccessKey="C">
    <AppBarButton.KeyboardAccelerators>
      <KeyboardAccelerator 
        Modifiers="Control" 
        Key="C" />
    </AppBarButton.KeyboardAccelerators>
  </AppBarButton>

  <AppBarButton 
    Icon="Delete" 
    Label="Delete" 
    Click="OnDelete" 
    AccessKey="D" />
  <AppBarSeparator/>
  <AppBarButton 
    Icon="Rename" 
    Label="Rename" 
    ToolTipService.ToolTip="Rename (F2)" 
    Click="OnRename" 
    AccessKey="R">
    <AppBarButton.KeyboardAccelerators>
      <KeyboardAccelerator 
        Modifiers="None" Key="F2" />
    </AppBarButton.KeyboardAccelerators>
  </AppBarButton>

  <AppBarButton 
    Icon="SelectAll" 
    Label="Select" 
    Click="OnSelect" 
    AccessKey="A" />
  
  <CommandBar.SecondaryCommands>
    <AppBarButton 
      Icon="OpenWith" 
      Label="Sources" 
      AccessKey="S">
      <AppBarButton.Flyout>
        <MenuFlyout>
          <ToggleMenuFlyoutItem Text="OneDrive" />
          <ToggleMenuFlyoutItem Text="Contacts" />
          <ToggleMenuFlyoutItem Text="Photos"/>
          <ToggleMenuFlyoutItem Text="Videos"/>
        </MenuFlyout>
      </AppBarButton.Flyout>
    </AppBarButton>
    <AppBarToggleButton 
      Icon="Save" 
      Label="Auto Save" 
      IsChecked="True" 
      AccessKey="A"/>
  </CommandBar.SecondaryCommands>

</CommandBar>

In einer QuickInfo beschriebene Tastenkürzel

Das UIElement-Objekt verfügt über eine KeyboardAccelerator-Auflistung , KeyboardAccelerators, in der Sie Ihre benutzerdefinierten KeyboardAccelerator-Objekte angeben und die Tastaturanschläge für die Zugriffstaste definieren:

• Taste – der VirtualKey, der für das Tastenkürzel verwendet wird.

• Modifizierer – die VirtualKeyModifiers, die für das Tastenkürzel verwendet werden. Wenn "Modifizierer" nicht festgelegt ist, lautet der Standardwert "None".

Bereichsgebundene Beschleuniger

Einige Tastenkombinationen funktionieren nur in bestimmten Bereichen, während andere anwendungsweit funktionieren.

Beispielsweise enthält Microsoft Outlook die folgenden Beschleuniger:

• STRG+B, STRG+I und ESC funktionieren nur im Bereich des Formulars "E-Mail senden"
• Strg+1 und STRG+2 funktionieren app-breit

Kontextmenüs

Kontextmenüaktionen wirken sich nur auf bestimmte Bereiche oder Elemente aus, z. B. die ausgewählten Zeichen in einem Text-Editor oder einen Song in einer Wiedergabeliste. Deshalb empfehlen wir, den Geltungsbereich der Tastenkürzel für Kontextmenüelemente auf das übergeordnete Element des Kontextmenüs festzulegen.

Verwenden Sie die ScopeOwner-Eigenschaft, um den Bereich des Tastenkürzels anzugeben. Dieser Code zeigt, wie Sie ein Kontextmenü in einer ListView mit bereichsspezifischen Tastaturbeschleunigern implementieren.

<ListView x:Name="MyList">
  <ListView.ContextFlyout>
    <MenuFlyout>
      <MenuFlyoutItem Text="Share" Icon="Share"/>
      <MenuFlyoutItem Text="Copy" Icon="Copy">
        <MenuFlyoutItem.KeyboardAccelerators>
          <KeyboardAccelerator 
            Modifiers="Control" 
            Key="C" 
            ScopeOwner="{x:Bind MyList }" />
        </MenuFlyoutItem.KeyboardAccelerators>
      </MenuFlyoutItem>
      
      <MenuFlyoutItem Text="Delete" Icon="Delete" />
      <MenuFlyoutSeparator />
      
      <MenuFlyoutItem Text="Rename">
        <MenuFlyoutItem.KeyboardAccelerators>
          <KeyboardAccelerator 
            Modifiers="None" 
            Key="F2" 
            ScopeOwner="{x:Bind MyList}" />
        </MenuFlyoutItem.KeyboardAccelerators>
      </MenuFlyoutItem>
      
      <MenuFlyoutItem Text="Select" />
    </MenuFlyout>
    
  </ListView.ContextFlyout>
    
  <ListViewItem>Track 1</ListViewItem>
  <ListViewItem>Alternative Track 1</ListViewItem>

</ListView>

Das ScopeOwner-Attribut des MenuFlyoutItem.KeyboardAccelerators-Elements kennzeichnet die Tastenkombination als bereichsbezogen statt als global (der Standardwert ist null oder global). Weitere Einzelheiten finden Sie im Abschnitt Auflösen von Tastenkombinationen später in diesem Thema.

Aufrufen eines Tastenkürzels

Das KeyboardAccelerator-Objekt nutzt das Benutzeroberflächenautomatisierung-Steuerelementmuster, um eine Aktion auszuführen, wenn ein Akzelerator aufgerufen wird.

Die UIA [Steuerelementmuster] machen allgemeine Steuerelementfunktionen verfügbar. Beispielsweise implementiert das Button-Steuerelement das Aufrufen-Steuerelementmuster, um das Click-Ereignis zu unterstützen (in der Regel wird ein Steuerelement aufgerufen, indem man klickt, doppelklickt oder die EINGABETASTE drückt, eine vordefinierte Tastenkombination oder eine andere Kombination von Tastenanschlägen). Wenn ein Tastenkürzel zum Aufrufen eines Steuerelements verwendet wird, überprüft das XAML-Framework, ob das Steuerelement das Aufrufsteuerungsmuster implementiert, und aktiviert es in diesem Fall (es ist nicht erforderlich, auf das KeyboardAcceleratorInvoked-Ereignis zu warten).

Im folgenden Beispiel löst CTRL+S das Click-Ereignis aus, da die Schaltfläche das Invoke-Muster implementiert.

<Button Content="Save" Click="OnSave">
  <Button.KeyboardAccelerators>
    <KeyboardAccelerator Key="S" Modifiers="Control" />
  </Button.KeyboardAccelerators>
</Button>

Wenn ein Element mehrere Steuerelementmuster implementiert, kann nur ein Element über eine Tastenkombination aktiviert werden. Die Steuerelementmuster werden wie folgt priorisiert:

1. Aufruf (Schaltfläche)
2. Ankreuzen (Kontrollkästchen)
3. Auswahl (ListView)
4. Erweitern/Reduzieren (ComboBox)

Wenn keine Übereinstimmung identifiziert wird, ist die Tastenkombination ungültig, und es wird eine Debugmeldung bereitgestellt („Es wurden keine Automatisierungsmuster für diese Komponente gefunden. Implementieren Sie alle gewünschten Verhaltensweisen im Invoked-Ereignis. Wenn ‚Handled‘ in Ihrem Ereignishandler auf ‚true‘ festgelegt wird, unterdrückt dies diese Meldung.“)

Verhalten benutzerdefinierter Tastenkürzel

Das Invoked-Ereignis des KeyboardAccelerator-Objekts wird ausgelöst, wenn die Tastenkombination ausgelöst wird. Das KeyboardAcceleratorInvokedEventArgs-Ereignisobjekt enthält die folgenden Eigenschaften:

• Handled (boolesch): Durch Festlegen auf „true“ wird verhindert, dass das Ereignis das Steuerungsmuster auslöst, und das „Bubbling“ von Tastenkombinationsereignissen wird unterbunden. Der Standardwert ist "false".
• Element (DependencyObject): Das Objekt, das mit dem Beschleuniger verknüpft ist.
• KeyboardAccelerator: Der Tastaturbeschleuniger, der zum Auslösen des Invoked-Ereignisses verwendet wird.

Hier zeigen wir, wie Sie eine Sammlung von Tastenkürzeln für Elemente in einer ListView definieren und wie das Invoked-Ereignis für jede Tastenkombination behandelt wird.

<ListView x:Name="MyListView">
  <ListView.KeyboardAccelerators>
    <KeyboardAccelerator Key="A" Modifiers="Control,Shift" Invoked="SelectAllInvoked" />
    <KeyboardAccelerator Key="F5" Invoked="RefreshInvoked"  />
  </ListView.KeyboardAccelerators>
</ListView>

void SelectAllInvoked(KeyboardAccelerator sender, KeyboardAcceleratorInvokedEventArgs args)
{
  MyListView.SelectAll();
  args.Handled = true;
}

void RefreshInvoked(KeyboardAccelerator sender, KeyboardAcceleratorInvokedEventArgs args)
{
  MyListView.SelectionMode = ListViewSelectionMode.None;
  MyListView.SelectionMode = ListViewSelectionMode.Multiple;
  args.Handled = true;
}

Außerkraftsetzen des Standardverhaltens der Tastatur

Einige Steuerelemente unterstützen integrierte Tastenkürzel, die alle App-definierten Tastenkombinationen außer Kraft setzen, wenn sie fokussiert sind. Wenn beispielsweise ein TextBox-Steuerelement den Fokus hat, kopiert die CTRL+C-Tastenkombination nur den aktuell ausgewählten Text (App-definierte Tastenkombinationen werden ignoriert und keine andere Funktionalität wird ausgeführt).

Obwohl wir aufgrund der Gewohnheiten und Erwartungen der Benutzer davon abraten, das Standardverhalten von Steuerelementen außer Kraft zu setzen, können Sie die vordefinierte Tastenkürzel eines Steuerelements außer Kraft setzen. Das folgende Beispiel zeigt, wie Sie das CTRL+C-Tastenkürzel für ein TextBox-Steuerelement über den PreviewKeyDown-Ereignishandler außer Kraft gesetzt wird:

 private void TextBlock_PreviewKeyDown(object sender, KeyRoutedEventArgs e)
 {
    var ctrlState = CoreWindow.GetForCurrentThread().GetKeyState(Windows.System.VirtualKey.Control);
    var isCtrlDown = ctrlState == CoreVirtualKeyStates.Down || ctrlState 
        ==  (CoreVirtualKeyStates.Down | CoreVirtualKeyStates.Locked);
    if (isCtrlDown && e.Key == Windows.System.VirtualKey.C)
    {
        // Your custom keyboard accelerator behavior.
        
        e.Handled = true;
    }
 }

Eine Zugriffstaste deaktivieren.

Wenn ein Steuerelement deaktiviert ist, ist auch die zugehörige Tastenkombination deaktiviert. Im folgenden Beispiel kann die zugeordnete Strg+A-Tastenkombination nicht verwendet werden, da die IsEnabled-Eigenschaft der ListView auf „false“ festgelegt ist.

<ListView >
  <ListView.KeyboardAccelerators>
    <KeyboardAccelerator Key="A"
      Modifiers="Control"
      Invoked="CustomListViewSelecAllInvoked" />
  </ListView.KeyboardAccelerators>
  
  <TextBox>
    <TextBox.KeyboardAccelerators>
      <KeyboardAccelerator 
        Key="A" 
        Modifiers="Control" 
        Invoked="CustomTextSelecAllInvoked" 
        IsEnabled="False" />
    </TextBox.KeyboardAccelerators>
  </TextBox>

<ListView>

Übergeordnete und untergeordnete Steuerelemente können dieselbe Tastenkombination gemeinsam nutzen. In diesem Fall kann das übergeordnete Steuerelement aktiviert werden, auch wenn das untergeordnete Steuerelement den Fokus hat und seine Tastenkombinationen deaktiviert ist.

Bildschirmleser und Tastenkürzel

Bildschirmleser wie die Sprachausgabe können den Benutzern die Tastenkombination für das Tastenkürzel ankündigen. Standardmäßig ist dies jeder Modifizierer (in der Enumerationsreihenfolge von VirtualModifiers) gefolgt von der Taste (und getrennt durch "+"-Zeichen). Sie können dies über die angefügte AcceleratorKey AutomationProperties-Eigenschaft anpassen. Wenn mehr als ein Beschleuniger angegeben ist, wird nur der erste angekündigt.

In diesem Beispiel gibt der AutomationProperty.AcceleratorKey die Zeichenfolge "Strg+Umschalt+A" zurück.

<ListView x:Name="MyListView">
  <ListView.KeyboardAccelerators>

    <KeyboardAccelerator 
      Key="A" 
      Modifiers="Control,Shift" 
      Invoked="CustomSelectAllInvoked" />
      
    <KeyboardAccelerator 
      Key="F5" 
      Modifiers="None" 
      Invoked="RefreshInvoked" />

  </ListView.KeyboardAccelerators>

</ListView>   

Allgemeine Tastenkürzel

Es wird empfohlen, Tastenkürzel für Windows-Anwendungen einheitlich zu gestalten.

Benutzer müssen Tastenkombinationen auswendig lernen und erwarten die gleichen (oder ähnlichen) Ergebnisse, dies ist jedoch aufgrund von Unterschieden in der Funktionalität über verschiedene Apps hinweg möglicherweise nicht immer möglich.

Beachten Sie, dass einige der Kombinationen für lokalisierte Versionen von Windows nicht gültig sind. In der spanischen Version von Windows wird z. B. STRG+N anstelle von STRG+B fett verwendet. Es wird empfohlen, lokalisierte Tastenkürzel bereitzustellen, wenn die App lokalisiert ist.

Nutzbarkeitsangebot für Tastenkürzel

QuickInfos

Da Tastenkürzel in der Regel nicht direkt in der Benutzeroberfläche Ihrer Windows-Anwendung beschrieben werden, können Sie die Auffindbarkeit durch QuickInfos verbessern, die automatisch angezeigt werden, wenn der Benutzer ein Steuerelement fokussiert, gedrückt hält oder den Mauszeiger darüber bewegt. Mit der QuickInfo kann ermittelt werden, ob ein Steuerelement über ein zugeordnetes Tastenkürzel verfügt und, wenn ja, welche Tastenkombination es ist.

Wenn Tastenkürzel definiert werden, zeigen standardmäßig alle Steuerelemente (außer MenuFlyoutItem und ToggleMenuFlyoutItem) die entsprechenden Tastenkombinationen in einer QuickInfo an.

Tastenkombination in QuickInfo

Für Button-, AppBarButton- und AppBarToggleButton-Objekte, das Tastenkürzel wird an die Standard-QuickInfo des Steuerelements angehängt. Bei MenuFlyoutItem- und ToggleMenuFlyoutItem-Objekte, das Tastenkürzel wird zusammen mit dem Popup-Text angezeigt.

<StackPanel x:Name="Container" Grid.Row="0" Background="AliceBlue">
    <Button Content="Button1" Margin="20"
            Click="OnSave" 
            KeyboardAcceleratorPlacementMode="Auto" 
            ToolTipService.ToolTip="Tooltip">
        <Button.KeyboardAccelerators>
            <KeyboardAccelerator  Key="A" Modifiers="Windows"/>
        </Button.KeyboardAccelerators>
    </Button>
    <Button Content="Button2"  Margin="20"
            Click="OnSave" 
            KeyboardAcceleratorPlacementMode="Auto">
        <Button.KeyboardAccelerators>
            <KeyboardAccelerator  Key="B" Modifiers="Windows"/>
        </Button.KeyboardAccelerators>
    </Button>
    <Button Content="Button3"  Margin="20"
            Click="OnSave" 
            KeyboardAcceleratorPlacementMode="Auto">
        <Button.KeyboardAccelerators>
            <KeyboardAccelerator  Key="C" Modifiers="Windows"/>
        </Button.KeyboardAccelerators>
    </Button>
</StackPanel>

Tastenkombination für Schnellzugriff, die der Standard-QuickInfo der Schaltfläche hinzugefügt wurde

<AppBarButton Icon="Save" Label="Save">
    <AppBarButton.KeyboardAccelerators>
        <KeyboardAccelerator Key="S" Modifiers="Control"/>
    </AppBarButton.KeyboardAccelerators>
</AppBarButton>

Zugriffstastenkombination, die an die Standard-QuickInfo von AppBarButton angefügt wurde

<AppBarButton AccessKey="R" Icon="Refresh" Label="Refresh" IsAccessKeyScope="True">
    <AppBarButton.Flyout>
        <MenuFlyout>
            <MenuFlyoutItem AccessKey="A" Icon="Refresh" Text="Refresh A">
                <MenuFlyoutItem.KeyboardAccelerators>
                    <KeyboardAccelerator Key="R" Modifiers="Control"/>
                </MenuFlyoutItem.KeyboardAccelerators>
            </MenuFlyoutItem>
            <MenuFlyoutItem AccessKey="B" Icon="Globe" Text="Refresh B" />
            <MenuFlyoutItem AccessKey="C" Icon="Globe" Text="Refresh C" />
            <MenuFlyoutItem AccessKey="D" Icon="Globe" Text="Refresh D" />
            <ToggleMenuFlyoutItem AccessKey="E" Icon="Globe" Text="ToggleMe">
                <MenuFlyoutItem.KeyboardAccelerators>
                    <KeyboardAccelerator Key="Q" Modifiers="Control"/>
                </MenuFlyoutItem.KeyboardAccelerators>
            </ToggleMenuFlyoutItem>
        </MenuFlyout>
    </AppBarButton.Flyout>
</AppBarButton>

Zugriffstastenkombination, die dem Text von MenuFlyoutItem angefügt ist

Steuern Sie das Präsentationsverhalten mithilfe der KeyboardAcceleratorPlacementMode-Eigenschaft , die zwei Werte akzeptiert: Auto oder Ausgeblendet.

<Button Content="Save" Click="OnSave" KeyboardAcceleratorPlacementMode="Auto">
    <Button.KeyboardAccelerators>
        <KeyboardAccelerator Key="S" Modifiers="Control" />
    </Button.KeyboardAccelerators>
</Button>

In einigen Fällen müssen Sie möglicherweise eine QuickInfo relativ zu einem anderen Element (in der Regel einem Containerobjekt) darstellen.

Hier wird gezeigt, wie Sie die KeyboardAcceleratorPlacementTarget-Eigenschaft verwenden, um die Tastenkombination für eine Schaltfläche "Speichern" mit dem Grid-Container anstelle der Schaltfläche anzuzeigen.

<Grid x:Name="Container" Padding="30">
  <Button Content="Save"
    Click="OnSave"
    KeyboardAcceleratorPlacementMode="Auto"
    KeyboardAcceleratorPlacementTarget="{x:Bind Container}">
    <Button.KeyboardAccelerators>
      <KeyboardAccelerator  Key="S" Modifiers="Control" />
    </Button.KeyboardAccelerators>
  </Button>
</Grid>

Labels

In einigen Fällen wird empfohlen, die Beschriftung eines Steuerelements zu verwenden, um zu ermitteln, ob das Steuerelement über ein zugeordnetes Tastenkürzel verfügt und wenn ja, was die Zugriffstastenkombination ist.

Einige Plattformsteuerelemente tun dies standardmäßig, insbesondere das MenuFlyoutItem - und ToggleMenuFlyoutItem-Objekt , während das AppBarButton - und das AppBarToggleButton-Objekt dies tun, wenn sie im Überlaufmenü der CommandBar angezeigt werden.

Tastenkürzel, die in einer Menüelementbeschriftung beschrieben werden

Sie können den standardmäßigen Tastenkürzeltext für die Beschriftung über die KeyboardAcceleratorTextOverride-Eigenschaft der MenuFlyoutItem-, ToggleMenuFlyoutItem-, AppBarButton- und AppBarToggleButton-Steuerelemente außer Kraft setzen (verwenden Sie ein einzelnes Leerzeichen ohne Text).

Erweiterte Konzepte

Hier werden einige Aspekte der Tastaturbeschleuniger auf niedriger Ebene überprüft.

Priorität des Eingabeereignisses

Eingabeereignisse treten in einer bestimmten Reihenfolge auf, die Sie basierend auf den Anforderungen Ihrer App abfangen und verarbeiten können.

Das KeyDown/KeyUp-Bubbling-Ereignis

In XAML wird ein Tastenanschlag so verarbeitet, als ob nur eine Eingabebubblingpipeline vorhanden ist. Diese Eingabepipeline wird von KeyDown-/KeyUp-Ereignissen und der Zeicheneingabe verwendet. Wenn beispielsweise ein Element den Fokus hat und der Benutzer eine Taste drückt, wird ein KeyDown-Ereignis für das Element ausgelöst, gefolgt vom übergeordneten Element und so weiter im Baum nach oben, bis die args.Handled-Eigenschaft wahr ist.

Das KeyDown-Ereignis wird auch von einigen Steuerelementen verwendet, um die integrierten Steuerungskombinationen zu implementieren. Wenn ein Steuerelement über ein Tastenkürzel verfügt, behandelt es das KeyDown-Ereignis, was bedeutet, dass kein KeyDown-Ereignis-Bubbling vorhanden ist. Beispielsweise unterstützt das RichEditBox das Kopieren mit Strg+C. Wenn die Strg-Taste gedrückt wird, wird das KeyDown-Ereignis ausgelöst und sprudelt, aber wenn der Benutzer gleichzeitig C drückt, wird das KeyDown-Ereignis als Handled markiert und nicht ausgelöst (es sei denn, der handledEventsToo-Parameter von UIElement.AddHandler ist auf „true“ festgelegt).

Das CharacterReceived-Ereignis

Wenn das CharacterReceived-Ereignis nach dem KeyDown-Ereignis für Textsteuerelemente wie TextBox ausgelöst wird, können Sie die Zeicheneingabe im KeyDown-Ereignishandler abbrechen.

Die PreviewKeyDown- und PreviewKeyUp-Ereignisse

Die Vorschaueingabeereignisse werden vor allen anderen Ereignissen ausgelöst. Wenn Sie diese Ereignisse nicht behandeln, wird die Zugriffstaste für das Element mit dem Fokus ausgelöst, gefolgt vom KeyDown-Ereignis. Beide Ereignisse sprudeln, bis sie behandelt werden.

Schlüsselereignisfolge

Reihenfolge der Ereignisse:

Vorschau von KeyDown-Ereignissen
…
App-Beschleuniger
OnKeyDown-Methode
KeyDown-Ereignis
App-Tastenkombinationen auf dem übergeordneten Element
OnKeyDown-Methode für das übergeordnete Element
KeyDown-Ereignis im übergeordneten Element
(Sprudelt bis zur Wurzel)
…
CharacterReceived-Ereignis
PreviewKeyUp-Ereignisse
KeyUp-Ereignisse (KeyUpEvents)

Wenn das Tastenkombinationsereignis behandelt wird, wird das KeyDown-Ereignis ebenfalls als behandelt markiert. Das KeyUp-Ereignis bleibt unbehandelt.

Auflösen von Beschleunigern

Ein Tastenkürzelereignis sprudelt vom fokussierten Element bis zur Wurzel. Wenn das Ereignis nicht behandelt wird, sucht das XAML-Framework nach anderen App-Tastenkombinationen ohne Bereich in der Nähe des Bubbling-Pfads.

Wenn zwei Tastenkürzel mit derselben Tastenkombination definiert sind, wird das erste im visuellen Baum gefundene Tastenkürzel aufgerufen.

Bereichsbezogene Tastenkürzel werden nur aufgerufen, wenn sich der Fokus innerhalb eines bestimmten Bereichs befindet. Beispielsweise kann in einem Raster, das Dutzende von Steuerelementen enthält, ein Tastenkürzel nur für ein Steuerelement aufgerufen werden, wenn sich der Fokus im Raster befindet (der Bereichsbesitzer).

Programmatische Bereichsbestimmung von Tastenkombinationen

Die UIElement.TryInvokeKeyboardAccelerator-Methode ruft alle übereinstimmenden Tastenkombinationen im Subbaum des Elements auf.

Die UIElement.OnProcessKeyboardAccelerators-Methode wird vor dem Tastenkürzel ausgeführt. Diese Methode übergibt ein ProcessKeyboardAcceleratorArgs-Objekt, das die Taste, den Modifizierer und einen booleschen Wert enthält, der angibt, ob die Zugriffstaste behandelt wird. Wenn sie als behandelt gekennzeichnet ist, sprudelt das Tastenkürzel (sodass das äußere Tastenkürzel nie aufgerufen wird).

In diesem Beispiel verwenden wir OnProcessKeyboardAccelerators und TryInvokeKeyboardAccelerator, um Tastenkürzel auf das Page-Objekt zu beschränken:

protected override void OnProcessKeyboardAccelerators(
  ProcessKeyboardAcceleratorArgs args)
{
  if(args.Handled != true)
  {
    this.TryInvokeKeyboardAccelerator(args);
    args.Handled = true;
  }
}

Lokalisieren der Beschleuniger

Es wird empfohlen, alle Tastenkürzel zu lokalisieren. Dazu können Sie die Standardressourcendatei (.resw) und das x:Uid-Attribut in Ihren XAML-Deklarationen verwenden. In diesem Beispiel lädt die Windows-Runtime die Ressourcen automatisch.

Lokalisierung von Tastenkürzeln mit der Ressourcendatei

<Button x:Uid="myButton" Click="OnSave">
  <Button.KeyboardAccelerators>
    <KeyboardAccelerator x:Uid="myKeyAccelerator" Modifiers="Control"/>
  </Button.KeyboardAccelerators>
</Button>

Programmgesteuertes Einrichten eines Beschleunigers

Hier ist ein Beispiel für die programmgesteuerte Definition einer Tastenkombination:

void AddAccelerator(
  VirtualKeyModifiers keyModifiers, 
  VirtualKey key, 
  TypedEventHandler<KeyboardAccelerator, KeyboardAcceleratorInvokedEventArgs> handler )
  {
    var accelerator = 
      new KeyboardAccelerator() 
      { 
        Modifiers = keyModifiers, Key = key
      };
    accelerator.Invoked += handler;
    this.KeyboardAccelerators.Add(accelerator);
  }

Außerkraftsetzen des Verhaltens von Tastenkürzeln

Sie können das KeyboardAccelerator.Invoked-Ereignis behandeln, um das Standardverhalten von KeyboardAccelerator außer Kraft zu setzen.

In diesem Beispiel wird gezeigt, wie Sie den Befehl "Alle auswählen" (STRG+A-Tastenkombination) in einem benutzerdefinierten ListView-Steuerelement außer Kraft setzen. Außerdem legen wir die Handled-Eigenschaft auf „true“ fest, um das weitere Bubbling des Ereignisses zu stoppen.

public class MyListView : ListView
{
  …
  protected override void OnKeyboardAcceleratorInvoked(KeyboardAcceleratorInvokedEventArgs args) 
  {
    if(args.Accelerator.Key == VirtualKey.A 
      && args.Accelerator.Modifiers == KeyboardModifiers.Control)
    {
      CustomSelectAll(TypeOfSelection.OnlyNumbers); 
      args.Handled = true;
    }
  }
  …
}

Verwandte Artikel

• Tastaturinteraktionen
• Zugriffsschlüssel
• VirtualKey Enum

Beispiele

• WinUI 3-Katalog