Cenni preliminari sull’input

 

Data di pubblicazione: giugno 2016

IlWindows Presentation Foundation (WPF) sottosistema fornisce un potente API per ottenere input da un'ampia gamma di dispositivi, inclusi il mouse, tastiera, tocco e stilo. In questo argomento vengono descritti i servizi forniti da WPF e viene illustrata l'architettura dei sistemi di input.

L'input principale API esposizione viene rilevata nelle classi di elemento 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 gli eventi di input correlati a pressioni dei pulsanti del mouse, rotellina del mouse, movimento del mouse, gestione dello stato attivo e mouse capture, per citarne alcuni. Inserendo l'input API sugli elementi di base, invece di considerare tutti gli eventi di input come servizio, l'architettura di input Abilita gli eventi di input per essere originato da un particolare oggetto nell'interfaccia utente e per supportare uno schema di routing dell'evento in cui più di un elemento ha la possibilità di gestire un evento di input. Molti eventi di input includono una coppia di eventi associati. Ad esempio, la chiave all'evento è associata il KeyDown e PreviewKeyDown eventi. La differenza di questi eventi è in modalità di routing per l'elemento di destinazione. Tunnel di eventi di anteprima verso il basso nella struttura ad albero l'elemento radice all'elemento di destinazione. Gli eventi di bubbling bubbling dall'elemento di destinazione per l'elemento radice. Il routing degli eventi WPF descritti in dettaglio più avanti in questa panoramica e nel Cenni preliminari sugli eventi indirizzati.

Classi di Mouse e tastiera

Oltre a input API sulle classi di elemento di base, il tastiera (classe) e Mouse classi forniscono ulteriori API per l'utilizzo di input del mouse e tastiera.

Esempi di input API sul tastiera sono il modificatori proprietà, che restituisce il ModifierKeys attualmente premuti e IsKeyDown metodo, che determina se viene premuto un tasto specificato.

Nell'esempio seguente viene utilizzata la GetKeyStates per determinare se un chiave è 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 input API sul Mouse sono MiddleButton, che ottiene lo stato del pulsante centrale del mouse e DirectlyOver, che ottiene l'elemento, il puntatore del mouse è attualmente posizionato.

Nell'esempio seguente si determina se il LeftButton del mouse si trova il Pressed dello stato.

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

Il Mouse e tastiera classi sono descritti più dettagliatamente in tutta questa panoramica.

Input dello stilo

WPFè integrato il supporto per il stilo. Il stilo è un input penna divenuto dal Tablet PC. WPFle applicazioni possono considerare lo stilo come un mouse utilizzando il mouse API, ma WPF espone anche un'astrazione dispositivo stilo che utilizzano un modello simile alla tastiera e mouse. Tutte le relative stilo API contengono la parola "Stylus".

Poiché lo stilo può agire come un mouse, le applicazioni che supportano solo l'input del mouse possono comunque ottenere un certo livello di supporto dello stilo automaticamente. Quando lo stilo viene utilizzato in questo modo, l'applicazione viene data la possibilità di gestire l'evento dello stilo appropriato e quindi gestisce l'evento del mouse corrispondente. Inoltre, servizi di livello superiore, ad esempio input penna sono disponibili tramite l'astrazione del dispositivo stilo. Per ulteriori informazioni sull'input penna come input, vedere Getting Started with Ink.

Oggetto FrameworkElement possono contenere altri elementi come elementi figlio nel modello di contenuto, formando un struttura ad albero di elementi. In WPF, l'elemento padre può partecipare all'input diretto ai relativi elementi figlio o altri discendenti mediante la gestione degli eventi. Ciò è particolarmente utile per la creazione di controlli da controlli più piccoli, un processo noto come "controllo composizione" o "composizione". Per ulteriori informazioni sulle strutture ad albero dell'elemento e sulla rispettiva correlazione con le route degli eventi, vedere Trees in WPF.

Routing di eventi è il processo di inoltro di eventi a più elementi, in modo che un determinato oggetto o un elemento nella route è possibile scegliere 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: diretto, bubbling e tunneling. Nel routing diretto, l'elemento di origine è l'unico elemento di una notifica e l'evento non viene indirizzato a tutti gli altri elementi. Tuttavia, l'evento indirizzato diretto offre alcune funzionalità aggiuntive che sono disponibili solo per gli eventi indirizzati anziché standard CLR eventi. Bubbling, viene eseguito nella struttura ad albero notificando dapprima l'elemento che ha originato l'evento, quindi l'elemento padre e così via. Tunneling inizia alla 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.

