Billentyűzetgyorsítók

A gyorsítóbillentyűk (vagy billentyűzetgyorsítók) olyan billentyűparancsok, amelyek javítják a Windows-alkalmazások használhatóságát és akadálymentességét azáltal, hogy intuitív módot biztosítanak a felhasználók számára a gyakori műveletek vagy parancsok meghívására az alkalmazás felhasználói felületén való navigálás nélkül.

A Windows-alkalmazások felhasználói felületének billentyűparancsokkal való navigálásáról a Access billentyűk témakörben olvashat.

Saját egyéni billentyűparancsok létrehozásához tekintse meg a Billentyűzetesemények témakört .

Áttekintés

A gyorsítók kétféle kulcsból állnak: módosítókból és nem módosítókból. A módosító kulcsok közé tartozik a Shift, a Menu, a Control és a Windows billentyű, amelyek a VirtualKeyModifiers használatával érhetők el. A nem módosítók közé tartoznak a VirtualKey-kulcsok, például a Törlés, az F3, a Szóköz, a Nyíl, az Esc és az összes alfanumerikus és írásjeles kulcs.

Számos XAML-vezérlő beépített billentyűzetgyorsítókkal rendelkezik. A ListView például a Ctrl+A billentyűkombinációt támogatja a lista összes elemének kijelöléséhez, a RichEditBox pedig a Ctrl+Tab billentyűkombinációt támogatja a tabulátor beviteléhez a szövegmezőbe. Ezeket a beépített billentyűzetgyorsítókat vezérlőgyorsítóknak nevezzük, és csak akkor hajtják végre, ha a fókusz az elemre vagy valamelyik gyermekére összpontosít. Az itt tárgyalt billentyűzetgyorsító API-kat használó, Ön által definiált gyorsítókat alkalmazásgyorsítóknak nevezzük.

A billentyűzetgyorsítók nem minden művelethez érhetők el, de gyakran a menükben közzétett parancsokhoz vannak társítva (és meg kell adni a menüelem tartalmával). A gyorsítók olyan műveletekkel is társíthatók, amelyek nem rendelkeznek egyenértékű menüelemekkel. Mivel azonban a felhasználók az alkalmazás menüire támaszkodva derítik fel és tanulják meg a rendelkezésre álló parancskészletet, érdemes a lehető legegyszerűbben felderíteni a gyorsítókat (a címkék vagy a létrehozott minták használata segíthet ebben).

A gyorsító automatikusan ismétlődik (például ha a felhasználó lenyomja a Ctrl+Shift billentyűkombinációt, majd lenyomja az M billentyűkombinációt, a gyorsító többször is meg lesz hívva, amíg az M ki nem szabadul). Ez a viselkedés nem módosítható.

A menüelem címkéjében leírt billentyűzetgyorsítók

Mikor érdemes billentyűzetgyorsítókat használni?

Azt javasoljuk, hogy a felhasználói felületen szükség esetén adja meg a billentyűzetgyorsítókat, és minden egyéni vezérlőben támogassa a gyorsítókat.

• A billentyűzetgyorsítók akadálymentesebbé teszik az alkalmazást a mozgássérült felhasználók számára, beleértve azokat a felhasználókat is, akik egyszerre csak egy billentyűt tudnak lenyomni, vagy nehézséget okoznak az egér használata.

  A jól megtervezett billentyűzet felhasználói felülete fontos eleme a szoftveres akadálymentességnek. Lehetővé teszi a látássérült vagy bizonyos mozgássérült felhasználók számára, hogy navigáljanak egy alkalmazáson, és használják annak funkcióit. Előfordulhat, hogy az ilyen felhasználók nem tudnak egeret működtetni, és ehelyett különböző kisegítő technológiákra támaszkodnak, például a billentyűzetjavító eszközökre, a képernyő-billentyűzetekre, a képernyőnagyítókra, a képernyőolvasókra és a hangbeviteli segédprogramokra. Ezen felhasználók számára kulcsfontosságú az átfogó parancslefedettség.

• A billentyűzetgyorsítók segítségével az alkalmazás használhatóbbá teszi azokat a felhasználókat, akik szívesebben használják a billentyűzetet.

  A tapasztalt felhasználók gyakran előnyben részesítik a billentyűzet használatát, mivel a billentyűzetalapú parancsok gyorsabban beírhatók, és nem követelik meg tőlük, hogy eltávolítsák a kezüket a billentyűzetről. E felhasználók számára a hatékonyság és a konzisztencia kulcsfontosságú; az átfogóság csak a leggyakrabban használt parancsok esetében fontos.

