ActionScript 3
Praca ze zdarzeniami

Uwagi

Zdarzenia niestandardowe z danymi zdarzeń

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

Aby wysłać niestandardowe zdarzenie:

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

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

Aby nasłuchiwać niestandardowych zdarzeń:

addEventListener(CustomEvent.STOP, stopHandler);

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

Obsługa zdarzeń poza listą wyświetlania

package {
import flash.events.EventDispatcher;

public class AbstractDispatcher extends EventDispatcher {

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

}
}

Aby wywołać zdarzenie w instancji:

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

Aby nasłuchiwać zdarzeń w instancji:

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

function changeHandler(event:Event):void
{
}

Podstawowa obsługa zdarzeń

Flash wywołuje Events dla większości swoich obiektów. Jednym z najbardziej podstawowych zdarzeń jest ENTER_FRAME , które jest wywoływane (z prędkością klatek na sekundę SWF) na każdym obiekcie listy wyświetlania.

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

Ta funkcja będzie wywoływana asynchronicznie na każdej ramce. Oznacza to, że funkcja przypisana jako onEnterFrame obsługi zdarzeń onEnterFrame jest przetwarzany przed jakimkolwiek innym kodem ActionScript dołączonym do dotkniętych ramek.

Dodaj własne wydarzenia

Możesz tworzyć własne zdarzenia i wysyłać je, rozszerzając klasę 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);
    }
}

Następnie możesz go wysłać i wysłuchać za pomocą EventDispatcher . Zauważ, że większość obiektów flash to dyspozytorzy zdarzeń.

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

Pamiętaj, że metoda clone jest wymagana, jeśli chcesz ponownie wysłać wydarzenie.

Prosta struktura zdarzeń myszy

Dzięki zastosowaniu event types można łatwo zmniejszyć rozdęcie kodu, które często występuje podczas definiowania zdarzeń dla wielu obiektów na scenie, poprzez filtrowanie zdarzeń w funkcji 1 zamiast definiowania wielu funkcji obsługi zdarzeń.

Wyobraź sobie, mamy 10 obiektów na scenie nazwie object1 , object2 ... object10

Możesz wykonać następujące czynności:

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

Korzyści z tej metody obejmują:

1. Nie trzeba określać liczby obiektów, dla których mają zostać zastosowane zdarzenia.
2. Nie trzeba dokładnie wiedzieć, z którym obiektem przeprowadzono interakcję, a mimo to zastosować funkcjonalność.
3. Łatwe stosowanie zdarzeń masowych.