Tastaturereignisse

Tastaturereignisse und Fokus

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

Ereignis	Beschreibung
KeyDown	Tritt beim Drücken einer Taste ein.
KeyUp	Tritt ein, wenn eine Taste losgelassen wird.

Wichtig

Einige XAML-Steuerelemente behandeln Eingabeereignisse intern. In diesen Fällen kann es vorkommen, dass ein Eingabeereignis nicht auftritt, da ihr Ereignislistener den zugehörigen Handler nicht aufruft. In der Regel wird diese Teilmenge der Tasten vom Klassenhandler verarbeitet, um integrierte Unterstützung grundlegender Tastaturbarrierefreiheit bereitzustellen. Beispielsweise überschreibt die Button-Klasse die OnKeyDown-Ereignisse sowohl für die LEERTASTE als auch für die EINGABETASTE (sowie OnPointerPressed) und leitet sie an das Click-Ereignis des Steuerelements weiter. Wenn ein Tastendruck von der Steuerelementklasse behandelt wird, werden die KeyDown - und KeyUp-Ereignisse nicht ausgelöst.
Dies bietet eine integrierte Tastaturentsprechung zum Aufrufen der Schaltfläche, ähnlich wie beim Tippen mit einem Finger oder Beim Klicken mit einer Maus. Andere Tasten als Leerzeichen oder EINGABETASTE werden weiterhin keyDown- und KeyUp-Ereignisse ausgelöst. Weitere Informationen dazu, wie klassenbasierte Behandlung von Ereignissen funktioniert (insbesondere der Abschnitt "Eingabeereignishandler in Steuerelementen"), finden Sie unter "Ereignisse und Routingereignisse" (Übersicht).

Steuerelemente in der Benutzeroberfläche generieren Tastaturereignisse nur, wenn sie den Eingabefokus haben. Ein einzelnes Steuerelement erhält den Fokus, wenn der Benutzer direkt auf dieses Steuerelement im Layout klickt oder tippt oder die TAB-TASTE verwendet, um in eine Tabstoppsequenz im Inhaltsbereich zu gelangen.

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 im Beispiel für Tastenkombinationen weiter unten in diesem Thema.

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 ist die Aktivierreihenfolge von Steuerelementen die Reihenfolge, in der sie in der XAML (Extensible Application Markup Language) angezeigt werden. 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 meldet das Objekt, an dem der Ereignishandler angefügt 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 über eine Objektstruktur blasen, ist OriginalSource manchmal das Bedenkobjekt und nicht der Absender. 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 ein Schlüssel losgelassen 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.

Zusatztasten

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.

Hinweis

Integrierte Tastenkombinationen finden Sie unter Zugriffstasten und Zugriffstasten.

Sie können Tastenkombinationen in den KeyDown- und KeyUp-Ereignishandlern erkennen. Wenn ein Tastaturereignis für eine Nichtmodifizierertaste auftritt, können Sie überprüfen, ob sich eine Zusatztaste im gedrückten Zustand befindet.

Alternativ kann die GetKeyState()-Funktion des CoreWindow (abgerufen über CoreWindow.GetForCurrentThread()) auch verwendet werden, 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.

Hinweis

Die ALT-TASTE wird durch den Wert "VirtualKey.Menu " dargestellt.

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 QuickInfos und AutomationProperties-Eigenschaften in den Schaltflächenbeschriftungen 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 = 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

Hinweis

Das Festlegen von AutomationProperties.AcceleratorKey oder AutomationProperties.AccessKey in XAML stellt Zeichenfolgeninformationen bereit, die die Tastenkombination zum Aufrufen dieser bestimmten Aktion dokumentiert. Die Informationen werden von Microsoft Benutzeroberflächenautomatisierung Clients wie der Sprachausgabe erfasst und in der Regel direkt für den Benutzer bereitgestellt.

Das Festlegen von AutomationProperties.AcceleratorKey oder AutomationProperties.AccessKey hat keine eigene Aktion. Sie müssen weiterhin Handler für KeyDown- oder KeyUp-Ereignisse anfügen, um das Verhalten der Tastenkombination tatsächlich in Ihrer App zu implementieren. Außerdem wird die Unterstreichungstext-Dekoration für eine Zugriffstaste nicht automatisch bereitgestellt. Sie müssen den Text für den spezifischen Schlüssel in Ihrem Mnemonic explizit als Inline-Unterstreichungsformatierung unterstreichen, wenn Sie unterstrichenen Text in der Benutzeroberfläche anzeigen möchten.

 

