Tastaturereignisse

Tastaturereignisse und Fokus

Die folgenden Tastaturereignisse können sowohl für Hardware- als auch für Bildschirmtastaturen auftreten.

Steuerelemente in der Benutzeroberfläche generieren Tastaturereignisse nur, wenn sie den Eingabefokus haben. Ein einzelnes Steuerelement erhält den Fokus, wenn der Benutzer im Layout direkt auf dieses Steuerelement klickt oder tippt oder die Tab-Taste verwendet, um innerhalb des Inhaltsbereichs in eine Tabreihenfolge zu wechseln.

Sie können auch die Focus-Methode eines Steuerelements aufrufen, um den Fokus zu erzwingen. Dies ist erforderlich, wenn Sie Tastenkombinationen implementieren, da der Tastaturfokus beim Laden der Benutzeroberfläche nicht standardmäßig festgelegt ist. Weitere Informationen finden Sie weiter unten in diesem Thema im Beispiel für Tastenkombinationen.

Damit ein Steuerelement den Eingabefokus empfängt, muss es aktiviert, sichtbar sein und isTabStop- und HitTestVisible-Eigenschaftswerte "true" aufweisen. Dies ist der Standardzustand für die meisten Steuerelemente. Wenn ein Steuerelement den Eingabefokus hat, kann es Tastatureingabeereignisse auslösen und darauf reagieren, wie weiter unten in diesem Thema beschrieben. Sie können auch auf ein Steuerelement reagieren, das den Fokus erhält oder verliert, indem Sie die GotFocus- und LostFocus-Ereignisse behandeln.

Standardmäßig entspricht die Tabreihenfolge von Steuerelementen der Reihenfolge, in der sie in XAML (Extensible Application Markup Language) definiert sind. Sie können diese Reihenfolge jedoch mithilfe der TabIndex-Eigenschaft ändern. Weitere Informationen finden Sie unter Implementieren der Barrierefreiheit der Tastatur.

Tastaturereignishandler

Ein Eingabeereignishandler implementiert einen Delegaten, der die folgenden Informationen bereitstellt:

• Der Absender des Ereignisses. Der Absender gibt das Objekt an, dem der Ereignishandler zugeordnet ist.
• Ereignisdaten. Bei Tastaturereignissen handelt es sich bei diesen Daten um eine Instanz von KeyRoutedEventArgs. Der Delegat für Handler ist KeyEventHandler. Die relevantesten Eigenschaften von KeyRoutedEventArgs für die meisten Handlerszenarien sind Key und möglicherweise KeyStatus.
• OriginalSource. Da die Tastaturereignisse Routingereignisse sind, stellen die Ereignisdaten OriginalSource bereit. Wenn Sie absichtlich zulassen, dass Ereignisse durch eine Objekthierarchie nach oben weitergereicht werden, ist OriginalSource manchmal das relevante Objekt und nicht der Sender. Dies hängt jedoch von Ihrem Design ab. Weitere Informationen dazu, wie Sie OriginalSource anstelle des Absenders verwenden können, finden Sie im Abschnitt "Tastaturroutenereignisse" dieses Themas oder in der Übersicht über Ereignisse und Routingereignisse.

Anfügen eines Tastaturereignishandlers

Sie können Tastaturereignishandlerfunktionen für jedes Objekt anfügen, das das Ereignis als Element enthält. Dazu gehören alle von UIElement abgeleiteten Klassen. Das folgende XAML-Beispiel zeigt, wie Handler für das KeyUp-Ereignis für ein Grid angefügt werden.

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

Sie können auch einen Ereignishandler im Code anfügen. Weitere Informationen finden Sie unter Übersicht über Ereignisse und Routingereignisse.

Definieren eines Tastaturereignishandlers

Das folgende Beispiel zeigt die unvollständige Ereignishandlerdefinition für den KeyUp-Ereignishandler , der im vorherigen Beispiel angefügt wurde.

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
  }

Verwenden von KeyRoutedEventArgs

Alle Tastaturereignisse verwenden KeyRoutedEventArgs für Ereignisdaten, und KeyRoutedEventArgs enthält die folgenden Eigenschaften:

• Schlüssel
• KeyStatus
• Gehandhabt
• OriginalSource (geerbt von RoutedEventArgs)

Virtuelle Schlüssel

Das KeyDown-Ereignis wird ausgelöst, wenn eine Taste gedrückt wird. Ebenso wird KeyUp ausgelöst, wenn eine Taste freigegeben wird. In der Regel lauschen Sie auf die Ereignisse, um einen bestimmten Schlüsselwert zu verarbeiten. Um zu ermitteln, welche Taste gedrückt oder losgelassen wird, überprüfen Sie den Schlüsselwert in den Ereignisdaten. Key gibt einen VirtualKey-Wert zurück. Die VirtualKey-Aufzählung enthält alle unterstützten Schlüssel.

