Delen via

Toetsenbordevenementen

Toetsenbord gebeurtenissen en focus

De volgende toetsenbord gebeurtenissen kunnen optreden voor zowel hardware- als aanraaktoetsenborden.

Event Description
KeyDown Treedt op wanneer een toets wordt ingedrukt.
KeyUp Treedt op wanneer een sleutel wordt vrijgegeven.

Belangrijk

Sommige XAML-besturingselementen verwerken intern invoerevenementen. In dergelijke gevallen kan het gebeuren dat er geen invoer gebeurtenis optreedt omdat de gebeurtenislistener de bijbehorende handler niet aanroept. Deze subset van sleutels wordt doorgaans verwerkt door de klassehandler om ingebouwde ondersteuning te bieden voor basistoetsenbordtoegankelijkheid. De knopklasse overschrijft bijvoorbeeld de OnKeyDown-gebeurtenissen voor zowel de spatietoets als de Enter-toets (evenals OnPointerPressed) en stuurt deze door naar de gebeurtenis Klik van het besturingselement. Wanneer een toets wordt verwerkt door de besturingsklasse, worden de KeyDown-gebeurtenissen en KeyUp-gebeurtenissen niet gegenereerd.
Dit biedt een ingebouwd toetsenbordequivalent voor het aanroepen van de knop, vergelijkbaar met tikken met een vinger of klikken met een muis. Toetsen anders dan Spatie of Enter genereren nog steeds KeyDown- en KeyUp-gebeurtenissen. Zie Overzicht van gebeurtenissen en gerouteerde gebeurtenissen voor meer informatie over hoe gebeurtenisafhandeling op basis van klassen werkt, met name de sectie "Invoergebeurtensafhandelaars in besturingselementen."

Besturingselementen in uw gebruikersinterface genereren alleen toetsenbordevenementen wanneer ze de invoerfocus hebben. Een afzonderlijk besturingselement krijgt de focus wanneer de gebruiker rechtstreeks op dat besturingselement in de indeling klikt of tikt, of de Tab-toets gebruikt om in een tabvolgorde binnen het inhoudsgebied te stappen.

U kunt ook de focusmethode van een besturingselement aanroepen om de focus af te dwingen. Dit is nodig wanneer u sneltoetsen implementeert, omdat de toetsenbordfocus niet standaard is ingesteld wanneer de gebruikersinterface wordt geladen. Zie het voorbeeld van sneltoetsen verderop in dit onderwerp voor meer informatie.

Als een besturingselement de invoerfocus wil ontvangen, moet het ingeschakeld zijn, zichtbaar zijn en moeten de eigenschappen IsTabStop en HitTestVisible de waarde 'waar' hebben. Dit is de standaardstatus voor de meeste besturingselementen. Wanneer een besturingselement de focus op invoer heeft, kan het de invoergebeurtenissen van het toetsenbord genereren en erop reageren, zoals verderop in dit onderwerp wordt beschreven. U kunt ook reageren op een besturingselement dat de focus ontvangt of verliest door de GotFocus - en LostFocus-gebeurtenissen te verwerken.

Standaard is de tabvolgorde van besturingselementen de volgorde waarin deze worden weergegeven in de Extensible Application Markup Language (XAML). U kunt deze volgorde echter wijzigen met behulp van de eigenschap TabIndex . Zie Toetsenbordtoegankelijkheid implementeren voor meer informatie.

Toetsenbord event-afhandelaars

Een handler voor invoergebeurtenissen implementeert een gemachtigde die de volgende informatie biedt:

  • De afzender van de gebeurtenis. De afzender rapporteert het object waaraan de gebeurtenis-handler is gekoppeld.
  • Gebeurtenisgegevens. Voor toetsenbordgebeurtenissen zijn deze gegevens een exemplaar van KeyRoutedEventArgs. De gemachtigde voor handlers is KeyEventHandler. De meest relevante eigenschappen van KeyRoutedEventArgs voor de meeste handlerscenario's zijn Key en mogelijk KeyStatus.
  • OriginalSource. Omdat de toetsenbordgebeurtenissen gerouteerd zijn, geven de gebeurtenisgegevens OriginalSource aan. Als u opzettelijk toestaat dat gebeurtenissen door een objecthiërarchie opborrelen, is OriginalSource soms het aandachtspunt in plaats van de afzender. Dat hangt echter af van uw ontwerp. Zie de sectie "Toetsenbordrouteringsgebeurtenissen" van dit onderwerp of de "Overzicht van gebeurtenissen en gerouteerde gebeurtenissen" voor meer informatie over hoe u OriginalSource kunt gebruiken in plaats van de afzender.

