ActionScript 3
Trabajando con eventos

Observaciones

Eventos personalizados con datos de eventos.

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;
        }
    }
}

Para enviar un evento personalizado:

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

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

Para escuchar eventos personalizados:

addEventListener(CustomEvent.STOP, stopHandler);

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

Manejo de eventos fuera de la lista de visualización

package {
import flash.events.EventDispatcher;

public class AbstractDispatcher extends EventDispatcher {

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

}
}

Para enviar un evento en una instancia:

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

Para escuchar eventos en una instancia:

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

function changeHandler(event:Event):void
{
}

Manejo básico de eventos

Flash despacha Events para la mayoría de sus objetos. Uno de los eventos más básicos es ENTER_FRAME , que se distribuye (a la velocidad de cuadros del SWF) en cada objeto de la lista de visualización.

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 !");
}

Esta función se llamará de forma asíncrona en cada fotograma. Esto significa que la función que asigna como el controlador de eventos onEnterFrame se procesa antes que cualquier otro código ActionScript que se adjunte a los marcos afectados.

Añade tus propios eventos

Puede crear sus propios eventos y enviarlos, extendiendo la clase 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);
    }
}

Luego puede enviarlo y escucharlo, usando un EventDispatcher . Tenga en cuenta que la mayoría de los objetos flash son despachadores de eventos.

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!"));

Tenga en cuenta que el método de clone es obligatorio si desea volver a ver su evento.

Estructura de evento de ratón simple

A través del uso de event types de event types , puede reducir fácilmente la acumulación de código que ocurre a menudo cuando se definen eventos para muchos objetos en el escenario filtrando eventos en una función en lugar de definir muchas funciones de manejo de eventos.

Imagina que tenemos 10 objetos en el escenario llamados object1 , object2 ... object10

Podrías hacer lo siguiente:

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;
    }
}

Los beneficios de este método incluyen:

1. No es necesario especificar la cantidad de objetos para aplicar eventos.
2. No es necesario saber específicamente con qué objeto interactuó y aún así aplicar la funcionalidad.
3. Fácilmente aplicando eventos a granel.