Modifikatortasten

Modifizierertasten sind Tasten wie STRG oder UMSCHALT, die Benutzer in der Regel in Kombination mit anderen Tasten drücken. Ihre App kann diese Kombinationen als benutzerdefinierte Tastenkombinationen verwenden, um App-Befehle aufzurufen.

Sie können Tastenkombinationen in den KeyDown- und KeyUp-Ereignishandlern erkennen. Wenn ein Tastaturereignis für eine Taste auftritt, die keine Modifikatortaste ist, können Sie anschließend prüfen, ob eine Modifikatortaste gedrückt ist.

Alternativ können Sie in WinUI 3 inputKeyboardSource.GetKeyStateForCurrentThread verwenden, um den Modifiziererstatus zu überprüfen, wenn eine Nicht-Modifizierertaste gedrückt wird.

Die folgenden Beispiele implementieren diese zweite Methode und enthalten auch Stubcode für die erste Implementierung.

Beispiel für Tastenkombinationen

Im folgenden Beispiel wird veranschaulicht, wie eine Reihe von benutzerdefinierten Tastenkombinationen implementiert wird. In diesem Beispiel können Benutzer die Medienwiedergabe mithilfe der Tastenkombinationen "Wiedergeben", "Anhalten" und "Beenden" oder "STRG+P", "STRG+A" und "STRG+S" steuern. Der XAML-Code der Schaltfläche zeigt die Tastenkombinationen mithilfe von Tooltips und AutomationProperties-Eigenschaften in den Beschriftungen der Schaltflächen an. Diese Selbstdokumentation ist wichtig, um die Benutzerfreundlichkeit und Barrierefreiheit Ihrer App zu erhöhen. Weitere Informationen finden Sie unter Barrierefreiheit der Tastatur.

Beachten Sie auch, dass die Seite den Eingabefokus auf sich selbst festlegt, wenn sie geladen wird. Ohne diesen Schritt hat kein Steuerelement den anfänglichen Eingabefokus, und die App löst keine Eingabeereignisse aus, bis der Benutzer den Eingabefokus manuell festlegt (z. B. durch Drücken der TAB-TASTE oder Klicken auf ein Steuerelement).