WPFeventi di input sono generalmente di coppie costituito da un evento di tunneling e un evento di bubbling. Gli eventi di tunneling si distinguono dai bubbling degli eventi con il prefisso "Anteprima". Ad esempio, PreviewMouseMove è la versione tunneling di un evento di spostamento del mouse e MouseMove è la versione di questo evento di bubbling. Questa coppia di eventi è una convenzione che viene implementata a livello di elemento e non è una funzionalità intrinseca del WPF sistema di eventi. Per informazioni dettagliate, vedere la sezione eventi di Input WPF in Cenni preliminari sugli eventi indirizzati.

Per ricevere l'input su un elemento, un gestore eventi deve essere associato a quel particolare evento. In XAML è semplice: si fa riferimento il nome dell'evento come attributo dell'elemento che rimarrà in ascolto di questo evento. Quindi, impostare il valore dell'attributo per il nome del gestore eventi che si definisce, basato su un delegato. Il gestore dell'evento deve essere scritto in codice, ad esempio C# e possono essere inclusi in un file code-behind.

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

Esempio di evento di Input da tastiera

Nell'esempio seguente è in attesa di un tasto freccia sinistra. Oggetto StackPanel viene creato ha un pulsante. Un gestore eventi per l'ascolto di pressione del tasto freccia sinistra è collegata al pulsante istanza.

Crea la prima sezione dell'esempio di StackPanel e pulsante e associa il gestore eventi per il 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 dell'evento. Quando si preme il tasto freccia sinistra e il pulsante con lo stato attivo, il gestore viene eseguito e Background colore del pulsante viene modificato. Se viene premuto il tasto, ma non è il tasto freccia sinistra, il Background colore del pulsante viene nuovamente impostata 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;
                }
            }
        }

Esempio di evento di Input del mouse

Nell'esempio seguente, il Background colore di un pulsante viene modificato quando il puntatore del mouse entra nell'area di pulsante. Il Background colore viene ripristinato quando il puntatore del mouse lascia il pulsante.

La prima sezione dell'esempio crea il StackPanel e pulsante controllare e associa i gestori eventi per il MouseEnter e MouseLeave eventi per il pulsante.

    <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 di eventi. Quando il mouse viene spostato il pulsante, Background colore del pulsante viene modificato in Grigioardesia. Quando il puntatore del mouse lascia il pulsante, il Background colore del pulsante ritorna bianco ghiaccio.

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

Il TextInput evento consente di ricevere l'input di testo in modo indipendente dal dispositivo. La tastiera è il mezzo principale di riconoscimento della grafia input, ma il riconoscimento vocale, testo e altri dispositivi di input possono generare anche l'input di testo.

Per l'input da tastiera, WPF invia appropriato KeyDown/KeyUp eventi. Se non vengono gestiti gli eventi e la chiave è testo anziché (chiave di controllo, ad esempio direzionali) o i tasti funzione, un TextInput viene generato l'evento. Non c'è sempre un semplice mapping uno a uno tra KeyDown/KeyUp e TextInput eventi perché più sequenze di tasti possono generare un singolo carattere di input di testo e singolo tasto può generare stringhe con più caratteri. Ciò vale soprattutto per lingue quali cinese, giapponese e coreano che utilizzano Input Method Editor (IME) per generare le migliaia di caratteri possibili nei corrispondenti alfabeti.

Quando WPF invia un KeyUp/KeyDown evento chiave è impostato su Key.System se le sequenze di tasti possono diventare parte di un TextInput evento (se ALT + S viene premuto, ad esempio). Ciò consente al codice un KeyDown gestore eventi per verificare la presenza di Key.System e, se trovato, abbandonare l'elaborazione del gestore di generato successivamente TextInput evento. In questi casi, le diverse proprietà di TextCompositionEventArgs argomento può essere utilizzato per determinare le sequenze di tasti originale. Analogamente, se un IME è attivo, chiave ha il valore di Key.ImeProcessed, e ImeProcessedKey fornisce la sequenza di tasti o originale.

