public function EventDispatcher(target:IEventDispatcher = null)

public function addEventListener(type:String, listener:Function, useCapture:Boolean = false, priority:int = 0, useWeakReference:Boolean = false):void

Once an event listener is successfully registered:

• Its priority cannot be modified by additional calls to this method. In order to change a listener's priority, you must first call removeListener before registering the listener again with the new priority level;
• Subsequent calls to the method with a different value for either type or useCapture result in the creation of a separate listener registration. For example, if you first register a listener with useCapture set to true, it listens only during the capture phase. If you subsequently call this method again using the same listener object, but with useCapture set to false, you have two separate listeners, one that listens during the capture phase and another that listens during the target and bubbling phases.

It is not possible to register an event listener for only one of the target and bubbling phases since those phases are coupled during registration. They are coupled because bubbling applies only to the ancestors of the target node.

You should remove an event listener when it is no longer needed by calling EventDispatcher.removeEventListener(). Failure to remove unnecessary event listeners may have a negative impact on memory usage. Any objects with registered event listeners are not removed from memory because the garbage collector does not remove objects that still have references.

Copying an EventDispatcher does not copy the event listeners attached to it. Event listeners must be attached to the newly created node afterwards if so desired.

Moving an EventDispatcher does not affect the event listeners attached to it.

If the event listener is being registered on a node while an event gets processed on this node, the event listener is not triggered during the current phase but may be triggered during a later phase in the event flow, such as the bubbling phase.

If an event listener is removed from a node while an event is being processed on the node, it is still triggered by the current actions. Once removed, the event listener is never invoked again (unless registered again for future processing).

For the Stage class, which extends the EventDispatcher class, the addEventListener() method is only available to an object that is in the same security sandbox as the Stage owner (the first SWF file loaded). The Stage owner can grant permission to the domain of the calling object by calling the Security.allowDomain() or Security.allowInsecureDomain() method. For more information, see the "Security" chapter in Programming ActionScript 3.0.

public function dispatchEvent(event:Event):Boolean

For the Stage class, which extends the EventDispatcher class, the dispatchEvent() method is only available to an object that is in the same security sandbox as the Stage owner (the first SWF file loaded). The Stage owner can grant permission to the domain of the calling object by calling the Security.allowDomain() or Security.allowInsecureDomain() method. For more information, see the "Security" chapter in Programming ActionScript 3.0.

For the LoaderInfo class, which extends the EventDispatcher class, calling the dispatchEvent() method throws an exception.

public function hasEventListener(type:String):Boolean

The difference between hasEventListener and willTrigger is that hasEventListener examines only the object to which it belongs, whereas willTrigger examines the entire event flow for the event specified by the type parameter.

When the hasEventListener method is called from a LoaderInfo object only the listeners that the caller can access are considered.

For the Stage class, which extends the EventDispatcher class, the hasEventListener() method is only available to an object that is in the same security sandbox as the Stage owner (the first SWF file loaded). The Stage owner can grant permission to the domain of the calling object by calling the Security.allowDomain() or Security.allowInsecureDomain() method. For more information, see the "Security" chapter in Programming ActionScript 3.0.

public function removeEventListener(type:String, listener:Function, useCapture:Boolean = false):void

public function willTrigger(type:String):Boolean

The difference between hasEventListener() and willTrigger() is that hasEventListener() examines only the object to which it belongs, whereas willTrigger() examines the entire event flow for the event specified by the type parameter.

When the willTrigger method is called from a LoaderInfo object only the listeners that the caller can access are considered.

For the Stage class, which extends the EventDispatcher class, the willTrigger() method is only available to an object that is in the same security sandbox as the Stage owner (the first SWF file loaded). The Stage owner can grant permission to the domain of the calling object by calling the Security.allowDomain() or Security.allowInsecureDomain() method. For more information, see the "Security" chapter in Programming ActionScript 3.0.

1. The constructor of EventDispatcherExample creates a local variable dispatcher and assigns it to a new CustomDispatcher object instance.
2. Inside CustomDispatcher, a string is set so that the event has the name action and the doAction() method the action event is created and dispatched using EventDispatcher.dispatchEvent() when the method is called.
3. The dispatcher property is then used to add the action event listener and associated subscriber method actionHandler(), which simply prints out text about the event when it is dispatched using trace().
4. The doAction() method is invoked, which dispatches the action event.

package {
    import flash.display.Sprite;
    import flash.events.Event;

    public class EventDispatcherExample extends Sprite {

        public function EventDispatcherExample() {
            var dispatcher:CustomDispatcher = new CustomDispatcher();
            dispatcher.addEventListener(CustomDispatcher.ACTION, actionHandler);
            dispatcher.doAction();
        }

        private function actionHandler(event:Event):void {
            trace("actionHandler: " + event);
        }
    }
}

import flash.events.EventDispatcher;
import flash.events.Event;

class CustomDispatcher extends EventDispatcher {
    public static var ACTION:String = "action";

    public function doAction():void {
        dispatchEvent(new Event(CustomDispatcher.ACTION));
    }
}