<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,&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 = Microsoft::UI::Input::InputKeyboardSource::GetKeyStateForCurrentThread(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 = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(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 = Microsoft.UI.Input.InputKeyboardSource.GetKeyStateForCurrentThread(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

Geroutete Tastaturereignisse

Bestimmte Ereignisse sind Routingereignisse, einschließlich KeyDown und KeyUp. Routingereignisse verwenden die Bubbling-Routingstrategie. Die Bubbling-Routingstrategie bedeutet, dass ein Ereignis von einem untergeordneten Objekt ausgeht und dann an aufeinanderfolgende übergeordnete Objekte im Objektbaum weitergeleitet wird. Dies bietet eine weitere Möglichkeit, dasselbe Ereignis zu behandeln und mit denselben Ereignisdaten zu interagieren.

Betrachten Sie das folgende XAML-Beispiel, das KeyUp-Ereignisse für ein Canvas- und zwei Button-Objekte behandelt. Wenn Sie in diesem Fall einen Schlüssel loslassen, während der Fokus von einem der Beiden Button-Objekte gehalten wird, löst es das KeyUp-Ereignis aus. Das Ereignis wird dann an das übergeordnete Canvas weitergegeben.

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

Das folgende Beispiel zeigt, wie der KeyUp-Ereignishandler für den entsprechenden XAML-Inhalt im vorherigen Beispiel implementiert wird.

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

Beachten Sie die Verwendung der OriginalSource-Eigenschaft im vorherigen Handler. Hier meldet OriginalSource das Objekt, das das Ereignis ausgelöst hat. Das Objekt konnte nicht das StackPanel sein, da das StackPanel kein Steuerelement ist und nicht den Fokus haben kann. Nur eine der beiden Schaltflächen innerhalb des StackPanel könnte das Ereignis ausgelöst haben, aber welches? Sie verwenden OriginalSource, um das tatsächliche Ereignisquellenobjekt zu identifizieren, wenn Sie das Ereignis in einem übergeordneten Objekt behandeln.

Die Eigenschaft „Handled“ in den Ereignisdaten

Je nach Ihrer Strategie zur Ereignisbehandlung möchten Sie möglicherweise, dass nur ein Ereignishandler auf ein Bubble-Ereignis reagiert. Wenn Sie beispielsweise über einen bestimmten KeyUp-Handler verfügen, der einem der Schaltflächensteuerelemente zugeordnet ist, wäre es die erste Möglichkeit, dieses Ereignis zu behandeln. In diesem Fall möchten Sie möglicherweise nicht, dass das übergeordnete Panel das Ereignis ebenfalls verarbeitet. In diesem Szenario können Sie die Handled-Eigenschaft in den Ereignisdaten verwenden.

Der Zweck der Eigenschaft Handled in einer Klasse für Daten weitergeleiteter Ereignisse besteht darin, anzuzeigen, dass ein anderer Handler, den Sie zuvor in der Ereignisroute registriert haben, bereits gehandelt hat. Dies beeinflusst das Verhalten des Systems für weitergeleitete Ereignisse. Wenn Sie "Handled" in einem Ereignishandler auf "true" festlegen, beendet dieses Ereignis das Routing und wird nicht an aufeinander folgende übergeordnete Elemente gesendet.

AddHandler und bereits behandelte Tastaturereignisse

Sie können eine spezielle Technik zum Anfügen von Ereignishandlern verwenden, die auf Ereignisse reagieren können, die Sie bereits als behandelt markiert haben. Diese Technik verwendet die AddHandler-Methode , um einen Handler zu registrieren, anstatt XAML-Attribute oder sprachspezifische Syntax zum Hinzufügen von Handlern wie += in C# zu verwenden.

Eine allgemeine Einschränkung dieser Technik besteht darin, dass die AddHandler-API einen Parameter vom Typ RoutedEvent verwendet, der das betreffende Routingereignis identifiziert. Nicht alle Routingereignisse stellen einen RoutedEvent-Bezeichner bereit, und diese Überlegung wirkt sich daher darauf aus, welche Routingereignisse weiterhin im Handled-Fall behandelt werden können. Die KeyDown- und KeyUp-Ereignisse haben in UIElement Bezeichner für weitergeleitete Ereignisse (KeyDownEvent und KeyUpEvent). Andere Ereignisse wie TextBox.TextChanged verfügen jedoch nicht über Routingereignisbezeichner und können daher nicht mit der AddHandler-Technik verwendet werden.

Außerkraftsetzung von Tastaturereignissen und -verhalten

Sie können Tastenereignisse für bestimmte Steuerelemente (z. B. GridView) überschreiben, um eine konsistente Fokusnavigation für verschiedene Eingabegeräte zu ermöglichen, einschließlich Tastatur und Gamepad.

Im folgenden Beispiel unterklassen wir das Steuerelement und überschreiben das KeyDown-Verhalten, um den Fokus auf den GridView-Inhalt zu verschieben, wenn eine Pfeiltaste gedrückt wird.

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

Befehlssteuerung

Eine kleine Anzahl von UI-Elementen bietet integrierte Unterstützung für Befehle. Die Steuerung verwendet eingabebezogene Routingereignisse in der zugrunde liegenden Implementierung. Sie ermöglicht die Verarbeitung zusammengehöriger UI-Eingaben, z. B. einer bestimmten Zeigeraktion oder einer bestimmten Tastenkombination, indem ein einziger Befehlshandler aufgerufen wird.

Wenn die Befehle für ein UI-Element verfügbar sind, sollten Sie die Befehls-APIs anstelle einzelner Eingabeereignisse verwenden. Weitere Informationen finden Sie unter ButtonBase.Command.

Sie können ICommand auch implementieren, um Befehlsfunktionen zu kapseln, die Sie aus normalen Ereignishandlern aufrufen. Auf diese Weise können Sie Befehle auch dann verwenden, wenn keine Command-Eigenschaft verfügbar ist.

Texteingabe und -steuerelemente

Bestimmte Steuerelemente reagieren mit eigener Verarbeitung auf Tastaturereignisse. Beispielsweise ist TextBox ein Steuerelement, das für die Erfassung und visuelle Darstellung von Text konzipiert ist, der mithilfe der Tastatur eingegeben wurde. Es verwendet KeyUp und KeyDown in seiner eigenen Logik, um Tastaturanschläge zu erfassen, löst dann auch sein eigenes TextChanged-Ereignis aus, wenn der Text tatsächlich geändert wurde.

Sie können einem TextBox-Steuerelement oder einem verwandten Steuerelement, das für die Verarbeitung von Texteingaben vorgesehen ist, weiterhin Handler für KeyUp und KeyDownhinzufügen. Im Rahmen des beabsichtigten Entwurfs reagiert ein Steuerelement möglicherweise nicht auf alle Schlüsselwerte, die über Schlüsselereignisse darauf weitergeleitet werden. Das Verhalten ist für jedes Steuerelement spezifisch.

Beispielsweise verarbeitet ButtonBase (die Basisklasse für Button) KeyUp, sodass geprüft werden kann, ob die Leertaste oder die Eingabetaste gedrückt wurde. ButtonBase betrachtet KeyUp als gleichwertig mit dem Drücken der linken Maustaste, um ein Click-Ereignis auszulösen. Diese Verarbeitung des Ereignisses erfolgt, wenn ButtonBase die virtuelle Methode OnKeyUp überschreibt. In seiner Implementierung setzt es Handled auf true. Das Ergebnis ist, dass jedes übergeordnete Element einer Schaltfläche, das auf ein Tastenereignis reagiert, im Fall der Leertaste das bereits behandelte Ereignis nicht für seine eigenen Behandlungsroutinen erhält.

Ein weiteres Beispiel ist TextBox. Einige Tasten, z. B. die Pfeiltasten, werden von TextBox nicht als Text betrachtet und gelten stattdessen als spezifisch für das Benutzeroberflächenverhalten des Steuerelements. Das TextBox-Objekt kennzeichnet diese Ereignisfälle als behandelt.

Benutzerdefinierte Steuerelemente können ein ähnliches Überschreibungsverhalten für Tastenereignisse selbst implementieren, indem OnKeyDown / und OnKeyUp überschrieben werden. Wenn Ihr benutzerdefiniertes Steuerelement bestimmte Tastenkürzel verarbeitet oder ein Steuerelement- oder Fokusverhalten aufweist, das dem für TextBox beschriebenen Szenario ähnelt, sollten Sie diese Logik in Ihren eigenen Überschreibungen von OnKeyDown / OnKeyUp platzieren.

Die Bildschirmtastatur

Texteingabesteuerelemente bieten automatische Unterstützung für die Bildschirmtastatur. Wenn der Benutzer den Eingabefokus mithilfe der Toucheingabe auf ein Textsteuerelement festlegt, wird die Bildschirmtastatur automatisch angezeigt. Wenn sich der Eingabefokus nicht auf einem Textsteuerelement befindet, wird die Bildschirmtastatur ausgeblendet.

Wenn die Bildschirmtastatur angezeigt wird, wird die Benutzeroberfläche automatisch neu positioniert, um sicherzustellen, dass das fokussierte Element sichtbar bleibt. Dies kann dazu führen, dass andere wichtige Bereiche der Benutzeroberfläche vom Bildschirm verschoben werden. Sie können jedoch das Standardverhalten deaktivieren und ihre eigenen UI-Anpassungen vornehmen, wenn die Bildschirmtastatur angezeigt wird. Weitere Informationen finden Sie im Beispiel „Bildschirmtastatur“.

Wenn Sie ein benutzerdefiniertes Steuerelement erstellen, das Texteingabe erfordert, aber nicht von einem Standardmäßigen Texteingabesteuerelement abgeleitet wird, können Sie die Unterstützung der Bildschirmtastatur hinzufügen, indem Sie die richtigen Benutzeroberflächenautomatisierung Steuerelementmuster implementieren. Weitere Informationen finden Sie im Beispiel für die Touch-Tastatur.

Tastendrücke auf der Bildschirmtastatur lösen KeyDown- und KeyUp-Ereignisse genau wie Tastendrücke auf Hardwaretastaturen aus. Die Bildschirmtastatur löst jedoch keine Eingabeereignisse für STRG+A, STRG+Z, STRG+X, STRG+C und STRG+V aus, die für die Textbearbeitung im Eingabesteuerelement reserviert sind.

Sie können die Dateneingabe in Ihrer Anwendung wesentlich beschleunigen und erleichtern, indem Sie den Eingabebereich des Textsteuerelements so einstellen, dass er der Art von Daten entspricht, die Sie vom Benutzer erwarten. Der Eingabeumfang bietet einen Hinweis auf den Typ der vom Steuerelement erwarteten Texteingabe, sodass das System ein spezielles Bildschirmtastaturlayout für den Eingabetyp bereitstellen kann. Wird ein Textfeld beispielsweise nur verwendet, um eine vierstellige PIN einzugeben, legen Sie die InputScope-Eigenschaft auf Number fest. Dadurch wird dem System mitgeteilt, dass das Layout der Zehnertastatur angezeigt wird, sodass der Benutzer die PIN einfacher eingeben kann. Weitere Details finden Sie unter Verwenden des Eingabeumfangs zum Ändern der Bildschirmtastatur.

Verwandte Artikel

Entwickler

• Tastaturinteraktionen
• Identifizieren von Eingabegeräten
• Reagieren auf das Vorhandensein der Bildschirmtastatur

Konstrukteure

• Richtlinien für tastaturdesigns

Beispiele

• Beispiel einer Touch-Tastatur
• Einfaches Eingabebeispiel
• Beispiel für eine Eingabe mit geringer Latenz
• Beispiel für Fokussierungsvisualisierung

Archivbeispiele

• Eingabebeispiel
• Eingabe: Beispiel für Gerätefunktionen
• Eingabe: Beispiel für die Touch-Tastatur
• Reaktion auf das Erscheinen des virtuellen Tastaturbeispiels
• Beispiel für die Bearbeitung von XAML-Text