Tangentbordsacceleratorer

Acceleratornycklar (eller tangentbordsacceleratorer) är kortkommandon som förbättrar användbarheten och tillgängligheten för dina Windows-program genom att tillhandahålla ett intuitivt sätt för användare att anropa vanliga åtgärder eller kommandon utan att navigera i appens användargränssnitt.

Anmärkning

Ett tangentbord är oumbärligt för användare med vissa funktionshinder (se Tangentbordstillgänglighet) och är också ett viktigt verktyg för användare som föredrar det som ett effektivare sätt att interagera med en app.

Mer information om hur du navigerar i användargränssnittet för ett Windows-program med kortkommandon finns i avsnittet Åtkomstnycklar .

Information om hur du skapar egna anpassade kortkommandon finns i avsnittet Tangentbordshändelser .

Översikt

Acceleratorer består av två typer av nycklar: modifierare och icke-modifierare. Modifierarnycklar inkluderar Skift, Meny, Kontroll och Windows-nyckeln, som exponeras via VirtualKeyModifiers. Icke-modifikatorer inkluderar alla VirtualKey, till exempel Ta bort, F3, Blanksteg, piltangenter, Esc och alla alfanumeriska tangenter och skiljeteckenstangenter.

Anmärkning

Acceleratorer inkluderar vanligtvis funktionsnycklarna F1 till F12 eller någon kombination av en standardnyckel i par med en eller flera modifierarnycklar (CTRL, Skift). Om en användare till exempel trycker på Ctrl+Skift+M kontrollerar ramverket modifierarna (Ctrl och Skift) och utlöser acceleratorn om den finns.

Många XAML-kontroller har inbyggda tangentbordsacceleratorer. ListView har till exempel stöd för Ctrl+A för att markera alla objekt i listan, och RichEditBox stöder Ctrl+Tabb för att infoga en flik i textrutan. Dessa inbyggda tangentbordsacceleratorer kallas för kontrollacceleratorer och körs endast om fokus ligger på elementet eller något av dess underordnade objekt. Acceleratorer som definieras av dig med hjälp av API:erna för tangentbordsacceleratorer som beskrivs här kallas appacceleratorer.

Tangentbordsacceleratorer är inte tillgängliga för varje åtgärd, men är ofta associerade med kommandon som exponeras i menyer (och bör anges med menyalternativets innehåll). Acceleratorer kan också associeras med åtgärder som inte har motsvarande menyalternativ. Men eftersom användarna förlitar sig på ett programs menyer för att identifiera och lära sig den tillgängliga kommandouppsättningen bör du försöka göra identifieringen av acceleratorer så enkel som möjligt (med hjälp av etiketter eller etablerade mönster kan du hjälpa till med detta).

En accelerator upprepas automatiskt (till exempel när användaren trycker på Ctrl + skift och sedan håller ned M, anropas acceleratorn upprepade gånger tills M släpps). Det går inte att ändra det här beteendet.

Tangentbordsacceleratorer som beskrivs i en menyobjektetikett

När tangentbordsacceleratorer ska användas

Vi rekommenderar att du anger tangentbordsacceleratorer när det är lämpligt i användargränssnittet och stöder acceleratorer i alla anpassade kontroller.

• Tangentbordsacceleratorer gör din app mer tillgänglig för användare med motoriska funktionshinder, inklusive de användare som bara kan trycka på en tangent i taget eller har svårt att använda en mus.

  Ett väldesignad tangentbordsgränssnitt är en viktig aspekt av programvarans tillgänglighet. Det gör det möjligt för användare med nedsatt syn eller som har vissa motoriska funktionshinder att navigera i en app och interagera med dess funktioner. Sådana användare kanske inte kan använda en mus och förlitar sig i stället på olika hjälpmedel såsom verktyg för tangentbordsförbättring, tangentbord på skärmen, skärmförstorare, skärmläsare och verktyg för röstinmatning. För dessa användare är omfattande kommandotäckning avgörande.

• Tangentbordsacceleratorer gör appen mer användbar för power-användare som föredrar att interagera via tangentbordet.

  Erfarna användare har ofta en stark inställning för att använda tangentbordet eftersom tangentbordsbaserade kommandon kan anges snabbare och inte kräver att de tar bort händerna från tangentbordet. För dessa användare är effektivitet och konsekvens avgörande; omfattningen är enbart viktig för de kommandon som används oftast.

Ange en tangentbordsaccelerator

