Basically it implements almost all the features in the Actionscript 3 event model, but with all the functionallity contained within the event class itself. This way events are identified as properties of the object rather than by Strings (or by static properties containing those strings).

A simple example of its use would be this clicked event

package
{
   import bigroom.BrEvent;
   import flash.display.*;
   import flash.events.MouseEvent;
   
   class Listenable extends Sprite
   {
      public var clicked:BrEvent;
      
      public function Listenable() {
         clicked = new BrEvent( this );
         graphics.beginFill( 0xFF0000 );
         graphics.drawCircle( 50, 50, 50 );
         addEventListener( MouseEvent.MOUSE_DOWN, mouseListener );
      }
      
      public function mouseListener( ev:MouseEvent ):void {
         clicked.notify();
      }
   }
}

package
{
   import flash.display.*;
   
   public class Test extends Sprite
   {
      public function Test() {
         var listen:Listenable = new Listenable();
         addChild( listen );
         listen.clicked.addListener( doClick );
      }
      
      public function doClick( ev:BrEvent ):void {
         trace( "clicked" );
      }
   }
}

Download the BrEvent classes.

I first tried to implement this using entirely custom code, and everything worked fine except the weak references. I used the weak references as described in this post, and came across the problem described here. This implementation is BrEvent1 in the download. It’s great if you don’t use the weak references, and interesting anyway.

So then I implemented it utilising the existing Event and EventDispatcher classes and that works fine. This implementation is BrEvent2 in the download. There’s a couple of redundant methods calling methods in the super class but they’re there to make the point about the overriden methods.

The one feature of the Actionscript 3 event model this class doesn’t implement is the capture and bubbling phases of events on display objects. The reason is, it’s not clear what events should be called in the various display objects up the chain. Unless I somehow hack the chosen events into the DisplayObject class itself, the events will only exists on selected display objects. So I didn’t implement this.

Having done this, I still don’t expect to use it. Although I prefer it to the built-in event handling in Actionscript 3, the built in event handling is good enough so I will use that for consistency.

So it was really just a short learning experience. It didn’t take long and I got to play meaninglessly with Actionscript for a morning. If you have any suggestions or you find the class(es) useful, let me know below.

Also, if you can think of a better name, let me know that too. I wanted to simply call the class Event but that would be too confusing with the built-in Event class.

• Both are mixins, with all the disadvantages that entails.
• Both require the listening object to define functions with specific names in order to handle the events.
• With ASBroadcaster, all events are broadcast to all listeners. There is no way for the listener to select only specific events to listen too.
• With EventDispatcher, events must be specified by name as a String, which means there is no compile time checking that the event exists.

So a couple of years ago I devised a new option. This technique uses a single Event class. You set-up events on an object by creating a public property that is an Event. Other objects may then listen to this event and the object dispatches the event when it wishes. For example

import BigRoom.Event; class SimpleButton { public var click:Event; public function SimpleButton() { click = new Event(); } public function onRelease():Void { click.notify( this ); } }

The notify call dispatches the event to all the listeners along with any parameters passed to the notify method. Listeners subscribe to the event via a call to the addListener method of the event, as in the following example

class ButtonListener { public function ButtonListener( btn:SimpleButton ) { btn.click.addlistener( this, buttonClick ); } public function buttonClick( obj:SimpleButton ):Void { // do something here… } }

No mixins, no Strings, no fixed method names, and listeners subscribe to receive specific events. The technique isn’t without its flaws, but I consider it far better than ASBroadcaster or EventDispatcher.

Download the Event class.