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

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

Article lu   fois.

L'auteur

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

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 EventDispatcherDocumentation officielle 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 en n'ont aucun.

L'utilisateur va transmettre des objets génériques qui seront dotés tout simplement des 2 propriétés type et target (et quelques autres si affinité), ce qui, au final, 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 devraient 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 :

 
Sélectionnez

- 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().

Au final, 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 2 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 .

A 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 :

 
Sélectionnez

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

 
Sélectionnez

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 tutorial 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.

Retrouvez cet article et d'autres sur ekameleon.developpez.com ou bien sur mon blog : www.ekameleon.net/blog/

  

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.