Använd API:er för KeyboardAccelerator för att skapa tangentbordsacceleratorer i Windows-appar. Med dessa API:er behöver du inte hantera flera KeyDown-händelser för att identifiera tangentkombinationen som trycks ned och du kan lokalisera acceleratorer i appresurserna.

Vi rekommenderar att du anger tangentbordsacceleratorer för de vanligaste åtgärderna i appen och dokumenterar dem med hjälp av menyalternativets etikett eller knappbeskrivning. I det här exemplet deklarerar vi endast tangentbordsacceleratorer för kommandona Byt namn och Kopiera.

<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>

Tangentbordsaccelerator som beskrivs i ett verktygstips

UIElement-objektet har en KeyboardAccelerator-samling, KeyboardAccelerators, där du anger dina anpassade KeyboardAccelerator-objekt och definierar tangenttryckningarna för tangentbordsacceleratorn:

• Key – VirtualKey som används för tangentbordsacceleratorn.

• Modifierare – VirtualKeyModifiers som används för tangentbordsacceleratorn. Om modifierare inte har angetts är standardvärdet Ingen.

Anmärkning

Snabbacceleratorer (A, Delete, F2, Spacebar, Esc, Multimedia Key) och acceleratorer med flera nycklar (Ctrl+Skift+M) stöds. Virtuella Gamepad-nycklar stöds dock inte.

Avsiktsacceleratorer

Vissa acceleratorer fungerar bara i specifika omfång medan andra arbetar i hela appen.

Microsoft Outlook innehåller till exempel följande acceleratorer:

• Ctrl+B, Ctrl+I och ESC fungerar endast med omfånget för formuläret skicka e-post
• Ctrl+1 och Ctrl+2 fungerar i hela appen

Kontextmenyer

Snabbmenyåtgärder påverkar endast specifika områden eller element, till exempel de markerade tecknen i en textredigerare eller en låt i en spellista. Därför rekommenderar vi att du ställer in omfånget för tangentbordsacceleratorer för snabbmenyobjekt till förälderelementet i snabbmenyn.

Använd egenskapen ScopeOwner för att ange tangentbordsacceleratorns omfång. Den här koden visar hur du implementerar en snabbmeny på en ListView med begränsade tangentbordsacceleratorer:

<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>

Attributet ScopeOwner för elementet MenuFlyoutItem.KeyboardAccelerators markerar acceleratorn som begränsad i stället för global (standardvärdet är null eller globalt). Mer information finns i avsnittet Lösa acceleratorer senare i det här avsnittet.

Anropa en tangentbordsgenväg

KeyboardAccelerator-objektet använder UIA-kontrollmönstret (UI Automation) för att vidta åtgärder när en accelerator anropas.

UIA [kontrollmönster] exponerar vanliga kontrollfunktioner. Knappkontrollen implementerar till exempel mönstret Anropa kontroll för att stödja händelsen Klicka (vanligtvis anropas en kontroll genom att klicka, dubbelklicka eller trycka på Retur, en fördefinierad kortkommando eller någon annan kombination av tangenttryckningar). När en tangentbordsaccelerator används för att anropa en kontroll letar XAML-ramverket upp om kontrollen implementerar mönstret Anropa kontroll och i så fall aktiverar det (det är inte nödvändigt att lyssna efter händelsen KeyboardAcceleratorInvoked).

I följande exempel utlöser Control+S händelsen Klicka eftersom knappen implementerar mönstret Anropa.

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

Om ett element implementerar flera kontrollmönster kan bara ett aktiveras via en accelerator. Kontrollmönstren prioriteras enligt följande:

1. Anropa (knapp)
2. Växla (markera kryssruta)
3. Val (ListView)
4. Expandera/dölj (kombinationsruta)

Om ingen matchning identifieras är acceleratorn ogiltig och ett felsökningsmeddelande anges ("Inga automatiseringsmönster för den här komponenten hittades. Implementera allt önskat beteende i händelsen Anropad. Inställningen Hanterad till true i händelsehanteraren undertrycker det här meddelandet.")

Beteende för anpassad tangentbordsaccelerator

Den anropade händelsen för KeyboardAccelerator-objektet utlöses när acceleratorn körs. Händelseobjektet KeyboardAcceleratorInvokedEventArgs innehåller följande egenskaper:

