Gestion des événements dans le framework VEGAS - Partie 1

Marc Alcaraz

Tutoriel introduisant la gestion des événements dans la framework VEGAS. ♪

- Titre : Gestion des événements dans le framework VEGAS - Partie 1

- Auteur : Marc Alcaraz

- Parution : 6 avril 2007

- Licence : Copyright ® 2006-2007 Marc Alcaraz. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Généralités

- II. Implémentation dans VEGAS

- III. La classe BasicEvent

- IV. La classe DynamicEvent

- V. Conclusion

I - Généralités

Les événements sont tout simplement des objets qui permettent d'informer d'autres objets. Ils peuvent être utilisés à la fin d'une action, pour notifier un changement d'état, etc.

Je vais commencer par vous donner une notion très « imagée » de la notion d'événement.

Prenons pour exemple une émission de télévision avec un présentateur, des spectateurs (les écouteurs) et un écran de télévision qui va indiquer aux spectateurs ce qu'ils vont devoir faire pendant les moments forts de l'émission. Si le présentateur raconte une blague, l'écran de télévision va indiquer le message « BLAGUE > RIRE » (événement) et si les spectateurs sont attentifs au message, ils vont aussitôt se mettre à rire aux éclats.

En gardant une vision un peu plus théorique :

- l'émetteur de l'événement est le présentateur ;

- l'événement est une BLAGUE qui a pour type le mot RIRE ;

- les écouteurs sont les spectateurs qui sont informés de la diffusion des événements sur l'écran de télévision.

1. Seuls les spectateurs informés de la présence de l'écran de télévision vont réagir correctement aux blagues du présentateur.

2. En fonction du type de l'événement, les spectateurs ne vont pas forcément réagir de la même manière. Ainsi si l'événement BLAGUE est de type RIRE, les spectateurs vont rire aux éclats et si l'événement est de type BOF alors les spectateurs vont se moquer du présentateur.

3. Si des spectateurs ne sont pas du tout au courant de l'existence de cet écran de télévision, ils réagiront peut-être à d'autres événements, mais ne pourront pas réagir aux événements émis par l'écran de télévision.

Toute la finesse, ici, est de bien comprendre qu'un événement est un objet qui va notifier certaines informations à des écouteurs. Maintenant il peut exister sur le plateau de l'émission d'autres types d'événements en considérant, par exemple, que le présentateur lui-même en parlant peut provoquer des rires ou autres si les spectateurs l'écoutent directement sans regarder la télévision… mais ceci est une autre histoire ;)

II - Implémentation dans VEGAS

Revenons maintenant à l'ActionScript et surtout à la programmation évènementielle en général.

Si vous avez l'habitude de programmer dans FLASH MX2004 ou FLASH 8 avec les composants Macromedia, vous avez déjà dû remarquer l'utilisation des événements avec la classe EventDispatcher.

Nous pouvons retrouver un descriptif des événements du modèle évènementiel EventDispatcher dans la « Référence du langage des composants » :

Classe EventDispatcher > Objets événement.

Le seul problème au niveau de ces événements se trouve au niveau du « typage » … en effet ils n’en ont aucun.

L'utilisateur va transmettre des objets génériques qui seront dotés tout simplement des deux propriétés type et target (et quelques autres si affinité), ce qui, finalement, est un peu maigre au niveau d'un code orienté objet digne de ce nom.

Du coup, il est intéressant de se pencher sur les recommandations du W3C à ce sujet et surtout sur les spécifications du modèle objet de document (DOM niveau 2) : Document Object Model Events. Dans ce très intéressant article, le W3C nous parle du flux des événements (Phase de capture, phase de Bubbling…), des écouteurs (EventListener), des diffuseurs d'événements (EventTarget) et surtout de l'interface Event qui permet de définir toutes les méthodes que devrait avoir un événement dans un système évènementiel concret.

En me basant sur cette spécification et ce que le framework AS3 nous propose, j'ai décidé d'établir une interface Event et une classe de base qui permettra de créer par la suite tous les événements qui serviront la diffusion des événements au sein de VEGAS. Cette classe, c'est la classe vegas.events.BasicEvent.

Voyons de plus près les propriétés publiques définies dans l'interface Event :

- cancel():Void

- clone()

- getBubbles():Boolean

- getContext()

- getCurrentTarget()

- getEventPhase():Number

- getTarget()

- getTimeStamp():Number

- getType():String

- initEvent(type:String, bubbles:Boolean, cancelable:Boolean)

