http://git-wip-us.apache.org/repos/asf/flex-typedefs/blob/eae676d5/createjs/src/main/patch/tweenjs.patch ---------------------------------------------------------------------- diff --git a/createjs/src/main/patch/tweenjs.patch b/createjs/src/main/patch/tweenjs.patch new file mode 100644 index 0000000..f7436c0 --- /dev/null +++ b/createjs/src/main/patch/tweenjs.patch @@ -0,0 +1,2863 @@ +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js +index 52e0206..0fe6341 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/CSSPlugin.js +@@ -31,16 +31,16 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; + +-(function() { +- "use strict"; ++ ++ ++ + + /** + * A TweenJS plugin for working with numeric CSS string properties (ex. top, left). To use simply install after + * TweenJS has loaded: + * +- * createjs.CSSPlugin.install(); ++ * createjs.createjs.CSSPlugin.install(); + * + * You can adjust the CSS properties it will work with by modifying the <code>cssSuffixMap</code> property. Currently, + * the top, left, bottom, right, width, height have a "px" suffix appended. +@@ -49,7 +49,7 @@ this.createjs = this.createjs||{}; + * @class CSSPlugin + * @constructor + **/ +- function CSSPlugin() { ++ createjs.CSSPlugin = function() { + throw("CSSPlugin cannot be instantiated.") + } + +@@ -65,14 +65,14 @@ this.createjs = this.createjs||{}; + * @type Object + * @static + **/ +- CSSPlugin.cssSuffixMap = {top:"px",left:"px",bottom:"px",right:"px",width:"px",height:"px",opacity:""}; ++ createjs.CSSPlugin.cssSuffixMap = {top:"px",left:"px",bottom:"px",right:"px",width:"px",height:"px",opacity:""}; + + /** + * @property priority + * @protected + * @static + **/ +- CSSPlugin.priority = -100; // very low priority, should run last ++ createjs.CSSPlugin.priority = -100; // very low priority, should run last + + + // static methods +@@ -81,8 +81,8 @@ this.createjs = this.createjs||{}; + * @method install + * @static + **/ +- CSSPlugin.install = function() { +- var arr = [], map = CSSPlugin.cssSuffixMap; ++ createjs.CSSPlugin.install = function() { ++ var arr = [], map = createjs.CSSPlugin.cssSuffixMap; + for (var n in map) { arr.push(n); } + createjs.Tween.installPlugin(CSSPlugin, arr); + } +@@ -92,8 +92,8 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- CSSPlugin.init = function(tween, prop, value) { +- var sfx0,sfx1,style,map = CSSPlugin.cssSuffixMap; ++ createjs.CSSPlugin.init = function(tween, prop, value) { ++ var sfx0,sfx1,style,map = createjs.CSSPlugin.cssSuffixMap; + if ((sfx0 = map[prop]) == null || !(style = tween.target.style)) { return value; } + var str = style[prop]; + if (!str) { return 0; } // no style set. +@@ -110,7 +110,7 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) { ++ createjs.CSSPlugin.step = function(tween, prop, startValue, endValue, injectProps) { + // unused + } + +@@ -119,13 +119,13 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- CSSPlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { +- var style,map = CSSPlugin.cssSuffixMap; ++ createjs.CSSPlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { ++ var style,map = createjs.CSSPlugin.cssSuffixMap; + if (map[prop] == null || !(style = tween.target.style)) { return value; } + style[prop] = value+map[prop]; + return createjs.Tween.IGNORE; + } + +- createjs.CSSPlugin = CSSPlugin; + +-}()); ++ ++ +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js +index e3a0809..51876a7 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Ease.js +@@ -1,462 +1,187 @@ +-/* +-* Ease +-* 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 TweenJS ++/** @fileoverview Auto-generated Externs files ++ * @externs + */ ++/** ++ * The Ease class provides a collection of easing functions for use with TweenJS. It does not use the standard 4 param ++ * easing signature. Instead it uses a single param which indicates the current linear ratio (0 to 1) of the tween. ++ * ++ * Most methods on Ease can be passed directly as easing functions: ++ * ++ * Tween.get(target).to({x:100}, 500, createjs.Ease.linear); ++ * ++ * However, methods beginning with "get" will return an easing function based on parameter values: ++ * ++ * Tween.get(target).to({y:200}, 500, createjs.Ease.getPowIn(2.2)); ++ * ++ * Please see the <a href="http://www.createjs.com/Demos/TweenJS/Tween_SparkTable";>spark table demo</a> for an ++ * overview of the different ease types on <a href="http://tweenjs.com";>TweenJS.com</a>. ++ * ++ * <em>Equations derived from work by Robert Penner.</em> ++ * ++ * @see [Ease] ++ * @constructor */ ++createjs.Ease = function () {} ++ ++ /** ++ * Configurable elastic ease. ++ * ++ * @param {(number|null)} amplitude ++ * @param {(number|null)} period ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getElasticIn = function (amplitude, period) { return null; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.circOut = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.linear = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.sineIn = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.sineOut = function (t) { return 0; } ++ ++ /** ++ * Mimics the simple -100 to 100 easing in Flash Pro. ++ * ++ * @param {(number|null)} amount A value from -1 (ease in) to 1 (ease out) indicating the strength and direction of the ease. ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.get = function (amount) { return null; } ++ ++ /** ++ * Configurable "back in" ease. ++ * ++ * @param {(number|null)} amount The strength of the ease. ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getBackIn = function (amount) { return null; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.circIn = function (t) { return 0; } ++ ++ /** ++ * Configurable "back out" ease. ++ * ++ * @param {(number|null)} amount The strength of the ease. ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getBackOut = function (amount) { return null; } ++ ++ /** ++ * Configurable elastic ease. ++ * ++ * @param {(number|null)} amplitude ++ * @param {(number|null)} period ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getElasticInOut = function (amplitude, period) { return null; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.bounceInOut = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.bounceIn = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.sineInOut = function (t) { return 0; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.circInOut = function (t) { return 0; } ++ ++ /** ++ * Configurable exponential ease. ++ * ++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease). ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getPowOut = function (pow) { return null; } ++ ++ /** ++ * Configurable "back in out" ease. ++ * ++ * @param {(number|null)} amount The strength of the ease. ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getBackInOut = function (amount) { return null; } ++ ++ /** ++ * Configurable exponential ease. ++ * ++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease). ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getPowIn = function (pow) { return null; } ++ ++ /** ++ * Configurable exponential ease. ++ * ++ * @param {(number|null)} pow The exponent to use (ex. 3 would return a cubic ease). ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getPowInOut = function (pow) { return null; } ++ ++ /** ++ * Configurable elastic ease. ++ * ++ * @param {(number|null)} amplitude ++ * @param {(number|null)} period ++ * @see [Ease] ++ * @returns {(Function|null)} ++ */ ++createjs.Ease.prototype.getElasticOut = function (amplitude, period) { return null; } ++ ++ /** ++ * @param {(number|null)} t ++ * @see [Ease] ++ * @returns {(number|null)} ++ */ ++createjs.Ease.prototype.bounceOut = function (t) { return 0; } + +-// namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; +- +- /** +- * The Ease class provides a collection of easing functions for use with TweenJS. It does not use the standard 4 param +- * easing signature. Instead it uses a single param which indicates the current linear ratio (0 to 1) of the tween. +- * +- * Most methods on Ease can be passed directly as easing functions: +- * +- * Tween.get(target).to({x:100}, 500, Ease.linear); +- * +- * However, methods beginning with "get" will return an easing function based on parameter values: +- * +- * Tween.get(target).to({y:200}, 500, Ease.getPowIn(2.2)); +- * +- * Please see the <a href="http://www.createjs.com/Demos/TweenJS/Tween_SparkTable";>spark table demo</a> for an +- * overview of the different ease types on <a href="http://tweenjs.com";>TweenJS.com</a>. +- * +- * <em>Equations derived from work by Robert Penner.</em> +- * @class Ease +- * @static +- **/ +- function Ease() { +- throw "Ease cannot be instantiated."; +- } +- +- +-// static methods and properties +- /** +- * @method linear +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.linear = function(t) { return t; }; +- +- /** +- * Identical to linear. +- * @method none +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.none = Ease.linear; +- +- /** +- * Mimics the simple -100 to 100 easing in Flash Pro. +- * @method get +- * @param {Number} amount A value from -1 (ease in) to 1 (ease out) indicating the strength and direction of the ease. +- * @static +- * @return {Function} +- **/ +- Ease.get = function(amount) { +- if (amount < -1) { amount = -1; } +- if (amount > 1) { amount = 1; } +- return function(t) { +- if (amount==0) { return t; } +- if (amount<0) { return t*(t*-amount+1+amount); } +- return t*((2-t)*amount+(1-amount)); +- }; +- }; +- +- /** +- * Configurable exponential ease. +- * @method getPowIn +- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease). +- * @static +- * @return {Function} +- **/ +- Ease.getPowIn = function(pow) { +- return function(t) { +- return Math.pow(t,pow); +- }; +- }; +- +- /** +- * Configurable exponential ease. +- * @method getPowOut +- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease). +- * @static +- * @return {Function} +- **/ +- Ease.getPowOut = function(pow) { +- return function(t) { +- return 1-Math.pow(1-t,pow); +- }; +- }; +- +- /** +- * Configurable exponential ease. +- * @method getPowInOut +- * @param {Number} pow The exponent to use (ex. 3 would return a cubic ease). +- * @static +- * @return {Function} +- **/ +- Ease.getPowInOut = function(pow) { +- return function(t) { +- if ((t*=2)<1) return 0.5*Math.pow(t,pow); +- return 1-0.5*Math.abs(Math.pow(2-t,pow)); +- }; +- }; +- +- /** +- * @method quadIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quadIn = Ease.getPowIn(2); +- /** +- * @method quadOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quadOut = Ease.getPowOut(2); +- /** +- * @method quadInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quadInOut = Ease.getPowInOut(2); +- +- /** +- * @method cubicIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.cubicIn = Ease.getPowIn(3); +- /** +- * @method cubicOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.cubicOut = Ease.getPowOut(3); +- /** +- * @method cubicInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.cubicInOut = Ease.getPowInOut(3); +- +- /** +- * @method quartIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quartIn = Ease.getPowIn(4); +- /** +- * @method quartOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quartOut = Ease.getPowOut(4); +- /** +- * @method quartInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quartInOut = Ease.getPowInOut(4); +- +- /** +- * @method quintIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quintIn = Ease.getPowIn(5); +- /** +- * @method quintOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quintOut = Ease.getPowOut(5); +- /** +- * @method quintInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.quintInOut = Ease.getPowInOut(5); +- +- /** +- * @method sineIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.sineIn = function(t) { +- return 1-Math.cos(t*Math.PI/2); +- }; +- +- /** +- * @method sineOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.sineOut = function(t) { +- return Math.sin(t*Math.PI/2); +- }; +- +- /** +- * @method sineInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.sineInOut = function(t) { +- return -0.5*(Math.cos(Math.PI*t) - 1); +- }; +- +- /** +- * Configurable "back in" ease. +- * @method getBackIn +- * @param {Number} amount The strength of the ease. +- * @static +- * @return {Function} +- **/ +- Ease.getBackIn = function(amount) { +- return function(t) { +- return t*t*((amount+1)*t-amount); +- }; +- }; +- /** +- * @method backIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.backIn = Ease.getBackIn(1.7); +- +- /** +- * Configurable "back out" ease. +- * @method getBackOut +- * @param {Number} amount The strength of the ease. +- * @static +- * @return {Function} +- **/ +- Ease.getBackOut = function(amount) { +- return function(t) { +- return (--t*t*((amount+1)*t + amount) + 1); +- }; +- }; +- /** +- * @method backOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.backOut = Ease.getBackOut(1.7); +- +- /** +- * Configurable "back in out" ease. +- * @method getBackInOut +- * @param {Number} amount The strength of the ease. +- * @static +- * @return {Function} +- **/ +- Ease.getBackInOut = function(amount) { +- amount*=1.525; +- return function(t) { +- if ((t*=2)<1) return 0.5*(t*t*((amount+1)*t-amount)); +- return 0.5*((t-=2)*t*((amount+1)*t+amount)+2); +- }; +- }; +- /** +- * @method backInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.backInOut = Ease.getBackInOut(1.7); +- +- /** +- * @method circIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.circIn = function(t) { +- return -(Math.sqrt(1-t*t)- 1); +- }; +- +- /** +- * @method circOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.circOut = function(t) { +- return Math.sqrt(1-(--t)*t); +- }; +- +- /** +- * @method circInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.circInOut = function(t) { +- if ((t*=2) < 1) return -0.5*(Math.sqrt(1-t*t)-1); +- return 0.5*(Math.sqrt(1-(t-=2)*t)+1); +- }; +- +- /** +- * @method bounceIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.bounceIn = function(t) { +- return 1-Ease.bounceOut(1-t); +- }; +- +- /** +- * @method bounceOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.bounceOut = function(t) { +- if (t < 1/2.75) { +- return (7.5625*t*t); +- } else if (t < 2/2.75) { +- return (7.5625*(t-=1.5/2.75)*t+0.75); +- } else if (t < 2.5/2.75) { +- return (7.5625*(t-=2.25/2.75)*t+0.9375); +- } else { +- return (7.5625*(t-=2.625/2.75)*t +0.984375); +- } +- }; +- +- /** +- * @method bounceInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.bounceInOut = function(t) { +- if (t<0.5) return Ease.bounceIn (t*2) * .5; +- return Ease.bounceOut(t*2-1)*0.5+0.5; +- }; +- +- /** +- * Configurable elastic ease. +- * @method getElasticIn +- * @param {Number} amplitude +- * @param {Number} period +- * @static +- * @return {Function} +- **/ +- Ease.getElasticIn = function(amplitude,period) { +- var pi2 = Math.PI*2; +- return function(t) { +- if (t==0 || t==1) return t; +- var s = period/pi2*Math.asin(1/amplitude); +- return -(amplitude*Math.pow(2,10*(t-=1))*Math.sin((t-s)*pi2/period)); +- }; +- }; +- /** +- * @method elasticIn +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.elasticIn = Ease.getElasticIn(1,0.3); +- +- /** +- * Configurable elastic ease. +- * @method getElasticOut +- * @param {Number} amplitude +- * @param {Number} period +- * @static +- * @return {Function} +- **/ +- Ease.getElasticOut = function(amplitude,period) { +- var pi2 = Math.PI*2; +- return function(t) { +- if (t==0 || t==1) return t; +- var s = period/pi2 * Math.asin(1/amplitude); +- return (amplitude*Math.pow(2,-10*t)*Math.sin((t-s)*pi2/period )+1); +- }; +- }; +- /** +- * @method elasticOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.elasticOut = Ease.getElasticOut(1,0.3); +- +- /** +- * Configurable elastic ease. +- * @method getElasticInOut +- * @param {Number} amplitude +- * @param {Number} period +- * @static +- * @return {Function} +- **/ +- Ease.getElasticInOut = function(amplitude,period) { +- var pi2 = Math.PI*2; +- return function(t) { +- var s = period/pi2 * Math.asin(1/amplitude); +- if ((t*=2)<1) return -0.5*(amplitude*Math.pow(2,10*(t-=1))*Math.sin( (t-s)*pi2/period )); +- return amplitude*Math.pow(2,-10*(t-=1))*Math.sin((t-s)*pi2/period)*0.5+1; +- }; +- }; +- /** +- * @method elasticInOut +- * @param {Number} t +- * @static +- * @return {Number} +- **/ +- Ease.elasticInOut = Ease.getElasticInOut(1,0.3*1.5); +- +- createjs.Ease = Ease; +- +-}()); +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js +index 48fe018..7d12309 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/MotionGuidePlugin.js +@@ -31,17 +31,17 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; + +-(function() { +- "use strict"; ++ ++ ++ + + /** + * A TweenJS plugin for working with motion guides. + * + * To use, install the plugin after TweenJS has loaded. Next tween the 'guide' property with an object as detailed below. + * +- * createjs.MotionGuidePlugin.install(); ++ * createjs.createjs.MotionGuidePlugin.install(); + * + * <h4>Example</h4> + * +@@ -68,7 +68,7 @@ this.createjs = this.createjs||{}; + * @class MotionGuidePlugin + * @constructor + **/ +- function MotionGuidePlugin() { ++ createjs.MotionGuidePlugin = function() { + throw("MotionGuidePlugin cannot be instantiated.") + }; + +@@ -79,32 +79,32 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- MotionGuidePlugin.priority = 0; // high priority, should run sooner ++ createjs.MotionGuidePlugin.priority = 0; // high priority, should run sooner + + /** + * @property temporary variable storage + * @private + * @static + */ +- MotionGuidePlugin._rotOffS; ++ createjs.MotionGuidePlugin._rotOffS; + /** + * @property temporary variable storage + * @private + * @static + */ +- MotionGuidePlugin._rotOffE; ++ createjs.MotionGuidePlugin._rotOffE; + /** + * @property temporary variable storage + * @private + * @static + */ +- MotionGuidePlugin._rotNormS; ++ createjs.MotionGuidePlugin._rotNormS; + /** + * @property temporary variable storage + * @private + * @static + */ +- MotionGuidePlugin._rotNormE; ++ createjs.MotionGuidePlugin._rotNormE; + + + // static methods +@@ -113,7 +113,7 @@ this.createjs = this.createjs||{}; + * @method install + * @static + **/ +- MotionGuidePlugin.install = function() { ++ createjs.MotionGuidePlugin.install = function() { + createjs.Tween.installPlugin(MotionGuidePlugin, ["guide", "x", "y", "rotation"]); + return createjs.Tween.IGNORE; + }; +@@ -123,7 +123,7 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- MotionGuidePlugin.init = function(tween, prop, value) { ++ createjs.MotionGuidePlugin.init = function(tween, prop, value) { + var target = tween.target; + if(!target.hasOwnProperty("x")){ target.x = 0; } + if(!target.hasOwnProperty("y")){ target.y = 0; } +@@ -138,12 +138,12 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- MotionGuidePlugin.step = function(tween, prop, startValue, endValue, injectProps) { ++ createjs.MotionGuidePlugin.step = function(tween, prop, startValue, endValue, injectProps) { + // other props + if(prop == "rotation"){ + tween.__rotGlobalS = startValue; + tween.__rotGlobalE = endValue; +- MotionGuidePlugin.testRotData(tween, injectProps); ++ createjs.MotionGuidePlugin.testRotData(tween, injectProps); + } + if(prop != "guide"){ return endValue; } + +@@ -191,18 +191,18 @@ this.createjs = this.createjs||{}; + temp = data.orient; + data.orient = true; + var o = {}; +- MotionGuidePlugin.calc(data, data.start, o); ++ createjs.MotionGuidePlugin.calc(data, data.start, o); + tween.__rotPathS = Number(o.rotation.toFixed(5)); +- MotionGuidePlugin.calc(data, data.end, o); ++ createjs.MotionGuidePlugin.calc(data, data.end, o); + tween.__rotPathE = Number(o.rotation.toFixed(5)); + data.orient = false; //here and now we don't know if we need to +- MotionGuidePlugin.calc(data, data.end, injectProps); ++ createjs.MotionGuidePlugin.calc(data, data.end, injectProps); + data.orient = temp; + + // Setup rotation properties + if(!data.orient){ return endValue; } + tween.__guideData = data; +- MotionGuidePlugin.testRotData(tween, injectProps); ++ createjs.MotionGuidePlugin.testRotData(tween, injectProps); + return endValue; + }; + +@@ -211,7 +211,7 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- MotionGuidePlugin.testRotData = function(tween, injectProps){ ++ createjs.MotionGuidePlugin.testRotData = function(tween, injectProps){ + + // no rotation informat? if we need it come back, if we don't use 0 & ensure we have guide data + if(tween.__rotGlobalS === undefined || tween.__rotGlobalE === undefined){ +@@ -256,13 +256,13 @@ this.createjs = this.createjs||{}; + * @protected + * @static + **/ +- MotionGuidePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { ++ createjs.MotionGuidePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { + var data = endValues.guide; + if(data == undefined || data === startValues.guide){ return value; } + if(data.lastRatio != ratio){ + // first time through so calculate what I need to + var t = ((data.end-data.start)*(wait?data.end:ratio)+data.start); +- MotionGuidePlugin.calc(data, t, tween.target); ++ createjs.MotionGuidePlugin.calc(data, t, tween.target); + switch(data.orient){ + case "cw": // mix in the original rotation + case "ccw": +@@ -279,13 +279,13 @@ this.createjs = this.createjs||{}; + /** + * Determine the appropriate x/y/rotation information about a path for a given ratio along the path. + * Assumes a path object with all optional parameters specified. +- * @param data Data object you would pass to the "guide:" property in a Tween +- * @param ratio 0-1 Distance along path, values outside 0-1 are "best guess" +- * @param target Object to copy the results onto, will use a new object if not supplied. ++ * @param {Object} data Data object you would pass to the "guide:" property in a Tween ++ * @param {Number} ratio 0-1 Distance along path, values outside 0-1 are "best guess" ++ * @param {Object} target Object to copy the results onto, will use a new object if not supplied. + * @return {Object} The target object or a new object w/ the tweened properties + * @static + */ +- MotionGuidePlugin.calc = function(data, ratio, target) { ++ createjs.MotionGuidePlugin.calc = function(data, ratio, target) { + if(data._segments == undefined){ throw("Missing critical pre-calculated information, please file a bug"); } + if(target == undefined){ target = {x:0, y:0, rotation:0}; } + var seg = data._segments; +@@ -326,6 +326,6 @@ this.createjs = this.createjs||{}; + return target; + }; + +- createjs.MotionGuidePlugin = MotionGuidePlugin; + +-}()); ++ ++ +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js +index 371baa7..4bfca8c 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/SamplePlugin.js +@@ -31,10 +31,10 @@ + */ + + // namespace: +-this.createjs = this.createjs||{}; + +-(function() { +- "use strict"; ++ ++ ++ + + /** + * A sample TweenJS plugin. This plugin does not actually affect tweens in any way, it's merely intended to document +@@ -45,7 +45,7 @@ this.createjs = this.createjs||{}; + * @class SamplePlugin + * @constructor + **/ +- function SamplePlugin() { ++ createjs.SamplePlugin = function() { + throw("SamplePlugin cannot be instantiated.") + }; + +@@ -56,7 +56,7 @@ this.createjs = this.createjs||{}; + * @property priority + * @static + **/ +- SamplePlugin.priority = 0; ++ createjs.SamplePlugin.priority = 0; + + /** + * Installs this plugin for use with TweenJS, and registers for a list of properties that this plugin will operate +@@ -64,7 +64,7 @@ this.createjs = this.createjs||{}; + * @method install + * @static + **/ +- SamplePlugin.install = function() { ++ createjs.SamplePlugin.install = function() { + // this registers this plugin to work with the "test" property. + createjs.Tween.installPlugin(SamplePlugin, ["test"]); + }; +@@ -75,12 +75,12 @@ this.createjs = this.createjs||{}; + * @method init + * @param {Tween} tween The related tween instance. + * @param {String} prop The name of the property that is being initialized. +- * @param {any} value The current value of the property on the tween's target. +- * @return {any} The starting tween value for the property. In most cases, you would simply ++ * @param {Object} value The current value of the property on the tween's target. ++ * @return {Object} The starting tween value for the property. In most cases, you would simply + * return the value parameter, but some plugins may need to modify the starting value. + * @static + **/ +- SamplePlugin.init = function(tween, prop, value) { ++ createjs.SamplePlugin.init = function(tween, prop, value) { + console.log("init", prop, value); + + // return the unmodified property value: +@@ -93,14 +93,14 @@ this.createjs = this.createjs||{}; + * @method init + * @param {Tween} tween The related tween instance. + * @param {String} prop The name of the property being tweened. +- * @param {any} startValue The value of the property at the beginning of the step. This will ++ * @param {Object} startValue The value of the property at the beginning of the step. This will + * be the same as the init value if this is the first step, or the same as the + * endValue of the previous step if not. + * @param {Object} injectProps A generic object to which the plugin can append other properties which should be updated on this step. +- * @param {any} endValue The value of the property at the end of the step. ++ * @param {Object} endValue The value of the property at the end of the step. + * @static + **/ +- SamplePlugin.step = function(tween, prop, startValue, endValue, injectProps) { ++ createjs.SamplePlugin.step = function(tween, prop, startValue, endValue, injectProps) { + console.log("to: ", prop, startValue, endValue); + }; + +@@ -109,7 +109,7 @@ this.createjs = this.createjs||{}; + * @method tween + * @param {Tween} tween The related tween instance. + * @param {String} prop The name of the property being tweened. +- * @param {any} value The current tweened value of the property, as calculated by TweenJS. ++ * @param {Object} value The current tweened value of the property, as calculated by TweenJS. + * @param {Object} startValues A hash of all of the property values at the start of the current + * step. You could access the start value of the current property using + * startValues[prop]. +@@ -120,13 +120,13 @@ this.createjs = this.createjs||{}; + * this range. + * @param {Boolean} wait Indicates whether the current step is a "wait" step. + * @param {Boolean} end Indicates that the tween has reached the end. +- * @return {any} Return the value that should be assigned to the target property. For example ++ * @return {Object} Return the value that should be assigned to the target property. For example + * returning <code>Math.round(value)</code> would assign the default calculated value + * as an integer. Returning Tween.IGNORE will prevent Tween from assigning a value to + * the target property. + * @static + **/ +- SamplePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { ++ createjs.SamplePlugin.tween = function(tween, prop, value, startValues, endValues, ratio, wait, end) { + // ratio is the eased ratio + console.log("tween", prop, value, ratio, wait, end); + +@@ -135,6 +135,6 @@ this.createjs = this.createjs||{}; + }; + + +- createjs.SamplePlugin = SamplePlugin; + +-}()); ++ ++ +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js +index 5546bc2..78be88d 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Timeline.js +@@ -1,444 +1,150 @@ +-/* +-* Timeline +-* 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 TweenJS ++ * The Timeline class synchronizes multiple tweens and allows them to be controlled as a group. Please note that if a ++ * timeline is looping, the tweens on it may appear to loop even if the "loop" property of the tween is false. ++ * ++ * @see [Timeline] ++ * @constructor * @extends createjs.EventDispatcher + */ ++createjs.Timeline = function (tweens, labels, props) {} ++ ++ /** ++ * @see [Timeline] ++ */ ++createjs.Timeline.clone = function () { } ++ ++ /** ++ * If a numeric position is passed, it is returned unchanged. If a string is passed, the position of the ++ * corresponding frame label will be returned, or `null` if a matching label is not defined. ++ * ++ * @param {(number|string|null)} positionOrLabel A numeric position value or label string. ++ * @see [Timeline] ++ */ ++createjs.Timeline.resolve = function (positionOrLabel) { } ++ ++ /** ++ * Adds a label that can be used with {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}. ++ * ++ * @param {(string|null)} label The label name. ++ * @param {(number|null)} position The position this label represents. ++ * @see [Timeline] ++ */ ++createjs.Timeline.addLabel = function (label, position) { } ++ ++ /** ++ * @param {(number|null)} value ++ * @see [Timeline] ++ * @returns {(number|null)} ++ */ ++createjs.Timeline._calcPosition = function (value) { return 0; } ++ ++ /** ++ * Pauses this timeline and jumps to the specified position or label. ++ * ++ * @param {(number|string|null)} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label to jump to. ++ * @see [Timeline] ++ */ ++createjs.Timeline.gotoAndStop = function (positionOrLabel) { } ++ ++ /** ++ * Removes one or more tweens from this timeline. ++ * ++ * @see [Timeline] ++ * @returns {?} Boolean Returns `true` if all of the tweens were successfully removed. ++ */ ++createjs.Timeline.removeTween = function (tween) { return null; } ++ ++ /** ++ * Returns the name of the label on or immediately before the current position. For example, given a timeline with ++ * two labels, "first" on frame index 4, and "second" on frame 8, getCurrentLabel would return: ++ * <UL> ++ * <LI>null if the current position is 2.</LI> ++ * <LI>"first" if the current position is 4.</LI> ++ * <LI>"first" if the current position is 7.</LI> ++ * <LI>"second" if the current position is 15.</LI> ++ * </UL> ++ * ++ * @see [Timeline] ++ * @returns {(string|null)} The name of the current label or null if there is no label ++ */ ++createjs.Timeline.getCurrentLabel = function () { return null; } ++ ++ /** ++ * Advances the timeline to the specified position. ++ * ++ * @param {(number|null)} value The position to seek to in milliseconds (or ticks if `useTicks` is `true`). ++ * @param {(number|null|undefined)} actionsMode parameter specifying how actions are handled. See the Tween {{#crossLink "Tween/setPosition"}}{{/crossLink}} method for more details. ++ * @see [Timeline] ++ * @returns {(boolean|null)} Returns `true` if the timeline is complete (ie. the full timeline has run & {{#crossLink "Timeline/loop:property"}}{{/crossLink}} is `false`). ++ */ ++createjs.Timeline.setPosition = function (value, actionsMode) { return null; } ++ ++ /** ++ * Pauses or plays this timeline. ++ * ++ * @param {(boolean|null)} value Indicates whether the tween should be paused (`true`) or played (`false`). ++ * @see [Timeline] ++ */ ++createjs.Timeline.setPaused = function (value) { } ++ ++ /** ++ * Advances this timeline by the specified amount of time in milliseconds (or ticks if `useTicks` is `true`). ++ * This is normally called automatically by the Tween engine (via the {{#crossLink "Tween/tick:event"}}{{/crossLink}} ++ * event), but is exposed for advanced uses. ++ * ++ * @param {(number|null)} delta The time to advance in milliseconds (or ticks if useTicks is true). ++ * @see [Timeline] ++ */ ++createjs.Timeline.tick = function (delta) { } ++ ++ /** ++ * @param {(number|string|null)} positionOrLabel ++ * @see [Timeline] ++ */ ++createjs.Timeline._goto = function (positionOrLabel) { } ++ ++ /** ++ * Returns a sorted list of the labels defined on this timeline. ++ * ++ * @see [Timeline] ++ * @returns {(Array|null)} Object]} A sorted array of objects with label and position properties. ++ */ ++createjs.Timeline.getLabels = function () { return null; } ++ ++ /** ++ * Recalculates the duration of the timeline. The duration is automatically updated when tweens are added or removed, ++ * but this method is useful if you modify a tween after it was added to the timeline. ++ * ++ * @see [Timeline] ++ */ ++createjs.Timeline.updateDuration = function () { } ++ ++ /** ++ * Adds one or more tweens (or timelines) to this timeline. The tweens will be paused (to remove them from the ++ * normal ticking system) and managed by this timeline. Adding a tween to multiple timelines will result in ++ * unexpected behaviour. ++ * ++ * @see [Timeline] ++ * @returns {(Tween|null)} The first tween that was passed in. ++ */ ++createjs.Timeline.addTween = function (tween) { return null; } ++ ++ ++ /** ++ * Defines labels for use with gotoAndPlay/Stop. Overwrites any previously set labels. ++ * ++ * @param {(Object|null)} o An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}} in the form `{labelName:time}` where time is in milliseconds (or ticks if `useTicks` is `true`). ++ * @see [Timeline] ++ */ ++createjs.Timeline.setLabels = function (o) { } ++ ++ /** ++ * Unpauses this timeline and jumps to the specified position or label. ++ * ++ * @param {(number|string|null)} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label to jump to. ++ * @see [Timeline] ++ */ ++createjs.Timeline.gotoAndPlay = function (positionOrLabel) { } + +-// namespace: +-this.createjs = this.createjs||{}; +- +- +-(function() { +- "use strict"; +- +- +-// constructor +- /** +- * The Timeline class synchronizes multiple tweens and allows them to be controlled as a group. Please note that if a +- * timeline is looping, the tweens on it may appear to loop even if the "loop" property of the tween is false. +- * @class Timeline +- * @param {Array} tweens An array of Tweens to add to this timeline. See {{#crossLink "Timeline/addTween"}}{{/crossLink}} +- * for more info. +- * @param {Object} labels An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}. +- * See {{#crossLink "Timeline/setLabels"}}{{/crossLink}} +- * for details. +- * @param {Object} props The configuration properties to apply to this tween instance (ex. `{loop:true}`). All properties +- * default to false. Supported props are:<UL> +- * <LI> loop: sets the loop property on this tween.</LI> +- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI> +- * <LI> ignoreGlobalPause: sets the ignoreGlobalPause property on this tween.</LI> +- * <LI> paused: indicates whether to start the tween paused.</LI> +- * <LI> position: indicates the initial position for this timeline.</LI> +- * <LI> onChange: specifies a listener to add for the {{#crossLink "Timeline/change:event"}}{{/crossLink}} event.</LI> +- * </UL> +- * @extends EventDispatcher +- * @constructor +- **/ +- function Timeline(tweens, labels, props) { +- this.EventDispatcher_constructor(); +- +- // public properties: +- /** +- * Causes this timeline to continue playing when a global pause is active. +- * @property ignoreGlobalPause +- * @type Boolean +- **/ +- this.ignoreGlobalPause = false; +- +- /** +- * The total duration of this timeline in milliseconds (or ticks if `useTicks `is `true`). This value is usually +- * automatically updated as you modify the timeline. See {{#crossLink "Timeline/updateDuration"}}{{/crossLink}} +- * for more information. +- * @property duration +- * @type Number +- * @default 0 +- * @readonly +- **/ +- this.duration = 0; +- +- /** +- * If true, the timeline will loop when it reaches the end. Can be set via the props param. +- * @property loop +- * @type Boolean +- **/ +- this.loop = false; +- +- /** +- * The current normalized position of the timeline. This will always be a value between 0 and +- * {{#crossLink "Timeline/duration:property"}}{{/crossLink}}. +- * Changing this property directly will have no effect. +- * @property position +- * @type Object +- * @readonly +- **/ +- this.position = null; +- +- // private properties: +- /** +- * @property _paused +- * @type Boolean +- * @protected +- **/ +- this._paused = false; +- +- /** +- * @property _tweens +- * @type Array[Tween] +- * @protected +- **/ +- this._tweens = []; +- +- /** +- * @property _labels +- * @type Object +- * @protected +- **/ +- this._labels = null; +- +- /** +- * @property _labelList +- * @type Array[Object] +- * @protected +- **/ +- this._labelList = null; +- +- /** +- * @property _prevPosition +- * @type Number +- * @default 0 +- * @protected +- **/ +- this._prevPosition = 0; +- +- /** +- * @property _prevPos +- * @type Number +- * @default -1 +- * @protected +- **/ +- this._prevPos = -1; +- +- /** +- * @property _useTicks +- * @type Boolean +- * @default false +- * @protected +- **/ +- this._useTicks = false; +- +- /** +- * Indicates whether the timeline is currently registered with Tween. +- * @property _registered +- * @type {boolean} +- * @default false +- * @protected +- */ +- this._registered = false; +- +- +- if (props) { +- this._useTicks = props.useTicks; +- this.loop = props.loop; +- this.ignoreGlobalPause = props.ignoreGlobalPause; +- props.onChange&&this.addEventListener("change", props.onChange); +- } +- if (tweens) { this.addTween.apply(this, tweens); } +- this.setLabels(labels); +- if (props&&props.paused) { this._paused=true; } +- else { createjs.Tween._register(this,true); } +- if (props&&props.position!=null) { this.setPosition(props.position, createjs.Tween.NONE); } +- +- }; +- +- var p = createjs.extend(Timeline, createjs.EventDispatcher); +- +- // TODO: deprecated +- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. +- +- +-// events: +- /** +- * Called whenever the timeline's position changes. +- * @event change +- * @since 0.5.0 +- **/ +- +- +-// public methods: +- /** +- * Adds one or more tweens (or timelines) to this timeline. The tweens will be paused (to remove them from the +- * normal ticking system) and managed by this timeline. Adding a tween to multiple timelines will result in +- * unexpected behaviour. +- * @method addTween +- * @param {Tween} ...tween The tween(s) to add. Accepts multiple arguments. +- * @return {Tween} The first tween that was passed in. +- **/ +- p.addTween = function(tween) { +- var l = arguments.length; +- if (l > 1) { +- for (var i=0; i<l; i++) { this.addTween(arguments[i]); } +- return arguments[0]; +- } else if (l == 0) { return null; } +- this.removeTween(tween); +- this._tweens.push(tween); +- tween.setPaused(true); +- tween._paused = false; +- tween._useTicks = this._useTicks; +- if (tween.duration > this.duration) { this.duration = tween.duration; } +- if (this._prevPos >= 0) { tween.setPosition(this._prevPos, createjs.Tween.NONE); } +- return tween; +- }; +- +- /** +- * Removes one or more tweens from this timeline. +- * @method removeTween +- * @param {Tween} ...tween The tween(s) to remove. Accepts multiple arguments. +- * @return Boolean Returns `true` if all of the tweens were successfully removed. +- **/ +- p.removeTween = function(tween) { +- var l = arguments.length; +- if (l > 1) { +- var good = true; +- for (var i=0; i<l; i++) { good = good && this.removeTween(arguments[i]); } +- return good; +- } else if (l == 0) { return false; } +- +- var tweens = this._tweens; +- var i = tweens.length; +- while (i--) { +- if (tweens[i] == tween) { +- tweens.splice(i, 1); +- if (tween.duration >= this.duration) { this.updateDuration(); } +- return true; +- } +- } +- return false; +- }; +- +- /** +- * Adds a label that can be used with {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}}. +- * @method addLabel +- * @param {String} label The label name. +- * @param {Number} position The position this label represents. +- **/ +- p.addLabel = function(label, position) { +- this._labels[label] = position; +- var list = this._labelList; +- if (list) { +- for (var i= 0,l=list.length; i<l; i++) { if (position < list[i].position) { break; } } +- list.splice(i, 0, {label:label, position:position}); +- } +- }; +- +- /** +- * Defines labels for use with gotoAndPlay/Stop. Overwrites any previously set labels. +- * @method setLabels +- * @param {Object} o An object defining labels for using {{#crossLink "Timeline/gotoAndPlay"}}{{/crossLink}}/{{#crossLink "Timeline/gotoAndStop"}}{{/crossLink}} +- * in the form `{labelName:time}` where time is in milliseconds (or ticks if `useTicks` is `true`). +- **/ +- p.setLabels = function(o) { +- this._labels = o ? o : {}; +- }; +- +- /** +- * Returns a sorted list of the labels defined on this timeline. +- * @method getLabels +- * @return {Array[Object]} A sorted array of objects with label and position properties. +- **/ +- p.getLabels = function() { +- var list = this._labelList; +- if (!list) { +- list = this._labelList = []; +- var labels = this._labels; +- for (var n in labels) { +- list.push({label:n, position:labels[n]}); +- } +- list.sort(function (a,b) { return a.position- b.position; }); +- } +- return list; +- }; +- +- /** +- * Returns the name of the label on or immediately before the current position. For example, given a timeline with +- * two labels, "first" on frame index 4, and "second" on frame 8, getCurrentLabel would return: +- * <UL> +- * <LI>null if the current position is 2.</LI> +- * <LI>"first" if the current position is 4.</LI> +- * <LI>"first" if the current position is 7.</LI> +- * <LI>"second" if the current position is 15.</LI> +- * </UL> +- * @method getCurrentLabel +- * @return {String} The name of the current label or null if there is no label +- **/ +- p.getCurrentLabel = function() { +- var labels = this.getLabels(); +- var pos = this.position; +- var l = labels.length; +- if (l) { +- for (var i = 0; i<l; i++) { if (pos < labels[i].position) { break; } } +- return (i==0) ? null : labels[i-1].label; +- } +- return null; +- }; +- +- /** +- * Unpauses this timeline and jumps to the specified position or label. +- * @method gotoAndPlay +- * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) +- * or label to jump to. +- **/ +- p.gotoAndPlay = function(positionOrLabel) { +- this.setPaused(false); +- this._goto(positionOrLabel); +- }; +- +- /** +- * Pauses this timeline and jumps to the specified position or label. +- * @method gotoAndStop +- * @param {String|Number} positionOrLabel The position in milliseconds (or ticks if `useTicks` is `true`) or label +- * to jump to. +- **/ +- p.gotoAndStop = function(positionOrLabel) { +- this.setPaused(true); +- this._goto(positionOrLabel); +- }; +- +- /** +- * Advances the timeline to the specified position. +- * @method setPosition +- * @param {Number} value The position to seek to in milliseconds (or ticks if `useTicks` is `true`). +- * @param {Number} [actionsMode] parameter specifying how actions are handled. See the Tween {{#crossLink "Tween/setPosition"}}{{/crossLink}} +- * method for more details. +- * @return {Boolean} Returns `true` if the timeline is complete (ie. the full timeline has run & {{#crossLink "Timeline/loop:property"}}{{/crossLink}} +- * is `false`). +- **/ +- p.setPosition = function(value, actionsMode) { +- var t = this._calcPosition(value); +- var end = !this.loop && value >= this.duration; +- if (t == this._prevPos) { return end; } +- this._prevPosition = value; +- this.position = this._prevPos = t; // in case an action changes the current frame. +- for (var i=0, l=this._tweens.length; i<l; i++) { +- this._tweens[i].setPosition(t, actionsMode); +- if (t != this._prevPos) { return false; } // an action changed this timeline's position. +- } +- if (end) { this.setPaused(true); } +- this.dispatchEvent("change"); +- return end; +- }; +- +- /** +- * Pauses or plays this timeline. +- * @method setPaused +- * @param {Boolean} value Indicates whether the tween should be paused (`true`) or played (`false`). +- **/ +- p.setPaused = function(value) { +- this._paused = !!value; +- createjs.Tween._register(this, !value); +- }; +- +- /** +- * Recalculates the duration of the timeline. The duration is automatically updated when tweens are added or removed, +- * but this method is useful if you modify a tween after it was added to the timeline. +- * @method updateDuration +- **/ +- p.updateDuration = function() { +- this.duration = 0; +- for (var i=0,l=this._tweens.length; i<l; i++) { +- var tween = this._tweens[i]; +- if (tween.duration > this.duration) { this.duration = tween.duration; } +- } +- }; +- +- /** +- * Advances this timeline by the specified amount of time in milliseconds (or ticks if `useTicks` is `true`). +- * This is normally called automatically by the Tween engine (via the {{#crossLink "Tween/tick:event"}}{{/crossLink}} +- * event), but is exposed for advanced uses. +- * @method tick +- * @param {Number} delta The time to advance in milliseconds (or ticks if useTicks is true). +- **/ +- p.tick = function(delta) { +- this.setPosition(this._prevPosition+delta); +- }; +- +- /** +- * If a numeric position is passed, it is returned unchanged. If a string is passed, the position of the +- * corresponding frame label will be returned, or `null` if a matching label is not defined. +- * @method resolve +- * @param {String|Number} positionOrLabel A numeric position value or label string. +- **/ +- p.resolve = function(positionOrLabel) { +- var pos = Number(positionOrLabel); +- if (isNaN(pos)) { pos = this._labels[positionOrLabel]; } +- return pos; +- }; +- +- /** +- * Returns a string representation of this object. +- * @method toString +- * @return {String} a string representation of the instance. +- **/ +- p.toString = function() { +- return "[Timeline]"; +- }; +- +- /** +- * @method clone +- * @protected +- **/ +- p.clone = function() { +- throw("Timeline can not be cloned.") +- }; +- +-// private methods: +- /** +- * @method _goto +- * @param {String | Number} positionOrLabel +- * @protected +- **/ +- p._goto = function(positionOrLabel) { +- var pos = this.resolve(positionOrLabel); +- if (pos != null) { this.setPosition(pos); } +- }; +- +- /** +- * @method _calcPosition +- * @param {Number} value +- * @return {Number} +- * @protected +- **/ +- p._calcPosition = function(value) { +- if (value < 0) { return 0; } +- if (value < this.duration) { return value; } +- return this.loop ? value%this.duration : this.duration; +- }; +- +- createjs.Timeline = createjs.promote(Timeline, "EventDispatcher"); +- +-}()); +diff --git a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js +index 8945830..f54bc42 100644 +--- a/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js ++++ b/externs/createjs/target/downloads/TweenJS-0.6.2/src/tweenjs/Tween.js +@@ -1,941 +1,279 @@ +-/* +-* Tween +-* 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 ++ */ + /** +- * The TweenJS Javascript library provides a simple but powerful tweening interface. It supports tweening of both +- * numeric object properties & CSS style properties, and allows you to chain tweens and actions together to create +- * complex sequences. +- * +- * <h4>Simple Tween</h4> +- * This tween will tween the target's alpha property from 0 to 1 for 1s then call the <code>handleComplete</code> function. +- * +- * target.alpha = 0; +- * createjs.Tween.get(target).to({alpha:1}, 1000).call(handleComplete); +- * function handleComplete() { +- * //Tween complete +- * } +- * +- * <strong>Arguments and Scope</strong> +- * Tween also supports a `call()` with arguments and/or a scope. If no scope is passed, then the function is called +- * anonymously (normal JavaScript behaviour). The scope is useful for maintaining scope when doing object-oriented +- * style development. +- * +- * createjs.Tween.get(target).to({alpha:0}) +- * .call(handleComplete, [argument1, argument2], this); +- * +- * <h4>Chainable Tween</h4> +- * This tween will wait 0.5s, tween the target's alpha property to 0 over 1s, set it's visible to false, then call the +- * <code>handleComplete</code> function. +- * +- * target.alpha = 1; +- * createjs.Tween.get(target).wait(500).to({alpha:0, visible:false}, 1000).call(handleComplete); +- * function handleComplete() { +- * //Tween complete +- * } +- * +- * <h4>Browser Support</h4> +- * TweenJS will work in modern browsers. To use TweenJS with IE8 and earlier, use an older version of PreloadJS +- * (version 0.4.1 and earlier). ++ * A Tween instance tweens properties for a single target. Instance methods can be chained for easy construction and sequencing: ++ * ++ * <h4>Example</h4> ++ * ++ * target.alpha = 1; ++ * createjs.createjs.Tween.get(target) ++ * .wait(500) ++ * .to({alpha:0, visible:false}, 1000) ++ * .call(handleComplete); ++ * function handleComplete() { ++ * //Tween complete ++ * } ++ * ++ * Multiple tweens can point to the same instance, however if they affect the same properties there could be unexpected ++ * behaviour. To stop all tweens on an object, use {{#crossLink "Tween/removeTweens"}}{{/crossLink}} or pass `override:true` ++ * in the props argument. ++ * ++ * createjs.createjs.Tween.get(target, {override:true}).to({x:100}); ++ * ++ * Subscribe to the {{#crossLink "Tween/change:event"}}{{/crossLink}} event to get notified when a property of the ++ * target is changed. ++ * ++ * createjs.createjs.Tween.get(target, {override:true}).to({x:100}).addEventListener("change", handleChange); ++ * function handleChange(event) { ++ * // The tween changed. ++ * } ++ * ++ * See the Tween {{#crossLink "Tween/get"}}{{/crossLink}} method for additional param documentation. + * +- * @module TweenJS +- * @main TweenJS ++ * @see [Tween] ++ * @constructor * @extends createjs.EventDispatcher + */ ++createjs.Tween = function (target, props, pluginData) {} ++ ++ /** ++ * Advances all tweens. This typically uses the {{#crossLink "Ticker"}}{{/crossLink}} class, but you can call it ++ * manually if you prefer to use your own "heartbeat" implementation. ++ * ++ * @param {(number|null)} delta The change in time in milliseconds since the last tick. Required unless all tweens have `useTicks` set to true. ++ * @param {(boolean|null)} paused Indicates whether a global pause is in effect. Tweens with {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} will ignore this, but all others will pause if this is `true`. ++ * @see [Tween] ++ */ ++createjs.Tween.prototype.tick = function (delta, paused) { } ++ ++ /** ++ * Stop and remove all existing tweens. ++ * ++ * @see [Tween] ++ */ ++createjs.Tween.prototype.removeAllTweens = function () { } ++ ++ /** ++ * Returns a new tween instance. This is functionally identical to using "new Tween(...)", but looks cleaner ++ * with the chained syntax of TweenJS. ++ * <h4>Example</h4> ++ * ++ * var tween = createjs.createjs.Tween.get(target); ++ * ++ * @param {(Object|null)} target The target object that will have its properties tweened. ++ * @param {(Object|null|undefined)} props The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`). All properties default to `false`. Supported props are: <UL> <LI> loop: sets the loop property on this tween.</LI> <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI> <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on this tween.</LI> <LI> override: if true, `createjs.createjs.Tween.removeTweens(target)` will be called to remove any other tweens with the same target. <LI> paused: indicates whether to start the tween paused.</LI> <LI> position: indicates the initial position for this tween.</LI> <LI> onChange: specifies a listener for the {{#crossLink "Tween/change:event"}}{{/crossLink}} event.</LI> </UL> ++ * @param {(Object|null|undefined)} pluginData An object containing data for use by installed plugins. See individual plugins' documentation for details. ++ * @param {(boolean|null|undefined)} override If true, any previous tweens on the same target will be removed. This is the same as calling `createjs.Tween.removeTweens(target)`. ++ * @see [Tween] ++ * @returns {(Tween|null)} A reference to the created tween. Additional chained tweens, method calls, or callbacks can be applied to the returned tween instance. ++ */ ++createjs.Tween.prototype.get = function (target, props, pluginData, override) { return null; } ++ ++ /** ++ * Handle events that result from Tween being used as an event handler. This is included to allow Tween to handle ++ * {{#crossLink "Ticker/tick:event"}}{{/crossLink}} events from the createjs {{#crossLink "Ticker"}}{{/crossLink}}. ++ * No other events are handled in createjs.Tween. ++ * ++ * @param {(Object|null)} event An event object passed in by the {{#crossLink "EventDispatcher"}}{{/crossLink}}. Will usually be of type "tick". ++ * @see [Tween] ++ */ ++createjs.Tween.prototype.handleEvent = function (event) { } ++ ++ /** ++ * Indicates whether there are any active tweens (and how many) on the target object (if specified) or in general. ++ * ++ * @param {(Object|null|undefined)} target The target to check for active tweens. If not specified, the return value will indicate if there are any active tweens on any target. ++ * @see [Tween] ++ * @returns {(boolean|null)} If there are active tweens. ++ */ ++createjs.Tween.prototype.hasActiveTweens = function (target) { return null; } ++ ++ /** ++ * Installs a plugin, which can modify how certain properties are handled when tweened. See the {{#crossLink "CSSPlugin"}}{{/crossLink}} ++ * for an example of how to write TweenJS plugins. ++ * ++ * @param {(Object|null)} plugin The plugin class to install ++ * @param {(Array|null)} properties An array of properties that the plugin will handle. ++ * @see [Tween] ++ */ ++createjs.Tween.prototype.installPlugin = function (plugin, properties) { } ++ ++ /** ++ * Removes all existing tweens for a target. This is called automatically by new tweens if the `override` ++ * property is `true`. ++ * ++ * @param {(Object|null)} target The target object to remove existing tweens from. ++ * @see [Tween] ++ */ ++createjs.Tween.prototype.removeTweens = function (target) { } ++ ++ /** ++ * Registers or unregisters a tween with the ticking system. ++ * ++ * @param {(Tween|null)} tween The tween instance to register or unregister. ++ * @param {(boolean|null)} value If `true`, the tween is registered. If `false` the tween is unregistered. ++ * @see [Tween] ++ */ ++createjs.Tween.prototype._register = function (tween, value) { } ++ ++ /** ++ * @param {(Object|null)} o ++ * @see [Tween] ++ */ ++createjs.Tween._addAction = function (o) { } ++ ++ /** ++ * Queues a tween from the current values to the target properties. Set duration to 0 to jump to these value. ++ * Numeric properties will be tweened from their current value in the tween to the target value. Non-numeric ++ * properties will be set at the end of the specified duration. ++ * <h4>Example</h4> ++ * ++ * createjs.createjs.Tween.get(target).to({alpha:0}, 1000); ++ * ++ * @param {(Object|null)} props An object specifying property target values for this tween (Ex. `{x:300}` would tween the x property of the target to 300). ++ * @param {(number|null|undefined)} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true). ++ * @param {(Function|null|undefined)} ease The easing function to use for this tween. See the {{#crossLink "Ease"}}{{/crossLink}} class for a list of built-in ease functions. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls). ++ */ ++createjs.Tween.to = function (props, duration, ease) { return null; } ++ ++ /** ++ * Queues an action to call the specified function. ++ * <h4>Example</h4> ++ * ++ * //would call myFunction() after 1 second. ++ * mycreatejs.Tween.wait(1000).call(myFunction); ++ * ++ * @param {(Function|null)} callback The function to call. ++ * @param {(Array|null|undefined)} params . The parameters to call the function with. If this is omitted, then the function will be called with a single param pointing to this tween. ++ * @param {(Object|null|undefined)} scope . The scope to call the function in. If omitted, it will be called in the target's scope. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls). ++ */ ++createjs.Tween.call = function (callback, params, scope) { return null; } ++ ++ /** ++ * @see [Tween] ++ */ ++createjs.Tween.clone = function () { } ++ ++ /** ++ * @param {(Object|null)} o ++ * @see [Tween] ++ */ ++createjs.Tween._appendQueueProps = function (o) { } ++ ++ /** ++ * @param {(number|null)} startPos ++ * @param {(number|null)} endPos ++ * @param {(boolean|null)} includeStart ++ * @see [Tween] ++ */ ++createjs.Tween._runActions = function (startPos, endPos, includeStart) { } ++ ++ /** ++ * Queues an action to set the specified props on the specified target. If target is null, it will use this tween's ++ * target. ++ * <h4>Example</h4> ++ * ++ * mycreatejs.Tween.wait(1000).set({visible:false},foo); ++ * ++ * @param {(Object|null)} props The properties to set (ex. `{visible:false}`). ++ * @param {(Object|null|undefined)} target The target to set the properties on. If omitted, they will be set on the tween's target. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls). ++ */ ++createjs.Tween.set = function (props, target) { return null; } ++ ++ /** ++ * Queues an action to play (unpause) the specified tween. This enables you to sequence multiple tweens. ++ * <h4>Example</h4> ++ * ++ * mycreatejs.Tween.to({x:100},500).play(otherTween); ++ * ++ * @param {(Tween|null)} tween The tween to play. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls). ++ */ ++createjs.Tween.play = function (tween) { return null; } ++ ++ /** ++ * Advances the tween to a specified position. ++ * ++ * @param {(number|null)} value The position to seek to in milliseconds (or ticks if useTicks is true). ++ * @param {(number|null|undefined)} actionsMode Specifies how actions are handled (ie. call, set, play, pause): <ul> <li>{{#crossLink "Tween/NONE:property"}}{{/crossLink}} (0) - run no actions.</li> <li>{{#crossLink "Tween/LOOP:property"}}{{/crossLink}} (1) - if new position is less than old, then run all actions between old and duration, then all actions between 0 and new.</li> <li>{{#crossLink "Tween/REVERSE:property"}}{{/crossLink}} (2) - if new position is less than old, run all actions between them in reverse.</li> </ul> ++ * @see [Tween] ++ * @returns {(boolean|null)} Returns `true` if the tween is complete (ie. the full tween has run & {{#crossLink "Tween/loop:property"}}{{/crossLink}} is `false`). ++ */ ++createjs.Tween.setPosition = function (value, actionsMode) { return null; } ++ ++ /** ++ * @param {(Object|null)} props ++ * @param {(Object|null)} o ++ * @see [Tween] ++ */ ++createjs.Tween._set = function (props, o) { } ++ ++ /** ++ * Queues a wait (essentially an empty tween). ++ * <h4>Example</h4> ++ * ++ * //This tween will wait 1s before alpha is faded to 0. ++ * createjs.createjs.Tween.get(target).wait(1000).to({alpha:0}, 1000); ++ * ++ * @param {(number|null)} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true). ++ * @param {(boolean|null|undefined)} passive Tween properties will not be updated during a passive wait. This is mostly useful for use with {{#crossLink "Timeline"}}{{/crossLink}} instances that contain multiple tweens affecting the same target at different times. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls). ++ */ ++createjs.Tween.wait = function (duration, passive) { return null; } ++ ++ /** ++ * Pauses or plays this tween. ++ * ++ * @param {(boolean|null|undefined)} value Indicates whether the tween should be paused (`true`) or played (`false`). ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls) ++ */ ++createjs.Tween.setPaused = function (value) { return null; } ++ ++ /** ++ * Queues an action to pause the specified tween. ++ * ++ * @param {(Tween|null)} tween The tween to pause. If null, it pauses this tween. ++ * @see [Tween] ++ * @returns {(Tween|null)} This tween instance (for chaining calls) ++ */ ++createjs.Tween.pause = function (tween) { return null; } ++ ++ /** ++ * @param {(Object|null)} step ++ * @param {(number|null)} ratio ++ * @see [Tween] ++ */ ++createjs.Tween._updateTargetProps = function (step, ratio) { } ++ ++ /** ++ * Advances this tween by the specified amount of time in milliseconds (or ticks if`useTicks` is `true`). ++ * This is normally called automatically by the Tween engine (via {{#crossLink "Tween/tick"}}{{/crossLink}}), but is ++ * exposed for advanced uses. ++ * ++ * @param {(number|null)} delta The time to advance in milliseconds (or ticks if `useTicks` is `true`). ++ * @see [Tween] ++ */ ++createjs.Tween.tick = function (delta) { } ++ ++ /** ++ * @param {(Object|null)} props ++ * @see [Tween] ++ */ ++createjs.Tween._cloneProps = function (props) { } ++ ++ ++ /** ++ * @param {(Object|null)} o ++ * @see [Tween] ++ */ ++createjs.Tween._addStep = function (o) { } + +-// TODO: possibly add a END actionsMode (only runs actions that == position)? +-// TODO: evaluate a way to decouple paused from tick registration. +- +-// namespace: +-this.createjs = this.createjs||{}; +- +-(function() { +- "use strict"; +- +- +-// constructor +- /** +- * A Tween instance tweens properties for a single target. Instance methods can be chained for easy construction and sequencing: +- * +- * <h4>Example</h4> +- * +- * target.alpha = 1; +- * createjs.Tween.get(target) +- * .wait(500) +- * .to({alpha:0, visible:false}, 1000) +- * .call(handleComplete); +- * function handleComplete() { +- * //Tween complete +- * } +- * +- * Multiple tweens can point to the same instance, however if they affect the same properties there could be unexpected +- * behaviour. To stop all tweens on an object, use {{#crossLink "Tween/removeTweens"}}{{/crossLink}} or pass `override:true` +- * in the props argument. +- * +- * createjs.Tween.get(target, {override:true}).to({x:100}); +- * +- * Subscribe to the {{#crossLink "Tween/change:event"}}{{/crossLink}} event to get notified when a property of the +- * target is changed. +- * +- * createjs.Tween.get(target, {override:true}).to({x:100}).addEventListener("change", handleChange); +- * function handleChange(event) { +- * // The tween changed. +- * } +- * +- * See the Tween {{#crossLink "Tween/get"}}{{/crossLink}} method for additional param documentation. +- * @class Tween +- * @param {Object} target The target object that will have its properties tweened. +- * @param {Object} [props] The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`. +- * All properties default to false. Supported props are:<UL> +- * <LI> loop: sets the loop property on this tween.</LI> +- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI> +- * <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on this tween.</LI> +- * <LI> override: if true, `Tween.removeTweens(target)` will be called to remove any other tweens with the same target. +- * <LI> paused: indicates whether to start the tween paused.</LI> +- * <LI> position: indicates the initial position for this tween.</LI> +- * <LI> onChange: specifies a listener for the "change" event.</LI> +- * </UL> +- * @param {Object} [pluginData] An object containing data for use by installed plugins. See individual +- * plugins' documentation for details. +- * @extends EventDispatcher +- * @constructor +- */ +- function Tween(target, props, pluginData) { +- +- // public properties: +- /** +- * Causes this tween to continue playing when a global pause is active. For example, if TweenJS is using {{#crossLink "Ticker"}}{{/crossLink}}, +- * then setting this to true (the default) will cause this tween to be paused when <code>Ticker.setPaused(true)</code> +- * is called. See the Tween {{#crossLink "Tween/tick"}}{{/crossLink}} method for more info. Can be set via the props +- * parameter. +- * @property ignoreGlobalPause +- * @type Boolean +- * @default false +- */ +- this.ignoreGlobalPause = false; +- +- /** +- * If true, the tween will loop when it reaches the end. Can be set via the props param. +- * @property loop +- * @type {Boolean} +- * @default false +- */ +- this.loop = false; +- +- /** +- * Specifies the total duration of this tween in milliseconds (or ticks if useTicks is true). +- * This value is automatically updated as you modify the tween. Changing it directly could result in unexpected +- * behaviour. +- * @property duration +- * @type {Number} +- * @default 0 +- * @readonly +- */ +- this.duration = 0; +- +- /** +- * Allows you to specify data that will be used by installed plugins. Each plugin uses this differently, but in general +- * you specify data by setting it to a property of pluginData with the same name as the plugin class. +- * @example +- * myTween.pluginData.PluginClassName = data; +- * <br/> +- * Also, most plugins support a property to enable or disable them. This is typically the plugin class name followed by "_enabled".<br/> +- * @example +- * myTween.pluginData.PluginClassName_enabled = false;<br/> +- * <br/> +- * Some plugins also store instance data in this object, usually in a property named _PluginClassName. +- * See the documentation for individual plugins for more details. +- * @property pluginData +- * @type {Object} +- */ +- this.pluginData = pluginData || {}; +- +- /** +- * The target of this tween. This is the object on which the tweened properties will be changed. Changing +- * this property after the tween is created will not have any effect. +- * @property target +- * @type {Object} +- * @readonly +- */ +- this.target = target; +- +- /** +- * The current normalized position of the tween. This will always be a value between 0 and duration. +- * Changing this property directly will have no effect. +- * @property position +- * @type {Object} +- * @readonly +- */ +- this.position = null; +- +- /** +- * Indicates the tween's current position is within a passive wait. +- * @property passive +- * @type {Boolean} +- * @default false +- * @readonly +- **/ +- this.passive = false; +- +- // private properties: +- /** +- * @property _paused +- * @type {Boolean} +- * @default false +- * @protected +- */ +- this._paused = false; +- +- /** +- * @property _curQueueProps +- * @type {Object} +- * @protected +- */ +- this._curQueueProps = {}; +- +- /** +- * @property _initQueueProps +- * @type {Object} +- * @protected +- */ +- this._initQueueProps = {}; +- +- /** +- * @property _steps +- * @type {Array} +- * @protected +- */ +- this._steps = []; +- +- /** +- * @property _actions +- * @type {Array} +- * @protected +- */ +- this._actions = []; +- +- /** +- * Raw position. +- * @property _prevPosition +- * @type {Number} +- * @default 0 +- * @protected +- */ +- this._prevPosition = 0; +- +- /** +- * The position within the current step. +- * @property _stepPosition +- * @type {Number} +- * @default 0 +- * @protected +- */ +- this._stepPosition = 0; // this is needed by MovieClip. +- +- /** +- * Normalized position. +- * @property _prevPos +- * @type {Number} +- * @default -1 +- * @protected +- */ +- this._prevPos = -1; +- +- /** +- * @property _target +- * @type {Object} +- * @protected +- */ +- this._target = target; +- +- /** +- * @property _useTicks +- * @type {Boolean} +- * @default false +- * @protected +- */ +- this._useTicks = false; +- +- /** +- * @property _inited +- * @type {boolean} +- * @default false +- * @protected +- */ +- this._inited = false; +- +- /** +- * Indicates whether the tween is currently registered with Tween. +- * @property _registered +- * @type {boolean} +- * @default false +- * @protected +- */ +- this._registered = false; +- +- +- if (props) { +- this._useTicks = props.useTicks; +- this.ignoreGlobalPause = props.ignoreGlobalPause; +- this.loop = props.loop; +- props.onChange && this.addEventListener("change", props.onChange); +- if (props.override) { Tween.removeTweens(target); } +- } +- if (props&&props.paused) { this._paused=true; } +- else { createjs.Tween._register(this,true); } +- if (props&&props.position!=null) { this.setPosition(props.position, Tween.NONE); } +- +- }; +- +- var p = createjs.extend(Tween, createjs.EventDispatcher); +- +- // TODO: deprecated +- // p.initialize = function() {}; // searchable for devs wondering where it is. REMOVED. See docs for details. +- +- +-// static properties +- /** +- * Constant defining the none actionsMode for use with setPosition. +- * @property NONE +- * @type Number +- * @default 0 +- * @static +- */ +- Tween.NONE = 0; +- +- /** +- * Constant defining the loop actionsMode for use with setPosition. +- * @property LOOP +- * @type Number +- * @default 1 +- * @static +- */ +- Tween.LOOP = 1; +- +- /** +- * Constant defining the reverse actionsMode for use with setPosition. +- * @property REVERSE +- * @type Number +- * @default 2 +- * @static +- */ +- Tween.REVERSE = 2; +- +- /** +- * Constant returned by plugins to tell the tween not to use default assignment. +- * @property IGNORE +- * @type Object +- * @static +- */ +- Tween.IGNORE = {}; +- +- /** +- * @property _listeners +- * @type Array[Tween] +- * @static +- * @protected +- */ +- Tween._tweens = []; +- +- /** +- * @property _plugins +- * @type Object +- * @static +- * @protected +- */ +- Tween._plugins = {}; +- +- +-// static methods +- /** +- * Returns a new tween instance. This is functionally identical to using "new Tween(...)", but looks cleaner +- * with the chained syntax of TweenJS. +- * <h4>Example</h4> +- * +- * var tween = createjs.Tween.get(target); +- * +- * @method get +- * @param {Object} target The target object that will have its properties tweened. +- * @param {Object} [props] The configuration properties to apply to this tween instance (ex. `{loop:true, paused:true}`). +- * All properties default to `false`. Supported props are: +- * <UL> +- * <LI> loop: sets the loop property on this tween.</LI> +- * <LI> useTicks: uses ticks for all durations instead of milliseconds.</LI> +- * <LI> ignoreGlobalPause: sets the {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} property on +- * this tween.</LI> +- * <LI> override: if true, `createjs.Tween.removeTweens(target)` will be called to remove any other tweens with +- * the same target. +- * <LI> paused: indicates whether to start the tween paused.</LI> +- * <LI> position: indicates the initial position for this tween.</LI> +- * <LI> onChange: specifies a listener for the {{#crossLink "Tween/change:event"}}{{/crossLink}} event.</LI> +- * </UL> +- * @param {Object} [pluginData] An object containing data for use by installed plugins. See individual plugins' +- * documentation for details. +- * @param {Boolean} [override=false] If true, any previous tweens on the same target will be removed. This is the +- * same as calling `Tween.removeTweens(target)`. +- * @return {Tween} A reference to the created tween. Additional chained tweens, method calls, or callbacks can be +- * applied to the returned tween instance. +- * @static +- */ +- Tween.get = function(target, props, pluginData, override) { +- if (override) { Tween.removeTweens(target); } +- return new Tween(target, props, pluginData); +- }; +- +- /** +- * Advances all tweens. This typically uses the {{#crossLink "Ticker"}}{{/crossLink}} class, but you can call it +- * manually if you prefer to use your own "heartbeat" implementation. +- * @method tick +- * @param {Number} delta The change in time in milliseconds since the last tick. Required unless all tweens have +- * `useTicks` set to true. +- * @param {Boolean} paused Indicates whether a global pause is in effect. Tweens with {{#crossLink "Tween/ignoreGlobalPause:property"}}{{/crossLink}} +- * will ignore this, but all others will pause if this is `true`. +- * @static +- */ +- Tween.tick = function(delta, paused) { +- var tweens = Tween._tweens.slice(); // to avoid race conditions. +- for (var i=tweens.length-1; i>=0; i--) { +- var tween = tweens[i]; +- if ((paused && !tween.ignoreGlobalPause) || tween._paused) { continue; } +- tween.tick(tween._useTicks?1:delta); +- } +- }; +- +- /** +- * Handle events that result from Tween being used as an event handler. This is included to allow Tween to handle +- * {{#crossLink "Ticker/tick:event"}}{{/crossLink}} events from the createjs {{#crossLink "Ticker"}}{{/crossLink}}. +- * No other events are handled in Tween. +- * @method handleEvent +- * @param {Object} event An event object passed in by the {{#crossLink "EventDispatcher"}}{{/crossLink}}. Will +- * usually be of type "tick". +- * @private +- * @static +- * @since 0.4.2 +- */ +- Tween.handleEvent = function(event) { +- if (event.type == "tick") { +- this.tick(event.delta, event.paused); +- } +- }; +- +- /** +- * Removes all existing tweens for a target. This is called automatically by new tweens if the `override` +- * property is `true`. +- * @method removeTweens +- * @param {Object} target The target object to remove existing tweens from. +- * @static +- */ +- Tween.removeTweens = function(target) { +- if (!target.tweenjs_count) { return; } +- var tweens = Tween._tweens; +- for (var i=tweens.length-1; i>=0; i--) { +- var tween = tweens[i]; +- if (tween._target == target) { +- tween._paused = true; +- tweens.splice(i, 1); +- } +- } +- target.tweenjs_count = 0; +- }; +- +- /** +- * Stop and remove all existing tweens. +- * @method removeAllTweens +- * @static +- * @since 0.4.1 +- */ +- Tween.removeAllTweens = function() { +- var tweens = Tween._tweens; +- for (var i= 0, l=tweens.length; i<l; i++) { +- var tween = tweens[i]; +- tween._paused = true; +- tween.target&&(tween.target.tweenjs_count = 0); +- } +- tweens.length = 0; +- }; +- +- /** +- * Indicates whether there are any active tweens (and how many) on the target object (if specified) or in general. +- * @method hasActiveTweens +- * @param {Object} [target] The target to check for active tweens. If not specified, the return value will indicate +- * if there are any active tweens on any target. +- * @return {Boolean} If there are active tweens. +- * @static +- */ +- Tween.hasActiveTweens = function(target) { +- if (target) { return target.tweenjs_count != null && !!target.tweenjs_count; } +- return Tween._tweens && !!Tween._tweens.length; +- }; +- +- /** +- * Installs a plugin, which can modify how certain properties are handled when tweened. See the {{#crossLink "CSSPlugin"}}{{/crossLink}} +- * for an example of how to write TweenJS plugins. +- * @method installPlugin +- * @static +- * @param {Object} plugin The plugin class to install +- * @param {Array} properties An array of properties that the plugin will handle. +- */ +- Tween.installPlugin = function(plugin, properties) { +- var priority = plugin.priority; +- if (priority == null) { plugin.priority = priority = 0; } +- for (var i=0,l=properties.length,p=Tween._plugins;i<l;i++) { +- var n = properties[i]; +- if (!p[n]) { p[n] = [plugin]; } +- else { +- var arr = p[n]; +- for (var j=0,jl=arr.length;j<jl;j++) { +- if (priority < arr[j].priority) { break; } +- } +- p[n].splice(j,0,plugin); +- } +- } +- }; +- +- /** +- * Registers or unregisters a tween with the ticking system. +- * @method _register +- * @param {Tween} tween The tween instance to register or unregister. +- * @param {Boolean} value If `true`, the tween is registered. If `false` the tween is unregistered. +- * @static +- * @protected +- */ +- Tween._register = function(tween, value) { +- var target = tween._target; +- var tweens = Tween._tweens; +- if (value && !tween._registered) { +- // TODO: this approach might fail if a dev is using sealed objects in ES5 +- if (target) { target.tweenjs_count = target.tweenjs_count ? target.tweenjs_count+1 : 1; } +- tweens.push(tween); +- if (!Tween._inited && createjs.Ticker) { createjs.Ticker.addEventListener("tick", Tween); Tween._inited = true; } +- } else if (!value && tween._registered) { +- if (target) { target.tweenjs_count--; } +- var i = tweens.length; +- while (i--) { +- if (tweens[i] == tween) { +- tweens.splice(i, 1); +- break; +- } +- } +- } +- tween._registered = value; +- }; +- +- +-// events: +- /** +- * Called whenever the tween's position changes. +- * @event change +- * @since 0.4.0 +- **/ +- +- +-// public methods: +- /** +- * Queues a wait (essentially an empty tween). +- * <h4>Example</h4> +- * +- * //This tween will wait 1s before alpha is faded to 0. +- * createjs.Tween.get(target).wait(1000).to({alpha:0}, 1000); +- * +- * @method wait +- * @param {Number} duration The duration of the wait in milliseconds (or in ticks if `useTicks` is true). +- * @param {Boolean} [passive] Tween properties will not be updated during a passive wait. This +- * is mostly useful for use with {{#crossLink "Timeline"}}{{/crossLink}} instances that contain multiple tweens +- * affecting the same target at different times. +- * @return {Tween} This tween instance (for chaining calls). +- **/ +- p.wait = function(duration, passive) { +- if (duration == null || duration <= 0) { return this; } +- var o = this._cloneProps(this._curQueueProps); +- return this._addStep({d:duration, p0:o, e:this._linearEase, p1:o, v:passive}); +- }; +- +- /** +- * Queues a tween from the current values to the target properties. Set duration to 0 to jump to these value. +- * Numeric properties will be tweened from their current value in the tween to the target value. Non-numeric +- * properties will be set at the end of the specified duration. +- * <h4>Example</h4> +- * +- * createjs.Tween.get(target).to({alpha:0}, 1000); +- * +- * @method to +- * @param {Object} props An object specifying property target values for this tween (Ex. `{x:300}` would tween the x +- * property of the target to 300). +- * @param {Number} [duration=0] The duration of the wait in milliseconds (or in ticks if `useTicks` is true). +- * @param {Function} [ease="linear"] The easing function to use for this tween. See the {{#crossLink "Ease"}}{{/crossLink}} +- * class for a list of built-in ease functions. +- * @return {Tween} This tween instance (for chaining calls). +- */ +- p.to = function(props, duration, ease) { +- if (isNaN(duration) || duration < 0) { duration = 0; } +- return this._addStep({d:duration||0, p0:this._cloneProps(this._curQueueProps), e:ease, p1:this._cloneProps(this._appendQueueProps(props))}); +- }; +- +- /** +- * Queues an action to call the specified function. +- * <h4>Example</h4> +- *
<TRUNCATED>