• Hanterad (Boolean): Om detta är inställt på 'true' förhindrar du att händelsen utlöser kontrollmönstret och stoppar att acceleratorhändelser bubblar. Standardvärdet är falskt.
• Element (DependencyObject): Objektet som är associerat med acceleratorn.
• KeyboardAccelerator: Tangentbordsacceleratorn som används för att höja den anropade händelsen.

Här visar vi hur du definierar en samling tangentbordsacceleratorer för objekt i en ListView och hur du hanterar den anropade händelsen för varje accelerator.

<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;
}

Åsidosätt standardbeteende för tangentbord

Vissa kontroller, när de har fokus, stöder inbyggda tangentbordsacceleratorer som åsidosätter alla appdefinierade acceleratorer. När en textruta till exempel har fokus kopierar Control+C-acceleratorn endast den markerade texten (appdefinierade acceleratorer ignoreras och inga andra funktioner körs).

Även om vi inte rekommenderar att du åsidosätter standardkontrollbeteenden på grund av användarnas kunskaper och förväntningar, kan du åsidosätta en kontrolls inbyggda tangentbordsaccelerator. I följande exempel visas hur du åsidosätter Control+C-tangentbordsacceleratorn för en textruta via händelsehanteraren PreviewKeyDown :

 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;
    }
 }

Inaktivera en tangentbordsaccelerator

Om en kontroll är inaktiverad inaktiveras även den associerade acceleratorn. I följande exempel går det inte att anropa den associerade Control+A-acceleratorn eftersom egenskapen IsEnabled för ListView är inställd på false.

<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>

Föräldra- och barnkontroller kan dela samma accelerator. I det här fallet kan den överordnade kontrollen anropas även om det underordnade objektet har fokus och dess accelerator är inaktiverad.

Skärmläsare och tangentbordsacceleratorer

Skärmläsare såsom Narrator kan meddela användarna om tangentbordsacceleratorns tangentkombination. Som standard är detta varje modifierare (i uppräkningsordningen VirtualModifiers) följt av nyckeln (och avgränsad med "+"-tecken). Du kan anpassa detta via den associerade egenskapen AcceleratorKey i AutomationProperties. Om mer än en accelerator har angivits är det endast den första som meddelas.

I det här exemplet returnerar AutomationProperty.AcceleratorKey strängen "Control+Shift+A":

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

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

  </ListView.KeyboardAccelerators>

</ListView>   

Anmärkning

Inställningen AutomationProperties.AcceleratorKey aktiverar inte tangentbordsfunktioner, det anger bara för UIA-ramverket vilka nycklar som används.

Vanliga tangentbordsacceleratorer

Vi rekommenderar att du gör tangentbordsacceleratorer konsekventa i Windows-program.

Användare måste memorera tangentbordsacceleratorer och förvänta sig samma (eller liknande) resultat, men det kanske inte alltid är möjligt på grund av skillnader i funktionalitet mellan appar.

Redigering	Gemensam tangentbordsaccelerator
Börja redigeringsläge	Ctrl + E
Markera alla objekt i en fokuserad kontroll eller ett fönster	Ctrl + A
Sök och ersätt	Ctrl + H
Undo	Ctrl + Z
Upprepa	Ctrl + Y
Ta bort markeringen och kopiera den till urklipp	Ctrl + X
Kopiera markeringen till urklipp	Ctrl + C, Ctrl + Insert
Klistra in innehållet i urklipp	Ctrl + V, Skift + Infoga
Klistra in innehållet i urklipp (med alternativ)	Ctrl + Alt + V
Byt namn på ett objekt	F2
Lägga till ett nytt objekt	Ctrl + N
Lägg till ett nytt sekundärt objekt	Ctrl + Skift + N
Ta bort valt objekt (med möjlighet att ångra)	Del, Ctrl+D
Ta bort markerat objekt (utan att ångra)	Skift + Del
Djärv	Ctrl + B
Understrykning	Ctrl + U
Kursiv	Ctrl + I
Navigering
Hitta innehåll i en fokuserad kontroll eller ett fönster	Ctrl + F
Gå till nästa sökresultat	F3
Gå till nästa gränssnittsfönster	F6
Gå till föregående gränssnittsfönster	Skift + F6
Andra åtgärder
Lägg till favoriter	Ctrl + D
Uppdatera	F5 eller Ctrl + R
Zooma in	Ctrl + +
Zooma ut	Ctrl + -
Zooma till standardvyn	Ctrl + 0
Spara	Ctrl + S
Close	Ctrl + W
Trycka	Ctrl + P

