Cenni preliminari sull'inputInput Overview

Il sottosistema Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) fornisce un'API potente per ottenere input da un'ampia gamma di dispositivi, tra cui mouse, tastiera, tocco e stilo.The Windows Presentation Foundation (WPF)Windows Presentation Foundation (WPF) subsystem provides a powerful API for obtaining input from a variety of devices, including the mouse, keyboard, touch, and stylus. Questo argomento descrive i servizi forniti da WPFWPF e illustra l'architettura dei sistemi di input.This topic describes the services provided by WPFWPF and explains the architecture of the input systems.

API di inputInput API

L'esposizione dell'API di input primaria si trova nelle classi degli elementi di base: UIElement, ContentElement, FrameworkElement e FrameworkContentElement.The primary input API exposure is found on the base element classes: UIElement, ContentElement, FrameworkElement, and FrameworkContentElement. Per altre informazioni sugli elementi di base, vedere Cenni preliminari sugli elementi di base.For more information about the base elements, see Base Elements Overview. Queste classi forniscono funzionalità per gli eventi di input correlati, ad esempio, a pressioni di tasti, pulsanti del mouse, rotellina del mouse, movimento del mouse, gestione dello stato attivo, stato mouse capture e altro.These classes provide functionality for input events related to key presses, mouse buttons, mouse wheel, mouse movement, focus management, and mouse capture, to name a few. Inserendo l'API di input sugli elementi di base, invece di considerare tutti gli eventi di input come un servizio, l'architettura di input consente di originare gli eventi di input da un determinato oggetto nell'interfaccia utente e di supportare uno schema di routing degli eventi in base al quale più di un elemento dispone di un opp ortunity per la gestione di un evento di input.By placing the input API on the base elements, rather than treating all input events as a service, the input architecture enables the input events to be sourced by a particular object in the UI, and to support an event routing scheme whereby more than one element has an opportunity to handle an input event. A molti eventi di input è associata una coppia di eventi.Many input events have a pair of events associated with them. Ad esempio, l'evento di riduzione della chiave è associato agli eventi KeyDown e PreviewKeyDown.For example, the key down event is associated with the KeyDown and PreviewKeyDown events. La differenza tra questi eventi consiste nel modo in cui ne viene eseguito il routing all'elemento di destinazione.The difference in these events is in how they are routed to the target element. Gli eventi di anteprima scendono lungo l'albero degli elementi (tunneling), dall'elemento radice all'elemento di destinazione.Preview events tunnel down the element tree from the root element to the target element. Gli eventi di bubbling invece salgono dall'elemento di destinazione all'elemento radice.Bubbling events bubble up from the target element to the root element. Il routing degli eventi in WPFWPF è illustrato in modo più dettagliato più avanti in questo articolo e nell'articolo Cenni preliminari sugli eventi indirizzati.Event routing in WPFWPF is discussed in more detail later in this overview and in the Routed Events Overview.

Classi Keyboard e MouseKeyboard and Mouse Classes

Oltre all'API di input sulle classi degli elementi di base, la classe Keyboard e le classi Mouse forniscono un'API aggiuntiva per l'utilizzo di input da tastiera e mouse.In addition to the input API on the base element classes, the Keyboard class and Mouse classes provide additional API for working with keyboard and mouse input.

Esempi di API di input nella classe Keyboard sono la proprietà Modifiers, che restituisce il ModifierKeys attualmente premuto e il metodo IsKeyDown, che determina se viene premuto un tasto specificato.Examples of input API on the Keyboard class are the Modifiers property, which returns the ModifierKeys currently pressed, and the IsKeyDown method, which determines whether a specified key is pressed.

Nell'esempio seguente viene usato il metodo GetKeyStates per determinare se uno Key è nello stato di inattività.The following example uses the GetKeyStates method to determine if a Key is in the down state.

// Uses the Keyboard.GetKeyStates to determine if a key is down.
// A bitwise AND operation is used in the comparison. 
// e is an instance of KeyEventArgs.
if ((Keyboard.GetKeyStates(Key.Return) & KeyStates.Down) > 0)
{
    btnNone.Background = Brushes.Red;
}
' Uses the Keyboard.GetKeyStates to determine if a key is down.
' A bitwise AND operation is used in the comparison. 
' e is an instance of KeyEventArgs.
If (Keyboard.GetKeyStates(Key.Return) And KeyStates.Down) > 0 Then
    btnNone.Background = Brushes.Red

Esempi di API di input nella classe Mouse sono MiddleButton, che ottiene lo stato del pulsante centrale del mouse e DirectlyOver, che ottiene l'elemento sul quale è attualmente posizionato il puntatore del mouse.Examples of input API on the Mouse class are MiddleButton, which obtains the state of the middle mouse button, and DirectlyOver, which gets the element the mouse pointer is currently over.

Nell'esempio seguente viene determinato se il LeftButton sul mouse è nello stato Pressed.The following example determines whether the LeftButton on the mouse is in the Pressed state.

if (Mouse.LeftButton == MouseButtonState.Pressed)
{
    UpdateSampleResults("Left Button Pressed");
}
If Mouse.LeftButton = MouseButtonState.Pressed Then
    UpdateSampleResults("Left Button Pressed")
End If

Le classi Mouse e Keyboard sono descritte in dettaglio in questa panoramica.The Mouse and Keyboard classes are covered in more detail throughout this overview.

Input dello stiloStylus Input

WPFWPF dispone del supporto integrato per Stylus.has integrated support for the Stylus. Il Stylus è un input penna reso popolare dal Tablet PC.The Stylus is a pen input made popular by the Tablet PC. le applicazioni WPFWPF possono trattare lo stilo come mouse usando l'API del mouse, ma WPFWPF espone anche un'astrazione del dispositivo stilo che usa un modello simile a quello della tastiera e del mouse.WPFWPF applications can treat the stylus as a mouse by using the mouse API, but WPFWPF also exposes a stylus device abstraction that use a model similar to the keyboard and mouse. Tutte le API correlate allo stilo contengono la parola "stilo".All stylus-related APIs contain the word "Stylus".

Dal momento che lo stilo può funzionare come un mouse, le applicazioni che supportano solo l'input del mouse possono comunque ottenere automaticamente un certo livello di supporto dello stilo.Because the stylus can act as a mouse, applications that support only mouse input can still obtain some level of stylus support automatically. Quando lo stilo viene usato in questo modo, l'applicazione può gestire l'evento dello stilo appropriato gestendo l'evento del mouse corrispondente.When the stylus is used in such a manner, the application is given the opportunity to handle the appropriate stylus event and then handles the corresponding mouse event. Inoltre, tramite l'astrazione del dispositivo stilo, sono disponibili anche servizi di livello superiore, come l'input penna.In addition, higher-level services such as ink input are also available through the stylus device abstraction. Per altre informazioni sull'input penna, vedere Nozioni di base sull'input penna.For more information about ink as input, see Getting Started with Ink.

Routing di eventiEvent Routing

Un FrameworkElement può contenere altri elementi come elementi figlio nel relativo modello di contenuto, formando una struttura ad albero di elementi.A FrameworkElement can contain other elements as child elements in its content model, forming a tree of elements. In WPFWPF l'elemento padre può partecipare all'input diretto verso i relativi elementi figlio o agli altri discendenti mediante la gestione degli eventi.In WPFWPF, the parent element can participate in input directed to its child elements or other descendants by handing events. Ciò risulta particolarmente utile per la creazione di controlli a partire da controlli più piccoli, processo noto come "composizione di controlli" o "composizione".This is especially useful for building controls out of smaller controls, a process known as "control composition" or "compositing." Per altre informazioni sugli alberi degli elementi e sulla loro relazione con le route degli eventi, vedere Strutture ad albero in WPF.For more information about element trees and how element trees relate to event routes, see Trees in WPF.

Il routing degli eventi è il processo di inoltro degli eventi a più elementi, in modo che un oggetto o un elemento specifico lungo la route possa offrire una risposta significativa (tramite la gestione) a un evento che potrebbe essere stato originato da un elemento diverso.Event routing is the process of forwarding events to multiple elements, so that a particular object or element along the route can choose to offer a significant response (through handling) to an event that might have been sourced by a different element. Gli eventi indirizzati usano uno dei tre meccanismi di routing indicati di seguito: diretto, bubbling e tunneling.Routed events use one of three routing mechanisms: direct, bubbling, and tunneling. Nel routing diretto, l'elemento di origine è l'unico elemento che riceve la notifica e l'evento non viene indirizzato a nessun altro elemento.In direct routing, the source element is the only element notified, and the event is not routed to any other elements. Tuttavia, l'evento indirizzato diretto offre ancora alcune funzionalità aggiuntive che sono presenti solo per gli eventi indirizzati anziché per gli eventi CLR standard.However, the direct routed event still offers some additional capabilities that are only present for routed events as opposed to standard CLR events. Il bubbling viene eseguito procedendo verso l'alto nell'albero degli elementi, notificando innanzitutto l'elemento che ha originato l'evento, quindi l'elemento padre e così via.Bubbling works up the element tree by first notifying the element that sourced the event, then the parent element, and so on. Il tunneling parte dalla radice dell'albero degli elementi e procede verso il basso, terminando con l'elemento di origine.Tunneling starts at the root of the element tree and works down, ending with the original source element. Per altre informazioni sugli eventi indirizzati, vedere Cenni preliminari sugli eventi indirizzati.For more information about routed events, see Routed Events Overview.

Gli eventi di input WPFWPF sono in genere a coppie, costituite da un evento di tunneling e un evento di bubbling.WPFWPF input events generally come in pairs that consists of a tunneling event and a bubbling event. Gli eventi di tunneling si distinguono da quelli di bubbling tramite il prefisso "Preview".Tunneling events are distinguished from bubbling events with the "Preview" prefix. Ad esempio, PreviewMouseMove è la versione di tunneling di un evento di spostamento del mouse e MouseMove è la versione di bubbling di questo evento.For instance, PreviewMouseMove is the tunneling version of a mouse move event and MouseMove is the bubbling version of this event. Questa coppia di eventi è una convenzione implementata a livello di elemento e non è una funzionalità intrinseca del sistema di eventi WPFWPF.This event pairing is a convention that is implemented at the element level and is not an inherent capability of the WPFWPF event system. Per informazioni dettagliate, vedere la sezione Eventi di input WPF in Cenni preliminari sugli eventi indirizzati.For details, see the WPF Input Events section in Routed Events Overview.

Gestione degli eventi di inputHandling Input Events

Per ricevere input su un elemento, un gestore eventi deve essere associato a quel particolare evento.To receive input on an element, an event handler must be associated with that particular event. In XAMLXAML tale associazione è semplice: è sufficiente fare riferimento al nome dell'evento come attributo dell'elemento che rimarrà in ascolto di questo evento.In XAMLXAML this is straightforward: you reference the name of the event as an attribute of the element that will be listening for this event. Si imposta quindi il valore dell'attributo sul nome del gestore eventi definito, in base a un delegato.Then, you set the value of the attribute to the name of the event handler that you define, based on a delegate. Il gestore eventi deve essere scritto in codice, ad C# esempio e, può essere incluso in un file code-behind.The event handler must be written in code such as C# and can be included in a code-behind file.

Gli eventi della tastiera si verificano quando il sistema operativo segnala azioni dei tasti eseguite quando lo stato attivo della tastiera è su un elemento.Keyboard events occur when the operating system reports key actions that occur while keyboard focus is on an element. Gli eventi del mouse e dello stilo rientrano ciascuno in due categorie: eventi che segnalano modifiche nella posizione del puntatore rispetto all'elemento ed eventi che segnalano modifiche nello stato dei pulsanti del dispositivo.Mouse and stylus events each fall into two categories: events that report changes in pointer position relative to the element, and events that report changes in the state of device buttons.

Esempio di evento di input da tastieraKeyboard Input Event Example

L'esempio seguente illustra una situazione di ascolto della pressione del tasto freccia SINISTRA.The following example listens for a left arrow key press. Viene creato un StackPanel con Button.A StackPanel is created that has a Button. Un gestore eventi per restare in attesa della pressione del tasto freccia sinistra viene collegato all'istanza Button.An event handler to listen for the left arrow key press is attached to the Button instance.

Nella prima sezione dell'esempio viene creato il StackPanel e il Button e viene collegato il gestore eventi per il KeyDown.The first section of the example creates the StackPanel and the Button and attaches the event handler for the KeyDown.

<StackPanel>
  <Button Background="AliceBlue"
          KeyDown="OnButtonKeyDown"
          Content="Button1"/>
</StackPanel>
// Create the UI elements.
StackPanel keyboardStackPanel = new StackPanel();
Button keyboardButton1 = new Button();

// Set properties on Buttons.
keyboardButton1.Background = Brushes.AliceBlue;
keyboardButton1.Content = "Button 1";

// Attach Buttons to StackPanel.
keyboardStackPanel.Children.Add(keyboardButton1);

// Attach event handler.
keyboardButton1.KeyDown += new KeyEventHandler(OnButtonKeyDown);
' Create the UI elements.
Dim keyboardStackPanel As New StackPanel()
Dim keyboardButton1 As New Button()

' Set properties on Buttons.
keyboardButton1.Background = Brushes.AliceBlue
keyboardButton1.Content = "Button 1"

' Attach Buttons to StackPanel.
keyboardStackPanel.Children.Add(keyboardButton1)

' Attach event handler.
AddHandler keyboardButton1.KeyDown, AddressOf OnButtonKeyDown

La seconda sezione è scritta nel codice e definisce il gestore eventi.The second section is written in code and defines the event handler. Quando viene premuto il tasto freccia sinistra e il Button ha lo stato attivo della tastiera, il gestore viene eseguito e viene modificato il colore Background del Button.When the left arrow key is pressed and the Button has keyboard focus, the handler runs and the Background color of the Button is changed. Se il tasto è premuto, ma non è il tasto freccia sinistra, il colore Background del Button viene nuovamente modificato sul colore iniziale.If the key is pressed, but it is not the left arrow key, the Background color of the Button is changed back to its starting color.

private void OnButtonKeyDown(object sender, KeyEventArgs e)
{
    Button source = e.Source as Button;
    if (source != null)
    {
        if (e.Key == Key.Left)
        {
            source.Background = Brushes.LemonChiffon;
        }
        else
        {
            source.Background = Brushes.AliceBlue;
        }
    }
}
Private Sub OnButtonKeyDown(ByVal sender As Object, ByVal e As KeyEventArgs)
    Dim source As Button = TryCast(e.Source, Button)
    If source IsNot Nothing Then
        If e.Key = Key.Left Then
            source.Background = Brushes.LemonChiffon
        Else
            source.Background = Brushes.AliceBlue
        End If
    End If
End Sub

Esempio di evento di input del mouseMouse Input Event Example

Nell'esempio seguente il colore Background di un Button viene modificato quando il puntatore del mouse entra in Button.In the following example, the Background color of a Button is changed when the mouse pointer enters the Button. Il colore Background viene ripristinato quando il mouse esce dall'Button.The Background color is restored when the mouse leaves the Button.

La prima sezione dell'esempio crea il StackPanel e il controllo Button e connette i gestori eventi per gli eventi MouseEnter e MouseLeave a Button.The first section of the example creates the StackPanel and the Button control and attaches the event handlers for the MouseEnter and MouseLeave events to the Button.

<StackPanel>
  <Button Background="AliceBlue"
          MouseEnter="OnMouseExampleMouseEnter"
          MouseLeave="OnMosueExampleMouseLeave">Button
          
  </Button>
</StackPanel>
// Create the UI elements.
StackPanel mouseMoveStackPanel = new StackPanel();
Button mouseMoveButton = new Button();

// Set properties on Button.
mouseMoveButton.Background = Brushes.AliceBlue;
mouseMoveButton.Content = "Button";

// Attach Buttons to StackPanel.
mouseMoveStackPanel.Children.Add(mouseMoveButton);

// Attach event handler.
mouseMoveButton.MouseEnter += new MouseEventHandler(OnMouseExampleMouseEnter);
mouseMoveButton.MouseLeave += new MouseEventHandler(OnMosueExampleMouseLeave);
' Create the UI elements.
Dim mouseMoveStackPanel As New StackPanel()
Dim mouseMoveButton As New Button()

' Set properties on Button.
mouseMoveButton.Background = Brushes.AliceBlue
mouseMoveButton.Content = "Button"

' Attach Buttons to StackPanel.
mouseMoveStackPanel.Children.Add(mouseMoveButton)

' Attach event handler.
AddHandler mouseMoveButton.MouseEnter, AddressOf OnMouseExampleMouseEnter
AddHandler mouseMoveButton.MouseLeave, AddressOf OnMosueExampleMouseLeave

La seconda sezione dell'esempio è scritta nel codice e definisce i gestori eventi.The second section of the example is written in code and defines the event handlers. Quando il mouse entra nell'Button, il colore Background del Button viene modificato in SlateGray.When the mouse enters the Button, the Background color of the Button is changed to SlateGray. Quando il mouse esce dalla Button, il colore Background del Button viene nuovamente modificato in AliceBlue.When the mouse leaves the Button, the Background color of the Button is changed back to AliceBlue.

private void OnMouseExampleMouseEnter(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.SlateGray;
    }
}
Private Sub OnMouseExampleMouseEnter(ByVal sender As Object, ByVal e As MouseEventArgs)
    ' Cast the source of the event to a Button.
    Dim source As Button = TryCast(e.Source, Button)

    ' If source is a Button.
    If source IsNot Nothing Then
        source.Background = Brushes.SlateGray
    End If
End Sub
private void OnMosueExampleMouseLeave(object sender, MouseEventArgs e)
{
    // Cast the source of the event to a Button.
    Button source = e.Source as Button;

    // If source is a Button.
    if (source != null)
    {
        source.Background = Brushes.AliceBlue;
    }
}
Private Sub OnMosueExampleMouseLeave(ByVal sender As Object, ByVal e As MouseEventArgs)
    ' Cast the source of the event to a Button.
    Dim source As Button = TryCast(e.Source, Button)

    ' If source is a Button.
    If source IsNot Nothing Then
        source.Background = Brushes.AliceBlue
    End If
End Sub

Input di testoText Input

L'evento TextInput consente di ascoltare l'input di testo in modo indipendente dal dispositivo.The TextInput event enables you to listen for text input in a device-independent manner. La tastiera è il mezzo principale per l'immissione di testo, ma anche i comandi vocali, il riconoscimento della grafia e altri dispositivi di input possono generare input di testo.The keyboard is the primary means of text input, but speech, handwriting, and other input devices can generate text input also.

Per l'input da tastiera, WPFWPF invia prima gli eventi appropriati KeyDown @ no__t-2 @ no__t-3.For keyboard input, WPFWPF first sends the appropriate KeyDown/KeyUp events. Se tali eventi non vengono gestiti e la chiave è testuale, anziché una chiave di controllo come frecce direzionali o tasti funzione, viene generato un evento TextInput.If those events are not handled and the key is textual (rather than a control key such as directional arrows or function keys), then a TextInput event is raised. Non è sempre presente un semplice mapping uno-a-uno tra gli eventi KeyDown @ no__t-1 @ no__t-2 e TextInput perché più sequenze di tasti possono generare un singolo carattere di input di testo e singole sequenze di tasti possono generare stringhe multicarattere.There is not always a simple one-to-one mapping between KeyDown/KeyUp and TextInput events because multiple keystrokes can generate a single character of text input and single keystrokes can generate multi-character strings. Ciò vale soprattutto per le lingue quali il cinese, il giapponese e il coreano che usano IME (Input Method Editor) per generare le migliaia di caratteri possibili negli alfabeti corrispondenti.This is especially true for languages such as Chinese, Japanese, and Korean which use Input Method Editors (IMEs) to generate the thousands of possible characters in their corresponding alphabets.

Quando WPFWPF Invia un evento KeyUp @ no__t-2 @ no__t-3, Key è impostato su Key.System se le sequenze di tasti potrebbero far parte di un evento TextInput, ad esempio se si preme ALT + S.When WPFWPF sends a KeyUp/KeyDown event, Key is set to Key.System if the keystrokes could become part of a TextInput event (if ALT+S is pressed, for example). Ciò consente al codice in un gestore eventi KeyDown di verificare la presenza di Key.System e, se presente, di lasciare l'elaborazione per il gestore dell'evento TextInput generato successivamente.This allows code in a KeyDown event handler to check for Key.System and, if found, leave processing for the handler of the subsequently raised TextInput event. In questi casi, è possibile usare le varie proprietà dell'argomento TextCompositionEventArgs per determinare le sequenze di tasti originali.In these cases, the various properties of the TextCompositionEventArgs argument can be used to determine the original keystrokes. Analogamente, se un IME è attivo, Key ha il valore Key.ImeProcessed e ImeProcessedKey restituisce la sequenza di tasti originale o le sequenze di tasti.Similarly, if an IME is active, Key has the value of Key.ImeProcessed, and ImeProcessedKey gives the original keystroke or keystrokes.

Nell'esempio seguente viene definito un gestore per l'evento Click e un gestore per l'evento KeyDown.The following example defines a handler for the Click event and a handler for the KeyDown event.

Il primo segmento di codice o markup crea l'interfaccia utente.The first segment of code or markup creates the user interface.

<StackPanel KeyDown="OnTextInputKeyDown">
  <Button Click="OnTextInputButtonClick"
          Content="Open" />
  <TextBox> . . . </TextBox>
</StackPanel>
// Create the UI elements.
StackPanel textInputStackPanel = new StackPanel();
Button textInputeButton = new Button();
TextBox textInputTextBox = new TextBox();
textInputeButton.Content = "Open";

// Attach elements to StackPanel.
textInputStackPanel.Children.Add(textInputeButton);
textInputStackPanel.Children.Add(textInputTextBox);

// Attach event handlers.
textInputStackPanel.KeyDown += new KeyEventHandler(OnTextInputKeyDown);
textInputeButton.Click += new RoutedEventHandler(OnTextInputButtonClick);
' Create the UI elements.
Dim textInputStackPanel As New StackPanel()
Dim textInputeButton As New Button()
Dim textInputTextBox As New TextBox()
textInputeButton.Content = "Open"

' Attach elements to StackPanel.
textInputStackPanel.Children.Add(textInputeButton)
textInputStackPanel.Children.Add(textInputTextBox)

' Attach event handlers.
AddHandler textInputStackPanel.KeyDown, AddressOf OnTextInputKeyDown
AddHandler textInputeButton.Click, AddressOf OnTextInputButtonClick

Il secondo segmento di codice contiene i gestori eventi.The second segment of code contains the event handlers.

private void OnTextInputKeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.O && Keyboard.Modifiers == ModifierKeys.Control)
    {
        handle();
        e.Handled = true;
    }
}

private void OnTextInputButtonClick(object sender, RoutedEventArgs e)
{
    handle();
    e.Handled = true;
} 

public void handle()
{
    MessageBox.Show("Pretend this opens a file");
}
Private Sub OnTextInputKeyDown(ByVal sender As Object, ByVal e As KeyEventArgs)
    If e.Key = Key.O AndAlso Keyboard.Modifiers = ModifierKeys.Control Then
        handle()
        e.Handled = True
    End If
End Sub

Private Sub OnTextInputButtonClick(ByVal sender As Object, ByVal e As RoutedEventArgs)
    handle()
    e.Handled = True
End Sub

Public Sub handle()
    MessageBox.Show("Pretend this opens a file")
End Sub

Poiché gli eventi di input compongono la route dell'evento, il StackPanel riceve l'input indipendentemente dall'elemento con lo stato attivo della tastiera.Because input events bubble up the event route, the StackPanel receives the input regardless of which element has keyboard focus. Il controllo TextBox viene notificato per primo e il gestore OnTextInputKeyDown viene chiamato solo se l'input non è stato gestito da TextBox.The TextBox control is notified first and the OnTextInputKeyDown handler is called only if the TextBox did not handle the input. Se viene utilizzato l'evento PreviewKeyDown anziché l'evento KeyDown, viene chiamato per primo il gestore OnTextInputKeyDown.If the PreviewKeyDown event is used instead of the KeyDown event, the OnTextInputKeyDown handler is called first.

In questo esempio la logica di gestione viene scritta due volte, una per CTRL+O e una per l'evento Click del pulsante.In this example, the handling logic is written two times—one time for CTRL+O, and again for button's click event. È possibile semplificare questa operazione usando i comandi, invece di gestire direttamente gli eventi di input.This can be simplified by using commands, instead of handling the input events directly. I comandi vengono illustrati in questo articolo e in Cenni preliminari sull'esecuzione di comandi.Commands are discussed in this overview and in Commanding Overview.

Tocco e manipolazioneTouch and Manipulation

Il nuovo hardware e le nuove API del sistema operativo Windows 7 consentono alle applicazioni di ricevere contemporaneamente input da più tocchi.New hardware and API in the Windows 7 operating system provide applications the ability to receive input from multiple touches simultaneously. WPFWPF consente alle applicazioni di rilevare il tocco e rispondere in un modo simile alle risposte ad altri tipi di input, ad esempio di mouse o tastiera, generando eventi quando si verifica il tocco.enables applications to detect and respond to touch in a manner similar to responding to other input, such as the mouse or keyboard, by raising events when touch occurs.

WPFWPF espone due tipi di eventi quando si verifica il tocco: eventi di tocco ed eventi di manipolazione.exposes two types of events when touch occurs: touch events and manipulation events. Gli eventi di tocco forniscono dati non elaborati relativi a ogni dito appoggiato su un touchscreen e al suo movimento.Touch events provide raw data about each finger on a touchscreen and its movement. Gli eventi di manipolazione interpretano l'input come azioni specifiche.Manipulation events interpret the input as certain actions. Questa sezione illustra entrambi i tipi di eventi.Both types of events are discussed in this section.

PrerequisitiPrerequisites

Per sviluppare un'applicazione che risponde al tocco, sono necessari i componenti seguenti.You need the following components to develop an application that responds to touch.

  • Visual Studio 2010.Visual Studio 2010.

  • Windows 7.Windows 7.

  • Un dispositivo, ad esempio un touchscreen, che supporta Windows Touch.A device, such as a touchscreen, that supports Windows Touch.

TerminologiaTerminology

Quando si parla di tocco, vengono usati i termini seguenti.The following terms are used when touch is discussed.

  • Tocco è un tipo di input dell'utente riconosciuto da Windows 7.Touch is a type of user input that is recognized by Windows 7. In genere, il tocco viene generato appoggiando le dita su uno schermo sensibile al tocco.Usually, touch is initiated by putting fingers on a touch-sensitive screen. Si noti che dispositivi come i touchpad, diffusi sui computer portatili, non supportano il tocco se il dispositivo si limita a convertire la posizione e il movimento del dito come input del mouse.Note that devices such as a touchpad that is common on laptop computers do not support touch if the device merely converts the finger's position and movement as mouse input.

  • Multitocco è un tocco che si verifica in più punti contemporaneamente.Multitouch is touch that occurs from more than one point simultaneously. Windows 7 e WPFWPF supportano l'input multitocco.Windows 7 and WPFWPF supports multitouch. Ogni volta che il tocco viene trattato nella documentazione relativa a WPFWPF, i concetti illustrati si applicano al multitocco.Whenever touch is discussed in the documentation for WPFWPF, the concepts apply to multitouch.

  • Una manipolazione si verifica quando il tocco viene interpretato come azione fisica applicata a un oggetto.A manipulation occurs when touch is interpreted as a physical action that is applied to an object. In WPFWPF gli eventi di manipolazione interpretano l'input come una manipolazione di traslazione, espansione o rotazione.In WPFWPF, manipulation events interpret input as a translation, expansion, or rotation manipulation.

  • Un touch device rappresenta un dispositivo che produce un input tocco, ad esempio un singolo dito su un touchscreen.A touch device represents a device that produces touch input, such as a single finger on a touchscreen.

Controlli che rispondono al toccoControls that Respond to Touch

È possibile scorrere i controlli seguenti trascinando un dito attraverso il controllo, se c'è contenuto non visualizzato.The following controls can be scrolled by dragging a finger across the control if it has content that is scrolled out of view.

Il ScrollViewer definisce la proprietà associata ScrollViewer.PanningMode che consente di specificare se il panning tocco è abilitato orizzontalmente, verticalmente, entrambi o nessuno dei due.The ScrollViewer defines the ScrollViewer.PanningMode attached property that enables you to specify whether touch panning is enabled horizontally, vertically, both, or neither. La proprietà ScrollViewer.PanningDeceleration specifica la velocità con cui lo scorrimento rallenta quando l'utente solleva il dito dal touchscreen.The ScrollViewer.PanningDeceleration property specifies how quickly the scrolling slows down when the user lifts the finger from the touchscreen. La proprietà associata ScrollViewer.PanningRatio specifica il rapporto tra offset di scorrimento e offset di modifica della conversione.The ScrollViewer.PanningRatio attached property specifies the ratio of scrolling offset to translate manipulation offset.

Eventi di toccoTouch Events

Le classi base, UIElement, UIElement3D e ContentElement, definiscono gli eventi che è possibile sottoscrivere, in modo che l'applicazione possa rispondere al tocco.The base classes, UIElement, UIElement3D, and ContentElement, define events that you can subscribe to so your application will respond to touch. Gli eventi di tocco sono utili quando l'applicazione interpreta il tocco come qualcosa di diverso rispetto alla manipolazione di un oggetto.Touch events are useful when your application interprets touch as something other than manipulating an object. Un'applicazione che consente a un utente di disegnare con un dito o con più dita deve ad esempio sottoscrivere gli eventi di tocco.For example, an application that enables a user to draw with one or more fingers would subscribe to touch events.

Tutte tre le classi definiscono gli eventi seguenti, che hanno un comportamento simile, indipendentemente dalla classe che li definisce.All three classes define the following events, which behave similarly, regardless of the defining class.

Analogamente agli eventi di tastiera e mouse, gli eventi di tocco sono eventi indirizzati.Like keyboard and mouse events, the touch events are routed events. Gli eventi che iniziano con Preview sono eventi di tunneling e gli eventi che iniziano con Touch sono eventi di bubbling.The events that begin with Preview are tunneling events and the events that begin with Touch are bubbling events. Per altre informazioni sugli eventi indirizzati, vedere Cenni preliminari sugli eventi indirizzati.For more information about routed events, see Routed Events Overview. Quando si gestiscono questi eventi, è possibile ottenere la posizione dell'input, relativa a qualsiasi elemento, chiamando il metodo GetTouchPoint o GetIntermediateTouchPoints.When you handle these events, you can get the position of the input, relative to any element, by calling the GetTouchPoint or GetIntermediateTouchPoints method.