Billentyűzetgyorsító megadása

A KeyboardAccelerator API-kkal billentyűzetgyorsítókat hozhat létre Windows-alkalmazásokban. Ezekkel az API-kkal nem kell több KeyDown-eseményt kezelnie a lenyomott billentyűkombináció észleléséhez, és honosíthatja a gyorsítókat az alkalmazás erőforrásaiban.

Javasoljuk, hogy állítsa be a billentyűzetgyorsítókat az alkalmazásban leggyakrabban használt műveletekhez, és dokumentálja őket a menüelem feliratával vagy elemleírásával. Ebben a példában csak az Átnevezés és másolás parancsokhoz deklaráljuk a billentyűzetgyorsítókat.

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

Elemleírásban leírt billentyűzetgyorsító

A UIElement objektumhoz tartozik egy KeyboardAccelerator gyűjtemény, a KeyboardAccelerators, ahol megadhatja az egyéni KeyboardAccelerator-objektumokat, és meghatározhatja a billentyűzetgyorsító billentyűleütéseit:

• Billentyű – a billentyűzetgyorsítóhoz használt VirtualKey .

• Módosítók – a billentyűzetgyorsítóhoz használt VirtualKeyModifiers . Ha a módosítók nincsenek beállítva, az alapértelmezett érték Nincs.

Szűkített hatókörű gyorsítók

Egyes gyorsítók csak meghatározott hatókörökben működnek, míg mások alkalmazásszintűek.

A Microsoft Outlook például a következő gyorsítókat tartalmazza:

• A Ctrl+B, a Ctrl+I és az ESC csak az e-mail-küldési űrlap hatókörén működik
• Ctrl+1 és Ctrl+2 munkaalkalmazás-szerte

Helyi menük

A helyi menüműveletek csak bizonyos területeket vagy elemeket érintenek, például egy szövegszerkesztő kijelölt karaktereit vagy egy lejátszási lista egy dalát. Ezért javasoljuk, hogy a helyi menüelemek billentyűzetgyorsítóinak hatókörét a helyi menü szülőjének adja meg.

A ScopeOwner tulajdonság használatával adja meg a billentyűzetgyorsító hatókörét. Ez a kód bemutatja, hogyan implementálhat helyi menüt egy ListView-on hatókörrel rendelkező billentyűzetgyorsítókkal:

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

A MenuFlyoutItem.KeyboardAccelerators elem ScopeOwner attribútuma globális helyett hatókörként jelöli meg a gyorsítót (az alapértelmezett érték null vagy globális). További részletekért lásd a A gyorsítók feloldása szakaszt a jelen témakör későbbi részében.

Gyorsbillentyű aktiválása

A KeyboardAccelerator objektum a UI-automatizálás (UIA) vezérlőmintát használja a gyorsító meghívásakor.

Az UIA [vezérlőminták] általános vezérlőfunkciókat fednek fel. A Gomb vezérlőelem például a Click esemény támogatásához implementálja a Meghívás vezérlőmintát (általában egy vezérlő meghívása az Enterre kattintással, dupla kattintással vagy az Enter lenyomásával, egy előre definiált billentyűparancs vagy a billentyűleütések más kombinációjával történik). Ha egy vezérlő meghívásához billentyűzetgyorsítót használnak, az XAML-keretrendszer megvizsgálja, hogy a vezérlő implementálja-e a Meghívás vezérlőmintát, és ha igen, aktiválja-e (nem szükséges figyelni a KeyboardAcceleratorInvoked eseményt).

A következő példában a Control+S aktiválja a Kattintás eseményt, mert a gomb implementálja a meghívási mintát.

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

Ha egy elem több vezérlőmintát valósít meg, csak egy aktiválható egy gázpedálon keresztül. A vezérlőminták rangsorolása az alábbiak szerint történik:

1. Meghívás (gomb)
2. Kapcsoló (jelölőnégyzet)
3. Kijelölés (ListView)
4. Megnyitás/Összecsukás (Kombinált lista)

