Eventi della tastieraKeyboard events

Eventi della tastiera e stato attivoKeyboard events and focus

Gli eventi della tastiera seguenti possono verificarsi per tastiere hardware e virtuali.The following keyboard events can occur for both hardware and touch keyboards.

EventEvent DescrizioneDescription
KeyDownKeyDown Si verifica quando un tasto viene premuto.Occurs when a key is pressed.
KeyUpKeyUp Si verifica quando si rilascia un tasto.Occurs when a key is released.

Importante

Alcuni controlli di Windows Runtime gestiscono internamente gli eventi di input.Some Windows Runtime controls handle input events internally. In questi casi, potrebbe sembrare che non si sia verificato alcun evento di input, perché il listener di eventi non richiama il gestore associato.In these cases, it might appear that an input event doesn't occur because your event listener doesn't invoke the associated handler. In genere, questo subset di chiavi viene elaborato dal gestore di classi, per offrire supporto incorporato dell'accessibilità standard da tastiera.Typically, this subset of keys is processed by the class handler to provide built in support of basic keyboard accessibility. Ad esempio, la classe Button esegue l'override degli eventi OnKeyDown sia per la chiave dello spazio che per il tasto invio (oltre a OnPointerPressed) e li instrada all'evento Click del controllo.For example, the Button class overrides the OnKeyDown events for both the Space key and the Enter key (as well as OnPointerPressed) and routes them to the Click event of the control. Quando la pressione di un tasto viene gestita dalla classe del controllo, gli eventi KeyDown e KeyUp non vengono generati.When a key press is handled by the control class, the KeyDown and KeyUp events are not raised.
Sarà quindi disponibile un equivalente incorporato da tastiera per richiamare il pulsante, in modo simile al tocco con un dito o alla selezione con il mouse.This provides a built-in keyboard equivalent for invoking the button, similar to tapping it with a finger or clicking it with a mouse. I tasti diversi da BARRA SPAZIATRICE o INVIO generano eventi KeyDown e KeyUp.Keys other than Space or Enter still fire KeyDown and KeyUp events. Per altre info sul funzionamento della gestione di eventi basata sulle classi, vedi Panoramica degli eventi e degli eventi indirizzati, in particolare la sezione "Gestori di eventi di input nei controlli".For more info about how class-based handling of events works (specifically, the "Input event handlers in controls" section), see Events and routed events overview.

I controlli dell'interfaccia utente generano eventi della tastiera solo quando hanno lo stato attivo per l'input.Controls in your UI generate keyboard events only when they have input focus. Un singolo controllo acquisisce lo stato attivo quando l'utente tocca o fa clic direttamente sul controllo nel layout oppure usa il tasto Tab per avviare una sequenza di tabulazione nell'area di contenuto.An individual control gains focus when the user clicks or taps directly on that control in the layout, or uses the Tab key to step into a tab sequence within the content area.

È anche possibile chiamare il metodo Focus di un controllo per forzare lo stato attivo.You can also call a control's Focus method to force focus. Si tratta di un'azione necessaria quando implementi i tasti di scelta rapida, perché lo stato attivo della tastiera non è configurato per impostazione predefinita al caricamento dell'interfaccia utente.This is necessary when you implement shortcut keys, because keyboard focus is not set by default when your UI loads. Per altre info, vedi Esempio di tasti di scelta rapida più avanti in questo argomento.For more info, see the Shortcut keys example later in this topic.

Per acquisire lo stato attivo per l'input, un controllo deve essere abilitato, visibile e avere valori true per le proprietà IsTabStop e HitTestVisible.For a control to receive input focus, it must be enabled, visible, and have IsTabStop and HitTestVisible property values of true . È lo stato predefinito per la maggior parte dei controlli.This is the default state for most controls. Quando un controllo ha lo stato attivo per l'input, può generare e rispondere a eventi di input della tastiera, come descritto più avanti in questo argomento.When a control has input focus, it can raise and respond to keyboard input events as described later in this topic. È inoltre possibile rispondere a un controllo che riceve o perde lo stato attivo gestendo gli eventi GotFocus e LostFocus .You can also respond to a control that is receiving or losing focus by handling the GotFocus and LostFocus events.

