class myClass
{
private static var EventDispatcherDependancy = mx.events.EventDispatcher.initialize ( myClass.prototype );
public var addEventListener:Function;
public var removeEventListener:Function;
public var dispatchEvent:Function;
public var dispatchQueue:Function;

public function myClass (){}
}

The Flash app you seen in the video is part of a larger app that spits out a complete ARP application and actually writes .as files to disk.

http://muzakdeezign.com/flashcoders/create_component/MyButton.html

“By the way, in AS2 the fastest way to dispatch events is using the AsBroadcaster class, and the more listeners you add, the faster it gets compared to direct method invocation.”

Well there ya go!

The alternate is to store a variable of the function and pass that as the listener.

// typical
obj.addEventListener ( ’someEvent’, this );

// scoped and proxied event
obj.addEventListener ( ’someEvent’, mx.utils.Delegate.create ( this, myEventfunction );

The advantage of the later is that you can choose the scope and an alternately named function. The overhead occurs when it passes an object with all the information, not limited to the target and type sent by obj, but any property you want to add.

I use this method in my UIEventMovieClip class:
private function newEvent ( type, eventObj:Object ):Void
{
// check for optional passed prams
var eventObj = ( eventObj != undefined ) ? eventObj : new Object ();
// set event type
eventObj.type = type;
// set sender
eventObj.target = this;
// send event
this.dispatchEvent ( eventObj );
}

and call it by saying:
newEvent ( ’someEvent’, { prop1:true, prop2:false } );

Having a myEventfunction ( eventObj:Object ) { } is kinda cool because you never have to worry about the order of your variables in the function, its just ALWAYS going to send an eventObject as a single pram - so give it a point for consistency and predictability.

By using AsBroadcaster you are getting all events, and those events have to be named the same as you subscribed to. You can choose to not receive events by not making a function of the same name or just unsubscribing to all events.

I would say the pros include, low overhead in the prams passed. It’s probably faster because you spend less time packaging up an object before you send the event, and there is consistency between the event name being broadcast and the method name you use to capture that event.

The drawback is that you receive all events, you don’t know which object sent the event because it doesn’t include a reference to itself. That may be ok when you are subscribing to a Mouse or Stage, since there is only one.

Using the Proxy technique with Event Dispatcher you can easily to the following.
obj1.addEventListener ( ‘onPress’, mx.utils.Delegate.create ( this, obj1_onPress );
obj2.addEventListener ( ‘onPress’, obj2_onPress );

See http://www.justgooddesign.com/blog/jgdelegate.htm for more information on delegates.

I guess when it comes down to it, if you have a class witch TONS of events and TONS of subscribers and you only care about a couple of those events per subscriber, or you want to really section out who you subscribed to and tailor the individual method, the use EventDispatcher.

if you don’t need to tailor the event method and it’s not that big of a deal to receive all events, all of the time, then use AsBroadcaster.

Well, that’s just my opinion.

For the life of me I can’t seem to figure out which one is better to use. The only advantage I can see that EventDispatcher has is the ability to subscribe to specific events, which doesn’t seem so hot to me since you could pretty much do the same for AsBroadcaster (i.e. just make callback functions for the eventNames that are of interest for the receiving object).

I’ll reread this in the morning and it might become clearer to me, lol. Great site by the way, keep it up!

Extend the built-in broadcaster to allow for
manipulating the list of listeners during
the broadcast.

Additionally make the broadcaster a real
class to enable using it like a normal class.

@author Ralf Bokelberg
@credits Shinya Tomikawa, Peter Hall, Andre Michelle, Holger Kohnen

@lastChange 2003/06/05

@history
2003/06/05 published