Informazioni generali sulle modifiche e sull'inerzia
Le modifiche consentono agli utenti di spostare, ruotare e ridimensionare gli elementi dell'interfaccia utente tramite i manipolatori. Un manipolatore rappresenta un mouse o, in uno scenario abilitato al tocco, uno stilo o un dito.
L'inerzia emula il comportamento reale degli elementi dell'interfaccia utente in movimento simulando forze di attrito sugli elementi. Ciò consente agli elementi di rallentare gradualmente il movimento (lineare e angolare) prima dell'arresto. In questo articolo viene fornita un'introduzione alle modifiche e all'inerzia per .NET Framework.
Modifiche
Una modifica considera un insieme di manipolatori come oggetto composto. Un'applicazione può tenere traccia delle modifiche apportate all'oggetto composto anziché ai singoli componenti.
Si prenda in considerazione l'immagine illustrata di seguito. Un utente può utilizzare due manipolatori per spostare, ruotare e ridimensionare l'immagine. Le modifiche a ogni manipolatore vengono interpretate insieme agli altri manipolatori.
Ad esempio, se si dispone di due manipolatori (1 e 2) sull'immagine e si sposta il manipolatore 1 in una direzione +Y (in basso), la modifica dell'immagine dipende da ciò che si verifica in corrispondenza del manipolatore 2. Se anche il manipolatore 2 esegue lo spostamento nella direzione +Y (in basso), l'immagine si sposta semplicemente nella direzione +Y. Tuttavia, se il manipolatore 2 non cambia o esegue lo spostamento nella direzione -Y (in alto), l'immagine viene resa più piccola o ruotata.
.png "Foto virtuale che due dita stanno modificando.")
Un'immagine modificata da due manipolatori
L'elaborazione delle modifiche fornisce un framework che esamina un sottoinsieme di manipolatori e li interpreta come se stessero agendo insieme, anziché in modo indipendente. È possibile creare contemporaneamente diversi oggetti del processore di modifica, uno per ogni elemento dell'interfaccia utente da modificare in un'applicazione. Un processore di modifica viene informato dei dispositivi di input da osservare e segnala le modifiche attraverso eventi di .NET.
Un processore di modifica non dispone di informazioni sul particolare elemento modificato. Un'applicazione applica separatamente le modifiche a un elemento specifico dell'applicazione. Ad esempio, un'applicazione applica trasformazioni a un'immagine o la ridisegna per visualizzarla nella nuova posizione o con una nuova dimensione oppure orientamento.
Le modifiche sono progettate per trasformazioni affini (la pagina potrebbe essere in inglese) bidimensionali (2D). Queste trasformazioni includono la traslazione, la rotazione e il ridimensionamento.
Parti di una modifica
Una modifica è un insieme di oggetti Manipulator2D. Questa modifica aggregata viene rappresentata da un punto di origine e da un'ellisse. Il punto di origine è la posizione media di tutti i manipolatori che stanno modificando un elemento. L'ellisse ha un raggio che è costituito dalla distanza media dall'origine a ognuno degli oggetti Manipulator2D.
.png "Parti di una modifica.")
Due manipolatori (1 e 2), un'origine e un'ellisse specificano una modifica
Mentre i manipolatori vengono aggiunti, spostati o rimossi per un elemento dell'interfaccia utente, un'applicazione aggiorna l'oggetto ManipulationProcessor2D chiamando il metodo ProcessManipulators(). Quando inizia la modifica per la prima volta, viene generato l'evento Started.
.gif "Nota") Nota |
|---|
L'elaborazione delle modifiche è più efficiente quando utilizzata in un ambiente di aggiornamento basato su frame.L'utilizzo dell'elaborazione delle modifiche in un'applicazione di Microsoft XNA non rappresenta un problema perché XNA Framework fornisce aggiornamenti basati sui frame mediante il metodo Game.Update (la pagina potrebbe essere in inglese).In un altro ambiente, quale WinForms, potrebbe essere necessario fornire la logica basata su frame per raccogliere modifiche e inviarle periodicamente al metodo ProcessManipulators() in batch. |
Quando il numero di manipolatori o la relativa posizione cambia, viene generato l'evento Delta. Le proprietà dell'oggetto Manipulation2DDeltaEventArgs passate al gestore dell'evento Delta specificano modifiche in origine, scala, rotazione e traslazione che si sono verificate fin dall'ultimo evento. L'origine delle modifiche cambia quando i manipolatori si spostano e quando i manipolatori vengono aggiunti o rimossi. I valori della traslazione specificano la quantità di spostamento X o Y inclusa nella modifica.
Utilizzando i nuovi valori, un'applicazione ridisegna l'elemento dell'interfaccia utente.
.png "Modifica dopo lo spostamento verso destra del contatto A.")
Il manipolatore 1 si sposta e fa in modo che l'origine cambi
Quando l'ultimo manipolatore associato alla modifica viene rimosso dall'oggetto ManipulationProcessor2D, viene generato l'evento Completed.
Modello di elaborazione delle modifiche
Un processore di modifica utilizza un modello di utilizzo diretto. Con questo semplice modello, un'applicazione deve passare tutti i dettagli dell'evento di input al processore di modifica. Un evento di input potrebbe essere generato da qualsiasi primitiva di input, ad esempio un dispositivo mouse, uno stilo o un dito. Questo processo fornisce un meccanismo di filtro diretto e un modello di utilizzo semplice, pertanto l'applicazione può inviare in batch eventi di input quando necessario.
Affinché un'applicazione includa un primitiva di input nel processo della modifica, viene creata una struttura Manipulator2D dai dettagli della primitiva di input e viene passata la struttura al processore di modifica utilizzando il metodo ProcessManipulators(). Il processore di modifica genera quindi eventi che l'applicazione deve gestire per aggiornare il componente visivo in modo adatto.
.png "Flusso del modello di modifiche a utilizzo diretto.")
Modello di elaborazione delle modifiche
Inerzia
Il processore a inerzia consente alle applicazioni di estrapolare posizione, orientamento e altre proprietà di un elemento dell'interfaccia utente simulando il comportamento reale.
Ad esempio, quando un utente esegue un gesto rapido su un elemento, quest'ultimo può continuare a spostarsi, rallentare e arrestarsi lentamente. Il processore a inerzia implementa questo comportamento facendo in modo che i valori 2D affini (origine, scala, traslazione e rotazione) cambi in un periodo di tempo specificato a una frequenza di decelerazione specificata.
Come per l'elaborazione delle modifiche, un processore a inerzia non dispone di informazioni su alcun particolare elemento dell'interfaccia utente. In risposta agli eventi generati in corrispondenza di un oggetto InertiaProcessor2D, un'applicazione applica separatamente le modifiche a un elemento specifico dell'applicazione.
L'elaborazione dell'inerzia e l'elaborazione delle modifiche vengono spesso utilizzate insieme. Le interfacce sono simili e gli eventi che generano sono, in alcuni casi, identici. In generale l'elaborazione dell'inerzia inizia quando viene completata la modifica dell'elemento dell'interfaccia utente. Questa operazione viene portata a termine ascoltando l'evento Completed e avviando l'elaborazione dell'inerzia da tale gestore dell'evento.