Per impostazione predefinita, la sequenza di tabulazione dei controlli è l'ordine in cui appaiono in XAML (Extensible Application Markup Language).By default, the tab sequence of controls is the order in which they appear in the Extensible Application Markup Language (XAML). È tuttavia possibile modificare l'ordine usando la proprietà TabIndex.However, you can modify this order by using the TabIndex property. Per altre info, vedi Implementazione dell'accessibilità da tastiera.For more info, see Implementing keyboard accessibility.

Gestori di eventi della tastieraKeyboard event handlers

Un gestore di eventi di input implementa un delegato che consente di:An input event handler implements a delegate that provides the following information:

  • Mittente dell'evento.The sender of the event. Il mittente indica l'oggetto in cui è associato il gestore di eventi.The sender reports the object where the event handler is attached.
  • Dati dell'evento.Event data. Per gli eventi della tastiera, i dati saranno un'istanza di KeyRoutedEventArgs.For keyboard events, that data will be an instance of KeyRoutedEventArgs. Il delegato per i gestori è EventHandler.The delegate for handlers is KeyEventHandler. Per la maggior parte degli scenari con gestori, le proprietà più importanti di KeyRoutedEventArgs sono Key ed eventualmente KeyStatus.The most relevant properties of KeyRoutedEventArgs for most handler scenarios are Key and possibly KeyStatus.
  • OriginalSource.OriginalSource. Determinare l'oggetto OriginalSource in base ai dati dell'evento, dal momento che gli eventi della tastiera sono di tipo indirizzato.Because the keyboard events are routed events, the event data provides OriginalSource . Se consenti espressamente il bubbling degli eventi in un albero di oggetti, OriginalSource può essere un dato più rilevante del mittente,If you deliberately allow events to bubble up through an object tree, OriginalSource is sometimes the object of concern rather than sender. nonostante ciò dipenda dalla progettazione.However, that depends on your design. Per altre informazioni su come usare l'oggetto OriginalSource anziché il mittente, vedi la sezione "Eventi indirizzati della tastiera" in questo argomento oppure l'argomento Panoramica degli eventi e degli eventi indirizzati.For more information about how you might use OriginalSource rather than sender, see the "Keyboard Routed Events" section of this topic, or Events and routed events overview.

Associazione di un gestore di eventi della tastieraAttaching a keyboard event handler

Puoi associare funzioni del gestore di eventi della tastiera per qualsiasi oggetto che includa l'evento come membro.You can attach keyboard event-handler functions for any object that includes the event as a member. È inclusa qualsiasi classe derivata da UIElement.This includes any UIElement derived class. L'esempio XAML seguente mostra come associare gestori per l'evento KeyUp a un oggetto Grid.The following XAML example shows how to attach handlers for the KeyUp event for a Grid.

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

Il gestore eventi può essere inoltre associato nel codice.You can also attach an event handler in code. Per altre informazioni, vedi Panoramica degli eventi e degli eventi indirizzati.For more info, see Events and routed events overview.

Definizione di un gestore di eventi della tastieraDefining a keyboard event handler

Nell'esempio seguente viene illustrata la definizione del gestore eventi incompleta per il gestore eventi KeyUp collegato nell'esempio precedente.The following example shows the incomplete event handler definition for the KeyUp event handler that was attached in the preceding example.

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
  }

Uso di KeyRoutedEventArgsUsing KeyRoutedEventArgs

Tutti gli eventi della tastiera usano KeyRoutedEventArgs per i dati dell'evento. KeyRoutedEventArgs contiene le proprietà seguenti:All keyboard events use KeyRoutedEventArgs for event data, and KeyRoutedEventArgs contains the following properties:

ChiaveKey

