ActionScript 3
Travailler avec des événements

Remarques

Événements personnalisés avec données d'événement

package
{
    import flash.events.Event;

    public class CustomEvent extends Event
    {
        public static const START:String = "START";
        public static const STOP:String  = "STOP";

        public var data:*;

        public function CustomEvent(type:String, data:*,
                                    bubbles:Boolean=false, cancelable:Boolean=false)
        {
            super(type, bubbles, cancelable);

            if (data)
                this.data = data;
        }
    }
}

Pour envoyer un événement personnalisé:

var dataObject:Object = {name: "Example Data"};

dispatchEvent(new CustomEvent(CustomEvent.START, dataObject))

Pour écouter les événements personnalisés:

addEventListener(CustomEvent.STOP, stopHandler);

function stopHandler(event:CustomEvent):void
{
    var dataObject:* = event.data;
}

Gestion des événements hors liste d'affichage

package {
import flash.events.EventDispatcher;

public class AbstractDispatcher extends EventDispatcher {

    public function AbstractDispatcher(target:IEventDispatcher = null) {
        super(target);
    }

}
}

Pour envoyer un événement sur une instance:

var dispatcher:AbstractDispatcher = new AbstractDispatcher();
dispatcher.dispatchEvent(new Event(Event.CHANGE));

Pour écouter les événements sur une instance:

var dispatcher:AbstractDispatcher = new AbstractDispatcher();
dispatcher.addEventListener(Event.CHANGE, changeHandler);

function changeHandler(event:Event):void
{
}

Gestion d'événement de base

Flash distribue des Events pour la plupart de ses objets. L'un des événements les plus élémentaires est ENTER_FRAME , qui est envoyé (au débit du fichier SWF) sur chaque objet de la liste d'affichage.

import flash.display.Sprite;
import flash.events.Event;

var s:Sprite = new Sprite();
s.addEventListener(Event.ENTER_FRAME, onEnterFrame);

function onEnterFrame(e:Event)
{
    trace("I am called on every frame !");
}

Cette fonction sera appelée de manière asynchrone sur chaque image. Cela signifie que la fonction que vous attribuez en tant que gestionnaire d'événements onEnterFrame est traitée avant tout autre code ActionScript associé aux images concernées.

Ajoutez vos propres événements

Vous pouvez créer vos propres événements et les distribuer en étendant la classe Event .

import flash.events.Event;

class MyEvent extends Event
{
    var data: String;
    
    static public var MY_EVENT_TYPE = "my_event_my_event_code";

    public function MyEvent(type: String, data: String)
    {
        this.data = data;
    }
    
    override public function clone():Event
    {
        return new MyEvent(type, data);
    }
}

Vous pouvez ensuite l'envoyer et l'écouter en utilisant un EventDispatcher . Notez que la plupart des objets flash sont des répartiteurs d'événements.

import flash.events.EventDispatcher;

var d = new EventDispatcher();
d.addEventListener(MyEvent.MY_EVENT_TYPE, onType);

function onType(e: MyEvent)
{
    trace("I have a string: "+e.data);
}

d.dispatchEvent(new MyEvent(MyEvent.MY_EVENT_TYPE, "Hello events!"));

Notez que la méthode de clone est requise si vous souhaitez redistribuer votre événement.

Structure d'événement de souris simple

Grâce à l'utilisation de event types vous pouvez facilement réduire le gonflement du code qui se produit souvent lors de la définition des événements pour de nombreux objets sur la scène en filtrant les événements dans une fonction plutôt que de définir de nombreuses fonctions de gestion des événements.

Imaginez que nous avons 10 objets sur scène nommé object1 , object2 ... object10

Vous pouvez faire ce qui suit:

var i: int = 1;
while(getChildByName("object"+i) != null){
    var obj = getChildByName("object"+i)
    obj.addEventListener(MouseEvent.CLICK, ObjectMouseEventHandler);
    obj.addEventListener(MouseEvent.MOUSE_OVER, ObjectMouseEventHandler);
    obj.addEventListener(MouseEvent.MOUSE_OUT, ObjectMouseEventHandler);
    obj.alpha = 0.75;
    i++;
}

function ObjectMouseEventHandler(evt:Event)
{
    if(evt.type == "click")
    {
        trace(evt.currentTarget + " has been clicked");
    }
    else
    {
        evt.currentTarget.alpha = evt.type == "mouseOver" ? 1 : 0.75;
    }
}

Les avantages de cette méthode incluent:

1. Pas besoin de spécifier la quantité d'objets à appliquer aux événements.
2. Ne pas avoir besoin de savoir précisément quel objet a été interagi avec encore la fonctionnalité.
3. Appliquer facilement des événements en vrac.