/*
  * EventDispatcher
  * Visit http://createjs.com/ for documentation, updates and examples.
  *
  * Copyright (c) 2010 gskinner.com, inc.
  *
  * Permission is hereby granted, free of charge, to any person
  * obtaining a copy of this software and associated documentation
  * files (the "Software"), to deal in the Software without
  * restriction, including without limitation the rights to use,
  * copy, modify, merge, publish, distribute, sublicense, and/or sell
  * copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following
  * conditions:
  *
  * The above copyright notice and this permission notice shall be
  * included in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */
  
  // namespace:
  this.createjs = this.createjs||{};
  
  (function() {
  
  

The EventDispatcher provides methods for managing prioritized queues of event listeners and dispatching events. All {{#crossLink "DisplayObject"}}{{/crossLink}} classes dispatch events, as well as some of the utilities like {{#crossLink "Ticker"}}{{/crossLink}}. You can either extend this class or mix its methods into an existing prototype or instance by using the EventDispatcher {{#crossLink "EventDispatcher/initialize"}}{{/crossLink}} method. <h4>Example</h4> Add EventDispatcher capabilities to the "MyClass" class. EventDispatcher.initialize(MyClass.prototype); Add an event (see {{#crossLink "EventDispatcher/addEventListener"}}{{/crossLink}}). instance.addEventListener("eventName", handlerMethod); function handlerMethod(event) { console.log(event.target + " Was Clicked"); } <b>Maintaining proper scope</b><br /> When using EventDispatcher in a class, you may need to use <code>Function.bind</code> or another approach to maintain you method scope. Note that Function.bind is not supported in some older browsers. instance.addEventListener("click", handleClick.bind(this)); function handleClick(event) { console.log("Method called in scope: " + this); } Please note that currently, EventDispatcher does not support event priority or bubbling. Future versions may add support for one or both of these features. @class EventDispatcher @constructor

  
  var EventDispatcher = function() {
    this.initialize();
  };
  var p = EventDispatcher.prototype;
  
          

Static initializer to mix in EventDispatcher methods. @method initialize @static
parameter: {Object} target The target object to inject EventDispatcher methods into. This can be an instance or a prototype.

  
          EventDispatcher.initialize = function(target) {
                  target.addEventListener = p.addEventListener;
                  target.removeEventListener = p.removeEventListener;
                  target.removeAllEventListeners = p.removeAllEventListeners;
                  target.hasEventListener = p.hasEventListener;
                  target.dispatchEvent = p.dispatchEvent;
          };
  
  // private properties:
          

@protected @property _listeners @type Object

  
          p._listeners = null;
  
  // constructor:
          

Initialization method. @method initialize @protected

  
          p.initialize = function() {};
  
  // public methods:
          

Adds the specified event listener. @method addEventListener
parameter: {String} type The string type of the event.
parameter: {Function | Object} listener An object with a handleEvent method, or a function that will be called when the event is dispatched.
returns: {Function | Object} Returns the listener for chaining or assignment.

  
          p.addEventListener = function(type, listener) {
                  var listeners = this._listeners;
                  if (!listeners) { listeners = this._listeners = {}; }
                  else { this.removeEventListener(type, listener); }
                  var arr = listeners[type];
                  if (!arr) { arr = listeners[type] = []; }
                  arr.push(listener);
                  return listener;
          };
  
          

Removes the specified event listener. @method removeEventListener
parameter: {String} type The string type of the event.
parameter: {Function | Object} listener The listener function or object.

  
          p.removeEventListener = function(type, listener) {
                  var listeners = this._listeners;
                  if (!listeners) { return; }
                  var arr = listeners[type];
                  if (!arr) { return; }
                  for (var i=0,l=arr.length; i<l; i++) {
                          if (arr[i] == listener) {
                                  if (l==1) { delete(listeners[type]); } // allows for faster checks.
                                  else { arr.splice(i,1); }
                                  break;
                          }
                  }
          };
  
          

Removes all listeners for the specified type, or all listeners of all types. @method removeAllEventListeners
parameter: {String} [type] The string type of the event. If omitted, all listeners for all types will be removed.

  
          p.removeAllEventListeners = function(type) {
                  if (!type) { this._listeners = null; }
                  else if (this._listeners) { delete(this._listeners[type]); }
          };
  
          

Dispatches the specified event. @method dispatchEvent
parameter: {Object | String} eventObj An object with a "type" property, or a string type. If a string is used, dispatchEvent will construct a generic event object with the specified type.
parameter: {Object} [target] The object to use as the target property of the event object. This will default to the dispatching object.
returns: {Boolean} Returns true if any listener returned true.

  
          p.dispatchEvent = function(eventObj, target) {
                  var ret=false, listeners = this._listeners;
                  if (eventObj && listeners) {
                          if (typeof eventObj == "string") { eventObj = {type:eventObj}; }
                          var arr = listeners[eventObj.type];
                          if (!arr) { return ret; }
                          eventObj.target = target||this;
                          arr = arr.slice(); // to avoid issues with items being removed or added during the dispatch
                          for (var i=0,l=arr.length; i<l; i++) {
                                  var o = arr[i];
                                  if (o.handleEvent) { ret = ret||o.handleEvent(eventObj); }
                                  else { ret = ret||o(eventObj); }
                          }
                  }
                  return !!ret;
          };
  
          

Indicates whether there is at least one listener for the specified event type. @method hasEventListener
parameter: {String} type The string type of the event.
returns: {Boolean} Returns true if there is at least one listener for the specified event.

  
          p.hasEventListener = function(type) {
                  var listeners = this._listeners;
                  return !!(listeners && listeners[type]);
          };
  
          

@method toString
returns: {String} a string representation of the instance.

  
          p.toString = function() {
                  return "[EventDispatcher]";
          };
  
  createjs.EventDispatcher = EventDispatcher;
  }());

---

[] readme course(s) preface I 1 2 II 3 4 III 5 6 7 IV 8 9 10 V 11 12 afterthought(s) appendix reference(s) example(s) resource(s) _

---

(C) Æliens 04/09/2009

You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.