Observera att vissa av kombinationerna inte är giltiga för lokaliserade versioner av Windows. I den spanska versionen av Windows används till exempel Ctrl+N för fetstil i stället för Ctrl+B. Vi rekommenderar att du tillhandahåller lokaliserade tangentbordsacceleratorer om appen är lokaliserad.

Användbarhetsfunktioner för tangentbordsacceleratorer

Tooltips

Eftersom tangentbordsacceleratorer vanligtvis inte beskrivs direkt i användargränssnittet för ditt Windows-program kan du förbättra identifieringen via knappbeskrivningar som visas automatiskt när användaren flyttar fokus till, trycker och håller ned eller hovrar muspekaren över en kontroll. Verktygsfältet kan identifiera om en kontroll har en associerad tangentbordsaccelerator och i så fall vad acceleratorkombinationen är.

Windows 10, version 1803 (april 2018 Update) och senare

När tangentbordsacceleratorer deklareras visas som standard alla kontroller (förutom MenuFlyoutItem och ToggleMenuFlyoutItem) motsvarande tangentkombinationer i en knappbeskrivning.

Anmärkning

Om en kontroll har mer än en definierad accelerator visas endast den första.

Kombination av acceleratornyckel i knappbeskrivning

För Button, AppBarButton och AppBarToggleButton-objekt läggs tangentbordsacceleratorn till i verktygstipsen från kontrollens standardinställning. För MenuFlyoutItem - och ToggleMenuFlyoutItem-objekt visas tangentbordsacceleratorn med utfällbar text.

Anmärkning

Om du anger ett verktygstips (se Knapp1 i följande exempel) åsidosätts det här beteendet.

<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>

Kombination av acceleratornyckel som läggs till i Knapps standardknappbeskrivning

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

Acceleratortangentkombination läggs till i AppBarButtons standardverktygstips

<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>

Kombination av acceleratornyckel som läggs till i MenuFlyoutItems text

Kontrollera presentationsbeteendet med hjälp av egenskapen KeyboardAcceleratorPlacementMode , som accepterar två värden: Auto eller Hidden.

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

I vissa fall kan du behöva presentera ett verktygstips i förhållande till ett annat element (vanligtvis ett containerobjekt).

Här visar vi hur du använder egenskapen KeyboardAcceleratorPlacementTarget för att visa tangentbordsacceleratorns tangentkombination för en Spara-knapp med hjälp av Grid-containern istället för på knappen.

<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>

Etiketter

I vissa fall rekommenderar vi att du använder en kontrolls etikett för att identifiera om kontrollen har en associerad tangentbordsaccelerator och i så fall vad acceleratorns tangentkombination är.

Vissa plattformskontroller gör detta som standard, särskilt MenuFlyoutItem - och ToggleMenuFlyoutItem-objekten , medan AppBarButton och AppBarToggleButton gör det när de visas i spillmenyn i Kommandofältet.

Tangentbordsacceleratorer som beskrivs i en menyobjektetikett

Du kan åsidosätta standardacceleratortexten för etiketten via egenskapen KeyboardAcceleratorTextOverride för kontrollerna MenuFlyoutItem, ToggleMenuFlyoutItem, AppBarButton och AppBarToggleButton (använd ett enda blanksteg utan text).

Anmärkning

Åsidosättningstexten visas inte om systemet inte kan identifiera ett anslutet tangentbord (du kan kontrollera detta själv via egenskapen KeyboardPresent ).

Avancerade begrepp

Här granskar vi några lågnivåaspekter av tangentbordsacceleratorer.

Prioritet för indatahändelse

Indatahändelser inträffar i en specifik sekvens som du kan fånga upp och hantera baserat på kraven i din app.

KeyDown/KeyUp bubbling-händelsen

I XAML bearbetas en tangenttryckning som om det bara finns en bubbelpipeline för indata. Den här indatapipelinen används av KeyDown/KeyUp-händelser och teckenindata. Om ett element till exempel har fokus och användaren trycker ned en tangent, aktiveras en KeyDown-händelse på elementet, följt av elementets överordnade element och så vidare upp i trädet, tills egenskapen args.Handled är sann.

KeyDown-händelsen används också av vissa kontroller för att implementera de inbyggda kontrollacceleratorerna. När en kontroll har en tangentbordsaccelerator hanterar den KeyDown-händelsen, vilket innebär att keyDown-händelsen inte bubblar. RichEditBox stöder till exempel kopiering med Ctrl+C. När Ctrl trycks ned utlöses KeyDown-händelsen och bubblas, men när användaren trycker på C samtidigt markeras KeyDown-händelsen som Handled och sker inte (såvida inte parametern handledEventsToo för UIElement.AddHandler är inställd på true).