L'evento KeyDown viene generato se viene premuto un tasto.The KeyDown event is raised if a key is pressed. In modo analogo, l'evento KeyUp viene generato se viene rilasciato un tasto.Likewise, KeyUp is raised if a key is released. In genere, si rimane in ascolto degli eventi per elaborare un valore di tasto specifico.Usually, you listen to the events to process a specific key value. Per determinare quale tasto viene premuto o rilasciato, controllare il valore della chiave nei dati dell'evento.To determine which key is pressed or released, check the Key value in the event data. Key restituisce un valore VirtualKey.Key returns a VirtualKey value. L'enumerazione VirtualKey include tutti i tasti supportati.The VirtualKey enumeration includes all the supported keys.

Tasti di modificaModifier keys

I tasti di modifica, ad esempio CTRL o MAIUSC, vengono in genere premuti dagli utenti in combinazione con altri tasti.Modifier keys are keys such as Ctrl or Shift that users typically press in combination with other keys. L'app può usare queste combinazioni come tasti di scelta rapida per richiamare comandi dell'app.Your app can use these combinations as keyboard shortcuts to invoke app commands.

È possibile rilevare le combinazioni di tasti di scelta rapida nei gestori eventi KeyDown e KeyUp .You can detect shortcut key combinations in the KeyDown and KeyUp event handlers. Quando si verifica un evento di tastiera per un tasto non modificabile, è possibile verificare se un tasto di modifica è nello stato premuto.When a keyboard event occurs for a non-modifier key, you can then check whether a modifier key is in the pressed state.

In alternativa, la funzione GetKeyState () di CoreWindow (ottenuta tramite CoreWindow. GetForCurrentThread ()) può essere usata anche per controllare lo stato del modificatore quando viene premuto un tasto non modificabile.Alternatively, the GetKeyState() function of the CoreWindow (obtained through CoreWindow.GetForCurrentThread()) can also be used to check modifier state when a non-modifier key is pressed.

Gli esempi seguenti implementano questo secondo metodo, includendo anche il codice stub per la prima implementazione.The following examples implement this second method while also including stub code for the first implementation.

Nota

Il tasto ALT è rappresentato dal valore VirtualKey.Menu .The Alt key is represented by the VirtualKey.Menu value.

Esempio di tasti di scelta rapidaShortcut keys example

L'esempio seguente mostra come implementare i tasti di scelta rapida.The following example demonstrates how to implement shortcut keys. In questo esempio, gli utenti possono controllare la riproduzione di elementi multimediali usando i pulsanti di riproduzione, pausa e arresto o i tasti di scelta rapida CTRL+P, CTRL+A e CTRL+S.In this example, users can control media playback using Play, Pause, and Stop buttons or Ctrl+P, Ctrl+A, and Ctrl+S keyboard shortcuts. Il pulsante XAML mostra i tasti di scelta rapida usando le descrizioni comandi e le proprietà AutomationProperties nelle etichette dei pulsanti.The button XAML shows the shortcuts by using tooltips and AutomationProperties properties in the button labels. Questa autodocumentazione è importante per migliorare l'usabilità e l'accessibilità dell'app.This self-documentation is important to increase the usability and accessibility of your app. Per altre info, vedi Accessibilità tramite tastiera.For more info, see Keyboard accessibility.

Nota inoltre che la pagina imposta su se stessa lo stato attivo per l'input quando viene caricata.Note also that the page sets input focus to itself when it is loaded. Senza questo passaggio, nessun controllo ha lo stato attivo per l'input iniziale e l'app non genera eventi di input finché l'utente non imposta lo stato attivo per l'input manualmente (ad esempio spostandosi con il tasto TAB o facendo clic su un controllo).Without this step, no control has initial input focus, and the app does not raise input events until the user sets the input focus manually (for example, by tabbing to or clicking a control).

<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

Nota

L'impostazione di AutomationProperties.AcceleratorKey o di AutomationProperties.AccessKey in XAML fornisce informazioni sulle stringhe per documentare il tasto di scelta rapida per richiamare l'azione specifica.Setting AutomationProperties.AcceleratorKey or AutomationProperties.AccessKey in XAML provides string information, which documents the shortcut key for invoking that particular action. Le informazioni vengono acquisite dai client di automazione dell'interfaccia utente Microsoft, ad esempio l'Assistente vocale, e vengono in genere fornite direttamente all'utente.The information is captured by Microsoft UI Automation clients such as Narrator, and is typically provided directly to the user.