Ha nem található egyezés, a gyorsgomb érvénytelen, és megjelenik egy hibakeresési üzenet ("Nincs automatizálási minta ehhez az összetevőhöz. Implementálja az összes kívánt viselkedést a meghívott eseményben. Az eseménykezelőben a kezelt érték igazra állítása elnyomja ezt az üzenetet.")

Egyéni billentyűzetgyorsító viselkedése

A KeyboardAccelerator objektum meghívt eseménye a gázpedál végrehajtásakor aktiválódik. A KeyboardAcceleratorInvokedEventArgs eseményobjektum a következő tulajdonságokat tartalmazza:

• Kezelt (logikai): Ha ezt igaz értékre állítja, az megakadályozza a vezérlőmintát kiváltó eseményt, és leállítja a gyorsító esemény buborékosodását. Az alapértelmezett érték hamis.
• Elem (DependencyObject): A gyorsítóhoz társított objektum.
• KeyboardAccelerator: A meghívott esemény elindításához használt billentyűzetgyorsító.

Az alábbiakban bemutatjuk, hogyan definiálhat billentyűzetgyorsítókat a ListView-elemekhez, és hogyan kezelheti az egyes gyorsítók meghívott eseményeit.

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

A billentyűzet alapértelmezett viselkedésének felülbírálása

Egyes vezérlők, ha fókuszban vannak, támogatják a beépített billentyűzetgyorsítókat, amelyek felülírják az alkalmazás által definiált gyorsítókat. Ha például egy Szövegdoboz fókusza van, a Control+C gyorsító csak az aktuálisan kijelölt szöveget másolja (az alkalmazás által definiált gyorsítókat figyelmen kívül hagyja, és nincs más funkció).

Bár a felhasználói jártasság és az elvárások miatt nem javasoljuk az alapértelmezett vezérlési viselkedés felülbírálását, felülbírálhatja a vezérlő beépített billentyűzetgyorsítóját. Az alábbi példa bemutatja, hogyan bírálhatja felül a Control+C billentyűzetgyorsítót egy Szövegdobozhoz az PreviewKeyDown eseménykezelőn keresztül:

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

Billentyűzetgyorsító letiltása

Ha egy vezérlő le van tiltva, a társított gyorsító is le van tiltva. Az alábbi példában, mivel a ListView IsEnabled tulajdonsága hamis értékre van állítva, a társított Control+A gyorsító nem hívható meg.

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

A szülő- és gyermekvezérlők ugyanazt a gyorsítót használhatják. Ebben az esetben a szülővezérlő akkor is meghívható, ha a gyermek fókuszban van, és a gyorsítója le van tiltva.

Képernyőolvasók és billentyűzetgyorsítók

Az olyan képernyőolvasók, mint a Narrátor, felolvashatják a billentyűzetgyorsító billentyűkombinációt a felhasználóknak. Alapértelmezés szerint ez minden módosító (a VirtualModifiers enum sorrendben), amelyet a kulcs követ (és "+" jelekkel elválasztva). Ezt testre szabhatja az AcceleratorKey AutomationProperties csatolt tulajdonságával. Ha egynél több gázgyorsító van megadva, csak az elsőt jelenti be a rendszer.

Ebben a példában az AutomationProperty.AcceleratorKey a "Control+Shift+A" sztringet adja vissza:

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

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

  </ListView.KeyboardAccelerators>

</ListView>   

Gyakori billentyűzetgyorsítók

Javasoljuk, hogy a billentyűzetgyorsítókat konzisztenssé tegye a Windows-alkalmazásokban.

A felhasználóknak meg kell jegyeznie a billentyűzetgyorsítókat, és ugyanazokat a (vagy hasonló) eredményeket kell várniuk, de ez nem mindig lehetséges az alkalmazások közötti funkcióbeli különbségek miatt.

Figyelje meg, hogy a kombinációk némelyike nem érvényes a Windows honosított verzióira. A Windows spanyol verziójában például a Ctrl+N billentyűkombinációt használja félkövérre a Ctrl+B helyett. Ha az alkalmazás honosított, javasoljuk, hogy honosított billentyűzetgyorsítókat biztosítson.

A billentyűzetgyorsítók használhatósági lehetőségei

Tooltips