Per comprendere l'interazione tra gli eventi di tocco, si consideri lo scenario in cui un utente appoggia un dito su un elemento, muove il dito all'interno dell'elemento e quindi solleva il dito dall'elemento.To understand the interaction among the touch events, consider the scenario where a user puts one finger on an element, moves the finger in the element, and then lifts the finger from the element. La figura seguente illustra l'esecuzione degli eventi di bubbling. Gli eventi di tunneling vengono omessi per maggiore semplicità.The following illustration shows the execution of the bubbling events (the tunneling events are omitted for simplicity).

Sequenza di eventi di tocco. Eventi di toccoThe sequence of touch events. Touch events

L'elenco seguente descrive la sequenza degli eventi della figura precedente.The following list describes the sequence of the events in the preceding illustration.

  1. L'evento TouchEnter si verifica una volta quando l'utente inserisce un dito sull'elemento.The TouchEnter event occurs one time when the user puts a finger on the element.

  2. L'evento TouchDown si verifica una volta.The TouchDown event occurs one time.

  3. L'evento TouchMove si verifica più volte quando l'utente sposta il dito all'interno dell'elemento.The TouchMove event occurs multiple times as the user moves the finger within the element.

  4. L'evento TouchUp si verifica una volta quando l'utente solleva il dito dall'elemento.The TouchUp event occurs one time when the user lifts the finger from the element.

  5. L'evento TouchLeave si verifica una volta.The TouchLeave event occurs one time.

Quando vengono usate più di due dita, gli eventi si verificano per ogni dito.When more than two fingers are used, the events occur for each finger.

Eventi di manipolazioneManipulation Events

Per i casi in cui un'applicazione consente a un utente di modificare un oggetto, la classe UIElement definisce gli eventi di manipolazione.For cases where an application enables a user to manipulate an object, the UIElement class defines manipulation events. A differenza degli eventi di tocco che segnalano semplicemente la posizione del tocco, gli eventi di manipolazione segnalano come può essere interpretato l'input.Unlike the touch events that simply report the position of touch, the manipulation events report how the input can be interpreted. Ci sono tre tipi di manipolazioni: traslazione, espansione e rotazione.There are three types of manipulations, translation, expansion, and rotation. L'elenco seguente descrive come richiamare i tre tipi di manipolazioni.The following list describes how to invoke the three types of manipulations.

  • Appoggiare un dito su un oggetto e muovere il dito sul touchscreen per richiamare una manipolazione di traslazione.Put a finger on an object and move the finger across the touchscreen to invoke a translation manipulation. Ciò comporta in genere lo spostamento dell'oggetto.This usually moves the object.

  • Appoggiare due dita su un oggetto e avvicinare o allontanare le dita tra loro per richiamare una manipolazione di espansione.Put two fingers on an object and move the fingers closer together or farther apart from one another to invoke an expansion manipulation. Ciò comporta in genere il ridimensionamento dell'oggetto.This usually resizes the object.

  • Appoggiare due dita su un oggetto e ruotare le dita una attorno all'altra per richiamare una manipolazione di rotazione.Put two fingers on an object and rotate the fingers around each other to invoke a rotation manipulation. Ciò comporta in genere la rotazione dell'oggetto.This usually rotates the object.

Si possono verificare più tipi di manipolazioni contemporaneamente.More than one type of manipulation can occur simultaneously.

Quando gli oggetti rispondono alle manipolazioni, si può fare in modo che sembrino avere un'inerzia.When you cause objects to respond to manipulations, you can have the object appear to have inertia. In questo modo, gli oggetti possono simulare il mondo fisico.This can make your objects simulate the physical world. Ad esempio se si spinge un libro su un tavolo con sufficiente forza, il libro continuerà a muoversi anche dopo che lo si lascia.For example, when you push a book across a table, if you push hard enough the book will continue to move after you release it. WPFWPF consente di simulare questo comportamento generando eventi di manipolazione dopo che le dita dell'utente rilasciano l'oggetto.enables you to simulate this behavior by raising manipulation events after the user's fingers releases the object.

