http://git-wip-us.apache.org/repos/asf/flex-falcon/blob/3df891f4/externs/createjs/src/main/patch/easeljs.patch ---------------------------------------------------------------------- diff --git a/externs/createjs/src/main/patch/easeljs.patch b/externs/createjs/src/main/patch/easeljs.patch new file mode 100644 index 0000000..f934bc7 --- /dev/null +++ b/externs/createjs/src/main/patch/easeljs.patch @@ -0,0 +1,19219 @@ +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js +index 3ce0025..71160cf 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/Event.js +@@ -1,262 +1,76 @@ +-/* +-* Event +-* 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. +-*/ +- ++/** @fileoverview Auto-generated Externs files ++ * @externs ++ */ + /** +- * A collection of Classes that are shared across all the CreateJS libraries. The classes are included in the minified +- * files of each library and are available on the createsjs namespace directly. +- * +- * <h4>Example</h4> ++ * Contains properties and methods shared by all events for use with ++ * {{#crossLink "EventDispatcher"}}{{/crossLink}}. ++ * ++ * Note that Event objects are often reused, so you should never ++ * rely on an event object's state outside of the call stack it was received in. + * +- * myObject.addEventListener("change", createjs.proxy(myMethod, scope)); +- * +- * @module CreateJS +- * @main CreateJS +- */ +- +-// namespace: +-this.createjs = this.createjs||{}; ++ * @see [Event] ++ * @constructor */ ++createjs.Event = function (type, bubbles, cancelable) {} + +-(function() { +- "use strict"; ++ /** ++ * Returns a clone of the Event instance. ++ * ++ * @see [Event] ++ * @returns {(Event|null)} a clone of the Event instance. ++ */ ++createjs.Event.clone = function () { return null; } + +-// constructor: +- /** +- * Contains properties and methods shared by all events for use with +- * {{#crossLink "EventDispatcher"}}{{/crossLink}}. +- * +- * Note that Event objects are often reused, so you should never +- * rely on an event object's state outside of the call stack it was received in. +- * @class Event +- * @param {String} type The event type. +- * @param {Boolean} bubbles Indicates whether the event will bubble through the display list. +- * @param {Boolean} cancelable Indicates whether the default behaviour of this event can be cancelled. +- * @constructor +- **/ +- function Event(type, bubbles, cancelable) { +- +- +- // public properties: +- /** +- * The type of event. +- * @property type +- * @type String +- **/ +- this.type = type; +- +- /** +- * The object that generated an event. +- * @property target +- * @type Object +- * @default null +- * @readonly +- */ +- this.target = null; +- +- /** +- * The current target that a bubbling event is being dispatched from. For non-bubbling events, this will +- * always be the same as target. For example, if childObj.parent = parentObj, and a bubbling event +- * is generated from childObj, then a listener on parentObj would receive the event with +- * target=childObj (the original target) and currentTarget=parentObj (where the listener was added). +- * @property currentTarget +- * @type Object +- * @default null +- * @readonly +- */ +- this.currentTarget = null; +- +- /** +- * For bubbling events, this indicates the current event phase:<OL> +- * <LI> capture phase: starting from the top parent to the target</LI> +- * <LI> at target phase: currently being dispatched from the target</LI> +- * <LI> bubbling phase: from the target to the top parent</LI> +- * </OL> +- * @property eventPhase +- * @type Number +- * @default 0 +- * @readonly +- */ +- this.eventPhase = 0; +- +- /** +- * Indicates whether the event will bubble through the display list. +- * @property bubbles +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.bubbles = !!bubbles; +- +- /** +- * Indicates whether the default behaviour of this event can be cancelled via +- * {{#crossLink "Event/preventDefault"}}{{/crossLink}}. This is set via the Event constructor. +- * @property cancelable +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.cancelable = !!cancelable; +- +- /** +- * The epoch time at which this event was created. +- * @property timeStamp +- * @type Number +- * @default 0 +- * @readonly +- */ +- this.timeStamp = (new Date()).getTime(); +- +- /** +- * Indicates if {{#crossLink "Event/preventDefault"}}{{/crossLink}} has been called +- * on this event. +- * @property defaultPrevented +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.defaultPrevented = false; +- +- /** +- * Indicates if {{#crossLink "Event/stopPropagation"}}{{/crossLink}} or +- * {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called on this event. +- * @property propagationStopped +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.propagationStopped = false; +- +- /** +- * Indicates if {{#crossLink "Event/stopImmediatePropagation"}}{{/crossLink}} has been called +- * on this event. +- * @property immediatePropagationStopped +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.immediatePropagationStopped = false; +- +- /** +- * Indicates if {{#crossLink "Event/remove"}}{{/crossLink}} has been called on this event. +- * @property removed +- * @type Boolean +- * @default false +- * @readonly +- */ +- this.removed = false; +- } +- var p = Event.prototype; ++ /** ++ * Causes the active listener to be removed via removeEventListener(); ++ * ++ * myBtn.addEventListener("click", function(evt) { ++ * // do stuff... ++ * evt.remove(); // removes this listener. ++ * }); ++ * ++ * @see [Event] ++ */ ++createjs.Event.remove = function () { } + +- /** +- * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +- * See {{#crossLink "Utility Methods/extend"}}{{/crossLink}} and {{#crossLink "Utility Methods/promote"}}{{/crossLink}} +- * for details. +- * +- * There is an inheritance tutorial distributed with EaselJS in /tutorials/Inheritance. +- * +- * @method initialize +- * @protected +- * @deprecated +- */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. ++ /** ++ * Provides a chainable shortcut method for setting a number of properties on the instance. ++ * ++ * @param {(Object|null)} props A generic object containing properties to copy to the instance. ++ * @see [Event] ++ * @returns {(Event|null)} Returns the instance the method is called on (useful for chaining calls.) ++ */ ++createjs.Event.set = function (props) { return null; } + +-// public methods: +- /** +- * Sets {{#crossLink "Event/defaultPrevented"}}{{/crossLink}} to true. +- * Mirrors the DOM event standard. +- * @method preventDefault +- **/ +- p.preventDefault = function() { +- this.defaultPrevented = this.cancelable&&true; +- }; ++ /** ++ * Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} to true. ++ * Mirrors the DOM event standard. ++ * ++ * @see [Event] ++ */ ++createjs.Event.stopPropagation = function () { } + +- /** +- * Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} to true. +- * Mirrors the DOM event standard. +- * @method stopPropagation +- **/ +- p.stopPropagation = function() { +- this.propagationStopped = true; +- }; ++ /** ++ * Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} and ++ * {{#crossLink "Event/immediatePropagationStopped"}}{{/crossLink}} to true. ++ * Mirrors the DOM event standard. ++ * ++ * @see [Event] ++ */ ++createjs.Event.stopImmediatePropagation = function () { } + +- /** +- * Sets {{#crossLink "Event/propagationStopped"}}{{/crossLink}} and +- * {{#crossLink "Event/immediatePropagationStopped"}}{{/crossLink}} to true. +- * Mirrors the DOM event standard. +- * @method stopImmediatePropagation +- **/ +- p.stopImmediatePropagation = function() { +- this.immediatePropagationStopped = this.propagationStopped = true; +- }; +- +- /** +- * Causes the active listener to be removed via removeEventListener(); +- * +- * myBtn.addEventListener("click", function(evt) { +- * // do stuff... +- * evt.remove(); // removes this listener. +- * }); +- * +- * @method remove +- **/ +- p.remove = function() { +- this.removed = true; +- }; +- +- /** +- * Returns a clone of the Event instance. +- * @method clone +- * @return {Event} a clone of the Event instance. +- **/ +- p.clone = function() { +- return new Event(this.type, this.bubbles, this.cancelable); +- }; +- +- /** +- * Provides a chainable shortcut method for setting a number of properties on the instance. +- * +- * @method set +- * @param {Object} props A generic object containing properties to copy to the instance. +- * @return {Event} Returns the instance the method is called on (useful for chaining calls.) +- * @chainable +- */ +- p.set = function(props) { +- for (var n in props) { this[n] = props[n]; } +- return this; +- }; ++ /** ++ * Returns a string representation of this object. ++ * ++ * @see [Event] ++ * @returns {(string|null)} a string representation of the instance. ++ */ ++createjs.Event.toString = function () { return null; } + +- /** +- * Returns a string representation of this object. +- * @method toString +- * @return {String} a string representation of the instance. +- **/ +- p.toString = function() { +- return "[Event (type="+this.type+")]"; +- }; ++ /** ++ * Sets {{#crossLink "Event/defaultPrevented"}}{{/crossLink}} to true. ++ * Mirrors the DOM event standard. ++ * ++ * @see [Event] ++ */ ++createjs.Event.preventDefault = function () { } + +- createjs.Event = Event; +-}()); +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js +index b95257c..1e8dce8 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/events/EventDispatcher.js +@@ -1,407 +1,201 @@ +-/* +-* 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. +-*/ +- +-/** +- * @module CreateJS ++/** @fileoverview Auto-generated Externs files ++ * @externs + */ ++/** ++ * EventDispatcher provides methods for managing queues of event listeners and dispatching events. ++ * ++ * You can either extend EventDispatcher or mix its methods into an existing prototype or instance by using the ++ * EventDispatcher {{#crossLink "EventDispatcher/initialize"}}{{/crossLink}} method. ++ * ++ * Together with the CreateJS Event class, EventDispatcher provides an extended event model that is based on the ++ * DOM Level 2 event model, including addEventListener, removeEventListener, and dispatchEvent. It supports ++ * bubbling / capture, preventDefault, stopPropagation, stopImmediatePropagation, and handleEvent. ++ * ++ * EventDispatcher also exposes a {{#crossLink "EventDispatcher/on"}}{{/crossLink}} method, which makes it easier ++ * to create scoped listeners, listeners that only run once, and listeners with associated arbitrary data. The ++ * {{#crossLink "EventDispatcher/off"}}{{/crossLink}} method is merely an alias to ++ * {{#crossLink "EventDispatcher/removeEventListener"}}{{/crossLink}}. ++ * ++ * Another addition to the DOM Level 2 model is the {{#crossLink "EventDispatcher/removeAllEventListeners"}}{{/crossLink}} ++ * method, which can be used to listeners for all events, or listeners for a specific event. The Event object also ++ * includes a {{#crossLink "Event/remove"}}{{/crossLink}} method which removes the active listener. ++ * ++ * <h4>Example</h4> ++ * Add EventDispatcher capabilities to the "MyClass" class. ++ * ++ * createjs.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 /> ++ * Scope (ie. "this") can be be a challenge with events. Using the {{#crossLink "EventDispatcher/on"}}{{/crossLink}} ++ * method to subscribe to events simplifies this. ++ * ++ * instance.addEventListener("click", function(event) { ++ * console.log(instance == this); // false, scope is ambiguous. ++ * }); ++ * ++ * instance.on("click", function(event) { ++ * console.log(instance == this); // true, "on" uses dispatcher scope by default. ++ * }); ++ * ++ * If you want to use addEventListener instead, you may want to use function.bind() or a similar proxy to manage scope. ++ * ++ * @see [EventDispatcher] ++ * @constructor */ ++createjs.EventDispatcher = function () {} ++ ++ /** ++ * Static initializer to mix EventDispatcher methods into a target object or prototype. ++ * ++ * createjs.EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class ++ * createjs.EventDispatcher.initialize(myObject); // add to a specific instance ++ * ++ * @param {(Object|null)} target The target object to inject EventDispatcher methods into. This can be an instance or a prototype. ++ * @see [EventDispatcher] ++ */ ++createjs.EventDispatcher.prototype.initialize = function (target) { } ++ ++ /** ++ * Indicates whether there is at least one listener for the specified event type on this object or any of its ++ * ancestors (parent, parent's parent, etc). A return value of true indicates that if a bubbling event of the ++ * specified type is dispatched from this object, it will trigger at least one listener. ++ * ++ * This is similar to {{#crossLink "EventDispatcher/hasEventListener"}}{{/crossLink}}, but it searches the entire ++ * event flow for a listener, not just this object. ++ * ++ * @param {(string|null)} type The string type of the event. ++ * @see [EventDispatcher] ++ * @returns {(boolean|null)} Returns `true` if there is at least one listener for the specified event. ++ */ ++createjs.EventDispatcher.willTrigger = function (type) { return null; } ++ ++ /** ++ * Removes all listeners for the specified type, or all listeners of all types. ++ * ++ * <h4>Example</h4> ++ * ++ * // Remove all listeners ++ * displayObject.removeAllEventListeners(); ++ * ++ * // Remove all click listeners ++ * displayObject.removeAllEventListeners("click"); ++ * ++ * @param {(string|null|undefined)} type The string type of the event. If omitted, all listeners for all types will be removed. ++ * @see [EventDispatcher] ++ */ ++createjs.EventDispatcher.removeAllEventListeners = function (type) { } ++ ++ /** ++ * Adds the specified event listener. Note that adding multiple listeners to the same function will result in ++ * multiple callbacks getting fired. ++ * ++ * <h4>Example</h4> ++ * ++ * displayObject.addEventListener("click", handleClick); ++ * function handleClick(event) { ++ * // Click happened. ++ * } ++ * ++ * @param {(string|null)} type The string type of the event. ++ * @param {(Object|null)} listener An object with a handleEvent method, or a function that will be called when the event is dispatched. ++ * @param {(boolean|null|undefined)} useCapture For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. ++ * @see [EventDispatcher] ++ * @returns {(Object|null)} Returns the listener for chaining or assignment. ++ */ ++createjs.EventDispatcher.addEventListener = function (type, listener, useCapture) { return null; } ++ ++ /** ++ * @param {(Event|Object|null)} eventObj ++ * @param {(Object|null)} eventPhase ++ * @see [EventDispatcher] ++ */ ++createjs.EventDispatcher._dispatchEvent = function (eventObj, eventPhase) { } ++ ++ /** ++ * Dispatches the specified event to all listeners. ++ * ++ * <h4>Example</h4> ++ * ++ * // Use a string event ++ * this.dispatchEvent("complete"); ++ * ++ * // Use an Event instance ++ * var event = new createjs.Event("progress"); ++ * this.dispatchEvent(event); ++ * ++ * @param {(Event|Object|null)} eventObj An object with a "type" property, or a string type. While a generic object will work, it is recommended to use a CreateJS Event instance. If a string is used, dispatchEvent will construct an Event instance with the specified type. ++ * @see [EventDispatcher] ++ * @returns {(boolean|null)} Returns the value of eventObj.defaultPrevented. ++ */ ++createjs.EventDispatcher.dispatchEvent = function (eventObj) { return null; } ++ ++ /** ++ * Removes the specified event listener. ++ * ++ * <b>Important Note:</b> that you must pass the exact function reference used when the event was added. If a proxy ++ * function, or function closure is used as the callback, the proxy/closure reference must be used - a new proxy or ++ * closure will not work. ++ * ++ * <h4>Example</h4> ++ * ++ * displayObject.removeEventListener("click", handleClick); ++ * ++ * @param {(string|null)} type The string type of the event. ++ * @param {(Object|null)} listener The listener function or object. ++ * @param {(boolean|null|undefined)} useCapture For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. ++ * @see [EventDispatcher] ++ */ ++createjs.EventDispatcher.removeEventListener = function (type, listener, useCapture) { } ++ ++ /** ++ * A shortcut method for using addEventListener that makes it easier to specify an execution scope, have a listener ++ * only run once, associate arbitrary data with the listener, and remove the listener. ++ * ++ * This method works by creating an anonymous wrapper function and subscribing it with addEventListener. ++ * The created anonymous function is returned for use with .removeEventListener (or .off). ++ * ++ * <h4>Example</h4> ++ * ++ * var listener = myBtn.on("click", handleClick, null, false, {count:3}); ++ * function handleClick(evt, data) { ++ * data.count -= 1; ++ * console.log(this == myBtn); // true - scope defaults to the dispatcher ++ * if (data.count == 0) { ++ * alert("clicked 3 times!"); ++ * myBtn.off("click", listener); ++ * // alternately: evt.remove(); ++ * } ++ * } ++ * ++ * @param {(string|null)} type The string type of the event. ++ * @param {(Object|null)} listener An object with a handleEvent method, or a function that will be called when the event is dispatched. ++ * @param {(Object|null|undefined)} scope The scope to execute the listener in. Defaults to the dispatcher/currentTarget for function listeners, and to the listener itself for object listeners (ie. using handleEvent). ++ * @param {(boolean|null|undefined)} once If true, the listener will remove itself after the first time it is triggered. ++ * @param {*} data Arbitrary data that will be included as the second parameter when the listener is called. ++ * @param {(boolean|null|undefined)} useCapture For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. ++ * @see [EventDispatcher] ++ * @returns {(Function|null)} Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener. ++ */ ++createjs.EventDispatcher.on = function (type, listener, scope, once, data, useCapture) { return null; } ++ ++ /** ++ * @see [EventDispatcher] ++ * @returns {(string|null)} a string representation of the instance. ++ */ ++createjs.EventDispatcher.toString = function () { return null; } ++ ++ /** ++ * Indicates whether there is at least one listener for the specified event type. ++ * ++ * @param {(string|null)} type The string type of the event. ++ * @see [EventDispatcher] ++ * @returns {(boolean|null)} Returns true if there is at least one listener for the specified event. ++ */ ++createjs.EventDispatcher.hasEventListener = function (type) { return null; } + +-// namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; +- +- +-// constructor: +- /** +- * EventDispatcher provides methods for managing queues of event listeners and dispatching events. +- * +- * You can either extend EventDispatcher or mix its methods into an existing prototype or instance by using the +- * EventDispatcher {{#crossLink "EventDispatcher/initialize"}}{{/crossLink}} method. +- * +- * Together with the CreateJS Event class, EventDispatcher provides an extended event model that is based on the +- * DOM Level 2 event model, including addEventListener, removeEventListener, and dispatchEvent. It supports +- * bubbling / capture, preventDefault, stopPropagation, stopImmediatePropagation, and handleEvent. +- * +- * EventDispatcher also exposes a {{#crossLink "EventDispatcher/on"}}{{/crossLink}} method, which makes it easier +- * to create scoped listeners, listeners that only run once, and listeners with associated arbitrary data. The +- * {{#crossLink "EventDispatcher/off"}}{{/crossLink}} method is merely an alias to +- * {{#crossLink "EventDispatcher/removeEventListener"}}{{/crossLink}}. +- * +- * Another addition to the DOM Level 2 model is the {{#crossLink "EventDispatcher/removeAllEventListeners"}}{{/crossLink}} +- * method, which can be used to listeners for all events, or listeners for a specific event. The Event object also +- * includes a {{#crossLink "Event/remove"}}{{/crossLink}} method which removes the active listener. +- * +- * <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 /> +- * Scope (ie. "this") can be be a challenge with events. Using the {{#crossLink "EventDispatcher/on"}}{{/crossLink}} +- * method to subscribe to events simplifies this. +- * +- * instance.addEventListener("click", function(event) { +- * console.log(instance == this); // false, scope is ambiguous. +- * }); +- * +- * instance.on("click", function(event) { +- * console.log(instance == this); // true, "on" uses dispatcher scope by default. +- * }); +- * +- * If you want to use addEventListener instead, you may want to use function.bind() or a similar proxy to manage scope. +- * +- * +- * @class EventDispatcher +- * @constructor +- **/ +- function EventDispatcher() { +- +- +- // private properties: +- /** +- * @protected +- * @property _listeners +- * @type Object +- **/ +- this._listeners = null; +- +- /** +- * @protected +- * @property _captureListeners +- * @type Object +- **/ +- this._captureListeners = null; +- } +- var p = EventDispatcher.prototype; +- +- /** +- * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +- * See {{#crossLink "Utility Methods/extend"}}{{/crossLink}} and {{#crossLink "Utility Methods/promote"}}{{/crossLink}} +- * for details. +- * +- * There is an inheritance tutorial distributed with EaselJS in /tutorials/Inheritance. +- * +- * @method initialize +- * @protected +- * @deprecated +- */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. +- +- +-// static public methods: +- /** +- * Static initializer to mix EventDispatcher methods into a target object or prototype. +- * +- * EventDispatcher.initialize(MyClass.prototype); // add to the prototype of the class +- * EventDispatcher.initialize(myObject); // add to a specific instance +- * +- * @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.on = p.on; +- target.removeEventListener = target.off = p.removeEventListener; +- target.removeAllEventListeners = p.removeAllEventListeners; +- target.hasEventListener = p.hasEventListener; +- target.dispatchEvent = p.dispatchEvent; +- target._dispatchEvent = p._dispatchEvent; +- target.willTrigger = p.willTrigger; +- }; +- +- +-// public methods: +- /** +- * Adds the specified event listener. Note that adding multiple listeners to the same function will result in +- * multiple callbacks getting fired. +- * +- * <h4>Example</h4> +- * +- * displayObject.addEventListener("click", handleClick); +- * function handleClick(event) { +- * // Click happened. +- * } +- * +- * @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. +- * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. +- * @return {Function | Object} Returns the listener for chaining or assignment. +- **/ +- p.addEventListener = function(type, listener, useCapture) { +- var listeners; +- if (useCapture) { +- listeners = this._captureListeners = this._captureListeners||{}; +- } else { +- listeners = this._listeners = this._listeners||{}; +- } +- var arr = listeners[type]; +- if (arr) { this.removeEventListener(type, listener, useCapture); } +- arr = listeners[type]; // remove may have deleted the array +- if (!arr) { listeners[type] = [listener]; } +- else { arr.push(listener); } +- return listener; +- }; +- +- /** +- * A shortcut method for using addEventListener that makes it easier to specify an execution scope, have a listener +- * only run once, associate arbitrary data with the listener, and remove the listener. +- * +- * This method works by creating an anonymous wrapper function and subscribing it with addEventListener. +- * The created anonymous function is returned for use with .removeEventListener (or .off). +- * +- * <h4>Example</h4> +- * +- * var listener = myBtn.on("click", handleClick, null, false, {count:3}); +- * function handleClick(evt, data) { +- * data.count -= 1; +- * console.log(this == myBtn); // true - scope defaults to the dispatcher +- * if (data.count == 0) { +- * alert("clicked 3 times!"); +- * myBtn.off("click", listener); +- * // alternately: evt.remove(); +- * } +- * } +- * +- * @method on +- * @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. +- * @param {Object} [scope] The scope to execute the listener in. Defaults to the dispatcher/currentTarget for function listeners, and to the listener itself for object listeners (ie. using handleEvent). +- * @param {Boolean} [once=false] If true, the listener will remove itself after the first time it is triggered. +- * @param {*} [data] Arbitrary data that will be included as the second parameter when the listener is called. +- * @param {Boolean} [useCapture=false] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. +- * @return {Function} Returns the anonymous function that was created and assigned as the listener. This is needed to remove the listener later using .removeEventListener. +- **/ +- p.on = function(type, listener, scope, once, data, useCapture) { +- if (listener.handleEvent) { +- scope = scope||listener; +- listener = listener.handleEvent; +- } +- scope = scope||this; +- return this.addEventListener(type, function(evt) { +- listener.call(scope, evt, data); +- once&&evt.remove(); +- }, useCapture); +- }; +- +- /** +- * Removes the specified event listener. +- * +- * <b>Important Note:</b> that you must pass the exact function reference used when the event was added. If a proxy +- * function, or function closure is used as the callback, the proxy/closure reference must be used - a new proxy or +- * closure will not work. +- * +- * <h4>Example</h4> +- * +- * displayObject.removeEventListener("click", handleClick); +- * +- * @method removeEventListener +- * @param {String} type The string type of the event. +- * @param {Function | Object} listener The listener function or object. +- * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. +- **/ +- p.removeEventListener = function(type, listener, useCapture) { +- var listeners = useCapture ? this._captureListeners : 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; +- } +- } +- }; +- +- /** +- * A shortcut to the removeEventListener method, with the same parameters and return value. This is a companion to the +- * .on method. +- * +- * @method off +- * @param {String} type The string type of the event. +- * @param {Function | Object} listener The listener function or object. +- * @param {Boolean} [useCapture] For events that bubble, indicates whether to listen for the event in the capture or bubbling/target phase. +- **/ +- p.off = p.removeEventListener; +- +- /** +- * Removes all listeners for the specified type, or all listeners of all types. +- * +- * <h4>Example</h4> +- * +- * // Remove all listeners +- * displayObject.removeAllEventListeners(); +- * +- * // Remove all click listeners +- * displayObject.removeAllEventListeners("click"); +- * +- * @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 = this._captureListeners = null; } +- else { +- if (this._listeners) { delete(this._listeners[type]); } +- if (this._captureListeners) { delete(this._captureListeners[type]); } +- } +- }; +- +- /** +- * Dispatches the specified event to all listeners. +- * +- * <h4>Example</h4> +- * +- * // Use a string event +- * this.dispatchEvent("complete"); +- * +- * // Use an Event instance +- * var event = new createjs.Event("progress"); +- * this.dispatchEvent(event); +- * +- * @method dispatchEvent +- * @param {Object | String | Event} eventObj An object with a "type" property, or a string type. +- * While a generic object will work, it is recommended to use a CreateJS Event instance. If a string is used, +- * dispatchEvent will construct an Event instance with the specified type. +- * @return {Boolean} Returns the value of eventObj.defaultPrevented. +- **/ +- p.dispatchEvent = function(eventObj) { +- if (typeof eventObj == "string") { +- // won't bubble, so skip everything if there's no listeners: +- var listeners = this._listeners; +- if (!listeners || !listeners[eventObj]) { return false; } +- eventObj = new createjs.Event(eventObj); +- } else if (eventObj.target && eventObj.clone) { +- // redispatching an active event object, so clone it: +- eventObj = eventObj.clone(); +- } +- try { eventObj.target = this; } catch (e) {} // try/catch allows redispatching of native events +- +- if (!eventObj.bubbles || !this.parent) { +- this._dispatchEvent(eventObj, 2); +- } else { +- var top=this, list=[top]; +- while (top.parent) { list.push(top = top.parent); } +- var i, l=list.length; +- +- // capture & atTarget +- for (i=l-1; i>=0 && !eventObj.propagationStopped; i--) { +- list[i]._dispatchEvent(eventObj, 1+(i==0)); +- } +- // bubbling +- for (i=1; i<l && !eventObj.propagationStopped; i++) { +- list[i]._dispatchEvent(eventObj, 3); +- } +- } +- return eventObj.defaultPrevented; +- }; +- +- /** +- * 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, captureListeners = this._captureListeners; +- return !!((listeners && listeners[type]) || (captureListeners && captureListeners[type])); +- }; +- +- /** +- * Indicates whether there is at least one listener for the specified event type on this object or any of its +- * ancestors (parent, parent's parent, etc). A return value of true indicates that if a bubbling event of the +- * specified type is dispatched from this object, it will trigger at least one listener. +- * +- * This is similar to {{#crossLink "EventDispatcher/hasEventListener"}}{{/crossLink}}, but it searches the entire +- * event flow for a listener, not just this object. +- * @method willTrigger +- * @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.willTrigger = function(type) { +- var o = this; +- while (o) { +- if (o.hasEventListener(type)) { return true; } +- o = o.parent; +- } +- return false; +- }; +- +- /** +- * @method toString +- * @return {String} a string representation of the instance. +- **/ +- p.toString = function() { +- return "[EventDispatcher]"; +- }; +- +- +-// private methods: +- /** +- * @method _dispatchEvent +- * @param {Object | String | Event} eventObj +- * @param {Object} eventPhase +- * @protected +- **/ +- p._dispatchEvent = function(eventObj, eventPhase) { +- var l, listeners = (eventPhase==1) ? this._captureListeners : this._listeners; +- if (eventObj && listeners) { +- var arr = listeners[eventObj.type]; +- if (!arr||!(l=arr.length)) { return; } +- try { eventObj.currentTarget = this; } catch (e) {} +- try { eventObj.eventPhase = eventPhase; } catch (e) {} +- eventObj.removed = false; +- +- arr = arr.slice(); // to avoid issues with items being removed or added during the dispatch +- for (var i=0; i<l && !eventObj.immediatePropagationStopped; i++) { +- var o = arr[i]; +- if (o.handleEvent) { o.handleEvent(eventObj); } +- else { o(eventObj); } +- if (eventObj.removed) { +- this.off(eventObj.type, o, eventPhase==1); +- eventObj.removed = false; +- } +- } +- } +- }; +- +- +- createjs.EventDispatcher = EventDispatcher; +-}()); +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js +index 3c5c4a6..ad87beb 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/Ticker.js +@@ -1,632 +1,182 @@ +-/* +-* Ticker +-* 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. +-*/ +- +-/** +- * @module CreateJS ++/** @fileoverview Auto-generated Externs files ++ * @externs + */ ++/** ++ * The Ticker provides a centralized tick or heartbeat broadcast at a set interval. Listeners can subscribe to the tick ++ * event to be notified when a set time interval has elapsed. ++ * ++ * Note that the interval that the tick event is called is a target interval, and may be broadcast at a slower interval ++ * when under high CPU load. The Ticker class uses a static interface (ex. `createjs.Ticker.framerate = 30;`) and ++ * can not be instantiated. ++ * ++ * <h4>Example</h4> ++ * ++ * createjs.createjs.Ticker.addEventListener("tick", handleTick); ++ * function handleTick(event) { ++ * // Actions carried out each tick (aka frame) ++ * if (!event.paused) { ++ * // Actions carried out when the Ticker is not paused. ++ * } ++ * } ++ * ++ * @see [Ticker] ++ * @constructor */ ++createjs.Ticker = function () {} ++ ++ /** ++ * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. ++ * ++ * @param {(number|null)} value ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.setFPS = function (value) { } ++ ++ /** ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._setupTick = function () { } ++ ++ /** ++ * Generated doc for missing method JSDoc. ++ * ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.addEventListener = function (type, handler) { } ++ ++ /** ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._handleRAF = function () { } ++ ++ /** ++ * Starts the tick. This is called automatically when the first listener is added. ++ * ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.init = function () { } ++ ++ /** ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._handleTimeout = function () { } ++ ++ /** ++ * Similar to getTime(), but returns the time on the most recent tick event object. ++ * ++ * @param runTime {Boolean} [runTime=false] If true, the runTime property will be returned instead of time. ++ * @see [Ticker] ++ * @returns {number} The time or runTime property from the most recent tick event or -1. ++ */ ++createjs.Ticker.prototype.getEventTime = function (runTime) { return 0; } ++ ++ /** ++ * Use the {{#crossLink "Ticker/paused:property"}}{{/crossLink}} property instead. ++ * ++ * @param {(boolean|null)} value ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.setPaused = function (value) { } ++ ++ /** ++ * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. ++ * ++ * @see [Ticker] ++ * @returns {(number|null)} ++ */ ++createjs.Ticker.prototype.getInterval = function () { return 0; } ++ ++ /** ++ * Use the {{#crossLink "Ticker/paused:property"}}{{/crossLink}} property instead. ++ * ++ * @see [Ticker] ++ * @returns {(boolean|null)} ++ */ ++createjs.Ticker.prototype.getPaused = function () { return null; } ++ ++ /** ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._handleSynch = function () { } ++ ++ /** ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._tick = function () { } ++ ++ /** ++ * Returns the actual frames / ticks per second. ++ * ++ * @param {(number|null|undefined)} ticks The number of previous ticks over which to measure the actual frames / ticks per second. Defaults to the number of ticks per second. ++ * @see [Ticker] ++ * @returns {(number|null)} The actual frames / ticks per second. Depending on performance, this may differ from the target frames per second. ++ */ ++createjs.Ticker.prototype.getMeasuredFPS = function (ticks) { return 0; } ++ ++ /** ++ * Returns the number of milliseconds that have elapsed since Ticker was initialized via {{#crossLink "Ticker/init"}}. ++ * Returns -1 if Ticker has not been initialized. For example, you could use ++ * this in a time synchronized animation to determine the exact amount of time that has elapsed. ++ * ++ * @param {(boolean|null|undefined)} runTime If true only time elapsed while Ticker was not paused will be returned. If false, the value returned will be total time elapsed since the first tick event listener was added. ++ * @see [Ticker] ++ * @returns {(number|null)} Number of milliseconds that have elapsed since Ticker was initialized or -1. ++ */ ++createjs.Ticker.prototype.getTime = function (runTime) { return 0; } ++ ++ /** ++ * Returns the average time spent within a tick. This can vary significantly from the value provided by getMeasuredFPS ++ * because it only measures the time spent within the tick execution stack. ++ * ++ * Example 1: With a target FPS of 20, getMeasuredFPS() returns 20fps, which indicates an average of 50ms between ++ * the end of one tick and the end of the next. However, getMeasuredTickTime() returns 15ms. This indicates that ++ * there may be up to 35ms of "idle" time between the end of one tick and the start of the next. ++ * ++ * Example 2: With a target FPS of 30, getFPS() returns 10fps, which indicates an average of 100ms between the end of ++ * one tick and the end of the next. However, getMeasuredTickTime() returns 20ms. This would indicate that something ++ * other than the tick is using ~80ms (another script, DOM rendering, etc). ++ * ++ * @param {(number|null|undefined)} ticks The number of previous ticks over which to measure the average time spent in a tick. Defaults to the number of ticks per second. To get only the last tick's time, pass in 1. ++ * @see [Ticker] ++ * @returns {(number|null)} The average time spent in a tick in milliseconds. ++ */ ++createjs.Ticker.prototype.getMeasuredTickTime = function (ticks) { return 0; } ++ ++ /** ++ * Generated doc for missing method JSDoc. ++ * ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype._getTime = function () { } ++ ++ /** ++ * Stops the Ticker and removes all listeners. Use init() to restart the createjs.Ticker. ++ * ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.reset = function () { } ++ ++ /** ++ * Returns the number of ticks that have been broadcast by createjs.Ticker. ++ * ++ * @param {(boolean|null)} pauseable Indicates whether to include ticks that would have been broadcast while Ticker was paused. If true only tick events broadcast while Ticker is not paused will be returned. If false, tick events that would have been broadcast while Ticker was paused will be included in the return value. The default value is false. ++ * @see [Ticker] ++ * @returns {(number|null)} of ticks that have been broadcast. ++ */ ++createjs.Ticker.prototype.getTicks = function (pauseable) { return 0; } ++ ++ /** ++ * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. ++ * ++ * @see [Ticker] ++ * @returns {(number|null)} ++ */ ++createjs.Ticker.prototype.getFPS = function () { return 0; } ++ ++ /** ++ * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. ++ * ++ * @param {(number|null)} interval ++ * @see [Ticker] ++ */ ++createjs.Ticker.prototype.setInterval = function (interval) { } + +-// namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; +- +- +-// constructor: +- /** +- * The Ticker provides a centralized tick or heartbeat broadcast at a set interval. Listeners can subscribe to the tick +- * event to be notified when a set time interval has elapsed. +- * +- * Note that the interval that the tick event is called is a target interval, and may be broadcast at a slower interval +- * when under high CPU load. The Ticker class uses a static interface (ex. `Ticker.framerate = 30;`) and +- * can not be instantiated. +- * +- * <h4>Example</h4> +- * +- * createjs.Ticker.addEventListener("tick", handleTick); +- * function handleTick(event) { +- * // Actions carried out each tick (aka frame) +- * if (!event.paused) { +- * // Actions carried out when the Ticker is not paused. +- * } +- * } +- * +- * @class Ticker +- * @uses EventDispatcher +- * @static +- **/ +- function Ticker() { +- throw "Ticker cannot be instantiated."; +- } +- +- +-// constants: +- /** +- * In this mode, Ticker uses the requestAnimationFrame API, but attempts to synch the ticks to target framerate. It +- * uses a simple heuristic that compares the time of the RAF return to the target time for the current frame and +- * dispatches the tick when the time is within a certain threshold. +- * +- * This mode has a higher variance for time between frames than TIMEOUT, but does not require that content be time +- * based as with RAF while gaining the benefits of that API (screen synch, background throttling). +- * +- * Variance is usually lowest for framerates that are a divisor of the RAF frequency. This is usually 60, so +- * framerates of 10, 12, 15, 20, and 30 work well. +- * +- * Falls back on TIMEOUT if the requestAnimationFrame API is not supported. +- * @property RAF_SYNCHED +- * @static +- * @type {String} +- * @default "synched" +- * @readonly +- **/ +- Ticker.RAF_SYNCHED = "synched"; +- +- /** +- * In this mode, Ticker passes through the requestAnimationFrame heartbeat, ignoring the target framerate completely. +- * Because requestAnimationFrame frequency is not deterministic, any content using this mode should be time based. +- * You can leverage {{#crossLink "Ticker/getTime"}}{{/crossLink}} and the tick event object's "delta" properties +- * to make this easier. +- * +- * Falls back on TIMEOUT if the requestAnimationFrame API is not supported. +- * @property RAF +- * @static +- * @type {String} +- * @default "raf" +- * @readonly +- **/ +- Ticker.RAF = "raf"; +- +- /** +- * In this mode, Ticker uses the setTimeout API. This provides predictable, adaptive frame timing, but does not +- * provide the benefits of requestAnimationFrame (screen synch, background throttling). +- * @property TIMEOUT +- * @static +- * @type {String} +- * @default "timer" +- * @readonly +- **/ +- Ticker.TIMEOUT = "timeout"; +- +- +-// static events: +- /** +- * Dispatched each tick. The event will be dispatched to each listener even when the Ticker has been paused using +- * {{#crossLink "Ticker/setPaused"}}{{/crossLink}}. +- * +- * <h4>Example</h4> +- * +- * createjs.Ticker.addEventListener("tick", handleTick); +- * function handleTick(event) { +- * console.log("Paused:", event.paused, event.delta); +- * } +- * +- * @event tick +- * @param {Object} target The object that dispatched the event. +- * @param {String} type The event type. +- * @param {Boolean} paused Indicates whether the ticker is currently paused. +- * @param {Number} delta The time elapsed in ms since the last tick. +- * @param {Number} time The total time in ms since Ticker was initialized. +- * @param {Number} runTime The total time in ms that Ticker was not paused since it was initialized. For example, +- * you could determine the amount of time that the Ticker has been paused since initialization with time-runTime. +- * @since 0.6.0 +- */ +- +- +-// public static properties: +- /** +- * Deprecated in favour of {{#crossLink "Ticker/timingMode"}}{{/crossLink}}, and will be removed in a future version. If true, timingMode will +- * use {{#crossLink "Ticker/RAF_SYNCHED"}}{{/crossLink}} by default. +- * @deprecated Deprecated in favour of {{#crossLink "Ticker/timingMode"}}{{/crossLink}}. +- * @property useRAF +- * @static +- * @type {Boolean} +- * @default false +- **/ +- Ticker.useRAF = false; +- +- /** +- * Specifies the timing api (setTimeout or requestAnimationFrame) and mode to use. See +- * {{#crossLink "Ticker/TIMEOUT"}}{{/crossLink}}, {{#crossLink "Ticker/RAF"}}{{/crossLink}}, and +- * {{#crossLink "Ticker/RAF_SYNCHED"}}{{/crossLink}} for mode details. +- * @property timingMode +- * @static +- * @type {String} +- * @default Ticker.TIMEOUT +- **/ +- Ticker.timingMode = null; +- +- /** +- * Specifies a maximum value for the delta property in the tick event object. This is useful when building time +- * based animations and systems to prevent issues caused by large time gaps caused by background tabs, system sleep, +- * alert dialogs, or other blocking routines. Double the expected frame duration is often an effective value +- * (ex. maxDelta=50 when running at 40fps). +- * +- * This does not impact any other values (ex. time, runTime, etc), so you may experience issues if you enable maxDelta +- * when using both delta and other values. +- * +- * If 0, there is no maximum. +- * @property maxDelta +- * @static +- * @type {number} +- * @default 0 +- */ +- Ticker.maxDelta = 0; +- +- /** +- * When the ticker is paused, all listeners will still receive a tick event, but the <code>paused</code> property of the event will be false. +- * Also, while paused the `runTime` will not increase. See {{#crossLink "Ticker/tick:event"}}{{/crossLink}}, +- * {{#crossLink "Ticker/getTime"}}{{/crossLink}}, and {{#crossLink "Ticker/getEventTime"}}{{/crossLink}} for more info. +- * +- * <h4>Example</h4> +- * +- * createjs.Ticker.addEventListener("tick", handleTick); +- * createjs.Ticker.paused = true; +- * function handleTick(event) { +- * console.log(event.paused, +- * createjs.Ticker.getTime(false), +- * createjs.Ticker.getTime(true)); +- * } +- * +- * @property paused +- * @static +- * @type {Boolean} +- * @default false +- **/ +- Ticker.paused = false; +- +- +-// mix-ins: +- // EventDispatcher methods: +- Ticker.removeEventListener = null; +- Ticker.removeAllEventListeners = null; +- Ticker.dispatchEvent = null; +- Ticker.hasEventListener = null; +- Ticker._listeners = null; +- createjs.EventDispatcher.initialize(Ticker); // inject EventDispatcher methods. +- Ticker._addEventListener = Ticker.addEventListener; +- Ticker.addEventListener = function() { +- !Ticker._inited&&Ticker.init(); +- return Ticker._addEventListener.apply(Ticker, arguments); +- }; +- +- +-// private static properties: +- /** +- * @property _inited +- * @static +- * @type {Boolean} +- * @protected +- **/ +- Ticker._inited = false; +- +- /** +- * @property _startTime +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._startTime = 0; +- +- /** +- * @property _pausedTime +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._pausedTime=0; +- +- /** +- * The number of ticks that have passed +- * @property _ticks +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._ticks = 0; +- +- /** +- * The number of ticks that have passed while Ticker has been paused +- * @property _pausedTicks +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._pausedTicks = 0; +- +- /** +- * @property _interval +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._interval = 50; +- +- /** +- * @property _lastTime +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._lastTime = 0; +- +- /** +- * @property _times +- * @static +- * @type {Array} +- * @protected +- **/ +- Ticker._times = null; +- +- /** +- * @property _tickTimes +- * @static +- * @type {Array} +- * @protected +- **/ +- Ticker._tickTimes = null; +- +- /** +- * Stores the timeout or requestAnimationFrame id. +- * @property _timerId +- * @static +- * @type {Number} +- * @protected +- **/ +- Ticker._timerId = null; +- +- /** +- * True if currently using requestAnimationFrame, false if using setTimeout. This may be different than timingMode +- * if that property changed and a tick hasn't fired. +- * @property _raf +- * @static +- * @type {Boolean} +- * @protected +- **/ +- Ticker._raf = true; +- +- +-// static getter / setters: +- /** +- * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. +- * @method setInterval +- * @static +- * @param {Number} interval +- * @deprecated +- **/ +- Ticker.setInterval = function(interval) { +- Ticker._interval = interval; +- if (!Ticker._inited) { return; } +- Ticker._setupTick(); +- }; +- +- /** +- * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. +- * @method getInterval +- * @static +- * @return {Number} +- * @deprecated +- **/ +- Ticker.getInterval = function() { +- return Ticker._interval; +- }; +- +- /** +- * Use the {{#crossLink "Ticker/framerate:property"}}{{/crossLink}} property instead. +- * @method setFPS +- * @static +- * @param {Number} value +- * @deprecated +- **/ +- Ticker.setFPS = function(value) { +- Ticker.setInterval(1000/value); +- }; +- +- /** +- * Use the {{#crossLink "Ticker/interval:property"}}{{/crossLink}} property instead. +- * @method getFPS +- * @static +- * @return {Number} +- * @deprecated +- **/ +- Ticker.getFPS = function() { +- return 1000/Ticker._interval; +- }; +- +- /** +- * Indicates the target time (in milliseconds) between ticks. Default is 50 (20 FPS). +- * Note that actual time between ticks may be more than specified depending on CPU load. +- * This property is ignored if the ticker is using the `RAF` timing mode. +- * @property interval +- * @static +- * @type {Number} +- **/ +- +- /** +- * Indicates the target frame rate in frames per second (FPS). Effectively just a shortcut to `interval`, where +- * `framerate == 1000/interval`. +- * @property framerate +- * @static +- * @type {Number} +- **/ +- try { +- Object.defineProperties(Ticker, { +- interval: { get: Ticker.getInterval, set: Ticker.setInterval }, +- framerate: { get: Ticker.getFPS, set: Ticker.setFPS } +- }); +- } catch (e) { console.log(e); } +- +- +-// public static methods: +- /** +- * Starts the tick. This is called automatically when the first listener is added. +- * @method init +- * @static +- **/ +- Ticker.init = function() { +- if (Ticker._inited) { return; } +- Ticker._inited = true; +- Ticker._times = []; +- Ticker._tickTimes = []; +- Ticker._startTime = Ticker._getTime(); +- Ticker._times.push(Ticker._lastTime = 0); +- Ticker.interval = Ticker._interval; +- }; +- +- /** +- * Stops the Ticker and removes all listeners. Use init() to restart the Ticker. +- * @method reset +- * @static +- **/ +- Ticker.reset = function() { +- if (Ticker._raf) { +- var f = window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame; +- f&&f(Ticker._timerId); +- } else { +- clearTimeout(Ticker._timerId); +- } +- Ticker.removeAllEventListeners("tick"); +- Ticker._timerId = Ticker._times = Ticker._tickTimes = null; +- Ticker._startTime = Ticker._lastTime = Ticker._ticks = 0; +- Ticker._inited = false; +- }; +- +- /** +- * Returns the average time spent within a tick. This can vary significantly from the value provided by getMeasuredFPS +- * because it only measures the time spent within the tick execution stack. +- * +- * Example 1: With a target FPS of 20, getMeasuredFPS() returns 20fps, which indicates an average of 50ms between +- * the end of one tick and the end of the next. However, getMeasuredTickTime() returns 15ms. This indicates that +- * there may be up to 35ms of "idle" time between the end of one tick and the start of the next. +- * +- * Example 2: With a target FPS of 30, getFPS() returns 10fps, which indicates an average of 100ms between the end of +- * one tick and the end of the next. However, getMeasuredTickTime() returns 20ms. This would indicate that something +- * other than the tick is using ~80ms (another script, DOM rendering, etc). +- * @method getMeasuredTickTime +- * @static +- * @param {Number} [ticks] The number of previous ticks over which to measure the average time spent in a tick. +- * Defaults to the number of ticks per second. To get only the last tick's time, pass in 1. +- * @return {Number} The average time spent in a tick in milliseconds. +- **/ +- Ticker.getMeasuredTickTime = function(ticks) { +- var ttl=0, times=Ticker._tickTimes; +- if (!times || times.length < 1) { return -1; } +- +- // by default, calculate average for the past ~1 second: +- ticks = Math.min(times.length, ticks||(Ticker.getFPS()|0)); +- for (var i=0; i<ticks; i++) { ttl += times[i]; } +- return ttl/ticks; +- }; +- +- /** +- * Returns the actual frames / ticks per second. +- * @method getMeasuredFPS +- * @static +- * @param {Number} [ticks] The number of previous ticks over which to measure the actual frames / ticks per second. +- * Defaults to the number of ticks per second. +- * @return {Number} The actual frames / ticks per second. Depending on performance, this may differ +- * from the target frames per second. +- **/ +- Ticker.getMeasuredFPS = function(ticks) { +- var times = Ticker._times; +- if (!times || times.length < 2) { return -1; } +- +- // by default, calculate fps for the past ~1 second: +- ticks = Math.min(times.length-1, ticks||(Ticker.getFPS()|0)); +- return 1000/((times[0]-times[ticks])/ticks); +- }; +- +- /** +- * Use the {{#crossLink "Ticker/paused:property"}}{{/crossLink}} property instead. +- * @method setPaused +- * @static +- * @param {Boolean} value +- * @deprecated +- **/ +- Ticker.setPaused = function(value) { +- // TODO: deprecated. +- Ticker.paused = value; +- }; +- +- /** +- * Use the {{#crossLink "Ticker/paused:property"}}{{/crossLink}} property instead. +- * @method getPaused +- * @static +- * @return {Boolean} +- * @deprecated +- **/ +- Ticker.getPaused = function() { +- // TODO: deprecated. +- return Ticker.paused; +- }; +- +- /** +- * Returns the number of milliseconds that have elapsed since Ticker was initialized via {{#crossLink "Ticker/init"}}. +- * Returns -1 if Ticker has not been initialized. For example, you could use +- * this in a time synchronized animation to determine the exact amount of time that has elapsed. +- * @method getTime +- * @static +- * @param {Boolean} [runTime=false] If true only time elapsed while Ticker was not paused will be returned. +- * If false, the value returned will be total time elapsed since the first tick event listener was added. +- * @return {Number} Number of milliseconds that have elapsed since Ticker was initialized or -1. +- **/ +- Ticker.getTime = function(runTime) { +- return Ticker._startTime ? Ticker._getTime() - (runTime ? Ticker._pausedTime : 0) : -1; +- }; +- +- /** +- * Similar to getTime(), but returns the time on the most recent tick event object. +- * @method getEventTime +- * @static +- * @param runTime {Boolean} [runTime=false] If true, the runTime property will be returned instead of time. +- * @returns {number} The time or runTime property from the most recent tick event or -1. +- */ +- Ticker.getEventTime = function(runTime) { +- return Ticker._startTime ? (Ticker._lastTime || Ticker._startTime) - (runTime ? Ticker._pausedTime : 0) : -1; +- }; +- +- /** +- * Returns the number of ticks that have been broadcast by Ticker. +- * @method getTicks +- * @static +- * @param {Boolean} pauseable Indicates whether to include ticks that would have been broadcast +- * while Ticker was paused. If true only tick events broadcast while Ticker is not paused will be returned. +- * If false, tick events that would have been broadcast while Ticker was paused will be included in the return +- * value. The default value is false. +- * @return {Number} of ticks that have been broadcast. +- **/ +- Ticker.getTicks = function(pauseable) { +- return Ticker._ticks - (pauseable ? Ticker._pausedTicks : 0); +- }; +- +- +-// private static methods: +- /** +- * @method _handleSynch +- * @static +- * @protected +- **/ +- Ticker._handleSynch = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); +- +- // run if enough time has elapsed, with a little bit of flexibility to be early: +- if (Ticker._getTime() - Ticker._lastTime >= (Ticker._interval-1)*0.97) { +- Ticker._tick(); +- } +- }; +- +- /** +- * @method _handleRAF +- * @static +- * @protected +- **/ +- Ticker._handleRAF = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); +- Ticker._tick(); +- }; +- +- /** +- * @method _handleTimeout +- * @static +- * @protected +- **/ +- Ticker._handleTimeout = function() { +- Ticker._timerId = null; +- Ticker._setupTick(); +- Ticker._tick(); +- }; +- +- /** +- * @method _setupTick +- * @static +- * @protected +- **/ +- Ticker._setupTick = function() { +- if (Ticker._timerId != null) { return; } // avoid duplicates +- +- var mode = Ticker.timingMode||(Ticker.useRAF&&Ticker.RAF_SYNCHED); +- if (mode == Ticker.RAF_SYNCHED || mode == Ticker.RAF) { +- var f = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame; +- if (f) { +- Ticker._timerId = f(mode == Ticker.RAF ? Ticker._handleRAF : Ticker._handleSynch); +- Ticker._raf = true; +- return; +- } +- } +- Ticker._raf = false; +- Ticker._timerId = setTimeout(Ticker._handleTimeout, Ticker._interval); +- }; +- +- /** +- * @method _tick +- * @static +- * @protected +- **/ +- Ticker._tick = function() { +- var paused = Ticker.paused; +- var time = Ticker._getTime(); +- var elapsedTime = time-Ticker._lastTime; +- Ticker._lastTime = time; +- Ticker._ticks++; +- +- if (paused) { +- Ticker._pausedTicks++; +- Ticker._pausedTime += elapsedTime; +- } +- +- if (Ticker.hasEventListener("tick")) { +- var event = new createjs.Event("tick"); +- var maxDelta = Ticker.maxDelta; +- event.delta = (maxDelta && elapsedTime > maxDelta) ? maxDelta : elapsedTime; +- event.paused = paused; +- event.time = time; +- event.runTime = time-Ticker._pausedTime; +- Ticker.dispatchEvent(event); +- } +- +- Ticker._tickTimes.unshift(Ticker._getTime()-time); +- while (Ticker._tickTimes.length > 100) { Ticker._tickTimes.pop(); } +- +- Ticker._times.unshift(time); +- while (Ticker._times.length > 100) { Ticker._times.pop(); } +- }; +- +- /** +- * @method _getTime +- * @static +- * @protected +- **/ +- var now = window.performance && (performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow); +- Ticker._getTime = function() { +- return ((now&&now.call(performance))||(new Date().getTime())) - Ticker._startTime; +- }; +- +- +- createjs.Ticker = Ticker; +-}()); +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js +index 690de15..9bf84cb 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/extend.js +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -52,11 +52,11 @@ this.createjs = this.createjs||{}; + * + * @method extend + * @param {Function} subclass The subclass. +- * @param {Function} superclass The superclass to extend. ++ * @param {Function} superclass The superclass to createjs.extend. + * @return {Function} Returns the subclass's new prototype. + */ + createjs.extend = function(subclass, superclass) { +- "use strict"; ++ + + function o() { this.constructor = subclass; } + o.prototype = superclass.prototype; +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js +index 9719d4d..18b0bf0 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/indexOf.js +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -45,11 +45,11 @@ this.createjs = this.createjs||{}; + * + * @method indexOf + * @param {Array} array Array to search for searchElement +- * @param searchElement Element to find in array. ++ * @param {Object} searchElement Element to find in array. + * @return {Number} The first index of searchElement in array. + */ + createjs.indexOf = function (array, searchElement){ +- "use strict"; ++ + + for (var i = 0,l=array.length; i < l; i++) { + if (searchElement === array[i]) { +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js +index d09a381..4cdf289 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/createjs/utils/promote.js +@@ -31,7 +31,7 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; ++ + + /** + * @class Utility Methods +@@ -75,7 +75,7 @@ this.createjs = this.createjs||{}; + * @return {Function} Returns the subclass. + */ + createjs.promote = function(subclass, prefix) { +- "use strict"; ++ + + var subP = subclass.prototype, supP = (Object.getPrototypeOf&&Object.getPrototypeOf(subP))||subP.__proto__; + if (supP) { +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js +index eecac1a..99c556d 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/Bitmap.js +@@ -1,214 +1,34 @@ +-/* +-* Bitmap +-* 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. +-*/ +- ++/** @fileoverview Auto-generated Externs files ++ * @externs ++ */ + /** +-* @module EaselJS +-*/ ++ * A Bitmap represents an Image, Canvas, or Video in the display list. A Bitmap can be instantiated using an existing ++ * HTML element, or a string. ++ * ++ * <h4>Example</h4> ++ * ++ * var bitmap = new createjs.Bitmap("imagePath.jpg"); ++ * ++ * <strong>Notes:</strong> ++ * <ol> ++ * <li>When a string path or image tag that is not yet loaded is used, the stage may need to be redrawn before it ++ * will be displayed.</li> ++ * <li>Bitmaps with an SVG source currently will not respect an alpha value other than 0 or 1. To get around this, ++ * the Bitmap can be cached.</li> ++ * <li>Bitmaps with an SVG source will taint the canvas with cross-origin data, which prevents interactivity. This ++ * happens in all browsers except recent Firefox builds.</li> ++ * <li>Images loaded cross-origin will throw cross-origin security errors when interacted with using a mouse, using ++ * methods such as `getObjectUnderPoint`, or using filters, or caching. You can get around this by setting ++ * `crossOrigin` flags on your images before passing them to EaselJS, eg: `img.crossOrigin="Anonymous";`</li> ++ * </ol> ++ * ++ * @see [Bitmap] ++ * @constructor * @extends createjs.DisplayObject ++ */ ++createjs.Bitmap = function (imageOrUri) {} + +-// namespace: +-this.createjs = this.createjs||{}; + +-(function() { +- +- /** +- * A Bitmap represents an Image, Canvas, or Video in the display list. A Bitmap can be instantiated using an existing +- * HTML element, or a string. +- * +- * <h4>Example</h4> +- * +- * var bitmap = new createjs.Bitmap("imagePath.jpg"); +- * +- * <strong>Notes:</strong> +- * <ol> +- * <li>When a string path or image tag that is not yet loaded is used, the stage may need to be redrawn before it +- * will be displayed.</li> +- * <li>Bitmaps with an SVG source currently will not respect an alpha value other than 0 or 1. To get around this, +- * the Bitmap can be cached.</li> +- * <li>Bitmaps with an SVG source will taint the canvas with cross-origin data, which prevents interactivity. This +- * happens in all browsers except recent Firefox builds.</li> +- * <li>Images loaded cross-origin will throw cross-origin security errors when interacted with using a mouse, using +- * methods such as `getObjectUnderPoint`, or using filters, or caching. You can get around this by setting +- * `crossOrigin` flags on your images before passing them to EaselJS, eg: `img.crossOrigin="Anonymous";`</li> +- * </ol> +- * +- * @class Bitmap +- * @extends DisplayObject +- * @constructor +- * @param {Image | HTMLCanvasElement | HTMLVideoElement | String} imageOrUri The source object or URI to an image to +- * display. This can be either an Image, Canvas, or Video object, or a string URI to an image file to load and use. +- * If it is a URI, a new Image object will be constructed and assigned to the .image property. +- **/ +- function Bitmap(imageOrUri) { +- this.DisplayObject_constructor(); +- +- +- // public properties: +- /** +- * The image to render. This can be an Image, a Canvas, or a Video. Not all browsers (especially +- * mobile browsers) support drawing video to a canvas. +- * @property image +- * @type Image | HTMLCanvasElement | HTMLVideoElement +- **/ +- if (typeof imageOrUri == "string") { +- this.image = document.createElement("img"); +- this.image.src = imageOrUri; +- } else { +- this.image = imageOrUri; +- } +- +- /** +- * Specifies an area of the source image to draw. If omitted, the whole image will be drawn. +- * Note that video sources must have a width / height set to work correctly with `sourceRect`. +- * @property sourceRect +- * @type Rectangle +- * @default null +- */ +- this.sourceRect = null; +- } +- var p = createjs.extend(Bitmap, createjs.DisplayObject); +- +- +-// public methods: +- /** +- * Constructor alias for backwards compatibility. This method will be removed in future versions. +- * Subclasses should be updated to use {{#crossLink "Utility Methods/extends"}}{{/crossLink}}. +- * @method initialize +- * @deprecated in favour of `createjs.promote()` +- **/ +- p.initialize = Bitmap; // TODO: deprecated. + +- /** +- * Returns true or false indicating whether the display object would be visible if drawn to a canvas. +- * This does not account for whether it would be visible within the boundaries of the stage. +- * +- * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. +- * @method isVisible +- * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas +- **/ +- p.isVisible = function() { +- var hasContent = this.cacheCanvas || (this.image && (this.image.complete || this.image.getContext || this.image.readyState >= 2)); +- return !!(this.visible && this.alpha > 0 && this.scaleX != 0 && this.scaleY != 0 && hasContent); +- }; + +- /** +- * Draws the display object into the specified context ignoring its visible, alpha, shadow, and transform. +- * Returns true if the draw was handled (useful for overriding functionality). +- * +- * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. +- * @method draw +- * @param {CanvasRenderingContext2D} ctx The canvas 2D context object to draw into. +- * @param {Boolean} [ignoreCache=false] Indicates whether the draw operation should ignore any current cache. +- * For example, used for drawing the cache (to prevent it from simply drawing an existing cache back +- * into itself). +- * @return {Boolean} +- **/ +- p.draw = function(ctx, ignoreCache) { +- if (this.DisplayObject_draw(ctx, ignoreCache) || !this.image) { return true; } +- var img = this.image, rect = this.sourceRect; +- if (rect) { +- // some browsers choke on out of bound values, so we'll fix them: +- var x1 = rect.x, y1 = rect.y, x2 = x1 + rect.width, y2 = y1 + rect.height, x = 0, y = 0, w = img.width, h = img.height; +- if (x1 < 0) { x -= x1; x1 = 0; } +- if (x2 > w) { x2 = w; } +- if (y1 < 0) { y -= y1; y1 = 0; } +- if (y2 > h) { y2 = h; } +- ctx.drawImage(img, x1, y1, x2-x1, y2-y1, x, y, x2-x1, y2-y1); +- } else { +- ctx.drawImage(img, 0, 0); +- } +- return true; +- }; +- +- //Note, the doc sections below document using the specified APIs (from DisplayObject) from +- //Bitmap. This is why they have no method implementations. +- +- /** +- * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. +- * You should <b>not</b> cache Bitmap instances as it can degrade performance. +- * +- * <strong>However: If you want to use a filter on a Bitmap, you <em>MUST</em> cache it, or it will not work.</strong> +- * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} +- * method. +- * @method cache +- **/ +- +- /** +- * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. +- * You should <b>not</b> cache Bitmap instances as it can degrade performance. +- * +- * <strong>However: If you want to use a filter on a Bitmap, you <em>MUST</em> cache it, or it will not work.</strong> +- * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} +- * method. +- * @method updateCache +- **/ +- +- /** +- * Because the content of a Bitmap is already in a simple format, cache is unnecessary for Bitmap instances. +- * You should <b>not</b> cache Bitmap instances as it can degrade performance. +- * +- * <strong>However: If you want to use a filter on a Bitmap, you <em>MUST</em> cache it, or it will not work.</strong> +- * To see the API for caching, please visit the DisplayObject {{#crossLink "DisplayObject/cache"}}{{/crossLink}} +- * method. +- * @method uncache +- **/ + +- /** +- * Docced in superclass. +- */ +- p.getBounds = function() { +- var rect = this.DisplayObject_getBounds(); +- if (rect) { return rect; } +- var o = this.sourceRect || this.image; +- var hasContent = (this.image && (this.image.complete || this.image.getContext || this.image.readyState >= 2)); +- return hasContent ? this._rectangle.setValues(0, 0, o.width, o.height) : null; +- }; +- +- /** +- * Returns a clone of the Bitmap instance. +- * @method clone +- * @return {Bitmap} a clone of the Bitmap instance. +- **/ +- p.clone = function() { +- var o = new Bitmap(this.image); +- if (this.sourceRect) { o.sourceRect = this.sourceRect.clone(); } +- this._cloneProps(o); +- return o; +- }; +- +- /** +- * Returns a string representation of this object. +- * @method toString +- * @return {String} a string representation of the instance. +- **/ +- p.toString = function() { +- return "[Bitmap (name="+ this.name +")]"; +- }; + +- +- createjs.Bitmap = createjs.promote(Bitmap, "DisplayObject"); +-}()); +diff --git a/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js b/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js +index bad6f1c..60b3c83 100644 +--- a/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js ++++ b/externs/createjs/target/downloads/EaselJS-0.8.0/src/easeljs/display/BitmapText.js +@@ -1,343 +1,57 @@ +-/* +-* BitmapText +-* 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. +-*/ ++/** @fileoverview Auto-generated Externs files ++ * @externs ++ */ ++/** ++ * Displays text using bitmap glyphs defined in a sprite sheet. Multi-line text is supported ++ * using new line characters, but automatic wrapping is not supported. See the ++ * {{#crossLink "BitmapText/spriteSheet:property"}}{{/crossLink}} ++ * property for more information on defining glyphs. ++ * ++ * <strong>Important:</strong> BitmapText extends Container, but is not designed to be used as one. ++ * As such, methods like addChild and removeChild are disabled. ++ * ++ * @see [BitmapText] ++ * @constructor * @extends createjs.DisplayObject ++ */ ++createjs.BitmapText = function (text, spriteSheet) {} ++ ++ /** ++ * @param {(createjs.SpriteSheet|null)} ss ++ * @see [BitmapText] ++ * @returns {(number|null)} ++ */ ++createjs.BitmapText._getLineHeight = function (ss) { return 0; } ++ ++ ++ ++ ++ /** ++ * @param {(createjs.SpriteSheet|null)} ss ++ * @see [BitmapText] ++ * @returns {(number|null)} ++ */ ++createjs.BitmapText._getSpaceWidth = function (ss) { return 0; } ++ ++ ++ /** ++ * @param {(string|null)} character ++ * @param {(createjs.SpriteSheet|null)} spriteSheet ++ * @see [BitmapText] ++ * @returns {(number|null)} ++ */ ++createjs.BitmapText._getFrameIndex = function (character, spriteSheet) { return 0; } ++ ++ ++ /** ++ * @param {(string|null)} character ++ * @param {(createjs.SpriteSheet|null)} spriteSheet ++ * @see [BitmapText] ++ * @returns {(Object|null)} ++ */ ++createjs.BitmapText._getFrame = function (character, spriteSheet) { return null; } ++ ++ /** ++ * @see [BitmapText] ++ */ ++createjs.BitmapText._updateText = function () { } + +-this.createjs = this.createjs || {}; +- +-(function () { +- "use strict"; +- +- +-// constructor: +- /** +- * Displays text using bitmap glyphs defined in a sprite sheet. Multi-line text is supported +- * using new line characters, but automatic wrapping is not supported. See the +- * {{#crossLink "BitmapText/spriteSheet:property"}}{{/crossLink}} +- * property for more information on defining glyphs. +- * +- * <strong>Important:</strong> BitmapText extends Container, but is not designed to be used as one. +- * As such, methods like addChild and removeChild are disabled. +- * @class BitmapText +- * @extends DisplayObject +- * @param {String} [text=""] The text to display. +- * @param {SpriteSheet} [spriteSheet=null] The spritesheet that defines the character glyphs. +- * @constructor +- **/ +- function BitmapText(text, spriteSheet) { +- this.Container_constructor(); +- +- +- // public properties: +- /** +- * The text to display. +- * @property text +- * @type String +- * @default "" +- **/ +- this.text = text||""; +- +- /** +- * A SpriteSheet instance that defines the glyphs for this bitmap text. Each glyph/character +- * should have a single frame animation defined in the sprite sheet named the same as +- * corresponding character. For example, the following animation definition: +- * +- * "A": {frames: [0]} +- * +- * would indicate that the frame at index 0 of the spritesheet should be drawn for the "A" character. The short form +- * is also acceptable: +- * +- * "A": 0 +- * +- * Note that if a character in the text is not found in the sprite sheet, it will also +- * try to use the alternate case (upper or lower). +- * +- * See SpriteSheet for more information on defining sprite sheet data. +- * @property spriteSheet +- * @type String +- * @default null +- **/ +- this.spriteSheet = spriteSheet; +- +- /** +- * The height of each line of text. If 0, then it will use a line height calculated +- * by checking for the height of the "1", "T", or "L" character (in that order). If +- * those characters are not defined, it will use the height of the first frame of the +- * sprite sheet. +- * @property lineHeight +- * @type Number +- * @default 0 +- **/ +- this.lineHeight = 0; +- +- /** +- * This spacing (in pixels) will be added after each character in the output. +- * @property letterSpacing +- * @type Number +- * @default 0 +- **/ +- this.letterSpacing = 0; +- +- /** +- * If a space character is not defined in the sprite sheet, then empty pixels equal to +- * spaceWidth will be inserted instead. If 0, then it will use a value calculated +- * by checking for the width of the "1", "l", "E", or "A" character (in that order). If +- * those characters are not defined, it will use the width of the first frame of the +- * sprite sheet. +- * @property spaceWidth +- * @type Number +- * @default 0 +- **/ +- this.spaceWidth = 0; +- +- +- // private properties: +- /** +- * @property _oldProps +- * @type Object +- * @protected +- **/ +- this._oldProps = {text:0,spriteSheet:0,lineHeight:0,letterSpacing:0,spaceWidth:0}; +- } +- var p = createjs.extend(BitmapText, createjs.Container); +- +- /** +- * <strong>REMOVED</strong>. Removed in favor of using `MySuperClass_constructor`. +- * See {{#crossLink "Utility Methods/extend"}}{{/crossLink}} and {{#crossLink "Utility Methods/promote"}}{{/crossLink}} +- * for details. +- * +- * There is an inheritance tutorial distributed with EaselJS in /tutorials/Inheritance. +- * +- * @method initialize +- * @protected +- * @deprecated +- */ +- // p.initialize = function() {}; // searchable for devs wondering where it is. +- +-// static properties: +- /** +- * BitmapText uses Sprite instances to draw text. To reduce the creation and destruction of instances (and thus garbage collection), it maintains +- * an internal object pool of sprite instances to reuse. Increasing this value can cause more sprites to be +- * retained, slightly increasing memory use, but reducing instantiation. +- * @property maxPoolSize +- * @type Number +- * @static +- * @default 100 +- **/ +- BitmapText.maxPoolSize = 100; +- +- /** +- * Sprite object pool. +- * @type {Array} +- * @static +- * @private +- */ +- BitmapText._spritePool = []; +- +- +-// public methods: +- /** +- * Docced in superclass. +- **/ +- p.draw = function(ctx, ignoreCache) { +- if (this.DisplayObject_draw(ctx, ignoreCache)) { return; } +- this._updateText(); +- this.Container_draw(ctx, ignoreCache); +- }; +- +- /** +- * Docced in superclass. +- **/ +- p.getBounds = function() { +- this._updateText(); +- return this.Container_getBounds(); +- }; +- +- /** +- * Returns true or false indicating whether the display object would be visible if drawn to a canvas. +- * This does not account for whether it would be visible within the boundaries of the stage. +- * NOTE: This method is mainly for internal use, though it may be useful for advanced uses. +- * @method isVisible +- * @return {Boolean} Boolean indicating whether the display object would be visible if drawn to a canvas +- **/ +- p.isVisible = function() { +- var hasContent = this.cacheCanvas || (this.spriteSheet && this.spriteSheet.complete && this.text); +- return !!(this.visible && this.alpha > 0 && this.scaleX !== 0 && this.scaleY !== 0 && hasContent); +- }; +- +- p.clone = function() { +- return this._cloneProps(new BitmapText(this.text, this.spriteSheet)); +- }; +- +- /** +- * <strong>Disabled in BitmapText.</strong> +- * @method addChild +- **/ +- /** +- * <strong>Disabled in BitmapText.</strong> +- * @method addChildAt +- **/ +- /** +- * <strong>Disabled in BitmapText.</strong> +- * @method removeChild +- **/ +- /** +- * <strong>Disabled in BitmapText.</strong> +- * @method removeChildAt +- **/ +- /** +- *
<TRUNCATED>