- isCancelled():Boolean

- isQueued():Boolean

- queueEvent():Void

- setBubbles(b:Boolean):Void

- setContext(context):Void

- setCurrentTarget(target):Void

- setEventPhase(n:Number):Void

- setTarget(target):Void

- setType(type:String):Void

- stopImmediatePropagation():Void

- toString():String

Cette interface hérite de la classe ICloneable ce qui lui permet de s'assurer que tous les événements auront la méthode clone().

Finalement, qu'est-ce qui ressort du contenu de cette interface ?

Vous pourrez remarquer :

- un événement pourra être annulé ;

- un événement pourra suivre un flux, exposé dans le DOM2 du W3C. Je parlerai plus tard des phases de CAPTURING (ascendante) et de BUBBLING (descendante) et pourra même à n'importe quel moment interrompre ce flux ;

- une méthode getType() et une autre getTarget() qui va nous permettre de retrouver les deux propriétés type et target dans le système évènementiel de Macromedia ;

- une méthode getContext() et une méthode setContext() qui permettent de définir un objet associé à l'événement qui permettra à l'écouteur de récupérer certaines informations sur celui qui émet l'événement ou sur ce qu'il doit faire exactement ;

- la possibilité de stocker dans une queue les événements. Et du coup de pouvoir les garder en mémoire jusqu'à ce qu'un écouteur s'enregistre pour les consulter.

III - La classe BasicEvent

La classe BasicEvent est donc l'implémentation immédiate de l'interface Event et sera utilisée par la classe EventDispatcher, par les écouteurs qui implémenteront l'interface spécifique des écouteurs EventListener.

À noter que la classe FastDispatcher, qui utilise en interne le ASBroadcaster natif de Flash, utilise également des événements qui implémentent l'interface Event.

Il me reste maintenant à vous écrire un petit exemple d'utilisation (hors contexte) de la classe BasicEvent :

import vegas.events.BasicEvent ;
import vegas.events.Event ;

var ev:Event = new BasicEvent("onTest", this, "Hello World") ;
trace("-> " + ev) ;
trace("- what : " + ev.getType()) ;
trace("- who : " + ev.getTarget()) ;
trace("- when : " + new Date(ev.getTimeStamp())) ;
trace("- context : " + ev.getContext()) ;

/*
-> [BasicEvent onTest, AT TARGET, bubbles]
- what : onTest
- who : _level0
- when : Thu Mar 16 15:06:01 GMT+0100 2006
- context : Hello World
*/

IV - La classe DynamicEvent

Pour finir, je vais vous introduire très rapidement la classe DynamicEvent qui est une extension de la classe BasicEvent et qui permet tout simplement de récupérer une instance « dynamique » qui possède, en plus des méthodes de la classe BasicEvent, des propriétés virtuelles « type », « target »… ce qui permet un polymorphisme avec le framework de Macromedia par exemple et, pour certains, un peu plus de souplesse dans leur code… Je vous avouerai que je me sers de moins en moins de la classe DynamicEvent en préférant utiliser des méthodes qui m'assurent le typage et le respect du contrat défini par l'interface Event.

Voilà le petit exemple d'utilisation de la classe DynamicEvent, très similaire à la classe BasicEvent, sauf qu'il faut se méfier au typage de l'instance, qui doit être de type DynamicEvent et non plus de type « Event » directement…

import vegas.events.DynamicEvent ;

var ev:DynamicEvent = new DynamicEvent("onTest", this, "Hello World") ;
trace("-> " + ev) ;
trace("- what : " + ev.type) ;
trace("- who : " + ev.target) ;
trace("- when : " + ev.timeStamp + " -> " + new Date(ev.timeStamp)) ;
trace("- context : " + ev.context) ;

/*

-> [DynamicEvent onTest, AT TARGET, bubbles]
- what : onTest
- who : _level0
- when : 1142517989984 -> Thu Mar 16 15:06:29 GMT+0100 2006
- context : Hello World

*/

V - Conclusion

Voilà pour un premier petit tutoriel très simple en fin de compte, qui est le début d'une longue série pour expliquer le fonctionnement du package vegas.events de VEGAS (il y a de quoi dire à ce sujet…).

Il est évident que si vous ne maîtrisez pas encore un minimum la programmation évènementielle, ce tutoriel va vous sembler vraiment peu révélateur de tout ce que l'on peut faire avec les événements… Mais ne vous inquiétez pas, je vais rapidement vous donner les exemples qui vous permettront d'utiliser ces événements comme il faut.