Per informazioni su come creare un'applicazione che consenta all'utente di spostare, ridimensionare e ruotare un oggetto, vedere [Walkthrough: Creazione della prima applicazione touch @ no__t-0.For information about how to create an application that enables the user to move, resize, and rotate an object, see Walkthrough: Creating Your First Touch Application.

Il UIElement definisce gli eventi di manipolazione seguenti.The UIElement defines the following manipulation events.

Per impostazione predefinita, un UIElement non riceve questi eventi di manipolazione.By default, a UIElement does not receive these manipulation events. Per ricevere eventi di manipolazione in un UIElement, impostare UIElement.IsManipulationEnabled su true.To receive manipulation events on a UIElement, set UIElement.IsManipulationEnabled to true.

Percorso di esecuzione degli eventi di manipolazioneThe Execution Path of Manipulation Events

Si consideri uno scenario in cui un utente "lancia" un oggetto.Consider a scenario where a user "throws" an object. L'utente appoggia un dito sull'oggetto, sposta il dito sul touchscreen per un breve tratto e quindi solleva il dito mentre l'oggetto si sta muovendo.The user puts a finger on the object, moves the finger across the touchscreen for a short distance, and then lifts the finger while it is moving. Il risultato di questa azione è che l'oggetto si muoverà sotto il dito dell'utente e continuerà a muoversi dopo che l'utente ha sollevato il dito.The result of this is that the object will move under the user's finger and continue to move after the user lifts the finger.

La figura seguente mostra il percorso di esecuzione degli eventi di manipolazione, con informazioni importanti relative a ogni evento.The following illustration shows the execution path of manipulation events and important information about each event.

Sequenza di eventi di manipolazione. Eventi di manipolazioneThe sequence of manipulation events. Manipulation events

L'elenco seguente descrive la sequenza degli eventi della figura precedente.The following list describes the sequence of the events in the preceding illustration.

  1. L'evento ManipulationStarting si verifica quando l'utente posiziona un dito sull'oggetto.The ManipulationStarting event occurs when the user places a finger on the object. Tra le altre cose, questo evento consente di impostare la proprietà ManipulationContainer.Among other things, this event allows you to set the ManipulationContainer property. Negli eventi successivi la posizione della manipolazione sarà relativa a ManipulationContainer.In the subsequent events, the position of the manipulation will be relative to the ManipulationContainer. In eventi diversi da ManipulationStarting questa proprietà è di sola lettura, pertanto l'evento ManipulationStarting è l'unica volta in cui è possibile impostare questa proprietà.In events other than ManipulationStarting, this property is read-only, so the ManipulationStarting event is the only time that you can set this property.

  2. L'evento ManipulationStarted si verifica successivamente.The ManipulationStarted event occurs next. Questo evento segnala l'origine della manipolazione.This event reports the origin of the manipulation.

  3. L'evento ManipulationDelta si verifica più volte quando il dito di un utente si sposta su un touchscreen.The ManipulationDelta event occurs multiple times as a user's fingers move on a touchscreen. La proprietà DeltaManipulation della classe ManipulationDeltaEventArgs indica se la manipolazione viene interpretata come spostamento, espansione o traduzione.The DeltaManipulation property of the ManipulationDeltaEventArgs class reports whether the manipulation is interpreted as movement, expansion, or translation. In questo contesto si esegue la maggior parte del lavoro di manipolazione di un oggetto.This is where you perform most of the work of manipulating an object.

  4. L'evento ManipulationInertiaStarting si verifica quando le dita dell'utente perdono il contatto con l'oggetto.The ManipulationInertiaStarting event occurs when the user's fingers lose contact with the object. Questo evento consente di specificare la decelerazione delle manipolazioni durante l'inerzia.This event enables you to specify the deceleration of the manipulations during inertia. In questo modo, l'oggetto può emulare spazi fisici o attribuiti diversi, se si desidera.This is so your object can emulate different physical spaces or attributes if you choose. Si supponga, ad esempio, che l'applicazione includa due oggetti che rappresentano elementi nel mondo fisico e che uno di questi sia più pesante dell'altro.For example, suppose your application has two objects that represent items in the physical world, and one is heavier than the other. È possibile fare in modo che l'oggetto più pesante rallenti più velocemente rispetto a quello più leggero.You can make the heavier object decelerate faster than the lighter object.

  5. L'evento ManipulationDelta si verifica più volte quando si verifica un'inerzia.The ManipulationDelta event occurs multiple times as inertia occurs. Si noti che questo evento si verifica quando le dita dell'utente si muovono sul touchscreen e quando WPFWPF simula l'inerzia.Note that this event occurs when the user's fingers move across the touchscreen and when WPFWPF simulates inertia. In altre parole, ManipulationDelta si verifica prima e dopo l'evento ManipulationInertiaStarting.In other words, ManipulationDelta occurs before and after the ManipulationInertiaStarting event. La proprietà ManipulationDeltaEventArgs.IsInertial segnala se l'evento ManipulationDelta si verifica durante l'inerzia, quindi è possibile controllare tale proprietà ed eseguire azioni diverse, a seconda del valore.The ManipulationDeltaEventArgs.IsInertial property reports whether the ManipulationDelta event occurs during inertia, so you can check that property and perform different actions, depending on its value.

  6. L'evento ManipulationCompleted si verifica al termine della manipolazione e di qualsiasi inerzia.The ManipulationCompleted event occurs when the manipulation and any inertia ends. Ovvero, dopo che si sono verificati tutti gli eventi ManipulationDelta, viene generato l'evento ManipulationCompleted per segnalare che la manipolazione è stata completata.That is, after all the ManipulationDelta events occur, the ManipulationCompleted event occurs to signal that the manipulation is complete.

Il UIElement definisce anche l'evento ManipulationBoundaryFeedback.The UIElement also defines the ManipulationBoundaryFeedback event. Questo evento si verifica quando viene chiamato il metodo ReportBoundaryFeedback nell'evento ManipulationDelta.This event occurs when the ReportBoundaryFeedback method is called in the ManipulationDelta event. L'evento ManipulationBoundaryFeedback consente alle applicazioni o ai componenti di fornire feedback visivo quando un oggetto raggiunge un limite.The ManipulationBoundaryFeedback event enables applications or components to provide visual feedback when an object hits a boundary. Ad esempio, la classe Window gestisce l'evento ManipulationBoundaryFeedback per far sì che la finestra si sposti leggermente quando viene rilevato il bordo.For example, the Window class handles the ManipulationBoundaryFeedback event to cause the window to slightly move when its edge is encountered.

È possibile annullare la manipolazione chiamando il metodo Cancel sugli argomenti dell'evento in qualsiasi evento di manipolazione ad eccezione di @no__t evento-1.You can cancel the manipulation by calling the Cancel method on the event arguments in any manipulation event except ManipulationBoundaryFeedback event. Quando si chiama Cancel, gli eventi di manipolazione non vengono più generati e si verificano gli eventi del mouse per il tocco.When you call Cancel, the manipulation events are no longer raised and mouse events occur for touch. La tabella seguente descrive la relazione tra il momento in cui viene annullata la manipolazione e gli eventi del mouse che si verificano.The following table describes the relationship between the time the manipulation is canceled and the mouse events that occur.

Evento su cui viene chiamato il metodo CancelThe event that Cancel is called in Eventi del mouse che si verificano per l'input già avvenutoThe mouse events that occur for input that already occurred
ManipulationStarting e ManipulationStartedManipulationStarting and ManipulationStarted Eventi di pressione del pulsante del mouse.Mouse down events.
ManipulationDelta Eventi di pressione del pulsante e di spostamento del mouse.Mouse down and mouse move events.
ManipulationInertiaStarting e ManipulationCompletedManipulationInertiaStarting and ManipulationCompleted Eventi di pressione e rilascio del pulsante e di spostamento del mouse.Mouse down, mouse move, and mouse up events.

Si noti che se si chiama Cancel quando la manipolazione è in inerzia, il metodo restituisce false e l'input non genera eventi del mouse.Note that if you call Cancel when the manipulation is in inertia, the method returns false and the input does not raise mouse events.

Relazione tra eventi di tocco e di manipolazioneThe Relationship Between Touch and Manipulation Events

Un UIElement può ricevere sempre eventi di tocco.A UIElement can always receive touch events. Quando la proprietà IsManipulationEnabled è impostata su true, un UIElement può ricevere eventi di tocco e di manipolazione.When the IsManipulationEnabled property is set to true, a UIElement can receive both touch and manipulation events. Se l'evento TouchDown non viene gestito (ovvero la proprietà Handled è false), la logica di manipolazione acquisisce il tocco sull'elemento e genera gli eventi di manipolazione.If the TouchDown event is not handled (that is, the Handled property is false), the manipulation logic captures the touch to the element and generates the manipulation events. Se la proprietà Handled è impostata su true nell'evento TouchDown, la logica di manipolazione non genera eventi di manipolazione.If the Handled property is set to true in the TouchDown event, the manipulation logic does not generate manipulation events. La figura seguente mostra la relazione tra eventi di tocco ed eventi di manipolazione.The following illustration shows the relationship between touch events and manipulation events.

Relazione tra eventi di tocco ed eventi di manipolazione eventi di manipolazione e toccoRelationship between touch and manipulation events Touch and manipulation events

L'elenco seguente descrive la relazione tra gli eventi di tocco e gli eventi di manipolazione illustrati nella figura precedente.The following list describes the relationship between the touch and manipulation events that is shown in the preceding illustration.

Stato attivoFocus

Ci sono due concetti principali relativi allo stato attivo in WPFWPF: lo stato attivo della tastiera e lo stato attivo logico.There are two main concepts that pertain to focus in WPFWPF: keyboard focus and logical focus.

Stato attivo della tastieraKeyboard Focus

Lo stato attivo della tastiera fa riferimento all'elemento che riceve l'input dalla tastiera.Keyboard focus refers to the element that is receiving keyboard input. Su un desktop può esserci un solo elemento con lo stato attivo della tastiera.There can be only one element on the whole desktop that has keyboard focus. In WPFWPF, l'elemento con lo stato attivo della tastiera avrà IsKeyboardFocused impostato su true.In WPFWPF, the element that has keyboard focus will have IsKeyboardFocused set to true. Il metodo statico Keyboard FocusedElement restituisce l'elemento che dispone attualmente dello stato attivo della tastiera.The static Keyboard method FocusedElement returns the element that currently has keyboard focus.

Lo stato attivo della tastiera può essere ottenuto tramite tabulazione su un elemento o facendo clic sul mouse su determinati elementi, ad esempio un TextBox.Keyboard focus can be obtained by tabbing to an element or by clicking the mouse on certain elements, such as a TextBox. Lo stato attivo della tastiera può essere ottenuto anche a livello di programmazione tramite il metodo Focus sulla classe Keyboard.Keyboard focus can also be obtained programmatically by using the Focus method on the Keyboard class. Focus tenta di assegnare lo stato attivo della tastiera all'elemento specificato.Focus attempts to give the specified element keyboard focus. L'elemento restituito da Focus è l'elemento che dispone attualmente dello stato attivo della tastiera.The element returned by Focus is the element that currently has keyboard focus.

Affinché un elemento ottenga lo stato attivo della tastiera, la proprietà Focusable e le proprietà IsVisible devono essere impostate su true.In order for an element to obtain keyboard focus the Focusable property and the IsVisible properties must be set to true. Alcune classi, ad esempio Panel, hanno Focusable impostato su false per impostazione predefinita. Pertanto, potrebbe essere necessario impostare questa proprietà su true Se si desidera che tale elemento possa ottenere lo stato attivo.Some classes, such as Panel, have Focusable set to false by default; therefore, you may have to set this property to true if you want that element to be able to obtain focus.

Nell'esempio seguente viene utilizzato Focus per impostare lo stato attivo della tastiera su un Button.The following example uses Focus to set keyboard focus on a Button. La posizione consigliata per impostare lo stato attivo iniziale in un'applicazione è nel gestore dell'evento Loaded.The recommended place to set initial focus in an application is in the Loaded event handler.

private void OnLoaded(object sender, RoutedEventArgs e)
{
    // Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton);
}
Private Sub OnLoaded(ByVal sender As Object, ByVal e As RoutedEventArgs)
    ' Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton)
End Sub

Per altre informazioni sullo stato attivo della tastiera, vedere Cenni preliminari sullo stato attivo.For more information about keyboard focus, see Focus Overview.

Stato attivo logicoLogical Focus

Lo stato attivo logico fa riferimento all'FocusManager.FocusedElement in un ambito di stato attivo.Logical focus refers to the FocusManager.FocusedElement in a focus scope. In un'applicazione possono esserci più elementi con lo stato attivo logico, ma in un determinato ambito di stato attivo può esserci un solo elemento con lo stato attivo logico.There can be multiple elements that have logical focus in an application, but there may only be one element that has logical focus in a particular focus scope.

Un ambito di stato attivo è un elemento contenitore che tiene traccia dell'FocusedElement all'interno del relativo ambito.A focus scope is a container element that keeps track of the FocusedElement within its scope. Quando lo stato attivo lascia un ambito di stato attivo, l'elemento con lo stato attivo perde lo stato attivo della tastiera, ma mantiene quello logico.When focus leaves a focus scope, the focused element will lose keyboard focus but will retain logical focus. Quando lo stato attivo torna nell'ambito di stato attivo, l'elemento con lo stato attivo ottiene nuovamente lo stato attivo della tastiera.When focus returns to the focus scope, the focused element will obtain keyboard focus. In questo modo, lo stato attivo della tastiera può essere passato tra più ambiti, ma l'elemento con lo stato attivo in un determinato ambito rimane sicuramente tale al ritorno dello stato attivo.This allows for keyboard focus to be changed between multiple focus scopes but insures that the focused element within the focus scope remains the focused element when focus returns.

Un elemento può essere trasformato in un ambito di stato attivo in Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) impostando la proprietà associata FocusManager IsFocusScope su true o nel codice impostando la proprietà associata usando il metodo SetIsFocusScope.An element can be turned into a focus scope in Extensible Application Markup Language (XAML)Extensible Application Markup Language (XAML) by setting the FocusManager attached property IsFocusScope to true, or in code by setting the attached property by using the SetIsFocusScope method.

