Tastaturereignisse

Tastaturereignisse und Fokus

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

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 tritt ein Eingabeereignis möglicherweise nicht ein, weil der Ereignislistener den zugehörigen Handler nicht aufruft. Normalerweise wird diese Tastenteilmenge vom Klassenhandler verarbeitet, um eine integrierte Unterstützung für die Barrierefreiheit des einfachen Tastaturzugriffs bereitzustellen. Die Klasse Button setzt beispielsweise die OnKeyDown-Ereignisse für die LEERTASTE und die EINGABETASTE (sowie für OnPointerPressed) außer Kraft und leitet sie an das Ereignis Click des Steuerelements weiter. Wenn von der Steuerelementklasse ein Tastendruck verarbeitet wird, werden die Ereignisse KeyDown und KeyUp nicht ausgelöst.
Dadurch wird ein integriertes Tastaturäquivalent zum Aufrufen der Schaltfläche bereitgestellt, das dem Tippen mit dem Finger oder Klicken mit einer Maus ähnelt. Andere Tasten als die LEER- oder EINGABETASTE lösen die Ereignisse KeyDown und KeyUp trotzdem aus. Weitere Informationen zur klassenbasierten Behandlung von Ereignissen (insbesondere im Abschnitt "Eingabeereignishandler in Steuerelementen") finden Sie unter Übersicht über Ereignisse und Routingereignisse.

Die Steuerelemente der UI generieren nur dann Tastaturereignisse, wenn sie den Eingabefokus aufweisen. Ein einzelnes Steuerelement steht im Fokus, wenn Benutzer im Layout auf das Steuerelement klicken oder tippen oder mit der TAB-Taste im Inhaltsbereich eine Aktivierreihenfolge durchlaufen.

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

Damit ein Steuerelement den Eingabefokus erhält, muss es aktiviert und sichtbar sein. Außerdem müssen die Eigenschaften IsTabStop und HitTestVisible den Wert true haben. Dies ist der Standardzustand der meisten Steuerelemente. Wenn ein Steuerelement den Eingabefokus aufweist, kann es Tastatureingabeereignisse auslösen und auf diese reagieren. Dies wird weiter unten in diesem Thema beschrieben. Mit den Ereignissen GotFocus und LostFocus können Sie außerdem reagieren, wenn ein Steuerelement den Fokus erhält oder verliert.

Standardmäßig entspricht die Aktivierreihenfolge von Steuerelementen der Reihenfolge, in der sie in der Extensible Application Markup Language (XAML) angezeigt werden. Mit der Eigenschaft TabIndex können Sie diese Reihenfolge jedoch ändern. Weitere Informationen finden Sie unter Implementieren der Tastaturbarrierefreiheit.

Tastaturereignishandler

Ein Eingabe-Ereignishandler implementiert einen Delegaten, der die folgenden Informationen bereitstellt:

• Der Absender des Ereignisses. Der Sender meldet das Objekt, dem der Ereignishandler angefügt ist.
• Ereignisdaten. Bei Tastaturereignissen sind diese Daten eine Instanz von KeyRoutedEventArgs. KeyEventHandler ist der Delegat für Handler. Die wichtigsten Eigenschaften von KeyRoutedEventArgs für die meisten Handler-Szenarien sind Key und möglicherweise KeyStatus.
• OriginalSource. Da es sich bei Tastaturereignissen um Routingereignisse handelt, stellen die Ereignisdaten OriginalSource bereit. Wenn Sie bewusst das Bubbling von Ereignissen in der Objektstruktur zulassen, ist OriginalSource manchmal eher das fragliche Objekt als der Sender. Das hängt jedoch vom Design ab. Weitere Informationen dazu, wie Sie OriginalSource anstelle des Senders verwenden können, finden Sie im Abschnitt „Routingereignisse der Tastatur“ in diesem Thema oder unter Übersicht über Ereignisse und Routingereignisse.

Anfügen eines Tastaturereignishandlers

Sie können Funktionen von Tastatur-Ereignishandlern für jedes Objekt anfügen, das das Ereignis als Member einschließt. Dazu gehört jede von UIElement abgeleitete Klasse. Das folgende XAML-Beispiel zeigt, wie Sie Handler für das Ereignis KeyUp für Grid anfügen.

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

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

Definieren eines Tastaturereignishandlers

Das folgende Beispiel zeigt eine unvollständige Ereignishandler-Definition für den im vorherigen Beispiel hinzugefügten Ereignishandler KeyUp.

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. KeyRoutedEventArgs enthält die folgenden Eigenschaften:

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

Virtuelle Schlüssel

Das KeyDown-Ereignis wird ausgelöst, wenn eine Taste gedrückt wird. Entsprechend wird das KeyUp-Ereignis ausgelöst, wenn eine Taste losgelassen wird. In der Regel lauschen Sie auf Ereignisse, um einen bestimmten Tastenwert zu verarbeiten. Überprüfen Sie den Wert Key in den Ereignisdaten, um die gedrückte oder losgelassene Taste zu ermitteln. Key gibt einen VirtualKey-Wert zurück. Die VirtualKey-Enumeration umfasst alle unterstützten Tasten.

Zusatztasten

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

Hinweis

Informationen zu integrierten Tastenkombinationen finden Sie unter Zugriffstasten und Tastenkombinationen.

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

Alternativ kann die GetKeyState() -Funktion von CoreWindow (abgerufen über CoreWindow.GetForCurrentThread()) auch verwendet werden, um den Modifiziererstatus zu überprüfen, wenn eine Nicht-Modifizierertaste gedrückt wird.

In den folgenden Beispielen wird diese zweite Methode implementiert und gleichzeitig Stubcode für die erste Implementierung eingeschlossen.

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 mit den Schaltflächen „Play“, „Pause“ und „Stop“ oder mit den Tastenkombinationen STRG+P, STRG+A und STRG+S steuern. Das Schaltflächen-XAML zeigt die Tastenkombinationen in Form von QuickInfos und AutomationProperties-Eigenschaften in den Schaltflächenbeschriftungen. Diese Selbstdokumentation ist wichtig, um die Benutzerfreundlichkeit und Barrierefreiheit der App zu erhöhen. Weitere Informationen finden Sie unter Tastaturzugriff.

Beachten Sie auch, dass die Seite den Eingabefokus auf sich selbst festlegt, wenn sie geladen wird. Ohne diesen Schritt hat kein Steuerelement anfangs den Eingabefokus, und die App löst erst Eingabeereignisse aus, wenn Benutzer den Eingabefokus manuell festlegen (beispielsweise 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

Durch das Festlegen der AutomationProperties.AcceleratorKey- oder AutomationProperties.AccessKey-Eigenschaft in XAML werden Zeichenfolgeninformationen zum Dokumentieren der Tastenkombination zum Auslösen der jeweiligen Aktion bereitgestellt. Die Informationen werden von Microsoft-Benutzeroberflächenautomatisierungsclients wie der Sprachausgabe erfasst und normalerweise direkt für den Benutzer bereitgestellt.

Mit dem Festlegen der Eigenschaft AutomationProperties.AcceleratorKey oder AutomationProperties.AccessKey ist keine eigene Aktion verknüpft. Sie müssen weiterhin Handler für KeyDown- oder KeyUp-Ereignisse anhängen, um das Verhalten der Tastenkombination tatsächlich in die App zu implementieren. Außerdem wird der Unterstrichzusatz für eine Zugriffstaste nicht automatisch bereitgestellt. Sie müssen den Text für die jeweilige Taste in Ihrem mnemonischen Zeichen explizit als Underline-Formatierung unterstreichen, wenn in der UI unterstrichener Text angezeigt werden soll.

 

Routingereignisse der Tastatur

Bestimmte Ereignisse gelten als Routingereignisse, wie z. B. KeyDown und KeyUp. Routingereignisse verwenden die Bubbling-Routingstrategie. Bei der Bubbling-Routingstrategie geht ein Ereignis von einem untergeordneten Objekt aus und wird jeweils an die übergeordneten Objekte in der Struktur weitergeleitet. Dadurch ergibt sich eine weitere Möglichkeit, dasselbe Ereignis zu behandeln und mit denselben Ereignisdaten zu interagieren.

Im folgenden XAML-Beispiel werden KeyUp-Ereignisse für ein Canvas-Objekt und zwei Button-Objekte definiert. Wenn Sie in diesem Fall eine Taste loslassen, während der Fokus auf einem der Button-Objekte liegt, wird das KeyUp-Ereignis ausgelöst. Das Ereignis wird dann in die übergeordnete 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 Ereignishandler KeyUp 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 Eigenschaft OriginalSource im vorherigen Handler. Hier meldet OriginalSource das Objekt, das das Ereignis ausgelöst hat. Bei dem Objekt kann es sich nicht um StackPanel handeln, da StackPanel kein Steuerelement ist und nicht im Fokus stehen kann. Nur eine der beiden Schaltflächen in StackPanel kann das Ereignis ausgelöst haben. Die Frage ist, welche? Mit OriginalSource können Sie das tatsächliche Quellobjekt des Ereignisses unterscheiden, wenn Sie das Ereignis für ein übergeordnetes Objekt verarbeiten.

Die Handled-Eigenschaft in Ereignisdaten

Je nach Ihrer Strategie für die Ereignisverarbeitung empfiehlt sich vielleicht nur ein Ereignishandler, der auf ein Bubbling-Ereignis reagiert. Wenn beispielsweise ein bestimmter KeyUp-Handler an eines der Button-Steuerelemente angefügt ist, hat dieses zuerst Gelegenheit, das Ereignis zu verarbeiten. In diesem Fall ist es nicht sinnvoll, dass auch das übergeordnete Panel das Ereignis behandelt. Verwenden Sie in diesem Szenario die Eigenschaft Handled in den Ereignisdaten.

Der Zweck der Eigenschaft Handled in der Datenklasse eines Routingereignisses besteht darin, zu melden, dass ein anderer Handler, den Sie an früherer Stelle in der Ereignisroute registriert haben, bereits tätig war. Dies beeinflusst das Verhalten des Routingereignissystems. Wenn Sie Handled in einem Ereignishandler auf true festlegen, ist das Routing eines Ereignisses beendet, und das Ereignis wird nicht mehr an nachfolgende übergeordnete Elemente gesendet.

"AddHandler " und bereits behandelte Tastaturereignisse

Sie können eine spezielle Technik verwenden, um Handler anzufügen, die auf bereits als verarbeitet markierte Ereignisse reagieren können. Bei dieser Technik wird die AddHandler-Methode verwendet, um einen Handler zu registrieren, anstatt XAML-Attribute oder sprachspezifische Syntax zum Hinzufügen von Handlern wie += in C# zu verwenden.

Eine generelle Einschränkung dieser Technik besteht darin, dass die API AddHandler einen Parameter vom Typ RoutedEvent verwendet, der das fragliche Routingereignis identifiziert. Nicht alle Routingereignisse bieten einen RoutedEvent-Bezeichner. Dieser Umstand wirkt sich somit darauf aus, welche Routingereignisse im Fall Handled noch verarbeitet werden können. Die Ereignisse KeyDown und KeyUp haben Routingereignisbezeichner (KeyDownEvent und KeyUpEvent) in UIElement. Andere Texteingabe-Ereignisse, wie TextBox.TextChanged, besitzen jedoch keine Routingereignisbezeichner und können deshalb für die Technik AddHandler nicht verwendet werden.

Überschreiben von Tastaturereignissen und Verhalten

Sie können die wichtigsten Ereignisse für bestimmte Steuerelemente überschreiben (z. B. GridView), um eine konsistente Fokusnavigation für verschiedene Eingabegeräte (darunter Tastatur und Gamepad) bereitzustellen.

Im folgenden Beispiel wird das Steuerelement unterklassiert und das KeyDown-Verhalten überschrieben, 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 ein GridView nur für Layoutzwecke verwendet wird, sollten Sie möglicherweise andere Steuerelemente verwenden, wie z. B. ItemsControl mit ItemsWrapGrid.

Befehle

Eine geringe Anzahl von UI-Elementen verfügt über integrierte Unterstützung für die Steuerung. Die Steuerung verwendet eingabebezogene Routingereignisse in der zugrundeliegenden Implementierung. Sie ermöglicht die Verarbeitung verwandter UI-Eingaben (eine bestimmte Zeigeraktion oder Zugriffstaste) durch das Aufrufen eines einzelnen Befehlshandlers.

Wenn die Steuerung für ein UI-Element verfügbar ist, sollten Sie dessen Steuerungs-APIs anstelle einzelner Eingabeereignisse verwenden. Weitere Informationen finden Sie unter ButtonBase.Command.

Sie können auch ICommand implementieren, um die Befehlsfunktionalität zu kapseln, die Sie über normale Ereignishandler aufrufen. Auf diese Weise können Sie die Steuerung auch verwenden, wenn keine Command-Eigenschaft verfügbar ist.

Texteingabe und Steuerelemente

Bestimmte Steuerelemente reagieren mit einer eigenen Verarbeitung auf Tastaturereignisse. So ist beispielsweise das Steuerelement TextBox dazu gedacht, über die Tastatur eingegebenen Text zu erfassen und visuell darzustellen. Es verwendet in seiner eigenen Logik KeyUp und KeyDown zum Erfassen von Tastaturanschlägen und löst dann auch sein eigenes TextChanged-Ereignis aus, wenn der Text tatsächlich geändert wurde.

Trotzdem können Sie generell einer TextBox oder einem verwandten Steuerelement, das der Verarbeitung von Texteingaben dient, Handler für KeyUp und KeyDown hinzufügen. Jedoch reagiert ein Steuerelement möglicherweise im Rahmen seines Designs nicht auf alle Tastenwerte, die es über Tastaturereignisse empfängt. Das Verhalten hängt ganz vom jeweiligen Steuerelement ab.

Beispielsweise verarbeitet ButtonBase (die Basisklasse von Button) KeyUp so, dass eine Überprüfung für die LEERTASTE oder für die EINGABETASTE durchgeführt werden kann. ButtonBase verarbeitet KeyUp analog zu einem Ereignis für das Drücken der linken Maustaste, um ein Click-Ereignis auszulösen. Diese Verarbeitung des Ereignisses wird beim Überschreiben der virtuellen Methode OnKeyUp durch ButtonBase erreicht. In der Implementierung wird Handled auf true festgelegt. Als Ergebnis empfängt kein übergeordnetes Element einer Schaltfläche, die bei der LEERTASTE auf ein Tastaturereignis lauscht, das bereits verarbeitete Element für seine eigenen Handler.

TextBox ist ein weiteres Beispiel. Einige Tasten, z. B. die Pfeiltasten, werden von TextBox nicht als Text betrachtet und stattdessen als spezifisch für das Verhalten der Steuerelement-Benutzeroberfläche betrachtet. TextBox markiert diese Ereignisse als verarbeitet.

Benutzerdefinierte Steuerelemente können ihr eigenes ähnliches Außerkraftsetzungsverhalten für Schlüsselereignisse implementieren, indem OnKeyDown / OnKeyUp überschrieben wird. Wenn Ihr benutzerdefiniertes Steuerelement bestimmte Zugriffstasten verarbeitet oder ein Steuerelement- oder Fokusverhalten besitzt, das mit dem für TextBox geschilderten Szenario vergleichbar ist, sollten Sie diese Logik in Ihre eigenen OnKeyDown / OnKeyUp-Überschreibungen aufnehmen.

Die Touch-Bildschirmtastatur

Steuerelemente für die Texteingabe bieten automatische Unterstützung für die Touch-Bildschirmtastatur. Wenn Benutzer den Eingabefokus per Fingereingabe auf ein Textsteuerelement festlegen, wird automatisch die Bildschirmtastatur angezeigt. Wenn sich der Eingabefokus nicht auf einem Textsteuerelement befindet, ist die Bildschirmtastatur ausgeblendet.

Wenn die Bildschirmtastatur angezeigt wird, wird Ihre UI automatisch umpositioniert, um sicherzustellen, dass das Element mit dem Fokus sichtbar bleibt. Dies kann dazu führen, dass andere wichtige Bereiche der UI nicht mehr auf dem Bildschirm angezeigt werden. Sie können das Standardverhalten jedoch deaktivieren und eigene UI-Anpassungen vornehmen, wenn die Bildschirmtastatur eingeblendet wird. Weitere Informationen finden Sie im Bildschirmtastaturbeispiel.

Wenn Sie ein benutzerdefiniertes Steuerelement erstellen, das zwar Texteingabe erfordert, aber nicht von einem Standardsteuerelement für die Texteingabe abgeleitet ist, können Sie Unterstützung für die Touch-Bildschirmtastatur hinzufügen, indem Sie die richtigen Steuerelementmuster der Benutzeroberflächenautomatisierung implementieren. Weitere Informationen finden Sie im Bildschirmtastaturbeispiel.

Durch Drücken von Tasten auf der Touch-Bildschirmtastatur werden genau wie beim Drücken von Tasten auf Hardwaretastaturen die Ereignisse KeyDown und KeyUp ausgelöst. Die Touch-Bildschirmtastatur löst jedoch keine Eingabeereignisse für STRG+A, STRG+Z, STRG+X, STRG+C und STRG+V aus, da diese Tastenkombinationen für Textänderungen im Eingabesteuerelement reserviert sind.

Benutzer können Daten in Ihre App schneller und einfacher eingeben, wenn Sie den Eingabeumfang des Textsteuerelements an die Art der Daten anpassen, die der Benutzer vermutlich eingeben wird. Der Eingabeumfang bietet einen Hinweis auf die Art von Text, die vermutlich über das Steuerelement eingegeben wird. Auf diese Weise kann das System ein spezielles Bildschirmtastaturlayout für den Eingabetyp bereitstellen. Wenn beispielsweise ein Textfeld nur zum Eingeben einer 4-stelligen PIN verwendet wird, legen Sie die InputScope-Eigenschaft auf Zahl fest. Dies weist das System an, das Layout der Zehnertastatur anzuzeigen, das dem Benutzer die Eingabe der PIN erleichtert. Weitere Informationen 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

• Tastaturentwurfsrichtlinien

Beispiele

• Beispiel für die Bildschirmtastatur
• Einfaches Eingabebeispiel
• Eingabebeispiel mit geringer Latenz
• Beispiel für visuelle Fokuselemente

Archivbeispiele

• Eingabebeispiel
• Eingabe: Beispiel für Gerätefunktionen
• Eingabe: Beispiel für die Bildschirmtastatur
• Beispiel für die Reaktion auf die Anzeige der Bildschirmtastatur
• Beispiel für die XAML-Textbearbeitung