All'impostazione di AutomationProperties.AcceleratorKey o AutomationProperties.AccessKey non è di per sé associata nessuna azione.Setting AutomationProperties.AcceleratorKey or AutomationProperties.AccessKey does not have any action on its own. Per implementare effettivamente il comportamento del tasto di scelta rapida nell'app, sarà comunque necessario alleghi i gestori per gli eventi KeyDown o KeyUp .You will still need to attach handlers for KeyDown or KeyUp events in order to actually implement the keyboard shortcut behavior in your app. Anche la sottolineatura dei tasti di accesso rapido non viene fornita automaticamente.Also, the underline text decoration for an access key is not provided automatically. Se vuoi visualizzare il testo sottolineato nell'interfaccia utente, devi sottolineare esplicitamente il testo corrispondente al tasto specifico nello mnemonico come formattazione Underline in linea.You must explicitly underline the text for the specific key in your mnemonic as inline Underline formatting if you wish to show underlined text in the UI.

Eventi indirizzati della tastieraKeyboard routed events

Alcuni eventi, inclusi KeyDown e KeyUp, sono di tipo indirizzato.Certain events are routed events, including KeyDown and KeyUp. Gli eventi indirizzati usano la strategia di routing del bubbling.Routed events use the bubbling routing strategy. La strategia di routing del bubbling significa che un evento ha origine da un oggetto figlio e viene quindi indirizzato ai successivi oggetti padre nell'albero di oggetti.The bubbling routing strategy means that an event originates from a child object and is then routed up to successive parent objects in the object tree. Ciò offre un'altra opportunità per gestire lo stesso evento e interagire con i dati dello stesso evento.This presents another opportunity to handle the same event and interact with the same event data.

Si consideri l'esempio XAML seguente, che gestisce gli eventi KeyUp per un' area di disegno e due oggetti pulsante .Consider the following XAML example, which handles KeyUp events for a Canvas and two Button objects. In questo caso, se rilasci un tasto mentre lo stato attivo appartiene a uno degli oggetti Button , viene generato l'evento KeyUp .In this case, if you release a key while focus is held by either Button object, it raises the KeyUp event. Viene quindi eseguito il bubbling dell'evento all'oggetto Canvas padre.The event is then bubbled up to the parent Canvas .

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

Nell'esempio seguente viene illustrato come implementare il gestore eventi KeyUp per il contenuto XAML corrispondente nell'esempio precedente.The following example shows how to implement the KeyUp event handler for the corresponding XAML content in the preceding example.

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

Osserva l'uso della proprietà OriginalSource nel gestore precedente.Notice the use of the OriginalSource property in the preceding handler. Qui OriginalSource indica l'oggetto che ha generato l'evento.Here, OriginalSource reports the object that raised the event. L'oggetto non può essere StackPanel perché StackPanel non è un controllo e non può avere lo stato attivo.The object could not be the StackPanel because the StackPanel is not a control and cannot have focus. Solo uno dei due pulsanti all'interno di StackPanel possono avere generato l'evento, ma occorre capire quale.Only one of the two buttons within the StackPanel could possibly have raised the event, but which one? Con OriginalSource puoi distinguere l'oggetto di origine effettivo quando gestisci l'evento su un oggetto padre.You use OriginalSource to distinguish the actual event source object, if you are handling the event on a parent object.

Proprietà Handled nei dati dell'eventoThe Handled property in event data

In base alla strategia di gestione degli eventi che scegli, un evento di bubbling potrebbe dover essere gestito da un solo gestore di eventi.Depending on your event handling strategy, you might want only one event handler to react to a bubbling event. Ad esempio, se hai un gestore KeyUp specifico collegato a uno dei controlli Button, esso avrebbe la prima opportunità di gestire tale evento.For instance, if you have a specific KeyUp handler attached to one of the Button controls, it would have the first opportunity to handle that event. In questo caso, potresti preferire che l'evento non venga anche gestito dal pannello padre.In this case, you might not want the parent panel to also handle the event. Per questo scenario, è possibile utilizzare la proprietà Handled nei dati dell'evento.For this scenario, you can use the Handled property in the event data.