Tastaturroutenereignisse

Bestimmte Ereignisse sind Routingereignisse, einschließlich KeyDown und KeyUp. Routingereignisse verwenden die Bubbling-Routingstrategie. Die Bubblingroutingstrategie bedeutet, dass ein Ereignis von einem untergeordneten Objekt stammt und dann an aufeinander folgende übergeordnete Objekte in der Objektstruktur 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 bis zur übergeordneten Canvas eingeblasen.

<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 stackPanel sein, da 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 Ereignisquellobjekt zu unterscheiden, wenn Sie das Ereignis für ein übergeordnetes Objekt behandeln.

Die Handled-Eigenschaft in Ereignisdaten

Je nach Ereignisbehandlungsstrategie möchten Sie möglicherweise nur einen Ereignishandler auf ein Bubbling-Ereignis reagieren. 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 auch das Ereignis behandelt. In diesem Szenario können Sie die Handled-Eigenschaft in den Ereignisdaten verwenden.

Der Zweck der Handled-Eigenschaft in einer Routingereignisdatenklasse besteht darin, zu melden, dass bereits ein anderer Handler gemeldet wird, den Sie zuvor auf der Ereignisroute registriert haben. Dies beeinflusst das Verhalten des Routingereignissystems. 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 Handlern verwenden, die auf Bereits als behandelt markierte Ereignisse reagieren können. 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 Routingereignisbezeichner (KeyDownEvent und KeyUpEvent) für UIElement. 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 wichtige Ereignisse für bestimmte Steuerelemente (z . B. GridView) außer Kraft setzen, um eine konsistente Fokusnavigation für verschiedene Eingabegeräte bereitzustellen, 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);
    }
  }

Hinweis

Wenn Sie eine GridView nur für das Layout verwenden, sollten Sie andere Steuerelemente wie ItemsControl mit ItemsWrapGrid verwenden.

Befehle

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 verwandter UI-Eingaben, z. B. einer bestimmten Zeigeraktion oder einer bestimmten Zugriffstaste, indem sie einen einzelnen Befehlshandler aufrufen.

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 auf Tastaturereignisse mit eigener Behandlung. 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 KeyDown hinzufü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 Schaltfläche) KeyUp, sodass sie auf die LEERTASTE oder die EINGABETASTE überprüfen kann. ButtonBase betrachtet KeyUp als Äquivalent zu einer nach links zeigenden Maustaste, um ein Click-Ereignis auszulösen. Diese Verarbeitung des Ereignisses erfolgt, wenn ButtonBase die virtuelle Methode OnKeyUp überschreibt. In der Implementierung wird handled auf "true" festgelegt. Das Ergebnis ist, dass jedes übergeordnete Element einer Schaltfläche, die auf ein Schlüsselereignis lauscht, im Falle einer Leertaste das bereits behandelte Ereignis für seine eigenen Handler nicht empfängt.

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 ihr eigenes ähnliches Überschreibungsverhalten für Schlüsselereignisse implementieren, indem OnKeyDown / OnKeyUp überschrieben wird. Wenn Ihr benutzerdefiniertes Steuerelement bestimmte Tastenkombinationen verarbeitet oder ein Steuerelement- oder Fokusverhalten aufweist, das dem für TextBox beschriebenen Szenario ähnelt, sollten Sie diese Logik in Ihre eigenen OnKeyDown / OnKeyUp-Außerkraftsetzungen setzen.

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 für die 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 Bildschirmtastatur.

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

Designer

• Richtlinien für tastaturdesigns

Beispiele

• Beispiel für die Bildschirmtastatur
• Beispiel für eine einfache Eingabe
• Beispiel für eine Eingabe mit geringer Latenz
• Beispiel für visuelle Fokuselemente

Archivbeispiele

• Eingabebeispiel
• Eingabe: Beispiel für Gerätefunktionen
• Eingabe: Beispiel für eine Bildschirmtastatur
• Beispiel für Reagieren auf die Darstellung der Bildschirmtastatur
• Beispiel für die XAML-Textbearbeitung