package Events
{
    /* http://www.kirupa.com/forum/showthread.php?223798-ActionScript-
+3-Tip-of-the-Day/page6
    
    Note that addEventListener only takes functions as listeners, not 
+objects.
    
    Also remember that class methods are bound to their instances so w
+hen used as
    listeners, 'this' in the event call still references the orginal c
+lass
    instance no matter what object dispatched the event.

    By extending the EventDispatcher class or any class that inherits 
+from
    it like Sprite (all DisplayObjects are inherently EventDispatchers
+),
    your class gains access to the EventDispatcher methods.
    
    Then, other instances (or the class instance itself) can
    add methods to instances of that class using addEventListener
    and in turn they can call those events through dispatchEvent.

    If there is some reason your class cannot inherit from the EventDi
+spatcher
    class  for example, if its already inheriting from another class w
+hich
    does not inherit from EventDispatcher), then you can use the Event
+Dispatcher
    constructor to intialize your class instance with the methods of E
+ventDispatcher
    via aggregation (composition).
    
    Just make sure you implement the IEventDispatcher interface (flash
+.events.IEventDispatcher)*/

    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.IEventDispatcher;
    import flash.utils.getQualifiedClassName;

    public class MyDispatcher implements IEventDispatcher
    {
        private var eventDispatcher:EventDispatcher;

        public function MyDispatcher()
        {
            trace("new " + getQualifiedClassName(this));
            eventDispatcher=new EventDispatcher(this);
        }

        public function addEventListener(type:String, listener:Functio
+n, useCapture:Boolean=false, priority:int=0, useWeakReference:Boolean
+=false):void
        {
            eventDispatcher.addEventListener(type, listener, useCaptur
+e, priority, useWeakReference);
        }

        public function dispatchEvent(event:Event):Boolean
        {
            return eventDispatcher.dispatchEvent(event);
        }

        public function hasEventListener(type:String):Boolean
        {
            return eventDispatcher.hasEventListener(type);
        }

        public function removeEventListener(type:String, listener:Func
+tion, useCapture:Boolean=false):void
        {
            eventDispatcher.removeEventListener(type, listener, useCap
+ture);
        }

        public function willTrigger(type:String):Boolean
        {
            return eventDispatcher.willTrigger(type);
        }
    }
}
[download]

package Events
{
    import flash.utils.getQualifiedClassName;

    public final class MyEventDispatcher extends MyDispatcher
    {
        private static var _instance:MyEventDispatcher;

        public function MyEventDispatcher(dummy:Dummy):void
        {
            super();
            if (dummy === null)
            {
                throw new Error("Call CustomEventDispatcher as CustomE
+ventDispatcher.instance!");
            }
        }

        public static function get instance():MyEventDispatcher
        {
            if (_instance === null)
            {
                _instance=new MyEventDispatcher(new Dummy());
                trace("new instance " + getQualifiedClassName(_instanc
+e));
            }
            trace("get instance " + getQualifiedClassName(_instance));
            return _instance;
        }
    }
}

internal class Dummy
{

}
[download]