Condividi tramite

Cenni preliminari sull’input

  • Articolo

Aggiornamento: novembre 2007

Il sottosistema Windows Presentation Foundation (WPF) fornisce un'API potente che consente di ottenere input da vari dispositivi, inclusi mouse, tastiera e stilo.

In questo argomento vengono descritti i servizi disponibili in WPF e viene illustrata l'architettura dei sistemi di input.

Nel presente argomento sono contenute le seguenti sezioni.

  • API di input
  • Routing degli eventi
  • Gestione degli eventi di input
  • Input di testo
  • Focus
  • Posizione del mouse
  • Mouse capture
  • Comandi
  • Il sistema di input e gli elementi di base
  • Argomenti successivi
  • Argomenti correlati

API di input

L'esposizione dell'API di input principale viene rilevata nelle classi degli elementi di base: UIElement, ContentElement, FrameworkElement e FrameworkContentElement. Per ulteriori informazioni sugli elementi di base, vedere Cenni preliminari sugli elementi di base. Queste classi forniscono funzionalità per eventi di input relativi alle sequenze di tasti, ai pulsanti del mouse, alla rotella del mouse, al movimento del mouse, alla gestione dello stato attivo e allo stato mouse capture, solo per citarne alcuni. Collocando l'API di input sugli elementi di base, invece di considerare tutti gli eventi di input come servizio, l'architettura di input consente di originare gli eventi di input da un particolare oggetto dell'interfaccia utente e di supportare uno schema di routing dell'evento con più elementi aventi la possibilità di gestire un evento di input. A molti eventi di input è associata una coppia di eventi. Ad esempio, l'evento di pressione di tasti è associato agli eventi KeyDown e PreviewKeyDown. La differenza tra questi eventi consiste nella modalità con cui vengono indirizzati all'elemento di destinazione. Gli eventi di anteprima effettuano il tunneling della struttura ad albero dell'elemento a partire dall'elemento radice all'elemento di destinazione. Gli eventi di bubbling invece effettuano il bubbling dall'elemento di destinazione all'elemento radice. Il routing degli eventi di WPF viene illustrato più dettagliatamente in seguito in questi cenni preliminari e in Cenni preliminari sugli eventi indirizzati.

Classi Keyboard e Mouse

Oltre all'API di input delle classi degli elementi di base, la classe Keyboard e le classi Mouse forniscono un'API aggiuntiva per utilizzare gli input della tastiera e del mouse.

Esempi di API di input della classe Keyboard sono la proprietà Modifiers, che restituisce l'oggetto ModifierKeys attualmente selezionato, e il metodo IsKeyDown, che consente di determinare se viene premuto un tasto specificato.

Nell'esempio seguente viene utilizzato il metodo GetKeyStates per determinare se Key si trova nello stato premuto.

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

Esempi di API di input nella classe Mouse sono l'oggetto MiddleButton, che ottiene lo stato del pulsante centrale del mouse, e l'oggetto DirectlyOver, che ottiene l'elemento su cui è attualmente posizionato il puntatore del mouse.

Nell'esempio seguente si stabilisce se l'oggetto LeftButton del mouse si trova nello stato Pressed.

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

Le classi Mouse e Keyboard vengono analizzate più dettagliatamente in seguito in questi cenni preliminari.

Input dello stilo

In WPF è stato integrato il supporto per l'oggetto Stylus. L'oggetto Stylus è un input penna divenuto comune grazie a Tablet PC. Le applicazioni WPF possono considerare lo stilo come un mouse utilizzando l'API del mouse; tuttavia WPF espone anche un'astrazione del dispositivo stilo che utilizza un modello simile alla tastiera e al mouse. Tutte le API correlate allo stilo contengono la parola "Stylus".

Dal momento che lo stilo può funzionare come un mouse, le applicazioni che supportano solo l'input da mouse possono comunque ottenere automaticamente un certo livello di supporto dello stilo. Quando lo stilo viene utilizzato in questa modalità, l'applicazione ha la possibilità di gestire l'evento dello stilo appropriato gestendo l'evento del mouse corrispondente. Inoltre, i servizi di livello superiore, ad esempio l'input penna, sono disponibili anche tramite l'astrazione del dispositivo stilo. Per ulteriori informazioni sull'input penna, vedere Nozioni di base sull'input penna.

