node-easel
Version:
node wrapper for EaselJS, utilizing node-canvas.
201 lines (186 loc) • 7.04 kB
JavaScript
/*
* 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
* @param {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
* @param {String} type The string type of the event.
* @param {Function | Object} listener An object with a handleEvent method, or a function that will be called when
* the event is dispatched.
* @return {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
* @param {String} type The string type of the event.
* @param {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
* @param {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
* @param {Object | String} eventObj An object with a "type" property, or a string type. If a string is used,
* dispatchEvent will contstruct a generic event object with "type" and "params" properties.
* @param {Object} [target] The object to use as the target property of the event object. This will default to the
* dispatching object.
* @return {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}; }
eventObj.target = target||this;
var arr = listeners[eventObj.type];
if (!arr) { return ret; }
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 instanceof Function) { ret = ret||o.apply(null, [eventObj]); }
else if (o.handleEvent) { ret = ret||o.handleEvent(eventObj); }
}
}
return !!ret;
};
/**
* Indicates whether there is at least one listener for the specified event type.
* @method hasEventListener
* @param {String} type The string type of the event.
* @return {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
* @return {String} a string representation of the instance.
**/
p.toString = function() {
return "[EventDispatcher]";
};
createjs.EventDispatcher = EventDispatcher;
}());