Händelsen CharacterReceived

När händelsen CharacterReceived utlöses efter KeyDown-händelsen för textkontroller, till exempel Textbox, kan du avbryta teckeninmatningen i KeyDown-händelsehanteraren.

PreviewKeyDown- och PreviewKeyUp-händelserna

Indatahändelserna för förhandsversionen utlöses före andra händelser. Om du inte hanterar dessa händelser utlöses acceleratorn för elementet som har fokus, följt av KeyDown-händelsen. Båda händelserna bubblar tills de hanteras.

Nyckelhändelsesekvens

Händelseordning:

Förhandsgranska KeyDown-händelser
…
Appaccelerator
OnKeyDown-metod
KeyDown-händelse
Appacceleratorer på moder
OnKeyDown-metod på det överordnade elementet
KeyDown-händelse på det överordnade elementet
(Bubblor till roten)
…
CharacterReceived-händelse
PreviewKeyUp-händelser
KeyUpEvents

När acceleratorhändelsen hanteras markeras även KeyDown-händelsen som hanterad. KeyUp-händelsen förblir ohanterad.

Felsökning av acceleratorer

En tangentbordsacceleratorhändelse bubblar från elementet som har fokus upp till roten. Om händelsen inte hanteras letar XAML-ramverket efter andra appacceleratorer utanför den bubblande sökvägen.

När två tangentbordsacceleratorer definieras med samma tangentkombination anropas den första tangentbordsacceleratorn som finns i det visuella trädet.

Begränsade tangentbordsacceleratorer anropas endast när fokus ligger inom ett specifikt omfång. I ett rutnät som innehåller dussintals kontroller kan till exempel en tangentbordsaccelerator anropas för en kontroll endast när fokus ligger inom rutnätet (omfångsägaren).

Omfångsacceleratorer programmatiskt

Metoden UIElement.TryInvokeKeyboardAccelerator anropar matchande acceleratorer i elementets underträd.

Metoden UIElement.OnProcessKeyboardAccelerators körs före tangentbordsacceleratorn. Den här metoden skickar ett ProcessKeyboardAcceleratorArgs-objekt som innehåller nyckeln, modifieraren och ett booleskt värde som anger om tangentbordsacceleratorn hanteras. Om den markeras som hanterad bubblar tangentbordsacceleratorn (så att den externa tangentbordsacceleratorn aldrig anropas).

Anmärkning

OnProcessKeyboardAccelerators utlöses alltid, oavsett om den hanteras eller inte (liknar händelsen OnKeyDown). Du måste kontrollera om händelsen har markerats som hanterad.

I det här exemplet använder vi OnProcessKeyboardAccelerators och TryInvokeKeyboardAccelerator för att begränsa tangentbordsacceleratorer till sidobjektet:

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

Lokalisera acceleratorerna

Vi rekommenderar att du lokaliserar alla tangentbordsacceleratorer. Du kan göra detta med standardresursfilen (.resw) och x:Uid-attributet i dina XAML-deklarationer. I det här exemplet läser Windows Runtime in resurserna automatiskt.

Tangentbordsacceleratorlokalisering med resursfilen

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

Anmärkning

Tangentbordsacceleratorer implementeras som virtuella nycklar. Lokaliserade acceleratorer måste väljas från den fördefinierade samlingen medVirtual-Key koder (annars uppstår ett XAML-parserfel).

Konfigurera en accelerator programmatiskt

Här är ett exempel på hur du programmatiskt definierar en accelerator:

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);
  }

Anmärkning

KeyboardAccelerator kan inte delas, samma KeyboardAccelerator kan inte läggas till i flera element.

Åsidosätt tangentbordsacceleratorbeteende

Du kan hantera händelsen KeyboardAccelerator.Invoked för att åsidosätta standardbeteendet för KeyboardAccelerator.

Det här exemplet visar hur du åsidosätter kommandot "Markera alla" (Ctrl+A tangentbordsaccelerator) i en anpassad ListView-kontroll. Vi ställer också in egenskapen Hanterad på true för att förhindra att händelsen bubblar vidare.

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;
    }
  }
  …
}

Relaterade artiklar

• tangentbordsinteraktioner
• Åtkomstnycklar
• VirtualKey-uppräkning

Samples

• WinUI-galleri