Mivel a billentyűzetgyorsítókat általában nem közvetlenül a Windows-alkalmazás felhasználói felületén írják le, az elemleírások segítségével javíthatja a felderíthetőséget, amely automatikusan megjelenik, amikor a felhasználó a fókuszt áthelyezi, lenyomja és tartja, vagy rámutat az egérmutatóra egy vezérlőre. Az eszköztipp azonosítani tudja, hogy egy vezérlő rendelkezik-e társított billentyűzetgyorsítóval, és ha igen, mi a gyorsbillentyű-kombináció.

Alapértelmezés szerint a billentyűzetgyorsítók deklarálásakor az összes vezérlő (a MenuFlyoutItem és a ToggleMenuFlyoutItem kivételével) egy elemleírásban jeleníti meg a megfelelő billentyűkombinációkat.

Gyorsbillentyű-kombináció az elemleírásban

Button, AppBarButton és AppBarToggleButton objektumok esetén a billentyűzetgyorsító hozzá van fűzve a vezérlő alapértelmezett elemleírásához. MenuFlyoutItem és ToggleMenuFlyoutItem objektumok esetén a billentyűzetgyorsító megjelenik a úszó szöveggel.

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

A gomb alapértelmezett elemleírásához hozzáfűzött gyorsbillentyű-kombináció

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

Az AppBarButton alapértelmezett elemleírásához fűzött gyorsítókulcs-kombináció

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

A MenuFlyoutItem szövegéhez hozzáfűzött gyorsítókulcs-kombináció

A bemutató viselkedésének szabályozásához használja a KeyboardAcceleratorPlacementMode tulajdonságot , amely két értéket fogad el: Automatikus vagy Rejtett.

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

Bizonyos esetekben előfordulhat, hogy egy elemleírást egy másik elemhez (általában egy tárolóobjektumhoz) viszonyítva kell bemutatnia.

Itt bemutatjuk, hogyan használható a KeyboardAcceleratorPlacementTarget tulajdonság a Mentés gomb billentyűkombinációjának megjelenítésére a Grid tárolóval, a gomb helyett.

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

Címkék

Bizonyos esetekben azt javasoljuk, hogy egy vezérlő címkéjét használva állapítsa meg, hogy a vezérlő rendelkezik-e társított billentyűzetgyorsítóval, és ha igen, akkor mi a gyorsítókulcs-kombináció.

Egyes platformvezérlők alapértelmezés szerint ezt végzik el, különösen a MenuFlyoutItem és a ToggleMenuFlyoutItem objektumokat, míg az AppBarButton és az AppBarToggleButton a parancssáv túlcsordulási menüjében jelennek meg.

A menüelem címkéjében leírt billentyűzetgyorsítók

Felülbírálhatja a címke alapértelmezett gyorsítószövegét a MenuFlyoutItem, a ToggleMenuFlyoutItem, az AppBarButton és az AppBarToggleButtonvezérlők KeyboardAcceleratorTextOverride tulajdonságával (egyetlen szóközt használva szöveg nélkül).

Speciális fogalmak

Itt áttekintjük a billentyűzetgyorsítók néhány alacsony szintű aspektusát.

Bemeneti esemény prioritása

A bemeneti események egy adott sorrendben történnek, amelyet az alkalmazás követelményeinek megfelelően elfoghat és kezelhet.

A KeyDown/KeyUp buborékos esemény

Az XAML-ben a billentyűleütések úgy lesznek feldolgozva, mintha csak egy bemeneti buborékfolyamat áll rendelkezésre. Ezt a bemeneti folyamatot a KeyDown/KeyUp események és a karakterbemenet használják. Ha például egy elem fókuszban van, és a felhasználó lenyom egy billentyűt, akkor egy KeyDown esemény keletkezik az elemen, majd az elem szülőjén, és így tovább a fán felfelé, amíg az args.Handled tulajdonság igaz nem lesz.

A KeyDown eseményt egyes vezérlők a beépített vezérlőgyorsítók implementálásához is használják. Ha egy vezérlő rendelkezik gyorsbillentyűvel, a vezérlő kezeli a KeyDown eseményt, ami azt jelenti, hogy a KeyDown-esemény nem fog továbbterjedni. A RichEditBox például a Ctrl+C billentyűkombinációval támogatja a másolást. A Ctrl billentyű lenyomásakor a KeyDown esemény aktiválódik, és buborékok lesznek, de amikor a felhasználó egyszerre nyomja le a C billentyűt, a KeyDown eseményt a rendszer kezeli, és nem emeli ki (kivéve, ha az UIElement.AddHandler handledEventsToo paramétere igaz értékre van állítva).

A 'CharacterReceived' esemény

Mivel a CharacterReceived esemény a KeyDown-esemény után aktiválódik a szövegvezérlők, például a TextBox esetében, megszakíthatja a karakterbevitelt a KeyDown eseménykezelőben.

A PreviewKeyDown és az PreviewKeyUp események

Az előzetes verziójú bemeneti események minden más esemény előtt aktiválódnak. Ha nem kezeli ezeket az eseményeket, a fókuszt tartalmazó elem gyorsítója aktiválódik, amelyet a KeyDown esemény követ. Mindkét esemény terjed, amíg nem kezelik őket.

– Kulcsesemény-sorozat

Események sorrendje:

KeyDown-események előnézete
…
Alkalmazásgyorsító
OnKeyDown metódus
KeyDown-esemény
Alkalmazásgyorsítók a szülő objektumon
OnKeyDown metódus a szülőn
KeyDown esemény a szülőn
(Buborékok a gyökérnél)
…
CharacterReceived-esemény
PreviewKeyUp események
KeyUpEvents

A gyorsító esemény kezelésekor a KeyDown esemény is megjelölésre kerül mint kezelt. A KeyUp esemény kezeletlen marad.

Gyorsítók feloldása

A billentyűzetgyorsító esemény a fókuszban lévő elemtől felfelé, a gyökér felé terjed. Ha az esemény kezelése nem történik meg, az XAML-keretrendszer más, nem felügyelt alkalmazásgyorsítókat keres a buborékos útvonalon kívül.

Ha két billentyűzetgyorsító azonos billentyűkombinációval van definiálva, a rendszer meghívja a vizualizációfán található első billentyűzetgyorsítót.

A hatókörrel rendelkező billentyűzetgyorsítók csak akkor lesznek meghívva, ha a fókusz egy adott hatókörön belül van. Például egy több tucat vezérlőt tartalmazó rácsban a billentyűzetgyorsító csak akkor hívható meg egy vezérlőhöz, ha a fókusz a Rácson belül van (a hatókör tulajdonosa).

Hatókörgyorsítók programozás útján

Az UIElement.TryInvokeKeyboardAccelerator metódus meghívja az elem almezőjében található összes egyezőgyorsítót.

A UIElement.OnProcessKeyboardAccelerators metódus végrehajtása a billentyűzetgyorsító előtt történik. Ez a metódus átad egy ProcessKeyboardAcceleratorArgs objektumot, amely tartalmazza a kulcsot, a módosítót és egy logikai értéket, amely jelzi, hogy a billentyűzetgyorsító kezelhető-e. Ha kezeltként van megjelölve, a billentyűparancs buborékokat képez (így a külső billentyűparancs soha nem hívható meg).

Ebben a példában az OnProcessKeyboardAccelerators és a TryInvokeKeyboardAccelerator segítségével hatókörbe vesszük a billentyűzetgyorsítókat a Page objektumra:

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

A gyorsítók honosítása

Javasoljuk az összes billentyűzetgyorsító honosítását. Ezt a standard erőforrásfájllal (.resw) és az x:Uid attribútummal teheti meg az XAML-deklarációkban. Ebben a példában a Windows-futtatókörnyezet automatikusan betölti az erőforrásokat.

Billentyűzetgyorsító honosítása az erőforrásfájllal

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

Gyorsító programozott beállítása

Íme egy példa egy gyorsító programozott meghatározására:

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

A billentyűzetgyorsító viselkedésének felülbírálása

A KeyboardAccelerator.Invoked eseményt az alapértelmezett KeyboardAccelerator viselkedés felülbírálásához kezelheti.

Ez a példa bemutatja, hogyan bírálhatja felül az "Összes kijelölése" parancsot (Ctrl+A billentyűzetgyorsító) egy egyéni ListView-vezérlőben. A Handled tulajdonságot is igaz értékre állítottuk, hogy megakadályozzuk az esemény további terjedését.

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

Kapcsolódó cikkek

• Billentyűzet-interakciók
• Access kulcsok
• VirtualKey Enum

Samples

• WinUI 3 katalógus