Nell'esempio seguente definisce un gestore per il fare clic su evento e un gestore per il KeyDown evento.

Il primo segmento di codice o 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 di 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 bubbling la route dell'evento, il StackPanel riceve l'input indipendentemente dalla quale l'elemento con lo stato attivo. Il TextBox controllo riceve una notifica prima e la OnTextInputKeyDown gestore viene chiamato solo se il TextBox non ha gestito l'input. Se il PreviewKeyDown l'evento viene utilizzato al posto di KeyDown evento, il OnTextInputKeyDown gestore viene chiamato per primo.

In questo esempio, la logica di gestione viene scritta due volte: una volta per CTRL + O e, successivamente, per del pulsante click (evento). Questo può essere semplificato tramite comandi, invece di gestire gli eventi di input direttamente. I comandi sono descritti in questa panoramica e in panoramica dei comandi.

Nuovo hardware e l'API del sistema operativo Windows 7 forniscono applicazioni la possibilità di ricevere input da più tocchi contemporaneamente. WPFconsente alle applicazioni di rilevare e rispondere agli input tocco in modo simile alle risposte ad altri input, ad esempio mouse o tastiera, generando eventi quando si verifica il tocco.

WPFespone due tipi di eventi quando si verifica il tocco: eventi tocco ed eventi di modifica. Gli eventi tocco forniscono dati non elaborati relativi ogni dito su un touchscreen e spostamento. Eventi di modifica interpretano l'input come determinate azioni. In questa sezione vengono descritti entrambi i tipi di eventi.

Prerequisiti

È necessario disporre dei componenti seguenti per sviluppare un'applicazione che risponde al tocco.

  • Microsoft Visual Studio 2010.

  • Windows 7.

  • Un dispositivo, ad esempio un touchscreen, che supporta Windows Touch.

Terminologia

Quando il tocco viene trattato, vengono utilizzati i seguenti termini.

  • Touch è un tipo di input dell'utente che è riconosciuto da Windows 7. In genere, viene avviato touch inserendo dita sullo schermo sensibile al tocco. Si noti che i dispositivi, ad esempio touchpad diffusi sui computer portatili non supportano touch se il dispositivo converte semplicemente il dito posizione e il movimento come input del mouse.

  • Multitouch è un tocco che si verifica contemporaneamente da più di un punto. Windows 7 e WPF supporti la funzionalità multitouch. Ogni volta che il tocco viene trattato nella documentazione relativa a WPF, i concetti si applicano al multitocco.

  • Oggetto manipolazione si verifica quando il tocco viene interpretato come un'azione fisica che viene applicata a un oggetto. In WPF, eventi di modifica interpretano input come una conversione, espansione o rotazione.

  • Oggetto touch device rappresenta un dispositivo che produce un input tocco, ad esempio un singolo dito su un touchscreen.

Controlli che rispondono al tocco

È possibile scorrere i controlli seguenti trascinando un dito all'interno del controllo se dispone di contenuto di fuori della visualizzazione.

Il ScrollViewer definisce il ScrollViewer.PanningMode associata che consente di specificare se la panoramica tocco è abilitata in orizzontale, verticale, entrambi o nessuno. Il ScrollViewer.PanningDeceleration proprietà specifica la rapidità di rallentamento dello scorrimento quando l'utente solleva il dito dal touchscreen. Il ScrollViewer.PanningRatio proprietà associata specifica il rapporto dell'offset per convertire l'offset di manipolazione di scorrimento.

Eventi tocco

Le classi di base, UIElement, UIElement3D, e ContentElement, definire gli eventi che è possibile sottoscrivere in modo che l'applicazione risponda al tocco. Gli eventi tocco sono utili quando l'applicazione interpreta il tocco come un valore diverso da un oggetto. Ad esempio, un'applicazione che consente di disegnare con uno o più dita sottoscriverà per eventi di tocco.

Tutti e tre le classi definiscono gli eventi seguenti, che si comportano allo stesso modo, indipendentemente dalla classe di definizione.

