AS3 Event handling

Introduzione alla gestione degli eventi in ActionScript 3

Inserito il 26-07-2007

Con l'avvento di Flash CS3 e del nuovo linguaggio ActionScript 3 molte cose sono cambiate, e buona parte delle classi e funzioni presenti in AS1/2, sono state eliminate o spostate in altri pacchetti o classi. Tale scelta, non è stata presa molto di buon grado dai "vecchi" sviluppatori e in generale dai designer, ma è stato un passo obbligato verso uno sviluppo delle applicazioni, più stabile. Di fatto AS3 definisce un approccio OOP (programmazione orientata agli oggetti) allo sviluppo di applicazioni attraverso l'IDE di Flex, Flash o programmi alternativi, ed elimina i diversi modi di interagire con gli oggetti, consentiti fino ad AS2, definendone uno solo uguale per tutti gli elementi, e assegnandogli il significativo nome di Event Handling (traduzione letterale: maneggiamento degli eventi). Nel nuovo linguaggio si può inoltre notare che le classi sono molte di più, e si distinguono in maniera più specifica, per dare al player un minor carico di informazioni da gestire sui singoli oggetti.

Come accennato nel paragrafo precedente, uno dei punti dolenti del vecchio AS, era quello di avere troppi modi di fare le cose, sopratutto quelle di routine, come ad esempio la semplice pratica di dare un comando ad un pulsante. Infatti, con AS1/2 era possibile dare ad un movieclip/button le funzioni di pulsante in almeno 3 modi differenti, più uno per i componenti.

Era infatti possibile scrivere del codice con la clausola on() e con onClipEvent() direttamente all'interno dei pulsanti e dei movieclip, era inoltre possibile richiamare sulla timeline il nome di istanza del movieclip e assegnargli il codice sottoforma di funzione con la sintassi oggetto.onRelease = function(){}.

Con AS3, si è cercato infine di fare chiarezza sulla gestione degli eventi, eliminando la possibilità di innestare comandi direttamente sui movieclip e sui button e affidando tutta la gestione degli eventi ad una classe preposta, la classe EventDispatcher, da cui ogni altra classe del linguaggio che richiama degli eventi, prende il metodo addEventListener. Il metodo prevede due parametri, il primo "type" è l'evento che si vuole registrare e che determina il momento in cui "listener", il secondo parametro e cioè la funzione da eseguire, deve appunto essere eseguita.

La sintassi di base della nuova gestione degli eventi è la seguente:

// ho un pulsante/clip sullo stage, di nome "prova"
// gli assegno la notifica dell'evento "click"
prova.addEventListener(MouseEvent.CLICK, clickHandler);
// e poi inizializzo la funzione corrispondente "clickHandler"
function clickHandler(e:MouseEvent) {
	// azioni legate al click del mouse sul pulsante "prova"
	trace("Hai cliccato sul pulsante 'prova'");
}

La gestione degli eventi si basa tutta su questa piccola situazione, infatti lo stesso metodo si può occupare della gestione delle Tween, dei caricamenti esterni, degli errori, dell'upload/download di file, della gestione di dati esterni pescati ad esempio da PHP, ASP o XML, ovviamente ogni situazione è legata al suo evento, ad esempio per gestire la classe Tween con gli eventi, va utilizzata la classe TweenEvent al posto del semplice Event, oppure come già abbiamo visto nell'esempio, per gestire gli eventi legati al Mouse, bisogna invocare la classe MouseEvent.
Facciamo un altro esempio, proprio con la classe Tween:

// importo la classe Tween e le easing functions
import fl.transitions.Tween;
import fl.transitions.easing.*;
// creo la tween basandomi sul fatto che sullo stage sia già presente un clip con nome "palla"
var t:Tween = new Tween(palla, "x", Bounce.easeOut, 0, 400, 5, true);
// aggiungo un listener che mi notifichi il momento in cui l'animazione viene terminata
t.addEventListener(TweenEvent.MOTION_FINISH, finishHandler);
// inizializzo la funzione finishHandler che verrà eseguita nel momento in cui l'animazione verrà terminata
function finishHandler(e:TweenEvent){
	trace(e.target); // output -> [object Tween]
	trace("Animazione terminata");
}

Risulta identico al codice del pulsante, ma gestisce una situazione completamente diversa, inoltre abbiamo inserito all'interno della funzione un "nuovo" elemento, il parametro che precedentemente non avevamo usato. In pratica questo parametro contiene alcune informazioni sull'evento eseguito e comprende anche una proprietà che riporta esattamente l'oggetto che ha fatto scaturire l'evento, in questo caso si tratta di una tween, nell'altro di un button; vien da sè quanto possa essere utile questo parametro nel momento in cui abbiamo particolari azioni da effettuare e la necessità di recuperare dinamicamente l'elemento che ha provocato l'evento e il tipo di evento che è stato invocato.

In conclusione, direi che si tratta solo di una questione di abitudine nell'utilizzo, ma che con l'uso diventa poi quasi irrinunciabile e difficilmente si rimpiangono i vecchi metodi di asegnazione diretta, in favore di una programmazione più solida e consapevole.