Lo scopo della proprietà gestita in una classe di dati degli eventi indirizzati consiste nel segnalare che un altro gestore registrato in precedenza nella route dell'evento ha già agito.The purpose of the Handled property in a routed event data class is to report that another handler you registered earlier on the event route has already acted. Ciò ha effetto sul comportamento del sistema di eventi indirizzati.This influences the behavior of the routed event system. Quando imposti la proprietà Handled su true in un gestore eventi, il routing dell'evento viene interrotto e l'evento non viene inviato agli elementi padre successivi.When you set Handled to true in an event handler, that event stops routing and is not sent to successive parent elements.

Metodo AddHandler ed eventi della tastiera già gestitiAddHandler and already-handled keyboard events

Puoi usare una tecnica speciale per associare gestori in grado di agire su eventi già contrassegnati come gestiti.You can use a special technique for attaching handlers that can act on events that you already marked as handled. Questa tecnica usa il metodo AddHandler per registrare un gestore, anziché usare gli attributi XAML o la sintassi specifica della lingua per l'aggiunta di gestori, ad esempio + = in C # .This technique uses the AddHandler method to register a handler, rather than using XAML attributes or language-specific syntax for adding handlers, such as += in C#.

Una limitazione generica di questa tecnica è che l'API AddHandler accetta un parametro di tipo RoutedEvent che identifica l'evento indirizzato in questione.A general limitation of this technique is that the AddHandler API takes a parameter of type RoutedEvent idnentifying the routed event in question. Non tutti gli eventi indirizzati forniscono tuttavia un identificatore RoutedEvent . Questa considerazione influisce pertanto sugli eventi indirizzati che è ancora possibile gestire nel caso della proprietà Handled.Not all routed events provide a RoutedEvent identifier, and this consideration thus affects which routed events can still be handled in the Handled case. Gli eventi KeyDown e KeyUp hanno gli identificatori degli eventi indirizzati ( KeyDownEvent e KeyUpEvent) su UIElement.The KeyDown and KeyUp events have routed event identifiers ( KeyDownEvent and KeyUpEvent) on UIElement. Altri eventi come TextBox.TextChanged non dispongono invece di identificatori di evento indirizzato e non possono pertanto essere usati per la tecnica basata sul metodo AddHandler .However, other events such as TextBox.TextChanged do not have routed event identifiers and thus cannot be used with the AddHandler technique.

Sostituzione degli eventi e del comportamento della tastieraOverriding keyboard events and behavior

Puoi sostituire gli eventi chiave per controlli specifici (ad esempio, GridView) per garantire una navigazione dello stato attivo coerente per i diversi dispositivi di input, inclusi tastiera e game pad.You can override key events for specific controls (such as GridView) to provide consistent focus navigation for various input devices, including keyboard and gamepad.

Nell'esempio seguente viene sottoposto a una sottoclasse del controllo e viene eseguito l'override del comportamento KeyDown per spostare lo stato attivo sul contenuto GridView quando viene premuto un tasto di direzione.In the following example, we subclass the control and override the KeyDown behavior to move focus to the GridView content when any arrow key is pressed.

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

Nota

Se si utilizza un controllo GridView solo per il layout, considerare l'utilizzo di altri controlli, ad esempio ItemsControl con ItemsWrapGrid.If using a GridView for layout only, consider using other controls such as ItemsControl with ItemsWrapGrid.

Esecuzione di comandiCommanding

Un numero limitato di elementi dell'interfaccia utente offre il supporto incorporato per l'esecuzione di comandi.A small number of UI elements provide built-in support for commanding. L'esecuzione di comandi usa eventi indirizzati correlati all'input nell'implementazione sottostante.Commanding uses input-related routed events in its underlying implementation. Abilita l'elaborazione dell'input dell'interfaccia utente correlato, ad esempio una determinata azione del puntatore o un tasto di scelta rapida specifico, richiamando un solo gestore di comandi.It enables processing of related UI input, such as a certain pointer action or a specific accelerator key, by invoking a single command handler.

Se l'esecuzione di comandi è disponibile per un elemento dell'interfaccia utente, puoi valutare se usare le API corrispondenti anziché eventi di input discreti.If commanding is available for a UI element, consider using its commanding APIs instead of any discrete input events. Per altre info, vedi ButtonBase.Command.For more info, see ButtonBase.Command.

È anche possibile implementare ICommand per incapsulare la funzionalità del comando richiamata dai gestori eventi normali.You can also implement ICommand to encapsulate command functionality that you invoke from ordinary event handlers. Ciò ti consente di usare l'esecuzione di comandi anche se non è disponibile alcuna proprietà Command .This enables you to use commanding even when there is no Command property available.

Input di testo e controlliText input and controls

Alcuni controlli usano una gestione personalizzata per rispondere agli eventi della tastiera.Certain controls react to keyboard events with their own handling. Ad esempio, TextBox è un controllo progettato per acquisire e quindi rappresentare visivamente il testo immesso tramite la tastiera.For instance, TextBox is a control that is designed to capture and then visually represent text that was entered by using the keyboard. USA KeyUp e KeyDown nella propria logica per acquisire le sequenze di tasti, quindi genera anche il proprio evento TextChanged se il testo è stato effettivamente modificato.It uses KeyUp and KeyDown in its own logic to capture keystrokes, then also raises its own TextChanged event if the text actually changed.

In generale, puoi comunque aggiungere gestori per gli eventi KeyUp e KeyDown a un oggetto TextBox o a qualsiasi controllo correlato destinato all'elaborazione di input di testo.You can still generally add handlers for KeyUp and KeyDown to a TextBox, or any related control that is intended to process text input. Nella progettazione prevista, tuttavia, un controllo potrebbe non rispondere a tutti i valori di tasto inviati ad esso mediante appositi eventi.However, as part of its intended design, a control might not respond to all key values that are directed to it through key events. Il comportamento è specifico di ogni controllo.Behavior is specific to each control.

Ad esempio, ButtonBase (la classe base per Button) elabora KeyUp in modo che possa controllare la BARRA SPAZIATRICE e il tasto INVIO.As an example, ButtonBase (the base class for Button) processes KeyUp so that it can check for the Spacebar or Enter key. ButtonBase considera KeyUp equivalente alla pressione del pulsante sinistro del mouse per generare un evento Click.ButtonBase considers KeyUp equivalent to a mouse left button down for purposes of raising a Click event. Questa elaborazione dell'evento viene adottata quando ButtonBase esegue l'override del metodo virtuale OnKeyUp.This processing of the event is accomplished when ButtonBase overrides the virtual method OnKeyUp. Nella sua implementazione imposta Handled su true .In its implementation, it sets Handled to true . Di conseguenza, qualsiasi padre di un pulsante in ascolto di un evento dei tasti nel caso della BARRA SPAZIATRICE non riceve l'evento già gestito per i propri gestori.The result is that any parent of a button that is listening for a key event, in the case of a Spacebar, would not receive the already-handled event for its own handlers.

Un altro esempio è TextBox.Another example is TextBox. Alcune chiavi, ad esempio i tasti di direzione, non sono considerate testo da TextBox e sono invece considerate specifiche del comportamento dell'interfaccia utente del controllo.Some keys, such as the arrow keys, are not considered text by TextBox and are instead considered specific to the control UI behavior. TextBox contrassegna pertanto questi eventi come gestiti.The TextBox marks these event cases as handled.

I controlli personalizzati possono implementare un comportamento di override simile per gli eventi principali eseguendo l'override di OnKeyDown / onkeyup.Custom controls can implement their own similar override behavior for key events by overriding OnKeyDown / OnKeyUp. Se un controllo personalizzato elabora tasti di scelta rapida specifici oppure prevede un comportamento di controllo o stato attivo simile allo scenario descritto per TextBox, devi inserire questa logica negli override di OnKeyDown / OnKeyUp .If your custom control processes specific accelerator keys, or has control or focus behavior that is similar to the scenario described for TextBox, you should place this logic in your own OnKeyDown / OnKeyUp overrides.

Tastiera virtualeThe touch keyboard

I controlli di input di testo offrono il supporto automatico per la tastiera virtuale.Text input controls provide automatic support for the touch keyboard. Quando l'utente imposta lo stato attivo per l'input su un controllo di testo usando l'input tocco, la tastiera virtuale viene automaticamente visualizzata.When the user sets the input focus to a text control by using touch input, the touch keyboard appears automatically. Quando lo stato attivo per l'input non si trova in un controllo di testo, la tastiera virtuale viene nascosta.When the input focus is not on a text control, the touch keyboard is hidden.

Quando viene visualizzata la tastiera virtuale, l'interfaccia utente viene automaticamente riposizionata per garantire che l'elemento con lo stato attivo rimanga visibile.When the touch keyboard appears, it automatically repositions your UI to ensure that the focused element remains visible. Ciò può causare la rimozione dalla schermo di altre aree importanti dell'interfaccia utente.This can cause other important areas of your UI to move off screen. Puoi tuttavia disabilitare il comportamento predefinito e apportare modifiche personalizzate all'interfaccia utente quando viene visualizzata la tastiera virtuale.However, you can disable the default behavior and make your own UI adjustments when the touch keyboard appears. Per altre informazioni, vedere l' esempio di tastiera touch.For more info, see the Touch keyboard sample.

Se crei un controllo personalizzato che richiede l'input di testo, ma non deriva da un controllo di input di testo standard, puoi aggiungere il supporto della tastiera virtuale implementando i pattern corretti di controllo di automazione dell'interfaccia utente.If you create a custom control that requires text input, but does not derive from a standard text input control, you can add touch keyboard support by implementing the correct UI Automation control patterns. Per altre informazioni, vedere l' esempio di tastiera touch.For more info, see the Touch keyboard sample.

Le pressioni dei tasti sulla tastiera virtuale generano eventi KeyDown e KeyUp come avviene quando si premono i tasti delle tastiere hardware.Key presses on the touch keyboard raise KeyDown and KeyUp events just like key presses on hardware keyboards. La tastiera virtuale, tuttavia, non genera eventi per CTRL+A, CTRL+Z, CTRL+X, CTRL+C e CTRL+V, che sono riservati alla modifica del testo nel controllo di input.However, the touch keyboard will not raise input events for Ctrl+A, Ctrl+Z, Ctrl+X, Ctrl+C, and Ctrl+V, which are reserved for text manipulation in the input control.

Puoi facilitare e velocizzare notevolmente l'immissione dei dati nella tua app impostando l'ambito di input del controllo di testo in base al tipo di dati che prevedi che l'utente immetta.You can make it much faster and easier for users to enter data in your app by setting the input scope of the text control to match the kind of data you expect the user to enter. L'ambito di input fornisce un suggerimento per il tipo di input di testo previsto dal controllo in modo che il sistema possa fornire un layout di tastiera virtuale specifico per il tipo di input.The input scope provides a hint at the type of text input expected by the control so the system can provide a specialized touch keyboard layout for the input type. Se, ad esempio, una casella di testo viene utilizzata solo per immettere un PIN di 4 cifre, impostare la proprietà InputScope su Number.For example, if a text box is used only to enter a 4-digit PIN, set the InputScope property to Number. In questo modo dai indicazione al sistema di mostrare il layout con il tastierino numerico, che rende più semplice l'immissione del PIN da parte dell'utente.This tells the system to show the numeric keypad layout, which makes it easier for the user to enter the PIN. Per altri dettagli vedi Usare l'ambito di input per modificare la tastiera virtuale.For more detail, see Use input scope to change the touch keyboard.

SviluppatoriDevelopers

Finestre di progettazioneDesigners

EsempiSamples

Esempi di archivioArchive Samples