Come gli eventi di tastiera e mouse, gli eventi tocco sono eventi indirizzati. Gli eventi che iniziano con Preview sono eventi di tunneling e gli eventi che iniziano con Touch sono eventi di bubbling. Per ulteriori informazioni sugli eventi indirizzati, vedere Cenni preliminari sugli eventi indirizzati. Quando si gestiscono questi eventi, è possibile ottenere la posizione dell'input, relativa a qualsiasi elemento chiamando il GetTouchPoint o GetIntermediateTouchPoints metodo.

Per comprendere l'interazione tra gli eventi di tocco, si consideri lo scenario in cui un utente inserisce un dito su un elemento, sposta il dito nell'elemento e quindi solleva il dito dall'elemento. Nella figura seguente è illustrata l'esecuzione degli eventi di bubbling (gli eventi di tunneling sono stati omessi per maggiore semplicità).

La sequenza di eventi di tocco.
Eventi tocco

Nell'elenco seguente viene descritta la sequenza degli eventi nell'illustrazione precedente.

  1. Il TouchEnter evento si verifica una volta quando l'utente inserisce un dito sull'elemento.

  2. Il TouchDown evento si verifica una volta.

  3. Il TouchMove evento si verifica più volte quando l'utente sposta il dito all'interno dell'elemento.

  4. Il Ritocco evento si verifica una volta quando l'utente solleva il dito dall'elemento.

  5. Il TouchLeave evento si verifica una volta.

Quando vengono utilizzate più di due dita, si verificano gli eventi per ogni dito.

Eventi di modifica

Nei casi in cui un'applicazione consente a un utente di modificare un oggetto, il UIElement classe definisce gli eventi di modifica. A differenza degli eventi di tocco che segnalano semplicemente la posizione di tocco, gli eventi di modifica di report come l'input può essere interpretato. Esistono tre tipi di modifiche, conversione, espansione e rotazione. Nell'elenco seguente viene descritto come richiamare i tre tipi di modifiche.

  • Posizionare un dito su un oggetto e spostare il dito sul touchscreen per richiamare una modifica della conversione. In genere viene spostato l'oggetto.

  • Posizionare due dita su un oggetto e spostarle o tra loro per richiamare una modifica di espansione. In genere Ridimensiona l'oggetto.

  • Posizionare due dita su un oggetto e ruotare un dito intorno a altro per richiamare una manipolazione di rotazione. Ciò in genere consente di ruotare l'oggetto.

Può verificarsi contemporaneamente più di un tipo di modifica.

Quando che gli oggetti rispondere a modifiche, è possibile impostare l'oggetto visualizzazione di inerzia. In questo modo gli oggetti di simulare il mondo fisico. Ad esempio, quando si esegue un libro in una tabella, se si esegue il push rigido sufficientemente il libro continuerà a spostarsi dopo essere stato rilasciato. WPFConsente di simulare questo comportamento generando eventi di modifica dopo l'oggetto viene rilasciato il dito dell'utente.

Per informazioni su come creare un'applicazione che consente all'utente di spostare, ridimensionare e ruotare un oggetto, vedere procedura dettagliata: creazione Your First Touch Application.

Il UIElement definisce gli eventi di modifica seguente.

Per impostazione predefinita, un UIElement non riceve questi eventi di modifica. Per ricevere eventi di modifica in un UIElement, impostare UIElement.IsManipulationEnabled a true.

Il percorso di esecuzione di eventi di modifica

Si consideri uno scenario in cui un utente "genera" un oggetto. L'utente inserisce un dito sull'oggetto, sposta il dito sul touchscreen per una breve distanza e quindi solleva il dito durante lo spostamento. Il risultato è che l'oggetto verrà spostata sotto il dito dell'utente e continuare a spostarsi dopo che l'utente solleva il dito.

Nella figura seguente mostra il percorso di esecuzione di eventi di manipolazione e informazioni importanti relative a ogni evento.

La sequenza di eventi di modifica.
Eventi di modifica