Nell'esempio seguente viene reso StackPanel in un ambito di stato attivo impostando la proprietà associata IsFocusScope.The following example makes a StackPanel into a focus scope by setting the IsFocusScope attached property.

<StackPanel Name="focusScope1" 
            FocusManager.IsFocusScope="True"
            Height="200" Width="200">
  <Button Name="button1" Height="50" Width="50"/>
  <Button Name="button2" Height="50" Width="50"/>
</StackPanel>
StackPanel focuseScope2 = new StackPanel();
FocusManager.SetIsFocusScope(focuseScope2, true);
Dim focuseScope2 As New StackPanel()
FocusManager.SetIsFocusScope(focuseScope2, True)

Per impostazione predefinita, le classi in WPFWPF, che sono ambiti di stato attivo, sono Window, Menu, ToolBar e ContextMenu.Classes in WPFWPF which are focus scopes by default are Window, Menu, ToolBar, and ContextMenu.

Un elemento con lo stato attivo della tastiera avrà anche lo stato attivo logico per l'ambito di stato attivo a cui appartiene. Pertanto, l'impostazione dello stato attivo su un elemento con il metodo Focus sulla classe Keyboard o sulle classi degli elementi di base tenterà di assegnare lo stato attivo della tastiera e lo stato attivo logico dell'elemento.An element that has keyboard focus will also have logical focus for the focus scope it belongs to; therefore, setting focus on an element with the Focus method on the Keyboard class or the base element classes will attempt to give the element keyboard focus and logical focus.

Per determinare l'elemento con stato attivo in un ambito di stato attivo, utilizzare GetFocusedElement.To determine the focused element in a focus scope, use GetFocusedElement. Per modificare l'elemento con stato attivo per un ambito di stato attivo, utilizzare SetFocusedElement.To change the focused element for a focus scope, use SetFocusedElement.

Per altre informazioni sullo stato attivo logico, vedere Cenni preliminari sullo stato attivo.For more information about logical focus, see Focus Overview.

Posizione del mouseMouse Position

L'API di input WPFWPF fornisce informazioni utili per quanto riguarda gli spazi delle coordinate.The WPFWPF input API provides helpful information with regard to coordinate spaces. Ad esempio, la coordinata (0,0) rappresenta la coordinata superiore sinistra, ma di quale elemento dell'albero?For example, coordinate (0,0) is the upper-left coordinate, but the upper-left of which element in the tree? Si tratta dell'elemento che costituisce la destinazione dell'input?The element that is the input target? O dell'elemento a cui è associato il gestore eventi?The element you attached your event handler to? Oppure di qualche altro elemento?Or something else? Per evitare confusione, l'API di input WPFWPF richiede di specificare il frame di riferimento quando si utilizzano le coordinate ottenute tramite il mouse.To avoid confusion, the WPFWPF input API requires that you specify your frame of reference when you work with coordinates obtained through the mouse. Il metodo GetPosition restituisce la coordinata del puntatore del mouse relativa all'elemento specificato.The GetPosition method returns the coordinate of the mouse pointer relative to the specified element.

Mouse CaptureMouse Capture

I dispositivi di tipo mouse hanno una caratteristica modale specifica nota come mouse capture.Mouse devices specifically hold a modal characteristic known as mouse capture. Tale caratteristica viene usata per mantenere uno stato di input di transizione all'avvio di un'operazione di trascinamento della selezione, in modo che le altre operazioni che riguardano la posizione su schermo nominale del puntatore del mouse non vengano necessariamente eseguite.Mouse capture is used to maintain a transitional input state when a drag-and-drop operation is started, so that other operations involving the nominal on-screen position of the mouse pointer do not necessarily occur. Durante il trascinamento, l'utente non può fare clic senza interrompere il trascinamento della selezione, quindi la maggior parte dei segnali di passaggio del mouse risulterà inappropriata quando l'origine del trascinamento mantiene lo stato mouse capture.During the drag, the user cannot click without aborting the drag-and-drop, which makes most mouseover cues inappropriate while the mouse capture is held by the drag origin. Il sistema di input espone le API che possono determinare lo stato di acquisizione del mouse, nonché le API che possono forzare l'acquisizione del mouse su un elemento specifico o cancellare lo stato di acquisizione del mouse.The input system exposes APIs that can determine mouse capture state, as well as APIs that can force mouse capture to a specific element, or clear mouse capture state. Per altre informazioni sulle operazioni di trascinamento della selezione, vedere Cenni preliminari sul trascinamento della selezione.For more information on drag-and-drop operations, see Drag and Drop Overview.

ComandiCommands

I comandi consentono la gestione dell'input a un livello più semantico rispetto all'input dei dispositivi.Commands enable input handling at a more semantic level than device input. I comandi sono semplici direttive, come Cut, Copy, Paste o Open.Commands are simple directives, such as Cut, Copy, Paste, or Open. I comandi sono utili per centralizzare la logica di comando.Commands are useful for centralizing your command logic. È possibile accedere allo stesso comando da un Menu, da un ToolBar o tramite un tasto di scelta rapida.The same command might be accessed from a Menu, on a ToolBar, or through a keyboard shortcut. I comandi forniscono anche un meccanismo per disabilitare i controlli quando il comando non è più disponibile.Commands also provide a mechanism for disabling controls when the command becomes unavailable.

RoutedCommand è l'implementazione WPFWPF di ICommand.RoutedCommand is the WPFWPF implementation of ICommand. Quando viene eseguito un RoutedCommand, viene generato un evento PreviewExecuted e Executed sulla destinazione del comando, che esegue il tunneling e il bubbling attraverso l'albero degli elementi come altro input.When a RoutedCommand is executed, a PreviewExecuted and an Executed event are raised on the command target, which tunnel and bubble through the element tree like other input. Se non è impostata una destinazione del comando, questa sarà rappresentata dall'elemento con lo stato attivo della tastiera.If a command target is not set, the element with keyboard focus will be the command target. La logica che esegue il comando è associata a un CommandBinding.The logic that performs the command is attached to a CommandBinding. Quando un evento Executed raggiunge un CommandBinding per quel comando specifico, viene chiamato il ExecutedRoutedEventHandler sul CommandBinding.When an Executed event reaches a CommandBinding for that specific command, the ExecutedRoutedEventHandler on the CommandBinding is called. Il gestore esegue l'azione del comando.This handler performs the action of the command.

Per altre informazioni sui comandi, vedere Cenni preliminari sull'esecuzione di comandi.For more information on commanding, see Commanding Overview.

WPFWPF fornisce una libreria di comandi comuni costituiti da ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands e EditingCommands oppure è possibile definirne di propri.provides a library of common commands which consists of ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands, and EditingCommands, or you can define your own.

Nell'esempio seguente viene illustrato come configurare un MenuItem in modo che, quando viene fatto clic, richiami il comando Paste in TextBox, supponendo che lo stato di TextBox abbia lo stato attivo.The following example shows how to set up a MenuItem so that when it is clicked it will invoke the Paste command on the TextBox, assuming the TextBox has keyboard focus.

<StackPanel>
  <Menu>
    <MenuItem Command="ApplicationCommands.Paste" />
  </Menu>
  <TextBox />
</StackPanel>
  // Creating the UI objects
  StackPanel mainStackPanel = new StackPanel();
  TextBox pasteTextBox = new TextBox();
  Menu stackPanelMenu = new Menu();
  MenuItem pasteMenuItem = new MenuItem();
 
  // Adding objects to the panel and the menu
  stackPanelMenu.Items.Add(pasteMenuItem);
  mainStackPanel.Children.Add(stackPanelMenu);
  mainStackPanel.Children.Add(pasteTextBox);

  // Setting the command to the Paste command
  pasteMenuItem.Command = ApplicationCommands.Paste;

  // Setting the command target to the TextBox
  pasteMenuItem.CommandTarget = pasteTextBox;
' Creating the UI objects
Dim mainStackPanel As New StackPanel()
Dim pasteTextBox As New TextBox()
Dim stackPanelMenu As New Menu()
Dim pasteMenuItem As New MenuItem()

' Adding objects to the panel and the menu
stackPanelMenu.Items.Add(pasteMenuItem)
mainStackPanel.Children.Add(stackPanelMenu)
mainStackPanel.Children.Add(pasteTextBox)

' Setting the command to the Paste command
pasteMenuItem.Command = ApplicationCommands.Paste

Per altre informazioni sui comandi in WPFWPF, vedere Cenni preliminari sull'esecuzione di comandi.For more information about commands in WPFWPF, see Commanding Overview.

Sistema di input ed elementi di baseThe Input System and Base Elements

Gli eventi di input, ad esempio gli eventi associati definiti dalle classi Mouse, Keyboard e Stylus, vengono generati dal sistema di input e inseriti in una determinata posizione nel modello a oggetti in base all'hit test della struttura ad albero visuale in fase di esecuzione.Input events such as the attached events defined by the Mouse, Keyboard, and Stylus classes are raised by the input system and injected into a particular position in the object model based on hit testing the visual tree at run time.

Tutti gli eventi che Mouse, Keyboard e Stylus definiscono come un evento associato vengono riesposti anche dalle classi degli elementi di base UIElement e ContentElement come un nuovo evento indirizzato.Each of the events that Mouse, Keyboard, and Stylus define as an attached event is also re-exposed by the base element classes UIElement and ContentElement as a new routed event. Gli eventi indirizzati degli elementi di base vengono generati da classi che gestiscono l'evento associato originale e riutilizzano i dati dell'evento.The base element routed events are generated by classes handling the original attached event and reusing the event data.

Quando l'evento di input viene associato a un particolare elemento di origine tramite l'implementazione dell'evento di input dei relativi elementi di base, può essere indirizzato lungo la parte restante della route di un evento basata su una combinazione di oggetti albero logico e struttura ad albero visuale ed essere gestito dal codice dell'applicazione.When the input event becomes associated with a particular source element through its base element input event implementation, it can be routed through the remainder of an event route that is based on a combination of logical and visual tree objects, and be handled by application code. In genere, è più facile gestire questi eventi di input correlati al dispositivo usando gli eventi indirizzati in UIElement e ContentElement, perché è possibile usare una sintassi del gestore eventi più intuitiva in XAMLXAML e nel codice.Generally, it is more convenient to handle these device-related input events using the routed events on UIElement and ContentElement, because you can use more intuitive event handler syntax both in XAMLXAML and in code. È possibile scegliere di gestire invece l'evento associato che ha avviato il processo, ma potrebbero sorgere diversi problemi: l'evento associato potrebbe essere contrassegnato come gestito dalla gestione della classe dell'elemento di base, per cui potrebbe essere necessario usare i metodi della funzione di accesso invece della sintassi dell'evento vera e propria per associare i gestori per gli eventi associati.You could choose to handle the attached event that initiated the process instead, but you would face several issues: the attached event may be marked handled by the base element class handling, and you need to use accessor methods rather than true event syntax in order to attach handlers for attached events.

Argomenti successiviWhat's Next

A questo punto si conoscono diverse tecniche per la gestione dell'input in WPFWPF.You now have several techniques to handle input in WPFWPF. Si dovrebbe anche avere una conoscenza più approfondita dei vari tipi di eventi di input e dei meccanismi degli eventi indirizzati usati in WPFWPF.You should also have an improved understanding of the various types of input events and the routed event mechanisms used by WPFWPF.

Sono disponibili risorse aggiuntive che illustrano più dettagliatamente gli elementi del framework WPFWPF e il routing degli eventi.Additional resources are available that explain WPFWPF framework elements and event routing in more detail. Per altre informazioni generali, vedere Cenni preliminari sull'esecuzione di comandi, Cenni preliminari sullo stato attivo, Cenni preliminari sugli elementi di base, Strutture ad albero in WPF e Cenni preliminari sugli eventi indirizzati.See the following overviews for more information, Commanding Overview, Focus Overview, Base Elements Overview, Trees in WPF, and Routed Events Overview.

Vedere ancheSee also