Routing degli eventi

Un oggetto FrameworkElement può contenere nel modello di contenuto altri elementi come elementi figlio, formando una struttura ad albero di elementi. In WPF, l'elemento padre può partecipare all'input diretto ai relativi elementi figlio o agli altri discendenti mediante la gestione degli eventi. Ciò risulta particolarmente utile per la compilazione dei controlli a partire da controlli più piccoli, processo noto come "composizione dei controlli". Per ulteriori informazioni sulle strutture ad albero di elementi e sulla rispettiva correlazione con le route degli eventi, vedere Strutture ad albero in WPF.

Il routing degli eventi è il processo di inoltro di eventi a più elementi, che consente a un particolare oggetto o elemento della route di offrire una risposta significativa (tramite la gestione) a un evento che potrebbe essere stato originato da un elemento diverso. Gli eventi indirizzati utilizzano uno dei tre meccanismi di routing indicati di seguito: diretto, bubbling e tunneling. Nel routing diretto, l'elemento di origine è l'unico elemento notificato e l'evento non viene indirizzato a nessun altro elemento. Tuttavia, l'evento indirizzato tramite routing diretto offre alcune funzionalità aggiuntive che sono disponibili solo per gli eventi indirizzati rispetto agli eventi CLR standard. Il bubbling viene eseguito procedendo verso l'alto nella struttura ad albero dell'elemento, notificando dapprima l'elemento che ha originato l'evento, quindi l'elemento padre e così via. Il tunneling parte dalla radice della struttura ad albero dell'elemento e procede verso il basso, terminando con l'elemento di origine. Per ulteriori informazioni sugli eventi indirizzati, vedere Cenni preliminari sugli eventi indirizzati.

Gli eventi di input WPF vengono in genere eseguiti in coppie, costituite da un evento di tunneling e un evento di bubbling. Gli eventi di tunneling si distinguono da quelli di bubbling tramite il prefisso "Preview". L'evento PreviewMouseMove, ad esempio, è la versione di tunneling di un evento di spostamento del mouse, mentre MouseMove è la versione di bubbling dello stesso evento. Questa coppia di eventi rappresenta una convenzione implementata al livello dell'elemento e non è una funzionalità intrinseca del sistema di eventi WPF. Per informazioni dettagliate, vedere la sezione relativa agli eventi di input WPF in Cenni preliminari sugli eventi indirizzati.

Gestione degli eventi di input

Per ricevere input su un elemento, un gestore eventi deve essere associato a quel particolare evento. In XAML tale associazione è molto semplice: è sufficiente fare riferimento al nome dell'evento come attributo dell'elemento che rimarrà in ascolto di questo evento. Si imposta quindi il valore dell'attributo sul nome del gestore eventi che viene definito, in base a un delegato. Il gestore eventi deve essere scritto in codice, ad esempio C#, e può essere incluso in un file code-behind.

Gli eventi di tastiera si verificano quando il sistema operativo segnala le azioni principali che vengono eseguite quando lo stato attivo della tastiera è impostato su un elemento. Gli eventi del mouse e dello stilo rientrano ciascuno in due categorie: eventi che segnalano le modifiche nella posizione del puntatore in relazione all'elemento ed eventi che segnalano le modifiche nello stato dei pulsanti del dispositivo.

Esempio di eventi di input da tastiera

Nel seguente esempio viene attesa la pressione del tasto freccia sinistra. Viene creato un oggetto StackPanel che dispone di un oggetto Button. Un gestore eventi che rimane in ascolto della pressione del tasto freccia sinistra viene associato all'istanza di Button.

Nella prima parte dell'esempio vengono creati gli oggetti StackPanel e Button e viene associato il gestore eventi per 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);

La seconda parte è scritta in codice e definisce il gestore eventi. Quando si preme il tasto freccia sinistra e l'oggetto Button dispone dello stato attivo della tastiera, il gestore viene eseguito e il colore Background dell'oggetto Button viene modificato. Se il tasto viene premuto, ma non corrisponde al tasto freccia sinistra, il colore Background dell'oggetto Button viene impostato di nuovo sul colore iniziale.

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

Esempi di eventi di input da mouse

Nell'esempio seguente, il colore di Background di un oggetto Button viene modificato quando il puntatore del mouse viene spostato sull'oggetto Button. Il colore di Background viene ripristinato quando il mouse si allontana da Button.

Nella prima parte dell'esempio vengono creati l'oggetto StackPanel e il controllo Button; il gestore eventi per gli eventi MouseEnter e MouseLeave viene associato all'oggetto 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);

La seconda parte dell'esempio è scritta in codice e definisce i gestori eventi. Spostando il mouse sull'oggetto Button, il colore di Background dell'oggetto Button viene modificato in SlateGray. Quando il mouse si allontana da Button, il colore di Background dell'oggetto Button viene nuovamente impostato su 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 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;
    }
}

Input di testo

L'evento TextInput consente di rimanere in ascolto dell'input di testo in modo indipendente dal dispositivo. La tastiera è il mezzo principale per l'immissione di testo, ma anche il riconoscimento vocale, il riconoscimento grafia e altri dispositivi di input possono generare input di testo.

Per l'input da tastiera, WPF invia dapprima gli eventi KeyDown / KeyUp appropriati. Se tali eventi non sono gestiti e se si tratta di un tasto di testo (piuttosto che di un tasto di un controllo, quali le frecce direzionali o i tasti funzione), viene generato un evento TextInput. Il mapping tra gli eventi KeyDown/KeyUp e TextInput non è sempre di tipo semplice uno-a-uno, perché sequenze di più tasti possono generare un unico carattere di input di testo e la pressione di un singolo tasto può generare stringhe con più caratteri. Ciò si verifica soprattutto con lingue quali il cinese, il giapponese e il coreano che utilizzano Input Method Editor (IME) per generare le migliaia di caratteri possibili nei corrispondenti alfabeti.

Quando WPF invia un evento KeyUp/KeyDown, la proprietà Key viene impostata su Key.System se le sequenze di tasti possono diventare parte di un evento TextInput (ad esempio tramite la pressione di ALT+S). Ciò consente al codice di un gestore di eventi KeyDown di verificare la disponibilità di Key.System e, se la ricerca ha esito positivo,di abbandonare l'elaborazione del gestore dell' evento TextInput generato successivamente. In questi casi, le varie proprietà dell'argomento TextCompositionEventArgs possono essere utilizzate per determinare le sequenze di tasti originali. Analogamente, se un IME è attivo, il valore dell'oggetto Key è Key.ImeProcessede l'oggetto ImeProcessedKey fornisce la selezione del tasto o della sequenza di tasti originale.

Nell'esempio seguente viene definito un gestore per l'evento Click e uno per l'evento KeyDown.

Il primo segmento di codice o di markup crea l'interfaccia utente.

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

Il secondo segmento di codice contiene i gestori eventi.

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

Poiché gli eventi di input effettuano il bubbling sulla route dell'evento, l'oggetto StackPanel riceve l'input indipendentemente da quale sia l'elemento che presenta lo stato attivo della tastiera. Il controllo TextBox riceve per primo la notifica e il gestore OnTextInputKeyDown viene chiamato solo se l'oggetto TextBox non ha gestito l'input. Se l'evento PreviewKeyDown viene utilizzato al posto dell'evento KeyDown, il gestore OnTextInputKeyDown viene chiamato per primo.

In questo esempio, la logica di gestione viene scritta due volte: una prima volta per CTRL+O e una seconda volta per l'evento Click del pulsante. È possibile semplificare questa operazione utilizzando i comandi, invece di gestire direttamente gli eventi di input. I comandi vengono illustrati in questi cenni preliminari e in Cenni preliminari sull'esecuzione di comandi.

Focus

In WPF lo stato attivo è basato su due concetti principali, lo stato attivo della tastiera e lo stato attivo logico.

Stato attivo della tastiera

Lo stato attivo della tastiera fa riferimento all'elemento che riceve l'input dalla tastiera. Su un desktop un solo elemento può avere lo stato attivo della tastiera. In WPF la proprietà IsKeyboardFocused dell'elemento che presenta lo stato attivo della tastiera è impostata su true. L'oggetto FocusedElement del metodo statico Keyboard sulla classe restituisce l'elemento che attualmente dispone dello stato attivo della tastiera.