Nell'elenco seguente viene descritta la sequenza degli eventi nell'illustrazione precedente.

  1. Il ManipulationStarting evento si verifica quando l'utente posiziona un dito sull'oggetto. Tra le altre cose, questo evento consente di impostare il ManipulationContainer proprietà. Negli eventi successivi, la posizione della modifica sarà relativo al ManipulationContainer. Negli eventi diversi da ManipulationStarting, questa proprietà è di sola lettura, in modo che il ManipulationStarting evento è l'unica volta che è possibile impostare questa proprietà.

  2. Il ManipulationStarted l'evento. Questo evento indica l'origine della modifica.

  3. Il ManipulationDelta evento si verifica più volte come muove dell'utente su un touchscreen. Il DeltaManipulation di proprietà di ManipulationDeltaEventArgs classe indica se la modifica viene interpretata come movimento, espansione o conversione. Si tratta in cui si esegue la maggior parte delle operazioni di modifica di un oggetto.

  4. Il ManipulationInertiaStarting evento si verifica quando il dito dell'utente perde il contatto con l'oggetto. Questo evento consente di specificare la decelerazione delle manipolazioni durante l'inerzia. Si tratta pertanto l'oggetto può emulare spazi fisici diversi o attributi se si sceglie. Si supponga, ad esempio, l'applicazione dispone di due oggetti che rappresentano gli elementi nel mondo fisico e uno è più pesante rispetto a altra. È possibile rendere l'oggetto più pesante rallentare più velocemente rispetto all'oggetto più chiaro.

  5. Il ManipulationDelta evento si verifica più volte durante l'inerzia. Si noti che questo evento si verifica quando il dito dell'utente di spostare il touchscreen e WPF simula l'inerzia. In altre parole, ManipulationDelta si verifica prima e dopo il ManipulationInertiaStarting evento. Il ManipulationDeltaEventArgs.IsInertial proprietà report se il ManipulationDelta evento si verifica durante l'inerzia, pertanto è possibile controllare la proprietà ed eseguire azioni diverse, a seconda del valore.

  6. Il ManipulationCompleted evento si verifica quando termina la manipolazione e inerzia qualsiasi. Vale a dire, dopo tutti i ManipulationDelta si verificano gli eventi, il ManipulationCompleted si verifica l'evento per segnalare che la modifica è stata completata.

Il UIElement definisce inoltre il ManipulationBoundaryFeedback evento. Questo evento si verifica quando il ReportBoundaryFeedback metodo viene chiamato nel ManipulationDelta evento. Il ManipulationBoundaryFeedback evento consente alle applicazioni o componenti fornire feedback visivo quando un oggetto raggiunge un limite. Ad esempio, il finestra classe gestisce il ManipulationBoundaryFeedback la finestra spostare leggermente quando viene rilevato il bordo dell'evento.

È possibile annullare la modifica chiamando il Annulla metodo negli argomenti di evento in qualsiasi evento di modifica eccetto ManipulationBoundaryFeedback evento. Quando si chiama Annulla, non vengono generati gli eventi di manipolazione e gli eventi del mouse si verificano per il tocco. Nella tabella seguente descrive la relazione tra l'ora che di modifica viene annullata e gli eventi del mouse che si verificano.

L'evento che l'annullamento viene chiamatoGli eventi del mouse che si verificano per input che si è già verificato
ManipulationStarting e ManipulationStartedPassare il mouse gli eventi.
ManipulationDeltaSpostamento verso il basso e gli eventi di spostamento del mouse.
ManipulationInertiaStarting e ManipulationCompletedSelezione, spostamento e gli eventi mouse con il mouse.

Si noti che se si chiama Annulla quando la modifica si trova l'inerzia, il metodo restituisce false e l'input non genera gli eventi del mouse.

La relazione tra eventi tocco ed eventi di modifica

Oggetto UIElement può sempre ricevere eventi tocco. Quando il IsManipulationEnabled è impostata su true, UIElement può ricevere eventi di tocco e di manipolazione. Se il TouchDown non viene gestito l'evento (vale a dire il Handled è false), la logica di modifica acquisisce il tocco all'elemento e genera gli eventi di modifica. Se il Handled è impostata su true nel TouchDown evento, la logica di modifica non genera eventi di modifica. Nella figura seguente mostra la relazione tra eventi tocco ed eventi di modifica.

Relazione tra eventi tocco e modifica
Eventi di tocco e modifica

Nell'elenco seguente descrive la relazione tra gli eventi tocco e modifica è illustrato nella figura precedente.

Esistono due concetti principali relativi allo stato attivo in WPF: tastiera e lo stato attivo logico.

Stato attivo della tastiera