Een gebeurtenishandler voor een toetsenbord koppelen

U kunt toetsenbordgebeurtenishandlerfuncties koppelen voor elk object dat de gebeurtenis als lid bevat. Dit omvat een afgeleide uiElement-klasse . In het volgende XAML-voorbeeld ziet u hoe u handlers koppelt voor de KeyUp-gebeurtenis voor een raster.

<Grid KeyUp="Grid_KeyUp">
  ...
</Grid>

U kunt ook een gebeurtenis-handler toevoegen in code. Zie Het overzicht van gebeurtenissen en gerouteerde gebeurtenissen voor meer informatie.

Een toetsenbord gebeurtenis-handler definiëren

In het volgende voorbeeld ziet u de definitie van de onvolledige KeyUp-gebeurtenis-handler die in het vorige voorbeeld is gekoppeld.

void Grid_KeyUp(object sender, KeyRoutedEventArgs e)
{
    //handling code here
}

Private Sub Grid_KeyUp(ByVal sender As Object, ByVal e As KeyRoutedEventArgs)
    ' handling code here
End Sub

void MyProject::MainPage::Grid_KeyUp(
  Platform::Object^ sender,
  Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
  {
      //handling code here
  }

KeyRoutedEventArgs gebruiken

Alle toetsenbordgebeurtenissen gebruiken KeyRoutedEventArgs voor gebeurtenisgegevens en KeyRoutedEventArgs bevatten de volgende eigenschappen:

Virtuele sleutels

De KeyDown-gebeurtenis wordt gegenereerd als er op een toets wordt gedrukt. Op dezelfde manier wordt KeyUp gegenereerd als er een sleutel wordt vrijgegeven. Normaal gesproken luistert u naar de gebeurtenissen om een specifieke sleutelwaarde te verwerken. Als u wilt bepalen welke sleutel wordt ingedrukt of vrijgegeven, controleert u de sleutelwaarde in de gebeurtenisgegevens. Sleutel retourneert een VirtualKey-waarde . De opsomming VirtualKey bevat alle ondersteunde sleutels.

Wijzigingstoetsen

Modifier-toetsen zijn toetsen zoals Ctrl of Shift die gebruikers doorgaans in combinatie met andere toetsen drukken. Uw app kan deze combinaties gebruiken als aangepaste sneltoetsen om app-opdrachten aan te roepen.

Opmerking

Zie Toegangstoetsen en toetsenbordversnellers voor ingebouwde sneltoetsen.

U kunt sneltoetscombinaties detecteren in de KeyDown- en KeyUp-gebeurtenishandlers. Wanneer een toetsenbordgebeurtenis plaatsvindt voor een toets die geen modifier-toets is, kunt u vervolgens controleren of een modifier-toets is ingedrukt.

De functie GetKeyState() van de CoreWindow (verkregen via CoreWindow.GetForCurrentThread()) kan ook worden gebruikt om de wijzigingsstatus te controleren wanneer een niet-modifier-toets wordt ingedrukt.

In de volgende voorbeelden wordt deze tweede methode geïmplementeerd, terwijl ook stub-code voor de eerste implementatie wordt toegevoegd.

Opmerking

De Alt-toets wordt vertegenwoordigd door de waarde VirtualKey.Menu .

Het voorbeeld van sneltoetsen

In het volgende voorbeeld ziet u hoe u een set aangepaste sneltoetsen implementeert. In dit voorbeeld kunnen gebruikers het afspelen van media beheren met de knoppen Afspelen, Onderbreken en Stoppen of Ctrl+P, Ctrl+A en Ctrl+S-sneltoetsen. De knop XAML toont de sneltoetsen met behulp van knopinfo en AutomationProperties-eigenschappen in de knoplabels. Deze zelfdocumentatie is belangrijk om de bruikbaarheid en toegankelijkheid van uw app te vergroten. Zie Toetsenbordtoegankelijkheid voor meer informatie.

Houd er ook rekening mee dat de invoerfocus op zichzelf wordt ingesteld wanneer deze wordt geladen. Zonder deze stap heeft geen besturingselement de eerste invoerfocus en genereert de app geen invoergebeurtenissen totdat de gebruiker de invoerfocus handmatig instelt (bijvoorbeeld door op een tabtoets te drukken of op een besturingselement te klikken).

<Grid KeyDown="Grid_KeyDown">

  <Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
  </Grid.RowDefinitions>

  <MediaElement x:Name="DemoMovie" Source="xbox.wmv"
    Width="500" Height="500" Margin="20" HorizontalAlignment="Center" />

  <StackPanel Grid.Row="1" Margin="10"
    Orientation="Horizontal" HorizontalAlignment="Center">

    <Button x:Name="PlayButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+P"
      AutomationProperties.AcceleratorKey="Control P">
      <TextBlock>Play</TextBlock>
    </Button>

    <Button x:Name="PauseButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+A"
      AutomationProperties.AcceleratorKey="Control A">
      <TextBlock>Pause</TextBlock>
    </Button>

    <Button x:Name="StopButton" Click="MediaButton_Click"
      ToolTipService.ToolTip="Shortcut key: Ctrl+S"
      AutomationProperties.AcceleratorKey="Control S">
      <TextBlock>Stop</TextBlock>
    </Button>

  </StackPanel>

</Grid>

//showing implementations but not header definitions
void MainPage::OnNavigatedTo(NavigationEventArgs^ e)
{
    (void) e;    // Unused parameter
    this->Loaded+=ref new RoutedEventHandler(this,&amp;MainPage::ProgrammaticFocus);
}
void MainPage::ProgrammaticFocus(Object^ sender, RoutedEventArgs^ e) 
{
    this->Focus(Windows::UI::Xaml::FocusState::Programmatic);
}

void KeyboardSupport::MainPage::MediaButton_Click(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e)
{
    FrameworkElement^ fe = safe_cast<FrameworkElement^>(sender);
    if (fe->Name == "PlayButton") {DemoMovie->Play();}
    if (fe->Name == "PauseButton") {DemoMovie->Pause();}
    if (fe->Name == "StopButton") {DemoMovie->Stop();}
}


bool KeyboardSupport::MainPage::IsCtrlKeyPressed()
{
    auto ctrlState = CoreWindow::GetForCurrentThread()->GetKeyState(VirtualKey::Control);
    return (ctrlState & CoreVirtualKeyStates::Down) == CoreVirtualKeyStates::Down;
}

void KeyboardSupport::MainPage::Grid_KeyDown(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
{
    if (e->Key == VirtualKey::Control) isCtrlKeyPressed = true;
}


void KeyboardSupport::MainPage::Grid_KeyUp(Platform::Object^ sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e)
{
    if (IsCtrlKeyPressed()) 
    {
        if (e->Key==VirtualKey::P) { DemoMovie->Play(); }
        if (e->Key==VirtualKey::A) { DemoMovie->Pause(); }
        if (e->Key==VirtualKey::S) { DemoMovie->Stop(); }
    }
}

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    // Set the input focus to ensure that keyboard events are raised.
    this.Loaded += delegate { this.Focus(FocusState.Programmatic); };
}

private void MediaButton_Click(object sender, RoutedEventArgs e)
{
    switch ((sender as Button).Name)
    {
        case "PlayButton": DemoMovie.Play(); break;
        case "PauseButton": DemoMovie.Pause(); break;
        case "StopButton": DemoMovie.Stop(); break;
    }
}

private static bool IsCtrlKeyPressed()
{
    var ctrlState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
    return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
}

private void Grid_KeyDown(object sender, KeyRoutedEventArgs e)
{
    if (IsCtrlKeyPressed())
    {
        switch (e.Key)
        {
            case VirtualKey.P: DemoMovie.Play(); break;
            case VirtualKey.A: DemoMovie.Pause(); break;
            case VirtualKey.S: DemoMovie.Stop(); break;
        }
    }
}

Private isCtrlKeyPressed As Boolean
Protected Overrides Sub OnNavigatedTo(e As Navigation.NavigationEventArgs)

End Sub

Private Function IsCtrlKeyPressed As Boolean
    Dim ctrlState As CoreVirtualKeyStates = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
    Return (ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
End Function

Private Sub Grid_KeyDown(sender As Object, e As KeyRoutedEventArgs)
    If IsCtrlKeyPressed() Then
        Select Case e.Key
            Case Windows.System.VirtualKey.P
                DemoMovie.Play()
            Case Windows.System.VirtualKey.A
                DemoMovie.Pause()
            Case Windows.System.VirtualKey.S
                DemoMovie.Stop()
        End Select
    End If
End Sub

Private Sub MediaButton_Click(sender As Object, e As RoutedEventArgs)
    Dim fe As FrameworkElement = CType(sender, FrameworkElement)
    Select Case fe.Name
        Case "PlayButton"
            DemoMovie.Play()
        Case "PauseButton"
            DemoMovie.Pause()
        Case "StopButton"
            DemoMovie.Stop()
    End Select
End Sub

Opmerking

Het instellen van AutomationProperties.AcceleratorKey of AutomationProperties.AccessKey in XAML biedt tekenreeksinformatie, waarmee de sneltoets wordt gedocumenten voor het aanroepen van die specifieke actie. De informatie wordt vastgelegd door Microsoft UI Automation-clients zoals Verteller en wordt doorgaans rechtstreeks aan de gebruiker verstrekt.

Het instellen van AutomationProperties.AcceleratorKey of AutomationProperties.AccessKey heeft zelf geen actie. U moet nog steeds handlers koppelen voor KeyDown - of KeyUp-gebeurtenissen om het gedrag van de sneltoets in uw app daadwerkelijk te implementeren. Ook wordt de onderstrepingstekstversiering voor een toegangssleutel niet automatisch verstrekt. U moet de tekst voor de specifieke sleutel in uw nemonic expliciet onderstrepen als inline onderstrepen als u onderstreepte tekst in de gebruikersinterface wilt weergeven.

 

Door het toetsenbord gerouteerde gebeurtenissen

Bepaalde gebeurtenissen worden gerouteerd, waaronder KeyDown en KeyUp. Routeringsgebeurtenissen maken gebruik van de bubbling routeringsstrategie. De bubblingrouteringsstrategie houdt in dat een gebeurtenis afkomstig is van een kindobject en vervolgens wordt doorgestuurd naar opeenvolgende ouderobjecten in de bomenstructuur. Dit biedt een andere mogelijkheid om dezelfde gebeurtenis af te handelen en te communiceren met dezelfde gebeurtenisgegevens.

Bekijk het volgende XAML-voorbeeld, waarmee KeyUp-gebeurtenissen voor een canvas en twee knopobjecten worden verwerkt. Als u in dit geval een toets loslaat terwijl de focus zich bevindt op een knop object, wordt de KeyUp-gebeurtenis gegenereerd. De gebeurtenis wordt vervolgens doorgegeven naar het bovenliggende Canvas.

<StackPanel KeyUp="StackPanel_KeyUp">
  <Button Name="ButtonA" Content="Button A"/>
  <Button Name="ButtonB" Content="Button B"/>
  <TextBlock Name="statusTextBlock"/>
</StackPanel>

In het volgende voorbeeld ziet u hoe u de KeyUp-gebeurtenis-handler implementeert voor de bijbehorende XAML-inhoud in het voorgaande voorbeeld.

void StackPanel_KeyUp(object sender, KeyRoutedEventArgs e)
{
    statusTextBlock.Text = String.Format(
        "The key {0} was pressed while focus was on {1}",
        e.Key.ToString(), (e.OriginalSource as FrameworkElement).Name);
}

Let op het gebruik van de eigenschap OriginalSource in de voorgaande handler. Hier rapporteert OriginalSource het object dat de gebeurtenis heeft gegenereerd. Het object kan niet de StackPanel zijn omdat het StackPanel geen besturingselement is en geen focus kan hebben. Slechts één van de twee knoppen in de StackPanel had het evenement kunnen hebben gegenereerd, maar welke? U gebruikt OriginalSource om het eigenlijke bronobject van de gebeurtenis te onderscheiden wanneer u de gebeurtenis op een ouderobject verwerkt.

De afgehandelde eigenschap in gebeurtenisgegevens

Afhankelijk van uw strategie voor gebeurtenisafhandeling, wilt u misschien dat slechts één gebeurtenishandler reageert op een bubbling-gebeurtenis. Als u bijvoorbeeld een specifieke KeyUp-handler hebt die is gekoppeld aan een van de knopbesturingselementen , zou het de eerste mogelijkheid hebben om die gebeurtenis af te handelen. In dit geval wilt u mogelijk niet dat het ouderpaneel ook de gebeurtenis afhandelt. Voor dit scenario kunt u de eigenschap Handled gebruiken in de gebeurtenisgegevens.

Het doel van de eigenschap Handled in een gerouteerde gebeurtenisgegevens klasse is om te rapporteren dat een andere handler die u eerder op de gebeurtenisroute hebt geregistreerd, al heeft gehandeld. Dit is van invloed op het gedrag van het gerouteerde gebeurtenissysteem. Wanneer u handled instelt op true in een gebeurtenis-handler, stopt die gebeurtenis de routering en wordt deze niet verzonden naar opeenvolgende bovenliggende elementen.

AddHandler en al afgehandelde toetsenbordgebeurtenissen

U kunt een speciale techniek gebruiken voor het koppelen van handlers die kunnen reageren op gebeurtenissen die u al hebt gemarkeerd als afgehandeld. Deze techniek maakt gebruik van de Methode AddHandler om een handler te registreren in plaats van XAML-kenmerken of taalspecifieke syntaxis te gebruiken voor het toevoegen van handlers, zoals += in C#.

Een algemene beperking van deze techniek is dat de AddHandler-API een parameter van het type RoutedEvent gebruikt die de betreffende gerouteerde gebeurtenis identificeert. Niet alle gerouteerde gebeurtenissen bieden een RoutedEvent-id en deze overweging is dus van invloed op welke gerouteerde gebeurtenissen nog steeds kunnen worden verwerkt in de afgehandelde zaak. De KeyDown en KeyUp gebeurtenissen hebben gerouteerde gebeurtenisidentificatoren (KeyDownEvent en KeyUpEvent) op UIElement. Andere gebeurtenissen, zoals TextBox.TextChanged , hebben echter geen gerouteerde gebeurtenis-id's en kunnen dus niet worden gebruikt met de Methode AddHandler .

Toetsenbordgebeurtenissen en -gedrag negeren

U kunt belangrijke gebeurtenissen voor specifieke besturingselementen (zoals GridView) overschrijven om consistente focusnavigatie te bieden voor verschillende invoerapparaten, waaronder toetsenbord en gamepad.

In het volgende voorbeeld subklassen we het besturingselement en overschrijven we het KeyDown-gedrag om de focus naar de GridView-inhoud te verplaatsen wanneer er op een pijltoets wordt gedrukt.

  public class CustomGridView : GridView
  {
    protected override void OnKeyDown(KeyRoutedEventArgs e)
    {
      // Override arrow key behaviors.
      if (e.Key != Windows.System.VirtualKey.Left && e.Key !=
        Windows.System.VirtualKey.Right && e.Key !=
          Windows.System.VirtualKey.Down && e.Key !=
            Windows.System.VirtualKey.Up)
              base.OnKeyDown(e);
      else
        FocusManager.TryMoveFocus(FocusNavigationDirection.Down);
    }
  }

Opmerking

Als u een GridView alleen voor de lay-out gebruikt, overweeg dan andere besturingselementen zoals ItemsControl met ItemsWrapGrid.

Bevelvoering

Een klein aantal UI-elementen biedt ingebouwde ondersteuning voor het uitvoeren van opdrachten. Opdrachten maken gebruik van invoergerelateerde gerouteerde gebeurtenissen in de onderliggende implementatie. Het maakt verwerking mogelijk van gerelateerde UI-invoer, zoals een bepaalde aanwijzeractie of een specifieke acceleratorsleutel, door één opdrachthandler aan te roepen.

Als opdrachten beschikbaar zijn voor een UI-element, kunt u overwegen de bijbehorende opdracht-API's te gebruiken in plaats van afzonderlijke invoerevenementen. Zie ButtonBase.Command voor meer informatie.

U kunt ICommand ook implementeren om de opdrachtfunctionaliteit in te kapselen die u aanroept vanuit gewone gebeurtenis-handlers. Hiermee kunt u opdrachten gebruiken, zelfs als er geen opdrachteigenschap beschikbaar is.

Tekstinvoer en besturingselementen

Bepaalde besturingselementen reageren op toetsenbordevenementen met hun eigen verwerking. Tekstvak is bijvoorbeeld een besturingselement dat is ontworpen om tekst vast te leggen en vervolgens visueel weer te geven die is ingevoerd met behulp van het toetsenbord. Het gebruikt in zijn eigen logica KeyUp en KeyDown om toetsaanslagen vast te leggen, en roept vervolgens ook zijn eigen TextChanged-gebeurtenis op als de tekst daadwerkelijk is gewijzigd.

U kunt nog steeds handlers voor KeyUp en KeyDown toevoegen aan een tekstvak of een gerelateerd besturingselement dat bedoeld is om tekstinvoer te verwerken. Als onderdeel van het beoogde ontwerp reageert een besturingselement echter mogelijk niet op alle sleutelwaarden die ernaar worden doorgestuurd via belangrijke gebeurtenissen. Gedrag is specifiek voor elk besturingselement.

Als voorbeeld verwerkt ButtonBase (de basisklasse voor Knop) KeyUp , zodat deze kan controleren op de spatiebalk of Enter-toets. ButtonBase beschouwt KeyUp als gelijkwaardig aan een linkermuisklik voor het genereren van een klik-gebeurtenis. Deze verwerking van de gebeurtenis wordt uitgevoerd wanneer ButtonBase de virtuele methode OnKeyUp overschrijft. In de implementatie wordt Handled op true gezet. Het resultaat is dat elke ouder van een knop die luistert naar een toetsgebeurtenis, in het geval van de spatiebalk, de gebeurtenis die al is afgehandeld niet ontvangt voor zijn eigen handlers.

Een ander voorbeeld is Tekstvak. Sommige toetsen, zoals de pijltoetsen, worden niet beschouwd als tekst per tekstvak en worden in plaats daarvan beschouwd als specifiek voor het gedrag van de gebruikersinterface van het besturingselement. In het TextBox worden deze gebeurteniscases als afgehandeld gemarkeerd.

Aangepaste besturingselementen kunnen hun eigen vergelijkbare overschrijfgedrag implementeren voor toetsgebeurtenissen door OnKeyDown / OnKeyUp te overschrijven. Als uw aangepaste besturingselement specifieke acceleratorsleutels verwerkt, of als er controle- of focusgedrag is dat vergelijkbaar is met het scenario dat voor Tekstvak wordt beschreven, moet u deze logica in uw eigen OnKeyDown / OnKeyUp-onderdrukkingen plaatsen.

Het schermtoetsenbord

Besturingselementen voor tekstinvoer bieden automatische ondersteuning voor het schermtoetsenbord. Wanneer de gebruiker de invoerfocus instelt op een tekstbesturing met behulp van aanraakinvoer, wordt het schermtoetsenbord automatisch weergegeven. Wanneer de invoerfocus zich niet op een tekstveld bevindt, is het schermtoetsenbord verborgen.

Wanneer het schermtoetsenbord wordt weergegeven, wordt uw gebruikersinterface automatisch verplaatst om ervoor te zorgen dat het focuselement zichtbaar blijft. Dit kan ertoe leiden dat andere belangrijke gebieden van uw gebruikersinterface van het scherm worden verplaatst. U kunt echter het standaardgedrag uitschakelen en uw eigen ui-aanpassingen maken wanneer het schermtoetsenbord wordt weergegeven. Zie het voorbeeld van het schermtoetsenbord voor meer informatie.

Als u een aangepast besturingselement maakt waarvoor tekstinvoer is vereist, maar niet is afgeleid van een standaard besturingselement voor tekstinvoer, kunt u ondersteuning voor het aanraaktoetsenbord toevoegen door de juiste ui Automation-besturingspatronen te implementeren. Zie het voorbeeld van het schermtoetsenbord voor meer informatie.

Toetsaanslagen op het schermtoetsenbord veroorzaken KeyDown- en KeyUp-evenementen, net zoals toetsaanslagen op een hardwaretoetsenbord dat doen. Het aanraaktoetsenbord genereert echter geen invoerevenementen voor Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C en Ctrl+V, die zijn gereserveerd voor tekstbewerking in het invoerbeheer.

U kunt het veel sneller en eenvoudiger maken voor gebruikers om gegevens in uw app in te voeren door het invoerbereik van het tekstbeheer in te stellen op basis van het soort gegevens dat de gebruiker verwacht in te voeren. Het invoerbereik biedt een hint voor het type tekstinvoer dat door het besturingselement wordt verwacht, zodat het systeem een gespecialiseerde toetsenbordindeling voor aanraaktoetsenbord kan bieden voor het invoertype. Als een tekstvak bijvoorbeeld alleen wordt gebruikt om een pincode van 4 cijfers in te voeren, stelt u de eigenschap InputScope in op Number. Dit vertelt het systeem dat de indeling van het numerieke toetsenblok moet worden weergegeven, waardoor de gebruiker de pincode op een eenvoudigere manier kan invoeren. Zie Invoerbereik gebruiken om het schermtoetsenbord te wijzigen voor meer informatie.

Developers

Ontwerpers

Samples

Archiefvoorbeelden

  • Last updated on