Lo stato attivo della tastiera può essere ottenuto utilizzando il tasto TAB per spostarsi su un elemento o facendo clic con il mouse su determinati elementi, ad esempio TextBox. È possibile inoltre ottenere lo stato attivo della tastiera a livello di codice utilizzando il metodo Focus sulla classe Keyboard. Il metodo Focus tenta di passare lo stato attivo della tastiera all'elemento specificato. L'elemento restituito da Focus è quello che dispone attualmente dello stato attivo della tastiera.

Affinché un elemento ottenga lo stato attivo della tastiera, le proprietà Focusable e IsVisible devono essere impostate su true. Per alcune classi, ad esempio la classe di base Panel, l'impostazione predefinita di Focusable è false. Pertanto, potrebbe essere necessario impostare questa proprietà su true se si desidera che un elemento di questo tipo possa ottenere lo stato attivo.

Nell'esempio seguente, il metodo Focus viene utilizzato per impostare lo stato attivo della tastiera su un oggetto Button. È opportuno impostare lo stato attivo iniziale di un'applicazione nel gestore eventi Loaded.

private void OnLoaded(object sender, RoutedEventArgs e)
{
    // Sets keyboard focus on the first Button in the sample.
    Keyboard.Focus(firstButton);
}

Per ulteriori informazioni sullo stato attivo della tastiera, vedere Cenni preliminari sullo stato attivo.

Stato attivo logico

Lo stato attivo logico fa riferimento all'oggetto FocusManager.FocusedElement in un ambito di stato attivo. In un'applicazione possono essere presenti più elementi con stato attivo logico, ma in un determinato ambito può esistere un solo elemento con lo stato attivo.

Per ambito di stato attivo si intende un elemento contenitore che tiene traccia di FocusedElement all'interno del relativo ambito. 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. Quando lo stato attivo torna nell'ambito di stato attivo, l'elemento con lo stato attivo ottiene nuovamente lo stato attivo della tastiera. In questo modo, lo stato attivo della tastiera può essere passato tra più ambiti, ma è garantito che l'elemento con lo stato attivo nell'ambito di stato attivo rimanga tale al ritorno dello stato attivo.

Un elemento può essere convertito in un ambito dello stato attivo in Extensible Application Markup Language (XAML) impostando la proprietà associata IsFocusScope dell'oggetto FocusManager su true oppure nel codice impostando la proprietà associata tramite il metodo SetIsFocusScope.

Nell'esempio riportato di seguito StackPanel viene convertito in un ambito di stato attivo impostando la proprietà associata IsFocusScope.

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

In WPF le classi che per impostazione predefinita costituiscono ambiti di stato attivo sono Window, Menu, ToolBar e ContextMenu.

Un elemento che presenta lo stato attivo della tastiera dispone di conseguenza anche dello stato attivo logico per l'ambito di stato attivo a cui appartiene; pertanto, impostando lo stato attivo su un elemento tramite il metodo Focus sulla classe Keyboard o sulle classi degli elementi di base, si tenterà di fornire all'elemento lo stato attivo della tastiera e lo stato attivo logico.

Per determinare l'elemento con lo stato attivo in un ambito di stato attivo, utilizzare GetFocusedElement. Per cambiare l'elemento con lo stato attivo in un ambito di stato attivo, utilizzare SetFocusedElement.

Per ulteriori informazioni sullo stato attivo logico, vedere Cenni preliminari sullo stato attivo.

Posizione del mouse

In WPF, l'API di input fornisce informazioni utili relativamente agli spazi di coordinate. Ad esempio, la coordinata (0,0) rappresenta la coordinata superiore sinistra, ma in relazione a quale elemento della struttura ad albero? Potrebbe trattarsi dell'elemento che costituisce la destinazione dell'input, dell'elemento a cui è associato il gestore eventi o di qualche altro elemento. Per evitare confusione, l'API di input di WPF richiede che venga specificato il frame di riferimento quando si utilizzano le coordinate ottenute tramite il mouse. Il metodo GetPosition restituisce la coordinata del puntatore del mouse relativa all'elemento specificato.

Mouse capture

I dispositivi del mouse includono una caratteristica modale particolare nota come mouse capture. Tale caratteristica viene utilizzata 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. Durante il trascinamento, l'utente non può fare clic senza interrompere il trascinamento della selezione, pertanto la maggior parte dei segnali di passaggio del mouse risulteranno inappropriati, se lo stato mouse capture viene utilizzato dall'origine del trascinamento. Il sistema di input espone le API che possono determinare lo stato di mouse capture, nonché le API che possono imporre tale stato per uno specifico elemento o eliminare lo stato di mouse capture. Per ulteriori informazioni sulle operazioni di trascinamento delle selezione, vedere Cenni preliminari sul trascinamento della selezione.

Comandi

I comandi attivano la gestione di input a un livello più semantico rispetto all'input del dispositivo. Si tratta di direttive semplici, ad esempio Cut, Copy, Paste o Open. I comandi sono utili per centralizzare la logica di comando. È possibile accedere a uno stesso comando da un oggetto Menu, in un oggetto ToolBar oppure tramite un tasto di scelta rapida. I comandi forniscono anche un meccanismo per la disattivazione dei controlli qualora il comando non fosse più disponibile.

RoutedCommand è l'implementazione WPF di ICommand. Quando viene eseguito un oggetto RoutedCommand, nella destinazione comando vengono generati un evento PreviewExecuted e un evento Executed che eseguono il tunneling e il bubbling attraverso la struttura ad albero dell'elemento come altri input. Se non è impostata una destinazione comando, questa sarà rappresentata dall'elemento con lo stato attivo della tastiera. La logica che esegue il comando è associata a un oggetto CommandBinding. Quando un evento Executed raggiunge un oggetto CommandBinding per quel determinato comando, viene chiamato l'oggetto ExecutedRoutedEventHandler su quell'oggetto CommandBinding. Questo gestore esegue l'azione del comando.

Per ulteriori informazioni sui comandi, vedere Cenni preliminari sull'esecuzione di comandi.

In WPF viene fornita una libreria di comandi comuni costituita da ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommandse EditingCommands; in alternativa, è possibile definirne una personalizzata.

Nell'esempio seguente viene mostrato come configurare un oggetto MenuItem in modo che, una volta selezionato richiami il comando Paste sull'oggetto TextBox, presupponendo che tale oggetto disponga dello stato attivo.

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

Per ulteriori informazioni sui comandi in WPF, vedere Cenni preliminari sull'esecuzione di comandi.

Il sistema di input e gli elementi di base

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 particolare posizione nel modello a oggetti basato sull'hit testing della struttura ad albero visuale in fase di esecuzione.

Ciascuno degli eventi definiti da Mouse, Keyboard e Stylus come evento associato viene esposto nuovamente dalle classi degli elementi di base UIElement e ContentElement come nuovo evento indirizzato. Gli eventi indirizzati degli elementi di base vengono generati dalla gestione dell'evento associato originale e dal riutilizzo dei dati relativi all'evento da parte delle classi.

Quando l'evento di input viene associato a un particolare elemento di origine tramite l'implementazione dell'evento di input del relativo elemento di base, può essere indirizzato mediante 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. In genere, è preferibile gestire questi eventi di input correlati ai dispositivi utilizzando gli eventi indirizzati in UIElement e ContentElement, perché è possibile utilizzare una sintassi del gestore eventi più intuitiva sia in XAML che nel codice. È possibile inoltre scegliere di gestire l'evento associato che ha iniziato il processo, tuttavia potrebbero sorgere diversi problemi: l'evento associato potrebbe essere contrassegnato come gestito dalla gestione delle classi degli elementi di base, per cui potrebbe essere necessario utilizzare i metodi della funzione di accesso anziché la sintassi dell'evento vera e propria per associare i gestori per gli eventi associati.

Argomenti successivi

A questo punto si dispone di diverse tecniche per la gestione dell'input in WPF. Inoltre, si dovrebbe disporre di una conoscenza approfondita dei vari tipi di eventi di input e dei meccanismi degli eventi indirizzati utilizzati in WPF.

Sono disponibili risorse aggiuntive che illustrano più dettagliatamente gli elementi del framework WPF e il routing degli eventi. Vedere le seguenti informazioni generali: Cenni preliminari sull'esecuzione di comandi, Cenni preliminari sullo stato attivo, Cenni preliminari sugli elementi di base, informazioni generali su Strutture ad albero in WPF e Cenni preliminari sugli eventi indirizzati.

Vedere anche

Concetti

Cenni preliminari sullo stato attivo

Cenni preliminari sull'esecuzione di comandi

Cenni preliminari sugli eventi indirizzati

Cenni preliminari sugli elementi di base

Altre risorse

Proprietà