Lo stato attivo fa riferimento all'elemento che sta ricevendo l'input da tastiera. Può esistere un solo elemento per l'intero desktop con lo stato attivo. In WPF, l'elemento con lo stato attivo della tastiera avrà IsKeyboardFocused impostato su true. Il metodo statico tastiera metodo FocusedElement restituisce l'elemento che attualmente ha lo stato attivo.

È possibile ottenere lo stato attivo usando il tasto TAB per un elemento o facendo clic con il puntatore del mouse su determinati elementi, ad esempio un TextBox. Lo stato attivo può anche essere ottenuto a livello di codice utilizzando il lo stato attivo metodo il tastiera (classe). Lo stato attivo tenta di assegnare l'elemento specificato lo stato attivo. L'elemento restituito da lo stato attivo è l'elemento che ha attualmente lo stato attivo.

Affinché un elemento ottenere lo stato attivo di Focusable proprietà e IsVisible devono essere impostate su true. Alcune classi, ad esempio pannello, hanno Focusable impostato su false per impostazione predefinita; pertanto, potrebbe essere necessario impostare questa proprietà su true se si desidera che un elemento di essere in grado di ottenere lo stato attivo.

L'esempio seguente usa lo stato attivo per impostare lo stato attivo su un pulsante. La posizione consigliata per impostare lo stato attivo iniziale in un'applicazione è il Loaded gestore dell'evento.

        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 Focus Overview.

Stato attivo logico

Lo stato attivo logico si intende il FocusManager.FocusedElement un ambito. Possono essere presenti più elementi che lo stato attivo logico in un'applicazione, ma può essere presente solo un elemento che ha lo stato attivo logico un ambito specifico.

Un ambito attivo è un elemento contenitore che tiene traccia di FocusedElement all'interno dell'ambito. Quando lo stato attivo esce dall'ambito di stato attivo, l'elemento perderà lo stato attivo, ma verrà mantenuto lo stato attivo logico. Quando viene restituito lo stato attivo per l'ambito dello stato attivo, l'elemento otterrà lo stato attivo della tastiera. In questo modo lo stato attivo deve essere modificato tra più ambiti ma assicura che l'elemento all'interno dell'ambito dello stato attivo rimane l'elemento attivo quando viene restituito lo stato attivo.

Un elemento può essere convertito in un ambito attivo in Extensible Application Markup Language (XAML) impostando il FocusManager proprietà associata IsFocusScope a true, o nel codice impostando la proprietà associata tramite il SetIsFocusScope metodo.

Nell'esempio seguente un StackPanel in un ambito attivo impostando il IsFocusScope proprietà associata.

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

Le classi in WPF che sono ambiti per impostazione predefinita sono finestra, Menu, sulla barra degli strumenti, e ContextMenu.

Un elemento con lo stato attivo anche avrà lo stato attivo logico per l'ambito che a cui appartiene; Pertanto, impostando lo stato attivo su un elemento con la lo stato attivo metodo il tastiera classe o le classi di elemento di base tenterà di assegnare l'elemento lo stato attivo della tastiera e lo stato attivo logico.

Per determinare l'elemento in un ambito attivo, utilizzare GetFocusedElement. Per modificare l'elemento attivo per un ambito attivo, utilizzare SetFocusedElement.

Per ulteriori informazioni sullo stato attivo logico, vedere Focus Overview.

Il WPF input API fornisce informazioni utili relativamente agli spazi di coordinate. Ad esempio, coordinare (0,0) è la coordinata superiore sinistra, ma l'angolo superiore sinistro quale elemento nell'albero? L'elemento che è la destinazione dell'input? L'elemento è associato il gestore eventi al? O qualcos'altro? Per evitare confusione, il WPF input API richiede che venga specificato il frame di riferimento quando si utilizzano le coordinate ottenute tramite il mouse. Il GetPosition metodo restituisce la coordinata del puntatore del mouse rispetto all'elemento specificato.

Dispositivi mouse includono in particolare una caratteristica modale nota come input del mouse. Acquisizione del mouse viene utilizzato per mantenere un transizione dello stato di input quando viene avviata un'operazione di trascinamento e, in modo che altre operazioni che coinvolgono il nominale sullo schermo posizione del puntatore del mouse non necessariamente si verificano. Durante il trascinamento, l'utente non può fare clic su senza interrompere il e trascinamento, in modo appropriato la maggior parte dei segnali mouseover mentre il mouse viene acquisito dall'origine del trascinamento. Espone il sistema di input API che possono determinare lo stato di acquisizione del mouse, nonché API che possono forzare l'acquisizione del mouse in un elemento specifico o cancellare lo stato di acquisizione del mouse. Per ulteriori informazioni sulle operazioni di trascinamento e rilascio, vedere trascinare e rilasciare Panoramica.

Per abilitare la gestione di input a un livello semantico maggiore rispetto all'input di dispositivo del comandi. Si tratta di direttive semplici, ad esempio Cut, Copy, Paste, o Open. I comandi sono utili per centralizzare la logica di comando. Lo stesso comando potrebbe essere possibile accedere da un Menusu un sulla barra degli strumenti, o tramite un tasto di scelta rapida. I comandi forniscono anche un meccanismo per la disabilitazione di controlli quando il comando non è più disponibile.

RoutedCommand è il WPF implementazione di ICommand. Quando un RoutedCommand viene eseguito un PreviewExecuted e eseguite vengono generati eventi sulla destinazione del comando, il tunneling e bubbling nella struttura ad albero come altri input. Se una destinazione di comando non è impostata, l'elemento con lo stato attivo sarà la destinazione del comando. La logica che esegue il comando è associata a un CommandBinding. Quando un eseguite evento raggiunge un CommandBinding per il comando specifico, il ExecutedRoutedEventHandler sul CommandBinding viene chiamato. Questo gestore esegue l'azione del comando.

Per ulteriori informazioni sui comandi, vedere panoramica dei comandi.

WPFfornisce una libreria di comandi comuni che è costituito da ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands, e EditingCommands, è possibile definire.

Nell'esempio seguente viene illustrato come impostare un MenuItem in modo che quando viene selezionato, richiami il Incolla comando il TextBox, presupponendo che il TextBox con lo 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;
          
            // Setting the command target to the TextBox
            pasteMenuItem.CommandTarget = pasteTextBox;

Per ulteriori informazioni sui comandi in WPF, vedere panoramica dei comandi.

Ad esempio gli eventi associati definiti da eventi di input di Mouse, tastiera, e stilo classi vengono generate dal sistema di input e inserite in una posizione specifica nel modello a oggetti basato sull'hit testing la struttura visiva in fase di esecuzione.

Tutti gli eventi che Mouse, tastiera, e stilo definire come un evento associato viene esposto nuovamente dalle classi di elemento di base UIElement e ContentElement come un nuovo evento indirizzato. Vengono generati gli eventi indirizzati dell'elemento base dalle classi di gestione dell'evento associato originale e riutilizzare i dati dell'evento.

Quando l'evento di input viene associato a un particolare elemento di origine tramite l'implementazione di eventi di input dell'elemento di base, possono essere instradato tramite il resto della route di un evento che si basa su una combinazione di oggetti albero logico e visual ed essere gestito dal codice dell'applicazione. In genere, è preferibile gestire questi eventi di input correlati ai dispositivi utilizzando gli eventi indirizzati di UIElement e ContentElement, poiché è possibile utilizzare più intuitiva sintassi del gestore eventi sia in XAML e nel codice. È possibile scegliere di gestire l'evento che ha avviato il processo invece, ma si dovrebbe affrontare diversi problemi: l'evento può essere contrassegnato come gestito per la gestione della classe di elemento di base e si desidera utilizzare metodi di accesso anziché la sintassi dell'evento true per associare i gestori per gli eventi associati.

Ora si dispone di diverse tecniche per gestire l'input in WPF. È inoltre una conoscenza approfondita dei diversi tipi di eventi di input e i meccanismi di eventi indirizzati utilizzati da WPF.

Sono disponibili risorse aggiuntive che trattano WPF gli elementi del framework e il routing degli eventi in modo più dettagliato. Vedere le panoramiche seguenti per ulteriori informazioni, panoramica dei comandi, Focus Overview, Cenni preliminari sugli elementi di Base, Trees in WPF, e Cenni preliminari sugli eventi indirizzati.

Panoramica dello stato attivo
Panoramica dei comandi
Cenni preliminari sugli eventi indirizzati
Cenni preliminari sugli elementi di base
Proprietà

Mostra: