Skip to content

Tenzing / banners-with-skip

Go to a project
Toggle navigation
Toggle navigation pinning
8a45bf96 by Jeff Balicki
Options

first commit

1 parent 64dc3e4b
Expand all
Inline Side-by-side
Showing 213 changed files with 4776 additions and 0 deletions
This diff could not be displayed because it is too large.
/**
* VERSION: 0.86
* DATE: 6/15/2009
* AS2 (AS3 version is also available)
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock {
/**
* Static constants for defining tween alignment.
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
**/
public class TweenAlign {
public static const NORMAL:String = "normal";
public static const SEQUENCE:String = "sequence";
public static const START:String = "start";
}
}
\ No newline at end of file
/**
* VERSION: 2.1
* DATE: 2009-09-12
* ACTIONSCRIPT VERSION: 3.0 (AS2 version is also available)
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock.core {
/**
* Stores information about an individual property tween. There is no reason to use this class directly - TweenLite, TweenMax, and some plugins use it internally.<br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class PropTween {
/** Target object **/
public var target:Object;
/** Name of the property that is being tweened **/
public var property:String;
/** Starting value **/
public var start:Number;
/** Amount to change (basically, the difference between the starting value and ending value) **/
public var change:Number;
/** Alias to associate with the PropTween which is typically the same as the property, but can be different, particularly for plugins. **/
public var name:String;
/** Priority in the rendering queue. The lower the value the later it will be tweened. Typically all PropTweens get a priority of 0, but some plugins must be rendered later (or earlier) **/
public var priority:int;
/** If the target of the PropTween is a TweenPlugin, isPlugin should be true. **/
public var isPlugin:Boolean;
/** Next PropTween in the linked list **/
public var nextNode:PropTween;
/** Previous PropTween in the linked list **/
public var prevNode:PropTween;
/**
* Constructor
*
* @param target Target object
* @param property Name of the property that is being tweened
* @param start Starting value
* @param change Amount to change (basically, the difference between the starting value and ending value)
* @param name Alias to associate with the PropTween which is typically the same as the property, but can be different, particularly for plugins.
* @param isPlugin If the target of the PropTween is a TweenPlugin, isPlugin should be true.
* @param nextNode Next PropTween in the linked list
* @param priority Priority in the rendering queue. The lower the value the later it will be tweened. Typically all PropTweens get a priority of 0, but some plugins must be rendered later (or earlier)
*/
public function PropTween(target:Object, property:String, start:Number, change:Number, name:String, isPlugin:Boolean, nextNode:PropTween=null, priority:int=0) {
this.target = target;
this.property = property;
this.start = start;
this.change = change;
this.name = name;
this.isPlugin = isPlugin;
if (nextNode) {
nextNode.prevNode = this;
this.nextNode = nextNode;
}
this.priority = priority;
}
}
}
\ No newline at end of file
/**
* VERSION: 1.38
* DATE: 2010-05-24
* AS3 (AS2 version is also available)
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock.core {
/**
* SimpleTimeline is the base class for the TimelineLite and TimelineMax classes. It provides the
* most basic timeline functionality and is used for the root timelines in TweenLite. It is meant
* to be very fast and lightweight. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class SimpleTimeline extends TweenCore {
/** @private **/
protected var _firstChild:TweenCore;
/** @private **/
protected var _lastChild:TweenCore;
/** If a timeline's autoRemoveChildren is true, its children will be removed and made eligible for garbage collection as soon as they complete. This is the default behavior for the main/root timeline. **/
public var autoRemoveChildren:Boolean;
public function SimpleTimeline(vars:Object=null) {
super(0, vars);
}
/** @private **/
public function addChild(tween:TweenCore):void {
if (!tween.cachedOrphan && tween.timeline) {
tween.timeline.remove(tween, true); //removes from existing timeline so that it can be properly added to this one.
}
tween.timeline = this;
if (tween.gc) {
tween.setEnabled(true, true);
}
if (_firstChild) {
_firstChild.prevNode = tween;
}
tween.nextNode = _firstChild;
_firstChild = tween;
tween.prevNode = null;
tween.cachedOrphan = false;
}
/** @private **/
public function remove(tween:TweenCore, skipDisable:Boolean=false):void {
if (tween.cachedOrphan) {
return; //already removed!
} else if (!skipDisable) {
tween.setEnabled(false, true);
}
if (tween.nextNode) {
tween.nextNode.prevNode = tween.prevNode;
} else if (_lastChild == tween) {
_lastChild = tween.prevNode;
}
if (tween.prevNode) {
tween.prevNode.nextNode = tween.nextNode;
} else if (_firstChild == tween) {
_firstChild = tween.nextNode;
}
tween.cachedOrphan = true;
//don't null nextNode and prevNode, otherwise the chain could break in rendering loops.
}
/** @private **/
override public function renderTime(time:Number, suppressEvents:Boolean=false, force:Boolean=false):void {
var tween:TweenCore = _firstChild, dur:Number, next:TweenCore;
this.cachedTotalTime = time;
this.cachedTime = time;
while (tween) {
next = tween.nextNode; //record it here because the value could change after rendering...
if (tween.active || (time >= tween.cachedStartTime && !tween.cachedPaused && !tween.gc)) {
if (!tween.cachedReversed) {
tween.renderTime((time - tween.cachedStartTime) * tween.cachedTimeScale, suppressEvents, false);
} else {
dur = (tween.cacheIsDirty) ? tween.totalDuration : tween.cachedTotalDuration;
tween.renderTime(dur - ((time - tween.cachedStartTime) * tween.cachedTimeScale), suppressEvents, false);
}
}
tween = next;
}
}
//---- GETTERS / SETTERS ------------------------------------------------------------------------------
/**
* @private
* Reports the totalTime of the timeline without capping the number at the totalDuration (max) and zero (minimum) which can be useful when
* unpausing tweens/timelines. Imagine a case where a paused tween is in a timeline that has already reached the end, but then
* the tween gets unpaused - it needs a way to place itself accurately in time AFTER what was previously the timeline's end time.
* In a SimpleTimeline, rawTime is always the same as cachedTotalTime, but in TimelineLite and TimelineMax, it can be different.
*
* @return The totalTime of the timeline without capping the number at the totalDuration (max) and zero (minimum)
*/
public function get rawTime():Number {
return this.cachedTotalTime;
}
}
}
\ No newline at end of file
/*
VERSION: 1.01
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for filter tweens. See the documentation
in TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {bevelFilter:{distance:5, blurX:10, blurY:10, strength:2}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.bevelFilter = new BevelFilterVars(5, 10, 10, 2);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility. If you need relative values, just use the shorter (non strictly
data typed) syntax, like TweenMax.to(my_mc, 1, {bevelFilter:{blurX:"-5", blurY:"3"}});
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
public class BevelFilterVars extends FilterVars {
public var distance:Number;
public var blurX:Number;
public var blurY:Number;
public var strength:Number;
public var angle:Number;
public var highlightAlpha:Number;
public var shadowAlpha:Number;
public function BevelFilterVars(distance:Number=4, blurX:Number=4, blurY:Number=4, strength:Number=1, angle:Number=45, highlightAlpha:Number=1, highlightColor:uint=0xFFFFFF, shadowAlpha:Number=1, shadowColor:uint=0x000000, quality:uint=2, remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super(remove, index, addFilter);
this.distance = distance;
this.blurX = blurX;
this.blurY = blurY;
this.strength = strength;
this.angle = angle;
this.highlightAlpha = highlightAlpha;
this.highlightColor = highlightColor;
this.shadowAlpha = shadowAlpha;
this.shadowColor = shadowColor;
this.quality = quality;
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls, numbers.concat(["distance","blurX","blurY","strength","angle","highlightAlpha","shadowAlpha"]));
}
public static function create(vars:Object):BevelFilterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is BevelFilterVars) {
return vars as BevelFilterVars;
}
return new BevelFilterVars(vars.distance || 0,
vars.blurX || 0,
vars.blurY || 0,
(vars.strength == null) ? 1 : vars.strength,
(vars.angle == null) ? 45 : vars.angle,
(vars.highlightAlpha == null) ? 1 : vars.highlightAlpha,
(vars.highlightColor == null) ? 0xFFFFFF : vars.highlightColor,
(vars.shadowAlpha == null) ? 1 : vars.shadowAlpha,
(vars.shadowColor == null) ? 0xFFFFFF : vars.shadowColor,
vars.quality || 2,
vars.remove || false,
(vars.index == null) ? -1 : vars.index,
vars.addFilter || false);
}
//---- GETTERS / SETTERS --------------------------------------------------------------------------------------------
/** Highlight color. **/
public function get highlightColor():uint {
return uint(_values.highlightColor);
}
public function set highlightColor(value:uint):void {
setProp("highlightColor", value);
}
/** Shadow color. **/
public function get shadowColor():uint {
return uint(_values.shadowColor);
}
public function set shadowColor(value:uint):void {
setProp("shadowColor", value);
}
/** Quality (1, 2, or 3). **/
public function get quality():uint {
return uint(_values.quality);
}
public function set quality(value:uint):void {
setProp("quality", value);
}
}
}
\ No newline at end of file
/*
VERSION: 1.01
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for filter tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {blurFilter:{blurX:10, blurY:10}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.blurFilter = new BlurFilterVars(10, 10);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility. If you need relative values, just use the shorter (non strictly
data typed) syntax, like TweenMax.to(my_mc, 1, {blurFilter:{blurX:"-5", blurY:"3"}});
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
public class BlurFilterVars extends FilterVars {
public var blurX:Number;
public var blurY:Number;
public function BlurFilterVars(blurX:Number=10, blurY:Number=10, quality:uint=2, remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super(remove, index, addFilter);
this.blurX = blurX;
this.blurY = blurY;
this.quality = quality;
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls, numbers.concat(["blurX","blurY"]));
}
public static function create(vars:Object):BlurFilterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is BlurFilterVars) {
return vars as BlurFilterVars;
}
return new BlurFilterVars(vars.blurX || 0,
vars.blurY || 0,
vars.quality || 2,
vars.remove || false,
(vars.index == null) ? -1 : vars.index,
vars.addFilter || false);
}
//---- GETTERS / SETTERS ------------------------------------------------------------------------------
/** Quality (1, 2, or 3). **/
public function get quality():uint {
return uint(_values.quality);
}
public function set quality(value:uint):void {
setProp("quality", value);
}
}
}
\ No newline at end of file
/*
VERSION: 1.01
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for filter tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {colorMatrixFilter:{colorize:0xFF0000, amount:0.5}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.colorMatrixFilter = new ColorMatrixFilterVars(0xFF0000, 0.5);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility. If you need relative values, just use the shorter (non strictly
data typed) syntax, like TweenMax.to(my_mc, 1, {colorMatrixFilter:{contrast:0.5, relative:true}});
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
import com.greensock.plugins.*;
public class ColorMatrixFilterVars extends FilterVars {
protected static var _ID_MATRIX:Array = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];
protected static var _lumR:Number = 0.212671; //Red constant - used for a few color matrix filter functions
protected static var _lumG:Number = 0.715160; //Green constant - used for a few color matrix filter functions
protected static var _lumB:Number = 0.072169; //Blue constant - used for a few color matrix filter functions
public var matrix:Array;
public function ColorMatrixFilterVars(colorize:uint=0xFFFFFF, amount:Number=1, saturation:Number=1, contrast:Number=1, brightness:Number=1, hue:Number=0, threshold:Number=-1, remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super(remove, index, addFilter);
this.matrix = _ID_MATRIX.slice();
if (brightness != 1) {
setBrightness(brightness);
}
if (contrast != 1) {
setContrast(contrast);
}
if (hue != 0) {
setHue(hue);
}
if (saturation != 1) {
setSaturation(saturation);
}
if (threshold != -1) {
setThreshold(threshold);
}
if (colorize != 0xFFFFFF) {
setColorize(colorize, amount);
}
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls.concat(["matrix"]), numbers);
}
public function setBrightness(n:Number):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.setBrightness(this.matrix, n);
}
public function setContrast(n:Number):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.setContrast(this.matrix, n);
}
public function setHue(n:Number):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.setHue(this.matrix, n);
}
public function setSaturation(n:Number):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.setSaturation(this.matrix, n);
}
public function setThreshold(n:Number):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.setThreshold(this.matrix, n);
}
public function setColorize(color:uint, amount:Number=1):void {
this.matrix = this.exposedVars.matrix = ColorMatrixFilterPlugin.colorize(this.matrix, color, amount);
}
public static function create(vars:Object):ColorMatrixFilterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
var v:ColorMatrixFilterVars;
if (vars is ColorMatrixFilterVars) {
v = vars as ColorMatrixFilterVars;
} else if (vars.matrix != null) {
v = new ColorMatrixFilterVars();
v.matrix = vars.matrix;
} else {
v = new ColorMatrixFilterVars(vars.colorize || 0xFFFFFF,
(vars.amount == null) ? 1 : vars.amount,
(vars.saturation == null) ? 1 : vars.saturation,
(vars.contrast == null) ? 1 : vars.contrast,
(vars.brightness == null) ? 1 : vars.brightness,
vars.hue || 0,
(vars.threshold == null) ? -1 : vars.threshold,
vars.remove || false,
(vars.index == null) ? -1 : vars.index,
vars.addFilter || false);
}
return v;
}
}
}
\ No newline at end of file
/*
VERSION: 1.0
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for colorTransform tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {colorTransform:{exposure:2}}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
var ct:ColorTransformVars = new ColorTransformVars();
ct.exposure = 2;
myVars.colorTransform = ct;
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility.
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
public class ColorTransformVars extends VarsCore {
public var tintAmount:Number;
public var exposure:Number;
public var brightness:Number;
public var redMultiplier:Number;
public var redOffset:Number;
public var greenMultiplier:Number;
public var greenOffset:Number;
public var blueMultiplier:Number;
public var blueOffset:Number;
public var alphaMultiplier:Number;
public var alphaOffset:Number;
public function ColorTransformVars(tint:Number=NaN, tintAmount:Number=NaN, exposure:Number=NaN, brightness:Number=NaN, redMultiplier:Number=NaN, greenMultiplier:Number=NaN, blueMultiplier:Number=NaN, alphaMultiplier:Number=NaN, redOffset:Number=NaN, greenOffset:Number=NaN, blueOffset:Number=NaN, alphaOffset:Number=NaN) {
super();
if (tint || tint == 0) { //faster than !isNaN())
this.tint = uint(tint);
}
if (tintAmount || tintAmount == 0) {
this.tintAmount = tintAmount;
}
if (exposure || exposure == 0) {
this.exposure = exposure;
}
if (brightness || brightness == 0) {
this.brightness = brightness;
}
if (redMultiplier || redMultiplier == 0) {
this.redMultiplier = redMultiplier;
}
if (greenMultiplier || greenMultiplier == 0) {
this.greenMultiplier = greenMultiplier;
}
if (blueMultiplier || blueMultiplier == 0) {
this.blueMultiplier = blueMultiplier;
}
if (alphaMultiplier || alphaMultiplier == 0) {
this.alphaMultiplier = alphaMultiplier;
}
if (redOffset || redOffset == 0) {
this.redOffset = redOffset;
}
if (greenOffset || greenOffset == 0) {
this.greenOffset = greenOffset;
}
if (blueOffset || blueOffset == 0) {
this.blueOffset = blueOffset;
}
if (alphaOffset || alphaOffset == 0) {
this.alphaOffset = alphaOffset;
}
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls,
numbers.concat(["tintAmount","exposure","brightness","redMultiplier","redOffset",
"greenMultiplier","greenOffset","blueMultiplier","blueOffset",
"alphaMultiplier","alphaOffset"]));
}
public static function create(vars:Object):ColorTransformVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is ColorTransformVars) {
return vars as ColorTransformVars;
}
return new ColorTransformVars(vars.tint,
vars.tintAmount,
vars.exposure,
vars.brightness,
vars.redMultiplier,
vars.greenMultiplier,
vars.blueMultiplier,
vars.alphaMultiplier,
vars.redOffset,
vars.greenOffset,
vars.blueOffset,
vars.alphaOffset);
}
//---- GETTERS / SETTERS ------------------------------------------------------------------------------
/** To change a DisplayObject's tint, set this to the hex value of the color you'd like the DisplayObject to end up at(or begin at if you're using TweenLite.from()). An example hex value would be 0xFF0000. If you'd like to remove the tint from a DisplayObject, use the removeTint special property. **/
public function get tint():uint {
return uint(_values.tint);
}
public function set tint(value:uint):void {
setProp("tint", value);
}
}
}
\ No newline at end of file
/*
VERSION: 1.01
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for filter tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {dropShadowFilter:{distance:5, blurX:10, blurY:10, color:0xFF0000}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.dropShadowFilter = new DropShadowFilterVars(5, 10, 10, 1, 45, 0xFF0000);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility. If you need relative values, just use the shorter (non strictly
data typed) syntax, like TweenMax.to(my_mc, 1, {dropShadowFilter:{blurX:"-5", blurY:"3"}});
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
public class DropShadowFilterVars extends BlurFilterVars {
public var distance:Number;
public var alpha:Number;
public var angle:Number;
public var strength:Number;
public function DropShadowFilterVars(distance:Number=4, blurX:Number=4, blurY:Number=4, alpha:Number=1, angle:Number=45, color:uint=0x000000, strength:Number=2, inner:Boolean=false, knockout:Boolean=false, hideObject:Boolean=false, quality:uint=2, remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super(blurX, blurY, quality, remove, index, addFilter);
this.distance = distance;
this.alpha = alpha;
this.angle = angle;
this.color = color;
this.strength = strength;
this.inner = inner;
this.knockout = knockout;
this.hideObject = hideObject;
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls, numbers.concat(["distance","alpha","angle","strength"]));
}
public static function create(vars:Object):DropShadowFilterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is DropShadowFilterVars) {
return vars as DropShadowFilterVars;
}
return new DropShadowFilterVars(vars.distance || 0,
vars.blurX || 0,
vars.blurY || 0,
vars.alpha || 0,
(vars.angle == null) ? 45 : vars.angle,
(vars.color == null) ? 0x000000 : vars.color,
(vars.strength == null) ? 2 : vars.strength,
Boolean(vars.inner),
Boolean(vars.knockout),
Boolean(vars.hideObject),
vars.quality || 2,
vars.remove || false,
(vars.index == null) ? -1 : vars.index,
vars.addFilter);
}
//---- GETTERS / SETTERS --------------------------------------------------------------------------------------------
/** Color. **/
public function get color():uint {
return uint(_values.color);
}
public function set color(value:uint):void {
setProp("color", value);
}
/** **/
public function get inner():Boolean {
return Boolean(_values.inner);
}
public function set inner(value:Boolean):void {
setProp("inner", value);
}
/** **/
public function get knockout():Boolean {
return Boolean(_values.knockout);
}
public function set knockout(value:Boolean):void {
setProp("knockout", value);
}
/** **/
public function get hideObject():Boolean {
return Boolean(_values.hideObject);
}
public function set hideObject(value:Boolean):void {
setProp("hideObject", value);
}
}
}
\ No newline at end of file
/**
* VERSION: 2.0
* DATE: 8/1/2009
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock.data {
import com.greensock.data.VarsCore;
/**
* This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
* strict data typing and code hinting (in most code editors). See the documentation in
* the TweenLiteVars or TweenMaxVars for more information.
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class FilterVars extends VarsCore {
public function FilterVars(remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super();
this.remove = remove;
if (index > -1) {
this.index = index;
}
this.addFilter = addFilter;
}
//---- GETTERS / SETTERS -----------------------------------------------------------------------------------------
/** To remove the filter after the tween has completed, set remove to true. **/
public function get remove():Boolean {
return Boolean(_values.remove);
}
public function set remove(value:Boolean):void {
setProp("remove", value);
}
/** To force TweenLite/Max to create a new filter even if there's a filter of the same kind already applied to a DisplayObject, set addFilter to true. **/
public function get addFilter():Boolean {
return Boolean(_values.addFilter);
}
public function set addFilter(value:Boolean):void {
setProp("addFilter", value);
}
/** To define a particular index number in the target DisplayObject's filters Array for this filter, use index property. **/
public function get index():int {
return int(_values.index);
}
public function set index(value:int):void {
setProp("index", value);
}
}
}
\ No newline at end of file
/*
VERSION: 1.01
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for filter tweens. See the documentation in
the TweenLiteVars, or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {glowFilter:{blurX:10, blurY:10, color:0xFF0000}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.glowFilter = new GlowFilterVars(10, 10);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility. If you need relative values, just use the shorter (non strictly
data typed) syntax, like TweenMax.to(my_mc, 1, {glowFilter:{blurX:"-5", blurY:"3"}});
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
public class GlowFilterVars extends BlurFilterVars {
public var alpha:Number;
public var strength:Number;
public function GlowFilterVars(blurX:Number=10, blurY:Number=10, color:uint=0xFFFFFF, alpha:Number=1, strength:Number=2, inner:Boolean=false, knockout:Boolean=false, quality:uint=2, remove:Boolean=false, index:int=-1, addFilter:Boolean=false) {
super(blurX, blurY, quality, remove, index, addFilter);
this.color = color;
this.alpha = alpha;
this.strength = strength;
this.inner = inner;
this.knockout = knockout;
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls, numbers.concat(["alpha","strength"]));
}
public static function create(vars:Object):GlowFilterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is GlowFilterVars) {
return vars as GlowFilterVars;
}
return new GlowFilterVars(vars.blurX || 0,
vars.blurY || 0,
(vars.color == null) ? 0x000000 : vars.color,
vars.alpha || 0,
(vars.strength == null) ? 2 : vars.strength,
Boolean(vars.inner),
Boolean(vars.knockout),
vars.quality || 2,
vars.remove || false,
(vars.index == null) ? -1 : vars.index,
vars.addFilter || false);
}
//---- GETTERS / SETTERS -------------------------------------------------------------------------------------
/** Color. **/
public function get color():uint {
return uint(_values.color);
}
public function set color(value:uint):void {
setProp("color", value);
}
/** **/
public function get inner():Boolean {
return Boolean(_values.inner);
}
public function set inner(value:Boolean):void {
setProp("inner", value);
}
/** **/
public function get knockout():Boolean {
return Boolean(_values.knockout);
}
public function set knockout(value:Boolean):void {
setProp("knockout", value);
}
}
}
\ No newline at end of file
/*
VERSION: 1.0
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for transformAroundPoint tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {transformAroundCenter:{scaleX:2, scaleY:1.5, rotation:30}}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.transformAroundPoint = new TransformAroundCenterVars(2, 1.5, 30);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility.
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
import flash.geom.Point;
public class TransformAroundCenterVars extends TransformAroundPointVars {
public function TransformAroundCenterVars(scaleX:Number=NaN, scaleY:Number=NaN, rotation:Number=NaN, width:Number=NaN, height:Number=NaN, shortRotation:Object=null, x:Number=NaN, y:Number=NaN) {
super(null, scaleX, scaleY, rotation, width, height, shortRotation, x, y);
}
public static function create(vars:Object):TransformAroundCenterVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is TransformAroundCenterVars) {
return vars as TransformAroundCenterVars;
}
return new TransformAroundCenterVars(vars.scaleX,
vars.scaleY,
vars.rotation,
vars.width,
vars.height,
vars.shortRotation,
vars.x,
vars.y);
}
}
}
\ No newline at end of file
/*
VERSION: 1.0
DATE: 1/29/2009
ACTIONSCRIPT VERSION: 3.0
DESCRIPTION:
This class works in conjunction with the TweenLiteVars or TweenMaxVars class to grant
strict data typing and code hinting (in most code editors) for transformAroundPoint tweens. See the documentation in
the TweenLiteVars or TweenMaxVars for more information.
USAGE:
Instead of TweenMax.to(my_mc, 1, {transformAroundPoint:{point:new Point(100, 50), scaleX:2, scaleY:1.5, rotation:30}}, onComplete:myFunction}), you could use this utility like:
var myVars:TweenMaxVars = new TweenMaxVars();
myVars.transformAroundPoint = new TransformAroundPointVars(new Point(100, 50), 2, 1.5, 30);
myVars.onComplete = myFunction;
TweenMax.to(my_mc, 1, myVars);
NOTES:
- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite/TweenMax class, feel
free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict data typing.
- You cannot define relative tween values with this utility.
AUTHOR: Jack Doyle, jack@greensock.com
Copyright 2010, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*/
package com.greensock.data {
import flash.geom.Point;
public class TransformAroundPointVars extends VarsCore {
public var point:Point;
public var scaleX:Number;
public var scaleY:Number;
public var scale:Number;
public var rotation:Number;
public var width:Number;
public var height:Number;
public var shortRotation:Object;
public var x:Number;
public var y:Number;
public function TransformAroundPointVars(point:Point=null, scaleX:Number=NaN, scaleY:Number=NaN, rotation:Number=NaN, width:Number=NaN, height:Number=NaN, shortRotation:Object=null, x:Number=NaN, y:Number=NaN) {
super();
if (point != null) {
this.point = point;
}
if (scaleX || scaleX == 0) { //faster than !isNaN())
this.scaleX = scaleX;
}
if (scaleY || scaleY == 0) {
this.scaleY = scaleY;
}
if (rotation || rotation == 0) {
this.rotation = rotation;
}
if (width || width == 0) {
this.width = width;
}
if (height || height == 0) {
this.height = height;
}
if (shortRotation != null) {
this.shortRotation = shortRotation;
}
if (x || x == 0) {
this.x = x;
}
if (y || y == 0) {
this.y = y;
}
}
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls.concat(["point","shortRotation"]), numbers.concat(["scaleX","scaleY","scale","rotation","width","height","x","y"]));
}
public static function create(vars:Object):TransformAroundPointVars { //for parsing values that are passed in as generic Objects, like blurFilter:{blurX:5, blurY:3} (typically via the constructor)
if (vars is TransformAroundPointVars) {
return vars as TransformAroundPointVars;
}
return new TransformAroundPointVars(vars.point,
vars.scaleX,
vars.scaleY,
vars.rotation,
vars.width,
vars.height,
vars.shortRotation,
vars.x,
vars.y);
}
}
}
\ No newline at end of file
/**
* VERSION: 4.0
* DATE: 8/3/2009
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock.data {
import com.greensock.data.TweenLiteVars;
/**
* There are 2 primary benefits of using this utility to define your TweenMax variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in TweenMax</li>
* <li> It allows you to code using strict datatyping (although it doesn't force you to). </li>
* </ol>
*
* <b>USAGE:</b><br /><br />
*
* Instead of TweenMax.to(my_mc, 1, {x:300, tint:0xFF0000, onComplete:myFunction}), you could use this utility like:<br /><br /><code>
*
* var myVars:TweenMaxVars = new TweenMaxVars();<br />
* myVars.addProp("x", 300); // use addProp() to add any property that doesn't already exist in the TweenMaxVars instance.<br />
* myVars.tint = 0xFF0000;<br />
* myVars.onComplete = myFunction;<br />
* TweenMax.to(my_mc, 1, myVars);<br /><br /></code>
*
*
* <b>NOTES:</b>
* <ul>
* <li> This class adds about 14 Kb to your published SWF.</li>
* <li> This utility is completely optional. If you prefer the shorter synatax in the regular TweenMax class, feel
* free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict datatyping.</li>
* <li> You may add custom properties to this class if you want, but in order to expose them to TweenMax, make sure
* you also add a getter and a setter that adds the property to the _exposedVars Object.</li>
* <li> You can reuse a single TweenMaxVars Object for multiple tweens if you want, but be aware that there are a few
* properties that must be handled in a special way, and once you set them, you cannot remove them. Those properties
* are: frame, visible, tint, and volume. If you are altering these values, it might be better to avoid reusing a TweenMaxVars
* Object.</li>
* </ul>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class TweenMaxVars extends TweenLiteVars {
/** A function to which the TweenMax instance should dispatch a TweenEvent when it begins. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.START, myFunction); **/
public var onStartListener:Function;
/** A function to which the TweenMax instance should dispatch a TweenEvent every time it updates values. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.UPDATE, myFunction); **/
public var onUpdateListener:Function;
/** A function to which the TweenMax instance should dispatch a TweenEvent when it completes. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.COMPLETE, myFunction); **/
public var onCompleteListener:Function;
/** A function that should be called when the tween has reached its starting point again after having been reversed **/
public var onReverseComplete : Function;
/** An Array of parameters to pass the onReverseComplete functions **/
public var onReverseCompleteParams : Array;
/** A function that should be called every time the tween repeats **/
public var onRepeat : Function;
/** An Array of parameters to pass the onRepeat function **/
public var onRepeatParams : Array;
/** Amount of time in seconds (or frames for frames-based tween) between repeats. **/
public var repeatDelay:Number;
/** Allows you to define the starting values for each property. Typically, TweenMax uses the current value (whatever it happens to be at the time the tween begins) as the start value, but startAt allows you to override that behavior. Simply pass an object in with whatever properties you'd liketo set just before the tween begins. For example, if mc.x is currently 100, and you'd like to tween it from 0 to 500, do TweenMax.to(mc, 2, {x:500, startAt:{x:0}}); **/
public var startAt:TweenLiteVars;
/** An Array of the names of properties that should be rounded to the nearest integer when tweening **/
public var roundProps:Array;
/**
* @param vars An Object containing properties that correspond to the properties you'd like to add to this TweenMaxVars Object. For example, TweenMaxVars({blurFilter:{blurX:10, blurY:20}, onComplete:myFunction})
*/
public function TweenMaxVars(vars:Object=null) {
super(vars);
}
/** @private **/
override protected function initEnumerables(nulls:Array, numbers:Array):void {
super.initEnumerables(nulls.concat(["onStartListener","onUpdateListener","onReverseCompleteListener","onReverseCompleteParams",
"onRepeat","onRepeatParams","startAt","roundProps"]),
numbers.concat(["repeatDelay"]));
}
/** Clones the TweenMaxVars object. **/
override public function clone():TweenLiteVars {
return this.copyPropsTo(new TweenMaxVars()) as TweenMaxVars;
}
//---- GETTERS / SETTERS ---------------------------------------------------------------------------------------------
/** Works in conjunction with the repeat property, determining the behavior of each cycle. When yoyo is true, the tween will go back and forth, appearing to reverse every other cycle (this has no affect on the "reversed" property though). **/
public function get yoyo():Boolean {
return Boolean(_values.yoyo);
}
public function set yoyo(value:Boolean):void {
setProp("yoyo", value);
}
/** If true, the tween will be paused initially. **/
public function get paused():Boolean {
return Boolean(_values.paused);
}
public function set paused(value:Boolean):void {
setProp("paused", value);
}
/** If true, the tween will be reversed initially. This does not swap the starting/ending values in the tween - it literally changes its orientation/direction. Imagine the playhead moving backwards instead of forwards. **/
public function get reversed():Boolean {
return Boolean(_values.reversed);
}
public function set reversed(value:Boolean):void {
setProp("reversed", value);
}
/** Number of times that the tween should repeat (to repeat indefinitely, use -1). **/
public function get repeat():int {
return int(_values.repeat);
}
public function set repeat(value:int):void {
setProp("repeat", value);
}
}
}
\ No newline at end of file
/**
* VERSION: 2.01
* DATE: 9/23/2009
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.TweenLite.com
**/
package com.greensock.data {
import flash.utils.Proxy;
import flash.utils.flash_proxy;
/**
* VarsCore provides a way to make an object's non-dynamic properties enumerable (only if/when the property is
* set to a non-default value) which is necessary for many of the vars objects in the GreenSock tweening
* platform (TweenLiteVars, TweenMaxVars, etc.). There is no reason to use VarsCore directly, but rather use
* a subclass like TweenLiteVars to enable strict data typing and code hinting in modern apps like Flex Builder, FDT, etc.
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class VarsCore extends Proxy {
/** @private (for backwards compatibility) **/
public const isTV:Boolean = true;
/** @private faster to use an already-created empty Array rather than keep re-creating them. **/
protected static const _empty:Array = [];
/** @private **/
protected var _numbers:Object = {};
/** @private **/
protected var _props:Array;
/** @private **/
protected var _values:Object = {};
/** Constructor **/
public function VarsCore() {
initEnumerables(_empty, _empty);
}
/** @private **/
protected function initEnumerables(nulls:Array, numbers:Array):void {
_props = nulls.concat(numbers);
var i:int = numbers.length;
while (i-- > 0) {
_numbers[numbers[i]] = true;
}
}
/** @private **/
flash_proxy override function getProperty(prop:*):* {
return _values[prop];
}
/** @private **/
flash_proxy override function setProperty(prop:*, value:*):void {
setProp(String(prop), value);
}
flash_proxy override function hasProperty(name:*):Boolean {
return name in _values;
}
/** @private **/
flash_proxy override function deleteProperty(prop:*):Boolean {
var i:int = _props.indexOf(prop);
if (i != -1) {
_props.splice(i, 1);
delete _values[prop];
return true;
} else {
return false;
}
}
/** @private **/
override flash_proxy function nextNameIndex(index:int):int {
if (index >= _props.length) {
return 0;
} else {
var l:int = _props.length;
var p:String;
for (var i:int = index; i < l; i++) {
p = _props[i];
if (_numbers[p]) {
if (this[p] || this[p] == 0) {
return i + 1;
}
} else if (this[p] != null) {
return i + 1;
}
}
return 0;
}
}
/** @private **/
override flash_proxy function nextName(index:int):String {
return _props[index - 1];
}
/** @private **/
protected function setProp(name:String, value:*):void {
if (!(name in _values)) {
_props[_props.length] = name;
}
_values[name] = value;
}
protected function copyPropsTo(vars:VarsCore):VarsCore {
for (var p:String in this) {
vars[p] = this[p];
}
return vars;
}
//---- GETTERS / SETTERS ------------------------------------------------------------------------
/** @private For backwards compatibility **/
public function get exposedVars():Object {
return this;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Back {
public static function easeIn (t:Number, b:Number, c:Number, d:Number, s:Number = 1.70158):Number {
return c*(t/=d)*t*((s+1)*t - s) + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number, s:Number = 1.70158):Number {
return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number, s:Number = 1.70158):Number {
if ((t/=d*0.5) < 1) return c*0.5*(t*t*(((s*=(1.525))+1)*t - s)) + b;
return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b;
}
}
}
package com.greensock.easing {
public class Bounce {
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d) < (1/2.75)) {
return c*(7.5625*t*t) + b;
} else if (t < (2/2.75)) {
return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b;
} else if (t < (2.5/2.75)) {
return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b;
} else {
return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b;
}
}
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c - easeOut(d-t, 0, c, d) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if (t < d*0.5) return easeIn (t*2, 0, c, d) * .5 + b;
else return easeOut (t*2-d, 0, c, d) * .5 + c*.5 + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Circ {
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return c * Math.sqrt(1 - (t=t/d-1)*t) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return -c*0.5 * (Math.sqrt(1 - t*t) - 1) + b;
return c*0.5 * (Math.sqrt(1 - (t-=2)*t) + 1) + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Cubic {
public static const power:uint = 2;
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c*(t/=d)*t*t + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return c*((t=t/d-1)*t*t + 1) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return c*0.5*t*t*t + b;
return c*0.5*((t-=2)*t*t + 2) + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
/**
* EaseLookup enables you to find the easing function associated with a particular name (String),
* like "strongEaseOut" which can be useful when loading in XML data that comes in as Strings but
* needs to be translated to native function references.
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class EaseLookup {
/** @private **/
private static var _lookup:Object;
/**
* Finds the easing function associated with a particular name (String), like "strongEaseOut". This can be useful when
* loading in XML data that comes in as Strings but needs to be translated to native function references. You can pass in
* the name with or without the period, and it is case insensitive, so any of the following will find the Strong.easeOut function: <br /><br /><code>
* EaseLookup.find("Strong.easeOut") <br />
* EaseLookup.find("strongEaseOut") <br />
* EaseLookup.find("strongeaseout") <br /><br /></code>
*
* You can translate Strings directly when tweening, like this: <br /><code>
* TweenLite.to(mc, 1, {x:100, ease:EaseLookup.find(myString)});<br /><br /></code>
*
* @param name The name of the easing function, with or without the period and case insensitive (i.e. "Strong.easeOut" or "strongEaseOut")
* @return The easing function associated with the name
*/
public static function find(name:String):Function {
if (_lookup == null) {
buildLookup();
}
return _lookup[name.toLowerCase()];
}
/** @private **/
private static function buildLookup():void {
_lookup = {};
addInOut(Back, ["back"]);
addInOut(Bounce, ["bounce"]);
addInOut(Circ, ["circ", "circular"]);
addInOut(Cubic, ["cubic"]);
addInOut(Elastic, ["elastic"]);
addInOut(Expo, ["expo", "exponential"]);
addInOut(Linear, ["linear"]);
addInOut(Quad, ["quad", "quadratic"]);
addInOut(Quart, ["quart","quartic"]);
addInOut(Quint, ["quint", "quintic", "strong"]);
addInOut(Sine, ["sine"]);
_lookup["linear.easenone"] = _lookup["lineareasenone"] = Linear.easeNone;
}
/** @private **/
private static function addInOut(easeClass:Class, names:Array):void {
var name:String;
var i:int = names.length;
while (i-- > 0) {
name = names[i].toLowerCase();
_lookup[name + ".easein"] = _lookup[name + "easein"] = easeClass.easeIn;
_lookup[name + ".easeout"] = _lookup[name + "easeout"] = easeClass.easeOut;
_lookup[name + ".easeinout"] = _lookup[name + "easeinout"] = easeClass.easeInOut;
}
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Elastic {
private static const _2PI:Number = Math.PI * 2;
public static function easeIn (t:Number, b:Number, c:Number, d:Number, a:Number = 0, p:Number = 0):Number {
var s:Number;
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (!a || (c > 0 && a < c) || (c < 0 && a < -c)) { a=c; s = p/4; }
else s = p/_2PI * Math.asin (c/a);
return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*_2PI/p )) + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number, a:Number = 0, p:Number = 0):Number {
var s:Number;
if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3;
if (!a || (c > 0 && a < c) || (c < 0 && a < -c)) { a=c; s = p/4; }
else s = p/_2PI * Math.asin (c/a);
return (a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*_2PI/p ) + c + b);
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number, a:Number = 0, p:Number = 0):Number {
var s:Number;
if (t==0) return b; if ((t/=d*0.5)==2) return b+c; if (!p) p=d*(.3*1.5);
if (!a || (c > 0 && a < c) || (c < 0 && a < -c)) { a=c; s = p/4; }
else s = p/_2PI * Math.asin (c/a);
if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*_2PI/p )) + b;
return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*_2PI/p )*.5 + c + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Expo {
public static function easeIn(t:Number, b:Number, c:Number, d:Number):Number {
return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b - c * 0.001;
}
public static function easeOut(t:Number, b:Number, c:Number, d:Number):Number {
return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b;
}
public static function easeInOut(t:Number, b:Number, c:Number, d:Number):Number {
if (t==0) return b;
if (t==d) return b+c;
if ((t/=d*0.5) < 1) return c*0.5 * Math.pow(2, 10 * (t - 1)) + b;
return c*0.5 * (-Math.pow(2, -10 * --t) + 2) + b;
}
}
}
\ No newline at end of file
/**
* VERSION: 1.0
* DATE: 10/18/2009
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.easing {
import flash.utils.Dictionary;
import com.greensock.TweenLite;
/**
* TweenMax (AS3 only) has built-in algorithms that speed up the processing of certain easing equations but in order
* to take advantage of those optimizations, you must activate the easing equations first (you only need to
* activate them ONCE in your swf). The following easing equations from the com.greensock.easing package are
* eligible for activation:
* <code>
* <ul>
* <li>Linear (easeIn, easeOut, easeInOut, and easeNone)</li>
* <li>Quad (easeIn, easeOut, and easeInOut)</li>
* <li>Cubic (easeIn, easeOut, and easeInOut)</li>
* <li>Quart (easeIn, easeOut, and easeInOut)</li>
* <li>Quint (easeIn, easeOut, and easeInOut)</li>
* <li>Strong (easeIn, easeOut, and easeInOut)</li>
* </ul><br />
* </code>
*
* <b>EXAMPLE</b><br /><br />
*
* <code>
* import com.greensock.easing.*;<br /><br />
*
* //activate the optimized ease classes<br />
* FastEase.activate([Strong, Linear, Quad]);<br /><br />
*
* //then tween as usual (you don't have to do anything special in your tweens)<br />
* TweenMax.to(mc, 2, {x:200, ease:Linear.easeNone});<br /><br />
* </code>
*
* Once activated, the easing calculations run about <b>35-80% faster!</b> Keep in mind that the easing calculations are only one small part
* of the tweening engine, so you may only see a 2-15% improvement overall depending on the equation and quantity of simultaneous tweens.
*
* Notes: <br />
* <ul>
* <li>TweenLite does <b>NOT</b> have the internal algorithms in place to take advantage of optimized eases at this time (to conserve file size).</li>
* <li>Activating an ease multiple times doesn't hurt or help</li>
* </ul>
*
* @param easeClasses An Array containing the easing classes to activate, like [Strong, Linear, Quad]. It will automatically activate the easeIn, easeOut, easeInOut, and (if available) easeNone easing equations for each class in the Array.
*/
public class FastEase {
/**
* Normally you should use the <code>FastEase.activate()</code> method to activate optimized eases, but if you
* want to activate an ease that is NOT in the com.greensock.easing package (for example
* <code>fl.motion.easing.Quadratic</code>), you can register individual easing equations with
* this method. For example:
*
* <code>
* import fl.motion.easing.Quadratic;<br />
* import com.greensock.easing.FastEase;<br /><br />
*
* FastEase.activateEase(Quadratic.easeIn, 1, 1);
* </code>
*
* @param ease The easing equation (function) to activate. For example, Quadratic.easeIn
* @param type The type of ease (in, out, or inOut) where easeIn is 1, easeOut is 2, and easeInOut is 3.
* @param power The magnitude or power of the ease. For example, Linear is 0, Quad is 1, Cubic is 2, Quart is 3 and Quint and Strong are 4.
*/
public static function activateEase(ease:Function, type:int, power:uint):void {
TweenLite.fastEaseLookup[ease] = [type, power];
}
/**
* TweenMax (AS3 only) has built-in algorithms that speed up the processing of certain easing equations but in order
* to take advantage of those optimizations, you must activate the easing equations first (you only need to
* activate them ONCE in your swf). The following easing equations from the com.greensock.easing package are
* eligible for activation:
* <code>
* <ul>
* <li>Linear (easeIn, easeOut, easeInOut, and easeNone)</li>
* <li>Quad (easeIn, easeOut, and easeInOut)</li>
* <li>Cubic (easeIn, easeOut, and easeInOut)</li>
* <li>Quart (easeIn, easeOut, and easeInOut)</li>
* <li>Quint (easeIn, easeOut, and easeInOut)</li>
* <li>Strong (easeIn, easeOut, and easeInOut)</li>
* </ul><br />
* </code>
*
* <b>EXAMPLE</b><br /><br />
*
* <code>
* import com.greensock.easing.*;<br /><br />
*
* FastEase.activate([Strong, Linear, Quad]);<br /><br />
* </code>
*
* Notes: <br />
* <ul>
* <li>TweenLite does <b>NOT</b> have the internal algorithms in place to take advantage of optimized eases at this time (to conserve file size).</li>
* <li>Activating an ease multiple times doesn't hurt or help</li>
* </ul>
*
* @param easeClasses An Array containing the easing classes to activate, like [Strong, Linear, Quad]. It will automatically activate the easeIn, easeOut, easeInOut, and (if available) easeNone easing equations for each class in the Array.
*/
public static function activate(easeClasses:Array):void {
var i:int = easeClasses.length, easeClass:Object;
while (i--) {
easeClass = easeClasses[i];
if (easeClass.hasOwnProperty("power")) {
activateEase(easeClass.easeIn, 1, easeClass.power);
activateEase(easeClass.easeOut, 2, easeClass.power);
activateEase(easeClass.easeInOut, 3, easeClass.power);
if (easeClass.hasOwnProperty("easeNone")) {
activateEase(easeClass.easeNone, 1, 0);
}
}
}
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Linear {
public static const power:uint = 0;
public static function easeNone (t:Number, b:Number, c:Number, d:Number):Number {
return c*t/d + b;
}
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c*t/d + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return c*t/d + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
return c*t/d + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Quad {
public static const power:uint = 1;
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c*(t/=d)*t + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return -c *(t/=d)*(t-2) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return c*0.5*t*t + b;
return -c*0.5 * ((--t)*(t-2) - 1) + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Quart {
public static const power:uint = 3;
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c*(t/=d)*t*t*t + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return -c * ((t=t/d-1)*t*t*t - 1) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return c*0.5*t*t*t*t + b;
return -c*0.5 * ((t-=2)*t*t*t - 2) + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Quint {
public static const power:uint = 4;
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return c*(t/=d)*t*t*t*t + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return c*((t=t/d-1)*t*t*t*t + 1) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return c*0.5*t*t*t*t*t + b;
return c*0.5*((t-=2)*t*t*t*t + 2) + b;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.6
* DATE: 1/19/2010
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/roughease/
**/
package com.greensock.easing {
/**
* Most easing equations give a smooth, gradual transition between the start and end values, but RoughEase provides
* an easy way to get a rough, jagged effect instead. You can define an ease that it will use as a template (like a
* general guide - Linear.easeNone is the default) and then it will randomly plot points that wander from that template.
* The strength parameter controls how far from the template ease the points are allowed to go (a small number like
* 0.1 keeps it very close to the template ease whereas a larger number like 2 creates much larger jumps). You can
* also control the number of points in the ease, making it jerk more or less frequently. And lastly, you can associate
* a name with each RoughEase instance and retrieve it later like RoughEase.byName("myEaseName"). Since creating
* the initial RoughEase is the most processor-intensive part, it's a good idea to reuse instances if/when you can.<br /><br />
*
* <b>EXAMPLE CODE</b><br /><br /><code>
* import com.greensock.TweenLite;<br />
* import com.greensock.easing.RoughEase;<br /><br />
*
* TweenLite.from(mc, 3, {alpha:0, ease:RoughEase.create(1, 15)});<br /><br />
*
* //or create an instance directly<br />
* var rough:RoughEase = new RoughEase(1.5, 30, true, Strong.easeOut, "none", true, "superRoughEase");<br />
* TweenLite.to(mc, 3, {y:300, ease:rough.ease});<br /><br />
*
* //and later, you can find the ease by name like:<br />
* TweenLite.to(mc, 3, {y:300, ease:RoughEase.byName("superRoughEase")});
* </code><br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class RoughEase {
/** @private **/
private static var _all:Object = {}; //keeps track of all instances so we can find them by name.
/** @private **/
private static var _count:uint = 0;
/** @private **/
private var _name:String;
/** @private **/
private var _first:EasePoint;
/** @private **/
private var _last:EasePoint;
/**
* Constructor
*
* @param strength amount of variance from the templateEase (Linear.easeNone by default) that each random point can be placed. A low number like 0.1 will hug very closely to the templateEase whereas a larger number like 2 will allow the values to wander further away from the templateEase.
* @param points quantity of random points to plot in the ease. A larger number will cause more (and quicker) flickering.
* @param restrictMaxAndMin If true, the ease will prevent random points from exceeding the end value or dropping below the starting value. For example, if you're tweening the x property from 0 to 100, the RoughEase would force all random points to stay between 0 and 100 if restrictMaxAndMin is true, but if it is false, a x could potentially jump above 100 or below 0 at some point during the tween (it would always end at 100 though).
* @param templateEase an easing equation that should be used as a template or guide. Then random points are plotted at a certain distance away from the templateEase (based on the strength parameter). The default is Linear.easeNone.
* @param taper to make the strength of the roughness taper towards the end or beginning, use "out" or "in" respectively here (default is "none") .
* @param randomize to randomize the placement of the points, set randomize to true (otherwise the points will zig-zag evenly across the ease)
* @param name a name to associate with the ease so that you can use RoughEase.byName() to look it up later. Of course you should always make sure you use a unique name for each ease (if you leave it blank, a name will automatically be generated).
*/
public function RoughEase(strength:Number=1, points:uint=20, restrictMaxAndMin:Boolean=false, templateEase:Function=null, taper:String="none", randomize:Boolean=true, name:String="") {
if (name == "") {
_count++;
_name = "roughEase" + _count;
} else {
_name = name;
}
if (taper == "" || taper == null) {
taper = "none";
}
_all[_name] = this;
var a:Array = [];
var cnt:uint = 0;
var x:Number, y:Number, bump:Number, invX:Number, obj:Object;
var i:uint = points;
while (i--) {
x = randomize ? Math.random() : (1 / points) * i;
y = (templateEase != null) ? templateEase(x, 0, 1, 1) : x;
if (taper == "none") {
bump = 0.4 * strength;
} else if (taper == "out") {
invX = 1 - x;
bump = invX * invX * strength * 0.4;
} else {
bump = x * x * strength * 0.4;
}
if (randomize) {
y += (Math.random() * bump) - (bump * 0.5);
} else if (i % 2) {
y += bump * 0.5;
} else {
y -= bump * 0.5;
}
if (restrictMaxAndMin) {
if (y > 1) {
y = 1;
} else if (y < 0) {
y = 0;
}
}
a[cnt++] = {x:x, y:y};
}
a.sortOn("x", Array.NUMERIC);
_first = _last = new EasePoint(1, 1, null);
i = points;
while (i--) {
obj = a[i];
_first = new EasePoint(obj.x, obj.y, _first);
}
_first = new EasePoint(0, 0, _first);
}
/**
* This static function provides a quick way to create a RoughEase and immediately reference its ease function
* in a tween, like:<br /><br /><code>
*
* TweenLite.from(mc, 2, {alpha:0, ease:RoughEase.create(1.5, 15)});<br />
* </code>
*
* @param strength amount of variance from the templateEase (Linear.easeNone by default) that each random point can be placed. A low number like 0.1 will hug very closely to the templateEase whereas a larger number like 2 will allow the values to wander further away from the templateEase.
* @param points quantity of random points to plot in the ease. A larger number will cause more (and quicker) flickering.
* @param restrictMaxAndMin If true, the ease will prevent random points from exceeding the end value or dropping below the starting value. For example, if you're tweening the x property from 0 to 100, the RoughEase would force all random points to stay between 0 and 100 if restrictMaxAndMin is true, but if it is false, a x could potentially jump above 100 or below 0 at some point during the tween (it would always end at 100 though).
* @param templateEase an easing equation that should be used as a template or guide. Then random points are plotted at a certain distance away from the templateEase (based on the strength parameter). The default is Linear.easeNone.
* @param taper to make the strength of the roughness taper towards the end or beginning, use "out" or "in" respectively here (default is "none") .
* @param randomize to randomize the placement of the points, set randomize to true (otherwise the points will zig-zag evenly across the ease)
* @param name a name to associate with the ease so that you can use RoughEase.byName() to look it up later. Of course you should always make sure you use a unique name for each ease (if you leave it blank, a name will automatically be generated).
* @return easing function
*/
public static function create(strength:Number=1, points:uint=20, restrictMaxAndMin:Boolean=false, templateEase:Function=null, taper:String="none", randomize:Boolean=true, name:String=""):Function {
return new RoughEase(strength, points, restrictMaxAndMin, templateEase, taper, randomize, name).ease;
}
/**
* Provides a quick way to look up a RoughEase by its name.
*
* @param name the name of the RoughEase
* @return easing function from the RoughEase associated with the name
*/
public static function byName(name:String):Function {
return _all[name].ease;
}
/**
* Easing function that interpolates the numbers
*
* @param t time
* @param b start
* @param c change
* @param d duration
* @return Result of the ease
*/
public function ease(t:Number, b:Number, c:Number, d:Number):Number {
var time:Number = t / d;
var p:EasePoint;
if (time < 0.5) {
p = _first;
while (p.time <= time) {
p = p.next;
}
p = p.prev;
} else {
p = _last;
while (p.time >= time) {
p = p.prev;
}
}
return b + (p.value + ((time - p.time) / p.gap) * p.change) * c;
}
/** name of the RoughEase instance **/
public function get name():String {
return _name;
}
public function set name(s:String):void {
delete _all[_name];
_name = s;
_all[s] = this;
}
}
}
internal class EasePoint {
public var time:Number;
public var gap:Number;
public var value:Number;
public var change:Number;
public var next:EasePoint;
public var prev:EasePoint;
public function EasePoint(time:Number, value:Number, next:EasePoint) {
this.time = time;
this.value = value;
if (next) {
this.next = next;
next.prev = this;
this.change = next.value - value;
this.gap = next.time - time;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Sine {
private static const _HALF_PI:Number = Math.PI * 0.5;
public static function easeIn (t:Number, b:Number, c:Number, d:Number):Number {
return -c * Math.cos(t/d * _HALF_PI) + c + b;
}
public static function easeOut (t:Number, b:Number, c:Number, d:Number):Number {
return c * Math.sin(t/d * _HALF_PI) + b;
}
public static function easeInOut (t:Number, b:Number, c:Number, d:Number):Number {
return -c*0.5 * (Math.cos(Math.PI*t/d) - 1) + b;
}
}
}
\ No newline at end of file
package com.greensock.easing {
public class Strong {
public static const power:uint = 4;
public static function easeIn(t:Number, b:Number, c:Number, d:Number):Number {
return c*(t/=d)*t*t*t*t + b;
}
public static function easeOut(t:Number, b:Number, c:Number, d:Number):Number {
return c*((t=t/d-1)*t*t*t*t + 1) + b;
}
public static function easeInOut(t:Number, b:Number, c:Number, d:Number):Number {
if ((t/=d*0.5) < 1) return c*0.5*t*t*t*t*t + b;
return c*0.5*((t-=2)*t*t*t*t + 2) + b;
}
}
}
This readme file applies to all eases in this directory EXCEPT the CustomEase, EaseLookup, FastEase, and RoughEase.
============================================================================================
Easing Equations
(c) 2003 Robert Penner, all rights reserved.
This work is subject to the terms in http://www.robertpenner.com/easing_terms_of_use.html.
============================================================================================
TERMS OF USE - EASING EQUATIONS
Open source under the BSD License.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of the author nor the names of contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\ No newline at end of file
/**
* VERSION: 1.2
* DATE: 2010-07-28
* AS3
* UPDATES AND DOCS AT: http://www.greensock.com/loadermax/
**/
package com.greensock.events {
import flash.events.Event;
/**
* An Event dispatched by one of the loaders in the LoaderMax system.
* <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class LoaderEvent extends Event {
/** Dispatched by a LoaderMax (or other loader that may dynamically recognize nested loaders like XMLLoader and SWFLoader) when one of its children begins loading. **/
public static const CHILD_OPEN:String="childOpen";
/** Dispatched by a LoaderMax (or other loader that may dynamically recognize nested loaders like XMLLoader and SWFLoader) when one of its children dispatches a <code>PROGRESS</code> Event. **/
public static const CHILD_PROGRESS:String="childProgress";
/** Dispatched by a LoaderMax (or other loader that may dynamically recognize nested loaders like XMLLoader and SWFLoader) when one of its children aborts its loading. This can happen when the loader fails, when <code>cancel()</code> is manually called, or when another loader is prioritized in the loading queue. **/
public static const CHILD_CANCEL:String="childCancel";
/** Dispatched by a LoaderMax (or other loader that may dynamically recognize nested loaders like XMLLoader and SWFLoader) when one of its children finishes loading. **/
public static const CHILD_COMPLETE:String="childComplete";
/** Dispatched by a LoaderMax (or other loader that may dynamically recognize nested loaders like XMLLoader and SWFLoader) when one of its children fails to load. **/
public static const CHILD_FAIL:String="childFail";
/** Dispatched when the loader begins loading, like when its <code>load()</code> method is called. **/
public static const OPEN:String="open";
/** Dispatched when the loader's <code>bytesLoaded</code> changes. **/
public static const PROGRESS:String="progress";
/** Dispatched when the loader aborts its loading. This can happen when the loader fails, when <code>cancel()</code> is manually called, or when another loader is prioritized in the loading queue. **/
public static const CANCEL:String="cancel";
/** Dispatched when the loader fails. **/
public static const FAIL:String="fail";
/** Dispatched when the loader initializes which means different things for different loaders. For example, a SWFLoader dispatches <code>INIT</code> when it downloads enough of the swf to render the first frame. When a VideoLoader receives MetaData, it dispatches its <code>INIT</code> event, as does an MP3Loader when it receives ID3 data. See the docs for each class for specifics. **/
public static const INIT:String="init";
/** Dispatched when the loader finishes loading. **/
public static const COMPLETE:String="complete";
/** Dispatched when the loader (or one of its children) receives an HTTP_STATUS event (see Adobe docs for specifics). **/
public static const HTTP_STATUS:String="httpStatus";
/** When script access is denied for a particular loader (like if an ImageLoader or SWFLoader tries loading from another domain and the crossdomain.xml file is missing or doesn't grant permission properly), a SCRIPT_ACCESS_DENIED LoaderEvent will be dispatched. **/
public static const SCRIPT_ACCESS_DENIED:String="scriptAccessDenied";
/** Dispatched when the loader (or one of its children) throws any error, like an IO_ERROR or SECURITY_ERROR. **/
public static const ERROR:String="error";
/** Dispatched when the the loader (or one of its children) encounters an IO_ERROR (typically when it cannot find the file at the specified <code>url</code>). **/
public static const IO_ERROR:String="ioError";
/** Dispatched when the loader (or one of its children) encounters a SECURITY_ERROR (see Adobe's docs for details). **/
public static const SECURITY_ERROR:String="securityError";
/** @private **/
protected var _target:Object;
/** @private **/
protected var _ready:Boolean;
/** For <code>ERROR, FAIL</code>, and <code>CHILD_FAIL</code> events, this text will give more details about the error or failure. **/
public var text:String;
/** Event-related data which varies based on the type of event. For example, VideoLoader dispatches a VIDEO_CUE_POINT event containing data about the cue point. **/
public var data:*;
/**
* Constructor
*
* @param type Type of event
* @param target Target
* @param text Error text (if any)
*/
public function LoaderEvent(type:String, target:Object, text:String="", data:*=null){
super(type, false, false);
_target = target;
this.text = text;
this.data = data;
}
/** @inheritDoc **/
public override function clone():Event{
return new LoaderEvent(this.type, _target, this.text, this.data);
}
/**
* The loader associated with the LoaderEvent. This may be different than the <code>currentTarget</code>.
* The <code>target</code> always refers to the originating loader, so if there is an ImageLoader nested inside
* a LoaderMax instance and you add an event listener to the LoaderMax, if the ImageLoader dispatches an error
* event, the event's <code>target</code> will refer to the ImageLoader whereas the <code>currentTarget</code> will
* refer to the LoaderMax instance that is currently processing the event.
**/
override public function get target():Object {
if (_ready) {
return _target;
} else {
//when the event is re-dispatched, Flash's event system checks to see if the target has been set and if it has, Flash will clone() and reset the target so we need to report the target as null the first time and then on subsequent calls, report the real target.
_ready = true;
}
return null;
}
}
}
\ No newline at end of file
package com.greensock.events {
import flash.events.Event;
/**
* Used for dispatching events from the GreenSock Tweening Platform. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class TweenEvent extends Event {
/** @private **/
public static const VERSION:Number = 1.1;
public static const START:String = "start";
public static const UPDATE:String = "change";
public static const COMPLETE:String = "complete";
public static const REVERSE_COMPLETE:String = "reverseComplete";
public static const REPEAT:String = "repeat";
public static const INIT:String = "init";
public function TweenEvent(type:String, bubbles:Boolean=false, cancelable:Boolean=false) {
super(type, bubbles, cancelable);
}
public override function clone():Event {
return new TweenEvent(this.type, this.bubbles, this.cancelable);
}
}
}
\ No newline at end of file
/**
* VERSION: 1.01
* DATE: 2010-02-03
* AS3
* UPDATES AND DOCUMENTATION AT: http://blog.greensock.com/
**/
package com.greensock.layout {
/**
* Provides constants for defining the alignment of objects. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class AlignMode {
/** Align with the top of the area. **/
public static const TOP:String = "top";
/** Align with the center of the area. **/
public static const CENTER:String = "center";
/** Align with the right side of the area. **/
public static const RIGHT:String = "right";
/** Align with the left side of the area. **/
public static const LEFT:String = "left";
/** Align with the bottom of the area. **/
public static const BOTTOM:String = "bottom";
}
}
\ No newline at end of file
/**
* VERSION: 1.04
* DATE: 2010-03-06
* AS3
* UPDATES AND DOCUMENTATION AT: http://blog.greensock.com/
**/
package com.greensock.layout {
/**
* Provides constants for defining how objects should scale/stretch to fit within an area (like a <code>LiquidArea</code> or <code>AutoFitArea</code>). <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class ScaleMode {
/** Stretches the object to fill the area completely in terms of both width and height. This mode does <b>NOT</b> concern itself with preserving the object's original aspect ratio (proportions). **/
public static const STRETCH:String = "stretch";
/** Stretches the object's width to fill the area horizontally, but does not affect its height **/
public static const WIDTH_ONLY:String = "widthOnly";
/** Stretches the object's height to fill the area vertically, but does not affect its width **/
public static const HEIGHT_ONLY:String = "heightOnly";
/** Scales the object proportionally to completely fill the area, allowing portions of it to exceed the bounds when its aspect ratio doesn't match the area's. For example, if the area is 100x50 and the DisplayObject is natively 200x200, it will scale it down to 100x100 meaning it will exceed the bounds of the area vertically. **/
public static const PROPORTIONAL_OUTSIDE:String = "proportionalOutside";
/** Scales the object proportionally to fit inside the area (its edges will never exceed the bounds of the area). For example, if the area is 100x50 and the DisplayObject is natively 200x200, it will scale it down to 50x50 meaning it will not fill the area horizontally, but it will vertically. **/
public static const PROPORTIONAL_INSIDE:String = "proportionalInside";
/** Does not scale the object at all **/
public static const NONE:String = "none";
}
}
\ No newline at end of file
/**
* VERSION: 1.0
* DATE: 2010-06-16
* AS3
* UPDATES AND DOCS AT: http://www.greensock.com/loadermax/
**/
package com.greensock.loading {
/**
* Defines status values for loaders. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class LoaderStatus {
/** The loader is ready to load and has not completed yet. **/
public static const READY:int = 0;
/** The loader is actively in the process of loading. **/
public static const LOADING:int = 1;
/** The loader has completed. **/
public static const COMPLETED:int = 2;
/** The loader is paused. **/
public static const PAUSED:int = 3;
/** The loader failed and did not load properly. **/
public static const FAILED:int = 4;
/** The loader has been disposed. **/
public static const DISPOSED:int = 5;
}
}
\ No newline at end of file
/**
* VERSION: 1.3
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCS AT: http://www.greensock.com/loadermax/
**/
package com.greensock.loading {
import com.greensock.loading.core.LoaderItem;
import flash.display.DisplayObject;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.events.ProgressEvent;
/**
* Tracks the loading progress of the swf in which the loader resides (basically a simple tool for tracking
* the <code>loaderInfo</code>'s progress). SelfLoader is only useful in situations where you want to factor
* the current swf's loading progress into a LoaderMax queue or maybe display a progress bar for the current
* swf or fire an event when loading has finished.<br /><br />
*
* <strong>OPTIONAL VARS PROPERTIES</strong><br />
* The following special properties can be passed into the SelfLoader constructor via its <code>vars</code> parameter:<br />
* <ul>
* <li><strong> name : String</strong> - A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".</li>
* <li><strong> autoDispose : Boolean</strong> - When <code>autoDispose</code> is <code>true</code>, the loader will be disposed immediately after it completes (it calls the <code>dispose()</code> method internally after dispatching its <code>COMPLETE</code> event). This will remove any listeners that were defined in the vars object (like onComplete, onProgress, onError). Once a loader is disposed, it can no longer be found with <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code>. The default <code>autoDispose</code> value is <code>false</code>.
*
* <br /><br />----EVENT HANDLER SHORTCUTS----</li>
* <li><strong> onProgress : Function</strong> - A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.</li>
* <li><strong> onComplete : Function</strong> - A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).</li>
* </ul><br />
*
* @example Example AS3 code:<listing version="3.0">
import com.greensock.loading.~~;
import com.greensock.events.LoaderEvent;
//create a SelfLoader
var loader:SelfLoader = new SelfLoader(this, {name:"self", onProgress:progressHandler, onComplete:completeHandler});
//Or you could put the SelfLoader into a LoaderMax. Create one first...
var queue:LoaderMax = new LoaderMax({name:"mainQueue", onProgress:progressHandler, onComplete:completeHandler, onError:errorHandler});
//append the SelfLoader and several other loaders
queue.append( loader );
queue.append( new ImageLoader("images/photo1.jpg", {name:"photo1", container:this}) );
queue.append( new SWFLoader("swf/child.swf", {name:"child", container:this, x:100, estimatedBytes:3500}) );
//start loading the LoaderMax queue
queue.load();
function progressHandler(event:LoaderEvent):void {
trace("progress: " + event.target.progress);
}
function completeHandler(event:LoaderEvent):void {
trace(event.target + " complete");
}
function errorHandler(event:LoaderEvent):void {
trace("error occured with " + event.target + ": " + event.text);
}
</listing>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class SelfLoader extends LoaderItem {
/** @private **/
protected var _loaderInfo:LoaderInfo;
/**
* Constructor
*
* @param self A DisplayObject from the main swf (it will use this DisplayObject's <code>loaderInfo</code> to track the loading progress).
* @param vars An object containing optional configuration details. For example: <code>new SelfLoader(this, {name:"self", onComplete:completeHandler, onProgress:progressHandler})</code>.<br /><br />
*
* The following special properties can be passed into the constructor via the <code>vars</code> parameter:<br />
* <ul>
* <li><strong> name : String</strong> - A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".</li>
* <li><strong> autoDispose : Boolean</strong> - When <code>autoDispose</code> is <code>true</code>, the loader will be disposed immediately after it completes (it calls the <code>dispose()</code> method internally after dispatching its <code>COMPLETE</code> event). This will remove any listeners that were defined in the vars object (like onComplete, onProgress, onError). Once a loader is disposed, it can no longer be found with <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code>. The default <code>autoDispose</code> value is <code>false</code>.
*
* <br /><br />----EVENT HANDLER SHORTCUTS----</li>
* <li><strong> onProgress : Function</strong> - A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.</li>
* <li><strong> onComplete : Function</strong> - A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).</li>
* </ul>
*/
public function SelfLoader(self:DisplayObject, vars:Object=null) {
super(self.loaderInfo.url, vars);
_type = "SelfLoader";
_loaderInfo = self.loaderInfo;
_loaderInfo.addEventListener(ProgressEvent.PROGRESS, _progressHandler, false, 0, true);
_loaderInfo.addEventListener(Event.COMPLETE, _completeHandler, false, 0, true);
_cachedBytesTotal = _loaderInfo.bytesTotal;
_cachedBytesLoaded = _loaderInfo.bytesLoaded;
_status = LoaderStatus.LOADING;
_auditedSize = true;
_content = self;
}
/** @private scrubLevel: 0 = cancel, 1 = unload, 2 = dispose, 3 = flush **/
override protected function _dump(scrubLevel:int=0, newStatus:int=0, suppressEvents:Boolean=false):void {
if (scrubLevel >= 2) {
_loaderInfo.removeEventListener(ProgressEvent.PROGRESS, _progressHandler);
_loaderInfo.removeEventListener(Event.COMPLETE, _completeHandler);
}
super._dump(scrubLevel, newStatus, suppressEvents);
}
}
}
\ No newline at end of file
/**
* VERSION: 1.3
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCS AT: http://www.greensock.com/loadermax/
**/
package com.greensock.loading.core {
import com.greensock.events.LoaderEvent;
import com.greensock.loading.LoaderStatus;
import flash.events.Event;
import flash.events.ProgressEvent;
import flash.net.URLRequest;
import flash.net.URLStream;
/** Dispatched when the loader experiences an IO_ERROR while loading or auditing its size. **/
[Event(name="ioError", type="com.greensock.events.LoaderEvent")]
/**
* Serves as the base class for all individual loaders (not LoaderMax) like <code>ImageLoader,
* XMLLoader, SWFLoader, MP3Loader</code>, etc. There is no reason to use this class on its own.
* Please see the documentation for the other classes.
* <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class LoaderItem extends LoaderCore {
/** @private **/
protected static var _cacheID:uint = uint(Math.random() * 100000000) * int(Math.random() * 1000);
/** @private **/
protected var _url:String;
/** @private **/
protected var _request:URLRequest;
/** @private **/
protected var _scriptAccessDenied:Boolean;
/** @private used in auditSize() just to preload enough of the file to determine bytesTotal. **/
protected var _auditStream:URLStream;
/** @private For certain types of loaders like SWFLoader and XMLLoader where there may be nested loaders found, it's better to prioritize the estimatedBytes if one is defined. Otherwise, the file size will be used which may be MUCH smaller than all the assets inside of it (like an XML file with a bunch of VideoLoaders).**/
protected var _preferEstimatedBytesInAudit:Boolean;
/** @private **/
protected var _httpStatus:int;
/**
* Constructor
*
* @param urlOrRequest The url (<code>String</code>) or <code>URLRequest</code> from which the loader should get its content
* @param vars An object containing optional parameters like <code>estimatedBytes, name, autoDispose, onComplete, onProgress, onError</code>, etc. For example, <code>{estimatedBytes:2400, name:"myImage1", onComplete:completeHandler}</code>.
*/
public function LoaderItem(urlOrRequest:*, vars:Object=null) {
super(vars);
_request = (urlOrRequest is URLRequest) ? urlOrRequest as URLRequest : new URLRequest(urlOrRequest);
_url = _request.url;
}
/** @private **/
protected function _prepRequest():void {
_scriptAccessDenied = false;
_httpStatus = 0;
_closeStream();
if (this.vars.noCache && (!_isLocal || _url.substr(0, 4) == "http")) {
_request.url = _url + ((_url.indexOf("?") == -1) ? "?" : "&") + "cacheBusterID=" + (_cacheID++);
}
}
/** @private scrubLevel: 0 = cancel, 1 = unload, 2 = dispose, 3 = flush **/
override protected function _dump(scrubLevel:int=0, newStatus:int=0, suppressEvents:Boolean=false):void {
_closeStream();
super._dump(scrubLevel, newStatus, suppressEvents);
}
/** @inheritDoc **/
override public function auditSize():void {
if (_auditStream == null) {
_auditStream = new URLStream();
_auditStream.addEventListener(ProgressEvent.PROGRESS, _auditStreamHandler, false, 0, true);
_auditStream.addEventListener(Event.COMPLETE, _auditStreamHandler, false, 0, true);
_auditStream.addEventListener("ioError", _auditStreamHandler, false, 0, true);
_auditStream.addEventListener("securityError", _auditStreamHandler, false, 0, true);
_auditStream.load(_request);
}
}
/** @private **/
protected function _closeStream():void {
if (_auditStream != null) {
_auditStream.removeEventListener(ProgressEvent.PROGRESS, _auditStreamHandler);
_auditStream.removeEventListener(Event.COMPLETE, _auditStreamHandler);
_auditStream.removeEventListener("ioError", _auditStreamHandler);
_auditStream.removeEventListener("securityError", _auditStreamHandler);
try {
_auditStream.close();
} catch (error:Error) {
}
_auditStream = null;
}
}
//---- EVENT HANDLERS ------------------------------------------------------------------------------------
/** @private **/
protected function _auditStreamHandler(event:Event):void {
if (event is ProgressEvent) {
_cachedBytesTotal = (event as ProgressEvent).bytesTotal;
if (_preferEstimatedBytesInAudit && uint(this.vars.estimatedBytes) > _cachedBytesTotal) {
_cachedBytesTotal = uint(this.vars.estimatedBytes);
}
} else if (event.type == "ioError" || event.type == "securityError") {
if (this.vars.alternateURL != undefined && this.vars.alternateURL != "" && _url != this.vars.alternateURL) {
_url = _request.url = this.vars.alternateURL;
_auditStream.load(_request);
_errorHandler(event);
return;
} else {
//note: a CANCEL event won't be dispatched because technically the loader wasn't officially loading - we were only briefly checking the bytesTotal with a NetStream.
super._failHandler(event);
}
}
_auditedSize = true;
_closeStream();
dispatchEvent(new Event("auditedSize"));
}
/** @private **/
override protected function _failHandler(event:Event):void {
if (this.vars.alternateURL != undefined && this.vars.alternateURL != "" && _url != this.vars.alternateURL) {
this.url = this.vars.alternateURL; //also calls _load()
_errorHandler(event);
} else {
super._failHandler(event);
}
}
/** @private **/
protected function _httpStatusHandler(event:Event):void {
_httpStatus = (event as Object).status;
dispatchEvent(new LoaderEvent(LoaderEvent.HTTP_STATUS, this));
}
//---- GETTERS / SETTERS -------------------------------------------------------------------------
/** The url from which the loader should get its content. **/
public function get url():String {
return _url;
}
public function set url(value:String):void {
if (_url != value) {
_url = _request.url = value;
var isLoading:Boolean = Boolean(_status == LoaderStatus.LOADING);
_dump(0, LoaderStatus.READY, true);
if (isLoading) {
_load();
}
}
}
/** The <code>URLRequest</code> associated with the loader. **/
public function get request():URLRequest {
return _request;
}
/** The httpStatus code of the loader. You may listen for <code>LoaderEvent.HTTP_STATUS</code> events on certain types of loaders to be notified when it changes, but in some environments the Flash player cannot sense httpStatus codes in which case the value will remain <code>0</code>. **/
public function get httpStatus():int {
return _httpStatus;
}
/**
* If the loaded content is denied script access (because of security sandbox restrictions,
* a missing crossdomain.xml file, etc.), <code>scriptAccessDenied</code> will be set to <code>true</code>.
* In the case of loaded images or swf files, this means that you should not attempt to perform
* BitmapData operations on the content. An image's <code>smoothing</code> property cannot be set
* to <code>true</code> either. Even if script access is denied for particular content, LoaderMax will still
* attempt to load it.
**/
public function get scriptAccessDenied():Boolean {
return _scriptAccessDenied;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.data.core.LoaderItemVars;
import flash.display.DisplayObject;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of a CSSLoader's constructor. <br /><br />
*
* There are 2 primary benefits of using a CSSLoaderVars instance to define your CSSLoader variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in CSSLoader</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new CSSLoader("styles.css", {name:"css", estimatedBytes:1500, onComplete:completeHandler, onProgress:progressHandler})</code>,
* you could use this utility like:<br /><br /><code>
*
* var vars:CSSLoaderVars = new CSSLoaderVars();<br />
* vars.name = "css";<br />
* vars.estimatedBytes = 1500;<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var loader:CSSLoader = new CSSLoader("styles.css", vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var loader:CSSLoader = new CSSLoader("styles.css", new CSSLoaderVars("css", 1500, completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using CSSLoaderVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class CSSLoaderVars extends LoaderItemVars {
/**
* Constructor
*
* @param name A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".
* @param estimatedBytes Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details).
* @param onComplete A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param onProgress A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.
* @param onFail A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param noCache If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally).
* @param alternateURL If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example).
* @param requireWithRoot LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>.
*/
public function CSSLoaderVars(name:String="",
estimatedBytes:uint=0,
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, estimatedBytes, onComplete, onProgress, onFail, noCache, alternateURL, requireWithRoot);
}
/** Clones the object. **/
public function clone():CSSLoaderVars {
return _cloneProps(new CSSLoaderVars()) as CSSLoaderVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.core.LoaderCore;
import com.greensock.loading.data.core.LoaderItemVars;
import flash.display.DisplayObject;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of a DataLoader's constructor. <br /><br />
*
* There are 2 primary benefits of using a DataLoaderVars instance to define your DataLoader variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in DataLoader</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new DataLoader("getData.php", {name:"myData", estimatedBytes:1500, format:"text", onComplete:completeHandler, onProgress:progressHandler})</code>,
* you could use this utility like:<br /><br /><code>
*
* var vars:DataLoaderVars = new DataLoaderVars();<br />
* vars.name = "myData";<br />
* vars.estimatedBytes = 1500;<br />
* vars.format = "text";<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var loader:DataLoader = new DataLoader("getData.php", vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var loader:DataLoader = new DataLoader("getData.php", new DataLoaderVars("myData", 1500, "text", completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using DataLoaderVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class DataLoaderVars extends LoaderItemVars {
/** @private **/
private static var _vars:Array = ["format"];
/** Controls whether the downloaded data is received as text (<code>"text"</code>), raw binary data (<code>"binary"</code>), or URL-encoded variables (<code>"variables"</code>). **/
public var format:String;
/**
* Constructor
*
* @param name A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".
* @param estimatedBytes Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details).
* @param format Controls whether the downloaded data is received as text (<code>"text"</code>), raw binary data (<code>"binary"</code>), or URL-encoded variables (<code>"variables"</code>).
* @param onComplete A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param onProgress A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.
* @param onFail A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param noCache If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally).
* @param alternateURL If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example).
* @param requireWithRoot LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>.
*/
public function DataLoaderVars(name:String="",
estimatedBytes:uint=0,
format:String="text",
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, estimatedBytes, onComplete, onProgress, onFail, noCache, alternateURL, requireWithRoot);
_props = _props.concat(_vars);
this.format = format;
}
/** Clones the object. **/
public function clone():DataLoaderVars {
return _cloneProps(new DataLoaderVars()) as DataLoaderVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.data.core.DisplayObjectLoaderVars;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.system.LoaderContext;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of an ImageLoader's constructor. <br /><br />
*
* There are 2 primary benefits of using a ImageLoaderVars instance to define your ImageLoader variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in ImageLoader</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new ImageLoader("photo1.jpg", {name:"photo1", estimatedBytes:11500, container:this, width:200, height:100, onComplete:completeHandler, onProgress:progressHandler})</code>,
* you could use this utility like:<br /><br /><code>
*
* var vars:ImageLoaderVars = new ImageLoaderVars();<br />
* vars.name = "photo1";<br />
* vars.estimatedBytes = 11500;<br />
* vars.container = this;<br />
* vars.width = 200;<br />
* vars.height = 100;<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var loader:ImageLoader = new ImageLoader("photo1.jpg", vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var loader:ImageLoader = new ImageLoader("photo1.jpg", new ImageLoaderVars("photo1", 11500, this, 200, 100, completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using ImageLoaderVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class ImageLoaderVars extends DisplayObjectLoaderVars {
/** @private **/
private static var _vars:Array = ["smoothing","context"];
/** When <code>smoothing</code> is <code>true</code> (the default), smoothing will be enabled for the image which typically leads to much better scaling results (otherwise the image can look crunchy/jagged). If your image is loaded from another domain where the appropriate crossdomain.xml file doesn't grant permission, Flash will not allow smoothing to be enabled (it's a security restriction). **/
public var smoothing:Boolean = true;
/** To control whether or not a policy file is checked (which is required if you're loading an image from another domain and you want to use it in BitmapData operations), define a <code>LoaderContext</code> object. By default, the policy file <strong>will</strong> be checked when running remotely, so make sure the appropriate crossdomain.xml file is in place. See Adobe's <code>LoaderContext</code> documentation for details and precautions. **/
public var context:LoaderContext;
/**
* Constructor
*
* @param name A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".
* @param estimatedBytes Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details).
* @param container A DisplayObjectContainer into which the <code>ContentDisplay</code> Sprite should be added immediately.
* @param width Sets the <code>ContentDisplay</code>'s <code>width</code> property (applied before rotation, scaleX, and scaleY).
* @param height Sets the <code>ContentDisplay</code>'s <code>height</code> property (applied before rotation, scaleX, and scaleY).
* @param scaleMode When a <code>width</code> and <code>height</code> are defined, the <code>scaleMode</code> controls how the loaded image will be scaled to fit the area. The following values are recognized (you may use the <code>com.greensock.layout.ScaleMode</code> constants if you prefer):<code>"stretch" | "proportionalInside" | "proportionalOutside" | "widthOnly" | "heightOnly" | "none"</code>
* @param onComplete A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param onProgress A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.
* @param onFail A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param noCache If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally).
* @param alternateURL If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example).
* @param requireWithRoot LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>.
*/
public function ImageLoaderVars(name:String="",
estimatedBytes:uint=0,
container:DisplayObjectContainer=null,
width:Number=NaN,
height:Number=NaN,
scaleMode:String="stretch",
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, estimatedBytes, container, width, height, scaleMode, onComplete, onProgress, onFail, noCache, alternateURL, requireWithRoot);
_props = _props.concat(_vars);
}
/** Clones the object. **/
public function clone():ImageLoaderVars {
return _cloneProps(new ImageLoaderVars()) as ImageLoaderVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.core.LoaderCore;
import com.greensock.loading.data.core.LoaderCoreVars;
import com.greensock.loading.LoaderMax;
import flash.display.DisplayObject;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of a LoaderMax's constructor. <br /><br />
*
* There are 2 primary benefits of using a LoaderMaxVars instance to define your LoaderMax variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in LoaderMax</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new LoaderMax({name:"mainQueue", onComplete:completeHandler, onProgress:progressHandler})</code>, you could use this utility like:<br /><br /><code>
*
* var vars:LoaderMaxVars = new LoaderMaxVars();<br />
* vars.name = "mainQueue";<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var queue:LoaderMax = new LoaderMax(vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var queue:LoaderMax = new LoaderMax( new LoaderMaxVars("mainQueue", completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using LoaderMaxVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class LoaderMaxVars extends LoaderCoreVars {
/** @private **/
private static var _vars:Array = ["auditSize",
"maxConnections",
"skipFailed",
"skipPaused",
"loaders",
"onChildOpen",
"onChildProgress",
"onChildComplete",
"onChildCancel",
"onChildFail",
"onScriptAccessDenied"];
/** By default, when the LoaderMax begins to load it quickly loops through its children and if it finds any that don't have an <code>estimatedBytes</code> defined, it will briefly open a URLStream in order to attempt to determine its <code>bytesTotal</code>, immediately closing the URLStream once the value has been determined. This causes a brief delay initially, but greatly improves the accuracy of the <code>progress</code> and <code>bytesTotal</code> values. Set <code>auditSize</code> to <code>false</code> to prevent the LoaderMax from auditing its childrens' size (it is <code>true</code> by default). For maximum performance, it is best to define an <code>estimatedBytes</code> value for as many loaders as possible to avoid the delay caused by audits. When the LoaderMax audits an XMLLoader, it cannot recognize loaders that will be created from the XML data nor can it recognize loaders inside subloaded swf files from a SWFLoader (it would take far too long to load sufficient data for that - audits should be as fast as possible). If you do not set an appropriate <code>estimatedSize</code> for XMLLoaders or SWFLoaders that contain LoaderMax loaders, you'll notice that the parent LoaderMax's <code>progress</code> and <code>bytesTotal</code> change when the nested loaders are recognized (this is normal). To control the default <code>auditSize</code> value, use the static <code>LoaderMax.defaultAuditSize</code> property. **/
public var auditSize:Boolean;
/** Maximum number of simultaneous connections that should be used while loading the LoaderMax queue. A higher number will generally result in faster overall load times for the group. The default is 2. This value is instance-based, not system-wide, so if you have two LoaderMax instances that both have a <code>maxConnections</code> value of 3 and they are both loading, there could be up to 6 connections at a time total. Sometimes there are limits imposed by the Flash Player itself or the browser or the user's system, but LoaderMax will do its best to honor the <code>maxConnections</code> you define. **/
public var maxConnections:uint;
/** If <code>skipFailed</code> is <code>true</code> (the default), any failed loaders in the queue will be skipped. Otherwise, the LoaderMax will stop when it hits a failed loader and the LoaderMax's status will become <code>LoaderStatus.FAILED</code>. **/
public var skipFailed:Boolean;
/** If <code>skipPaused</code> is <code>true</code> (the default), any paused loaders in the queue will be skipped. Otherwise, the LoaderMax will stop when it hits a paused loader and the LoaderMax's status will become <code>LoaderStatus.FAILED</code>. **/
public var skipPaused:Boolean;
/** An array of loaders (ImageLoaders, SWFLoaders, XMLLoaders, MP3Loaders, other LoaderMax instances, etc.) that should be immediately inserted into the LoaderMax. **/
public var loaders:Array;
/** A handler function for <code>LoaderEvent.CHILD_OPEN</code> events which are dispatched each time one of the loader's children (or any descendant) begins loading. Make sure your onChildOpen function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildOpen:Function;
/** A handler function for <code>LoaderEvent.CHILD_PROGRESS</code> events which are dispatched each time one of the loader's children (or any descendant) dispatches a <code>PROGRESS</code> event. To listen for changes in the LoaderMax's overall progress, use the <code>onProgress</code> special property instead. You can use the LoaderEvent's <code>target.progress</code> to get the child loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>. The LoaderEvent's <code>currentTarget</code> refers to the LoaderMax, so you can check its overall progress with the LoaderEvent's <code>currentTarget.progress</code>. Make sure your onChildProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildProgress:Function;
/** A handler function for <code>LoaderEvent.CHILD_COMPLETE</code> events which are dispatched each time one of the loader's children (or any descendant) finishes loading successfully. Make sure your onChildComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildComplete:Function;
/** A handler function for <code>LoaderEvent.CHILD_CANCEL</code> events which are dispatched each time loading is aborted on one of the loader's children (or any descendant) due to either an error or because another loader was prioritized in the queue or because <code>cancel()</code> was manually called on the child loader. Make sure your onChildCancel function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildCancel:Function;
/** A handler function for <code>LoaderEvent.CHILD_FAIL</code> events which are dispatched each time one of the loader's children (or any descendant) fails (and its <code>status</code> chances to <code>LoaderStatus.FAILED</code>). Make sure your onChildFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildFail:Function;
/** A handler function for <code>LoaderEvent.SCRIPT_ACCESS_DENIED</code> events which are dispatched when one of the LoaderMax's children (or any descendant) is loaded from another domain and no crossdomain.xml is in place to grant full script access for things like smoothing or BitmapData manipulation. Make sure your function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).**/
public var onScriptAccessDenied:Function;
/**
* Constructor
*
*/
public function LoaderMaxVars(name:String="",
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
maxConnections:uint=2,
auditSize:Boolean=true,
requireWithRoot:DisplayObject=null,
skipFailed:Boolean=true,
skipPaused:Boolean=true) {
super(name, onComplete, onProgress, onFail, requireWithRoot);
_props = _props.concat(_vars);
this.maxConnections = maxConnections;
this.auditSize = (arguments.length >= 6) ? auditSize : LoaderMax.defaultAuditSize;
this.skipFailed = skipFailed;
this.skipPaused = skipPaused;
}
/** Clones the object. **/
public function clone():LoaderMaxVars {
return _cloneProps(new LoaderMaxVars()) as LoaderMaxVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.91
* DATE: 2010-09-10
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.core.LoaderCore;
import com.greensock.loading.data.core.LoaderItemVars;
import flash.display.DisplayObject;
import flash.media.SoundLoaderContext;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of an MP3Loader's constructor. <br /><br />
*
* There are 2 primary benefits of using a MP3LoaderVars instance to define your MP3Loader variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in MP3Loader</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new MP3Loader("audio.mp3", {name:"audio", estimatedBytes:11500, autoPlay:false, onComplete:completeHandler, onProgress:progressHandler})</code>,
* you could use this utility like:<br /><br /><code>
*
* var vars:MP3LoaderVars = new MP3LoaderVars();<br />
* vars.name = "audio";<br />
* vars.estimatedBytes = 11500;<br />
* vars.autoPlay = false;<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var loader:MP3Loader = new MP3Loader("audio.mp3", vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var loader:MP3Loader = new MP3Loader("audio.mp3", new MP3LoaderVars("audio", 11500, false, completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using MP3LoaderVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class MP3LoaderVars extends LoaderItemVars {
/** @private **/
private static var _vars:Array = ["autoPlay",
"repeat",
"volume",
"context",
"initThreshold"];
/** By default the MP3 will begin playing immediately when enough of the file has buffered, but to prevent it from autoPlaying, set <code>autoPlay</code> to <code>false</code>. **/
public var autoPlay:Boolean = true;
/** Number of times that the mp3 should repeat. To repeat indefinitely, use -1. Default is 0. **/
public var repeat:int = 0;
/** A value between 0 and 1 indicating the volume at which the sound should play when the MP3Loader's controls are used to play the sound, like <code>playSound()</code> or when <code>autoPlay</code> is <code>true</code> (default volume is 1). **/
public var volume:Number = 1;
/** To control things like the buffer time and whether or not a policy file is checked, define a <code>SoundLoaderContext</code> object. The default context is null. See Adobe's SoundLoaderContext documentation for details. **/
public var context:SoundLoaderContext;
/** The minimum number of <code>bytesLoaded</code> to wait for before the <code>LoaderEvent.INIT</code> event is dispatched - the higher the number the more accurate the <code>duration</code> estimate will be when the INIT event is dispatched (the default value is 102400 which is 100k). The MP3's duration cannot be determined with 100% accuracy until it has completely loaded, but it is estimated with more and more accuracy as the file loads. **/
public var initThreshold:uint = 102400;
/**
* Constructor
*
* @param name A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".
* @param estimatedBytes Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details).
* @param autoPlay By default, the MP3 will begin playing as soon as it has been adequately buffered, but to prevent it from playing initially, set <code>autoPlay</code> to <code>false</code>.
* @param onComplete A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param onProgress A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.
* @param onFail A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param noCache If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally).
* @param alternateURL If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example).
* @param requireWithRoot LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>.
*/
public function MP3LoaderVars(name:String="",
estimatedBytes:uint=0,
autoPlay:Boolean=true,
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, estimatedBytes, onComplete, onProgress, onFail, noCache, alternateURL, requireWithRoot);
_props = _props.concat(_vars);
this.autoPlay = autoPlay;
}
/** Clones the object. **/
public function clone():MP3LoaderVars {
return _cloneProps(new MP3LoaderVars()) as MP3LoaderVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data {
import com.greensock.loading.core.LoaderCore;
import com.greensock.loading.data.core.LoaderItemVars;
import flash.display.DisplayObject;
/**
* Can be used instead of a generic object to define the <code>vars</code> parameter of an XMLLoader's constructor. <br /><br />
*
* There are 2 primary benefits of using a XMLLoaderVars instance to define your XMLLoader variables:
* <ol>
* <li> In most code editors, code hinting will be activated which helps remind you which special properties are available in XMLLoader</li>
* <li> It enables strict data typing for improved debugging (ensuring, for example, that you don't define a Boolean value for <code>onComplete</code> where a Function is expected).</li>
* </ol>
*
* <strong>USAGE:</strong><br /><br />
*
* Instead of <code>new XMLLoader("getData.php", {name:"myData", estimatedBytes:1500, onComplete:completeHandler, onProgress:progressHandler})</code>,
* you could use this utility like:<br /><br /><code>
*
* var vars:XMLLoaderVars = new XMLLoaderVars();<br />
* vars.name = "myData";<br />
* vars.estimatedBytes = 1500;<br />
* vars.onComplete = completeHandler;<br />
* vars.onProgress = progressHandler;<br />
* var loader:XMLLoader = new XMLLoader("getData.php", vars);<br /><br /></code>
*
* Some of the most common properties can be defined directly in the constructor like this:<br /><br /><code>
*
* var loader:XMLLoader = new XMLLoader("getData.php", new XMLLoaderVars("myData", 1500, completeHandler, progressHandler) );<br /><br /></code>
*
* <strong>NOTE:</strong> Using XMLLoaderVars is completely optional. If you prefer the shorter synatax with the generic Object, feel
* free to use it. The purpose of this class is simply to enable code hinting and to allow for strict data typing. <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class XMLLoaderVars extends LoaderItemVars {
/** @private **/
private static var _vars:Array = ["integrateProgress",
"onChildOpen",
"onChildProgress",
"onChildComplete",
"onChildCancel",
"onChildFail"];
/** By default, the XMLLoader will automatically look for LoaderMax-related nodes like <code>&lt;LoaderMax&gt;, &lt;ImageLoader&gt;, &lt;SWFLoader&gt;, &lt;XMLLoader&gt;, &lt;MP3Loader&gt;, &lt;DataLoader&gt;</code>, and <code>&lt;CSSLoader&gt;</code> inside the XML when it inits. If it finds any that have a <code>load="true"</code> attribute, it will begin loading them and integrate their progress into the XMLLoader's overall progress. Its <code>COMPLETE</code> event won't fire until all of these loaders have completed as well. If you prefer NOT to integrate the dynamically-created loader instances into the XMLLoader's overall <code>progress</code>, set <code>integrateProgress</code> to <code>false</code>. **/
public var integrateProgress:Boolean=true;
/** A handler function for <code>LoaderEvent.CHILD_OPEN</code> events which are dispatched each time any nested LoaderMax-related loaders that were defined in the XML begins loading. Make sure your onChildOpen function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildOpen:Function;
/** A handler function for <code>LoaderEvent.CHILD_PROGRESS</code> events which are dispatched each time any nested LoaderMax-related loaders that were defined in the XML dispatches a <code>PROGRESS</code> event. To listen for changes in the XMLLoader's overall progress, use the <code>onProgress</code> special property instead. You can use the LoaderEvent's <code>target.progress</code> to get the child loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>. The LoaderEvent's <code>currentTarget</code> refers to the XMLLoader, so you can check its overall progress with the LoaderEvent's <code>currentTarget.progress</code>. Make sure your onChildProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildProgress:Function;
/** A handler function for <code>LoaderEvent.CHILD_COMPLETE</code> events which are dispatched each time any nested LoaderMax-related loaders that were defined in the XML finishes loading successfully. Make sure your onChildComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildComplete:Function;
/** A handler function for <code>LoaderEvent.CHILD_CANCEL</code> events which are dispatched each time loading is aborted on any nested LoaderMax-related loaders that were defined in the XML due to either an error or because another loader was prioritized in the queue or because <code>cancel()</code> was manually called on the child loader. Make sure your onChildCancel function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildCancel:Function;
/** A handler function for <code>LoaderEvent.CHILD_FAIL</code> events which are dispatched each time any nested LoaderMax-related loaders that were defined in the XML fails (and its <code>status</code> chances to <code>LoaderStatus.FAILED</code>). Make sure your onChildFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onChildFail:Function;
/**
* Constructor
*
* @param name A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21".
* @param estimatedBytes Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details).
* @param onComplete A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param onProgress A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.
* @param onFail A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).
* @param noCache If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally).
* @param alternateURL If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example).
* @param requireWithRoot LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>.
*/
public function XMLLoaderVars(name:String="",
estimatedBytes:uint=0,
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, estimatedBytes, onComplete, onProgress, onFail, noCache, alternateURL, requireWithRoot);
_props = _props.concat(_vars);
}
/** Clones the object. **/
public function clone():XMLLoaderVars {
return _cloneProps(new XMLLoaderVars()) as XMLLoaderVars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data.core {
import com.greensock.loading.core.LoaderCore;
import flash.display.DisplayObject;
/**
* Facilitates code hinting and data type enforcement for the <code>vars</code> object that's passed into the
* constructor of various loaders in the LoaderMax system. There is no reason to use this class directly - see
* docs for the vars classes that extend LoaderCoreVars like XMLLoaderVars, SWFLoaderVars, LoaderMaxVars, etc.<br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class LoaderCoreVars {
/** @private **/
private static var _vars:Array = ["name",
"onComplete",
"onProgress",
"onFail",
"requireWithRoot",
"autoDispose",
"onOpen",
"onCancel",
"onError",
"onIOError",
"onHTTPStatus"];
/** A name that is used to identify the loader instance. This name can be fed to the <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> methods or traced at any time. Each loader's name should be unique. If you don't define one, a unique name will be created automatically, like "loader21". **/
public var name:String;
/** A handler function for <code>LoaderEvent.COMPLETE</code> events which are dispatched when the loader has finished loading successfully. Make sure your onComplete function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onComplete:Function;
/** A handler function for <code>LoaderEvent.PROGRESS</code> events which are dispatched whenever the <code>bytesLoaded</code> changes. Make sure your onProgress function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can use the LoaderEvent's <code>target.progress</code> to get the loader's progress value or use its <code>target.bytesLoaded</code> and <code>target.bytesTotal</code>.**/
public var onProgress:Function;
/** A handler function for <code>LoaderEvent.FAIL</code> events which are dispatched whenever the loader fails and its <code>status</code> changes to <code>LoaderStatus.FAILED</code>. Make sure your onFail function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onFail:Function;
/** LoaderMax supports <i>subloading</i>, where an object can be factored into a parent's loading progress. If you want LoaderMax to require this loader as part of its parent SWFLoader's progress, you must set the <code>requireWithRoot</code> property to your swf's <code>root</code>. For example, <code>vars.requireWithRoot = this.root;</code>. **/
public var requireWithRoot:DisplayObject;
/** When <code>autoDispose</code> is <code>true</code>, the loader will be disposed immediately after it completes (it calls the <code>dispose()</code> method internally after dispatching its <code>COMPLETE</code> event). This will remove any listeners that were defined in the vars object (like onComplete, onProgress, onError, onInit). Once a loader is disposed, it can no longer be found with <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> - it is essentially destroyed but its content is not unloaded (you must call <code>unload()</code> or <code>dispose(true)</code> to unload its content). The default <code>autoDispose</code> value is <code>false</code>.**/
public var autoDispose:Boolean;
/** A handler function for <code>LoaderEvent.OPEN</code> events which are dispatched when the loader begins loading. Make sure your onOpen function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).**/
public var onOpen:Function;
/** A handler function for <code>LoaderEvent.CANCEL</code> events which are dispatched when loading is aborted due to either a failure or because another loader was prioritized or <code>cancel()</code> was manually called. Make sure your onCancel function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onCancel:Function;
/** A handler function for <code>LoaderEvent.ERROR</code> events which are dispatched whenever the loader experiences an error (typically an IO_ERROR or SECURITY_ERROR). An error doesn't necessarily mean the loader failed, however - to listen for when a loader fails, use the <code>onFail</code> special property. Make sure your onError function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). **/
public var onError:Function;
/** A handler function for <code>LoaderEvent.IO_ERROR</code> events which will also call the onError handler, so you can use that as more of a catch-all whereas <code>onIOError</code> is specifically for LoaderEvent.IO_ERROR events. Make sure your onIOError function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>).</li> **/
public var onIOError:Function;
/** A handler function for <code>LoaderEvent.HTTP_STATUS</code> events. Make sure your onHTTPStatus function accepts a single parameter of type <code>LoaderEvent</code> (<code>com.greensock.events.LoaderEvent</code>). You can determine the httpStatus code using the LoaderEvent's <code>target.httpStatus</code> (LoaderItems keep track of their <code>httpStatus</code> when possible, although certain environments prevent Flash from getting httpStatus information).**/
public var onHTTPStatus:Function;
/** @private **/
protected var _props:Array;
/**
* Constructor
* @private
*/
public function LoaderCoreVars(name:String="",
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
requireWithRoot:DisplayObject=null) {
_props = _vars.slice();
this.name = name;
this.onComplete = onComplete;
this.onProgress = onProgress;
this.onFail = onFail;
this.requireWithRoot = requireWithRoot;
}
/** @private **/
protected function _cloneProps(vars:LoaderCoreVars):LoaderCoreVars {
for each (var p:String in _props) {
vars[p] = this[p];
}
for (p in this) { //now do the dynamic props.
vars[p] = this[p];
}
return vars;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-08-09
* AS3
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com/LoaderMax/
**/
package com.greensock.loading.data.core {
import com.greensock.loading.data.core.LoaderCoreVars;
import flash.display.DisplayObject;
/**
* Facilitates code hinting and data type enforcement for the <code>vars</code> object that's passed into the
* constructor of various LoaderItems in the LoaderMax system. There is no reason to use this class directly - see
* docs for the vars classes that extend LoaderItemVars like XMLLoaderVars, SWFLoaderVars, etc.<br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
dynamic public class LoaderItemVars extends LoaderCoreVars {
/** @private **/
private static var _vars:Array = ["estimatedBytes",
"noCache",
"alternateURL"];
/** If you define an <code>alternateURL</code>, the loader will initially try to load from its original <code>url</code> and if it fails, it will automatically (and permanently) change the loader's <code>url</code> to the <code>alternateURL</code> and try again. Think of it as a fallback or backup <code>url</code>. It is perfectly acceptable to use the same <code>alternateURL</code> for multiple loaders (maybe a default image for various ImageLoaders for example). **/
public var alternateURL:String;
/** If <code>true</code>, a "cacheBusterID" parameter will be appended to the url with a random set of numbers to prevent caching (don't worry, this info is ignored when you <code>LoaderMax.getLoader()</code> or <code>LoaderMax.getContent()</code> by <code>url</code> or when you're running locally). **/
public var noCache:Boolean;
/** Initially, the loader's <code>bytesTotal</code> is set to the <code>estimatedBytes</code> value (or <code>LoaderMax.defaultEstimatedBytes</code> if one isn't defined). Then, when the loader begins loading and it can accurately determine the bytesTotal, it will do so. Setting <code>estimatedBytes</code> is optional, but the more accurate the value, the more accurate your loaders' overall progress will be initially. If the loader is inserted into a LoaderMax instance (for queue management), its <code>auditSize</code> feature can attempt to automatically determine the <code>bytesTotal</code> at runtime (there is a slight performance penalty for this, however - see LoaderMax's documentation for details). **/
public var estimatedBytes:uint;
/**
* Constructor
* @private
*/
public function LoaderItemVars(name:String="",
estimatedBytes:uint=0,
onComplete:Function=null,
onProgress:Function=null,
onFail:Function=null,
noCache:Boolean=false,
alternateURL:String="",
requireWithRoot:DisplayObject=null) {
super(name, onComplete, onProgress, onFail, requireWithRoot);
_props = _props.concat(_vars);
this.estimatedBytes = estimatedBytes;
this.noCache = noCache;
this.alternateURL = alternateURL;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.1 (beta)
* DATE: 1/19/2010
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com
**/
package com.greensock.motionPaths {
/**
* Constants for defining the direction in which to travel on a MotionPath (like <code>CLOCKWISE, COUNTER_CLOCKWISE, SHORTEST,</code> etc.). <br /><br />
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class Direction {
public static const CLOCKWISE:String="clockwise";
public static const COUNTER_CLOCKWISE:String="counterClockwise";
public static const SHORTEST:String="shortest";
}
}
\ No newline at end of file
/**
* VERSION: 0.2 (beta)
* DATE: 2010-04-21
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com
**/
package com.greensock.motionPaths {
/**
* A PathFollower is used to associate a particular target object (like a MovieClip, Point, Sprite, etc.)
* with a MotionPath and it offers a tweenable <code>progress</code> property that manages positioning
* the target on the path accordingly. The <code>progress</code> property is a value between
* 0 and 1 where 0 is at the beginning of the path, 0.5 is in the middle, and 1 is at the end.
* When the follower's <code>autoRotate</code> property is <code>true</code>, the target will be
* rotated in relation to the path that it is following. <br /><br />
*
* @example Example AS3 code:<listing version="3.0">
import com.greensock.~~;
import com.greensock.motionPaths.~~;
//create a circle motion path at coordinates x:150, y:150 with a radius of 100
var circle:Circle2D = new Circle2D(150, 150, 100);
//make the MovieClip "mc" follow the circle and start at a position of 90 degrees (this returns a PathFollower instance)
var follower:PathFollower = circle.addFollower(mc, circle.angleToProgress(90), true);
//tween the follower clockwise along the path to 315 degrees
TweenLite.to(follower, 2, {progress:circle.followerTween(follower, 315, Direction.CLOCKWISE)});
//tween the follower counter-clockwise to 200 degrees and add an extra revolution
TweenLite.to(follower, 2, {progress:circle.followerTween(follower, 200, Direction.COUNTER_CLOCKWISE, 1)});
</listing>
*
* <b>NOTES</b><br />
* <ul>
* <li>All followers are automatically updated when you alter the MotionPath that they're following.</li>
* <li>To tween all followers along the path at once, simply tween the MotionPath's <code>progress</code>
* property which will provide better performance than tweening each follower independently.</li>
* </ul>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class PathFollower {
/** The target object associated with the PathFollower (like a Sprite, MovieClip, Point, etc.). The object must have x and y properties. **/
public var target:Object;
/** @private **/
public var cachedProgress:Number;
/** @private **/
public var cachedNext:PathFollower;
/** @private **/
public var cachedPrev:PathFollower;
/** The MotionPath instance that this PathFollower should follow **/
public var path:MotionPath;
/** When <code>autoRotate</code> is <code>true</code>, the follower will automatically be rotated so that it is oriented to the angle of the path that it is following. To offset this value (like to always add 90 degrees for example), use the <code>rotationOffset</code> property. **/
public var autoRotate:Boolean;
/** When <code>autoRotate</code> is <code>true</code>, this value will always be added to the resulting <code>rotation</code> of the target. **/
public var rotationOffset:Number;
/**
* Constructor
*
* @param target The target object associated with the PathFollower (like a Sprite, MovieClip, Point, etc.). The object must have x and y properties.
* @param autoRotate When <code>autoRotate</code> is <code>true</code>, the follower will automatically be rotated so that it is oriented to the angle of the path that it is following. To offset this value (like to always add 90 degrees for example), use the <code>rotationOffset</code> property.
* @param rotationOffset When <code>autoRotate</code> is <code>true</code>, this value will always be added to the resulting <code>rotation</code> of the target.
*/
public function PathFollower(target:Object, autoRotate:Boolean=false, rotationOffset:Number=0) {
this.target = target;
this.autoRotate = autoRotate;
this.rotationOffset = rotationOffset;
this.cachedProgress = 0;
}
/**
* A value (typically between 0 and 1) that can be used to move all followers along the path. You can tween to
* values that are greater than 1 or less than 0 but the values are simply wrapped. So, for example, setting
* <code>progress</code> to 1.2 is the same as setting it to 0.2 and -0.2 is the same as 0.8. If your goal is to
* tween the PathFollower around a Circle2D twice completely, you could just add 2 to the <code>progress</code>
* value or use a relative value in the tween, like: <br /><br /><code>
*
* TweenLite.to(myFollower, 5, {progress:"2"}); //or myFollower.progress + 2
*
* </code>
**/
public function get progress():Number {
return this.cachedProgress;
}
public function set progress(value:Number):void {
if (value > 1) {
value -= int(value);
} else if (value < 0) {
value -= int(value) - 1;
}
this.cachedProgress = value;
if (this.path) {
this.path.renderObjectAt(this.target, value, this.autoRotate, this.rotationOffset);
}
}
}
}
\ No newline at end of file
/**
* VERSION: 0.2 (beta)
* DATE: 2010-04-21
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com
**/
package com.greensock.motionPaths {
import flash.display.Graphics;
import flash.geom.Matrix;
/**
* A RectanglePath2D defines a rectangular path on which a PathFollower can be placed, making it simple to tween objects
* along a rectangle's perimeter. A PathFollower's position along the path is described using its <code>progress</code> property,
* a value between 0 and 1 where 0 is at the beginning of the path (top left corner), and as the value increases, it
* moves clockwise along the path so that 0.5 would be at the lower right corner, and 1 is all the way back at the
* upper left corner of the path. So to tween a PathFollower along the path, you can simply tween its
* <code>progress</code> property. To tween ALL of the followers on the path at once, you can tween the
* RectanglePath2D's <code>progress</code> property. PathFollowers automatically wrap so that if the <code>progress</code>
* value exceeds 1 it continues at the beginning of the path.<br /><br />
*
* Since RectanglePath2D extends the Shape class, you can add an instance to the display list to see a line representation
* of the path drawn which can be helpful especially during the production phase. Use <code>lineStyle()</code>
* to adjust the color, thickness, and other attributes of the line that is drawn (or set the RectanglePath2D's
* <code>visible</code> property to false or don't add it to the display list if you don't want to see the line
* at all). You can also adjust all of its properties like <code>scaleX, scaleY, rotation, width, height, x,</code>
* and <code>y</code>. That means you can tween those values as well to achieve very dynamic, complex effects
* with ease.<br /><br />
*
* @example Example AS3 code:<listing version="3.0">
import com.greensock.~~;
import com.greensock.motionPaths.~~;
//create a rectangular motion path at coordinates x:25, y:25 with a width of 150 and a height of 100
var rect:RectanglePath2D = new RectanglePath2D(25, 25, 150, 100, false);
//position the MovieClip "mc" at the beginning of the path (upper left corner), and reference the resulting PathFollower instance with a "follower" variable.
var follower:PathFollower = rect.addFollower(mc, 0);
//tween the follower clockwise along the path all the way to the end, one full revolution
TweenLite.to(follower, 2, {progress:1});
//tween the follower counter-clockwise by using a negative progress value
TweenLite.to(follower, 2, {progress:-1});
</listing>
*
* <b>NOTES</b><br />
* <ul>
* <li>All followers' positions are automatically updated when you alter the MotionPath that they're following.</li>
* <li>To tween all followers along the path at once, simply tween the MotionPath's <code>progress</code>
* property which will provide better performance than tweening each follower independently.</li>
* </ul>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class RectanglePath2D extends MotionPath {
/** @private **/
protected var _rawWidth:Number;
/** @private **/
protected var _rawHeight:Number;
/** @private **/
protected var _centerOrigin:Boolean;
/**
* Constructor
*
* @param x The x coordinate of the origin of the rectangle (typically its top left corner unless <code>centerOrigin</code> is <code>true</code>)
* @param y The y coordinate of the origin of the rectangle (typically its top left corner unless <code>centerOrigin</code> is <code>true</code>)
* @param rawWidth The width of the rectangle in its unrotated and unscaled state
* @param rawHeight The height of the rectangle in its unrotated and unscaled state
* @param centerOrigin To position the origin (registration point around which transformations occur) at the center of the rectangle instead of its upper left corner, set <code>centerOrigin</code> to <code>true</code> (it is false by default).
*/
public function RectanglePath2D(x:Number, y:Number, rawWidth:Number, rawHeight:Number, centerOrigin:Boolean=false) {
super();
_rawWidth = rawWidth;
_rawHeight = rawHeight;
_centerOrigin = centerOrigin;
super.x = x;
super.y = y;
}
/** @private **/
override protected function renderAll():void {
var xOffset:Number = _centerOrigin ? _rawWidth / -2 : 0;
var yOffset:Number = _centerOrigin ? _rawHeight / -2 : 0;
var length:Number, px:Number, py:Number, xFactor:Number, yFactor:Number;
var m:Matrix = this.transform.matrix;
var a:Number = m.a, b:Number = m.b, c:Number = m.c, d:Number = m.d, tx:Number = m.tx, ty:Number = m.ty;
var f:PathFollower = _rootFollower;
while (f) {
px = xOffset;
py = yOffset;
if (f.cachedProgress < 0.5) {
length = f.cachedProgress * (_rawWidth + _rawHeight) * 2;
if (length > _rawWidth) { //top
px += _rawWidth;
py += length - _rawWidth;
xFactor = 0;
yFactor = _rawHeight;
} else { //right
px += length;
xFactor = _rawWidth;
yFactor = 0;
}
} else {
length = (f.cachedProgress - 0.5) / 0.5 * (_rawWidth + _rawHeight);
if (length <= _rawWidth) { //bottom
px += _rawWidth - length;
py += _rawHeight;
xFactor = -_rawWidth;
yFactor = 0;
} else { //left
py += _rawHeight - (length - _rawWidth);
xFactor = 0;
yFactor = -_rawHeight;
}
}
f.target.x = px * a + py * c + tx;
f.target.y = px * b + py * d + ty;
if (f.autoRotate) {
f.target.rotation = Math.atan2(xFactor * b + yFactor * d, xFactor * a + yFactor * c) * _RAD2DEG + f.rotationOffset;
}
f = f.cachedNext;
}
if (_redrawLine && this.visible && this.parent) {
var g:Graphics = this.graphics;
g.clear();
g.lineStyle(_thickness, _color, _lineAlpha, _pixelHinting, _scaleMode, _caps, _joints, _miterLimit);
g.drawRect(xOffset, yOffset, _rawWidth, _rawHeight);
_redrawLine = false;
}
}
/** @inheritDoc **/
override public function renderObjectAt(target:Object, progress:Number, autoRotate:Boolean=false, rotationOffset:Number=0):void {
if (progress > 1) {
progress -= int(progress);
} else if (progress < 0) {
progress -= int(progress) - 1;
}
var px:Number = _centerOrigin ? _rawWidth / -2 : 0;
var py:Number = _centerOrigin ? _rawHeight / -2 : 0;
var length:Number, xFactor:Number, yFactor:Number;
if (progress < 0.5) {
length = progress * (_rawWidth + _rawHeight) * 2;
if (length > _rawWidth) {
px += _rawWidth;
py += length - _rawWidth;
xFactor = 0;
yFactor = _rawHeight;
} else {
px += length;
xFactor = _rawWidth;
yFactor = 0;
}
} else {
length = (progress - 0.5) / 0.5 * (_rawWidth + _rawHeight);
if (length <= _rawWidth) {
px += _rawWidth - length;
py += _rawHeight;
xFactor = -_rawWidth;
yFactor = 0;
} else {
py += _rawHeight - (length - _rawWidth);
xFactor = 0;
yFactor = -_rawHeight;
}
}
var m:Matrix = this.transform.matrix;
target.x = px * m.a + py * m.c + m.tx;
target.y = px * m.b + py * m.d + m.ty;
if (autoRotate) {
target.rotation = Math.atan2(xFactor * m.b + yFactor * m.d, xFactor * m.a + yFactor * m.c) * _RAD2DEG + rotationOffset;
}
}
//---- GETTERS / SETTERS ----------------------------------------------------------------------
/** width of the rectangle in its unrotated, unscaled state (does not factor in any transformations like scaleX/scaleY/rotation) **/
public function get rawWidth():Number {
return _rawWidth;
}
public function set rawWidth(value:Number):void {
_rawWidth = value;
_redrawLine = true;
renderAll();
}
/** height of the rectangle in its unrotated, unscaled state (does not factor in any transformations like scaleX/scaleY/rotation) **/
public function get rawHeight():Number {
return _rawHeight;
}
public function set rawHeight(value:Number):void {
_rawHeight = value;
_redrawLine = true;
renderAll();
}
/** height of the rectangle in its unrotated, unscaled state (does not factor in any transformations like scaleX/scaleY/rotation) **/
public function get centerOrigin():Boolean {
return _centerOrigin;
}
public function set centerOrigin(value:Boolean):void {
_centerOrigin;
_redrawLine = true;
renderAll();
}
}
}
\ No newline at end of file
/**
* VERSION: 2.3
* DATE: 10/17/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import com.greensock.*;
import flash.display.*;
/**
* Tweening "autoAlpha" is exactly the same as tweening an object's "alpha" except that it ensures
* that the object's "visible" property is true until autoAlpha reaches zero at which point it will
* toggle the "visible" property to false. That not only improves rendering performance in the Flash Player,
* but also hides DisplayObjects so that they don't interact with the mouse. <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.AutoAlphaPlugin; <br />
* TweenPlugin.activate([AutoAlphaPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 2, {autoAlpha:0}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class AutoAlphaPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
protected var _target:Object;
/** @private **/
protected var _ignoreVisible:Boolean;
/** @private **/
public function AutoAlphaPlugin() {
super();
this.propName = "autoAlpha";
this.overwriteProps = ["alpha","visible"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target;
addTween(target, "alpha", target.alpha, value, "alpha");
return true;
}
/** @private **/
override public function killProps(lookup:Object):void {
super.killProps(lookup);
_ignoreVisible = Boolean("visible" in lookup);
}
/** @private **/
override public function set changeFactor(n:Number):void {
updateTweens(n);
if (!_ignoreVisible) {
_target.visible = Boolean(_target.alpha != 0);
}
}
}
}
\ No newline at end of file
/**
* VERSION: 2.0
* DATE: 8/18/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import flash.filters.*;
import flash.display.*;
import com.greensock.*;
/**
* Tweens a BevelFilter. The following properties are available (you only need to define the ones you want to tween): <br />
* <code>
* <ul>
* <li> distance : Number [0]</li>
* <li> angle : Number [0]</li>
* <li> highlightColor : uint [0xFFFFFF]</li>
* <li> highlightAlpha : Number [0.5]</li>
* <li> shadowColor : uint [0x000000]</li>
* <li> shadowAlpha :Number [0.5]</li>
* <li> blurX : Number [2]</li>
* <li> blurY : Number [2]</li>
* <li> strength : Number [0]</li>
* <li> quality : uint [2]</li>
* <li> index : uint</li>
* <li> addFilter : Boolean [false]</li>
* <li> remove : Boolean [false]</li>
* </ul>
* </code>
*
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.BevelFilterPlugin; <br />
* TweenPlugin.activate([BevelFilterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {bevelFilter:{blurX:10, blurY:10, distance:6, angle:45, strength:1}});<br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class BevelFilterPlugin extends FilterPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
private static var _propNames:Array = ["distance","angle","highlightColor","highlightAlpha","shadowColor","shadowAlpha","blurX","blurY","strength","quality"];
/** @private **/
public function BevelFilterPlugin() {
super();
this.propName = "bevelFilter";
this.overwriteProps = ["bevelFilter"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target;
_type = BevelFilter;
initFilter(value, new BevelFilter(0, 0, 0xFFFFFF, 0.5, 0x000000, 0.5, 2, 2, 0, value.quality || 2), _propNames);
return true;
}
}
}
\ No newline at end of file
/**
* VERSION: 2.21
* DATE: 2010-06-23
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import com.greensock.*;
/**
* Bezier tweening allows you to tween in a non-linear way. For example, you may want to tween
* a MovieClip's position from the origin (0,0) 500 pixels to the right (500,0) but curve downwards
* through the middle of the tween. Simply pass as many objects in the bezier Array as you'd like,
* one for each "control point" (see documentation on Flash's curveTo() drawing method for more
* about how control points work).<br /><br />
*
* Keep in mind that you can bezier tween ANY properties, not just x/y. <br /><br />
*
* Also, if you'd like to rotate the target in the direction of the bezier path,
* use the <code>orientToBezier</code> special property. In order to alter a rotation property accurately,
* TweenLite/Max needs 5 pieces of information: <br />
* <ol>
* <li> Position property 1 (typically <code>"x"</code>)</li>
* <li> Position property 2 (typically <code>"y"</code>)</li>
* <li> Rotational property (typically <code>"rotation"</code>)</li>
* <li> Number of degrees to add (optional - makes it easy to orient your MovieClip properly)</li>
* <li> Tolerance (default is 0.01, but increase this if the rotation seems to jitter during the tween)</li>
* </ol><br />
*
* The <code>orientToBezier</code> property should be an Array containing one Array for each set of these values.
* For maximum flexibility, you can pass in any number of arrays inside the container array, one
* for each rotational property. This can be convenient when working in 3D because you can rotate
* on multiple axis. If you're doing a standard 2D x/y tween on a bezier, you can simply pass
* in a Boolean value of true and TweenLite/Max will use a typical setup, <code>[["x", "y", "rotation", 0, 0.01]]</code>.
* Hint: Don't forget the container Array (notice the double outer brackets)<br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.BezierPlugin; <br />
* TweenPlugin.activate([BezierPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 3, {bezier:[{x:250, y:50}, {x:500, y:0}]}); //makes my_mc travel through 250,50 and end up at 500,0. <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class BezierPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
protected static const _RAD2DEG:Number = 180 / Math.PI; //precalculate for speed
/** @private **/
protected var _target:Object;
/** @private **/
protected var _orientData:Array;
/** @private **/
protected var _orient:Boolean;
/** @private used for orientToBezier projections **/
protected var _future:Object = {};
/** @private **/
protected var _beziers:Object;
/** @private **/
public function BezierPlugin() {
super();
this.propName = "bezier"; //name of the special property that the plugin should intercept/manage
this.overwriteProps = []; //will be populated in init()
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!(value is Array)) {
return false;
}
init(tween, value as Array, false);
return true;
}
/** @private **/
protected function init(tween:TweenLite, beziers:Array, through:Boolean):void {
_target = tween.target;
var enumerables:Object = (tween.vars.isTV == true) ? tween.vars.exposedVars : tween.vars; //for TweenLiteVars and TweenMaxVars (we need an object with enumerable properties);
if (enumerables.orientToBezier == true) {
_orientData = [["x", "y", "rotation", 0, 0.01]];
_orient = true;
} else if (enumerables.orientToBezier is Array) {
_orientData = enumerables.orientToBezier;
_orient = true;
}
var props:Object = {}, i:int, p:String, killVarsLookup:Object;
for (i = 0; i < beziers.length; i++) {
for (p in beziers[i]) {
if (props[p] == undefined) {
props[p] = [tween.target[p]];
}
if (typeof(beziers[i][p]) == "number") {
props[p].push(beziers[i][p]);
} else {
props[p].push(tween.target[p] + Number(beziers[i][p])); //relative value
}
}
}
for (p in props) {
this.overwriteProps[this.overwriteProps.length] = p;
if (enumerables[p] != undefined) {
if (typeof(enumerables[p]) == "number") {
props[p].push(enumerables[p]);
} else {
props[p].push(tween.target[p] + Number(enumerables[p])); //relative value
}
killVarsLookup = {};
killVarsLookup[p] = true;
tween.killVars(killVarsLookup, false);
delete enumerables[p]; //in case TweenLite/Max hasn't reached the enumerable yet in its init() function. This prevents normal tweens from getting created for the properties that should be controled with the BezierPlugin.
}
}
_beziers = parseBeziers(props, through);
}
/**
* Helper method for translating control points into bezier information.
*
* @param props Object containing a property corresponding to each one you'd like bezier paths for. Each property's value should be a single Array with the numeric point values (i.e. <code>props.x = [12,50,80]</code> and <code>props.y = [50,97,158]</code>).
* @param through If you want the paths drawn THROUGH the supplied control points, set this to true.
* @return A new object with an Array of values for each property. The first element in the Array is the start value, the second is the control point, and the 3rd is the end value. (i.e. <code>returnObject.x = [[12, 32, 50}, [50, 65, 80]]</code>)
*/
public static function parseBeziers(props:Object, through:Boolean=false):Object {
var i:int, a:Array, b:Object, p:String;
var all:Object = {};
if (through) {
for (p in props) {
a = props[p];
all[p] = b = [];
if (a.length > 2) {
b[b.length] = [a[0], a[1] - ((a[2] - a[0]) / 4), a[1]];
for (i = 1; i < a.length - 1; i++) {
b[b.length] = [a[i], a[i] + (a[i] - b[i - 1][1]), a[i + 1]];
}
} else {
b[b.length] = [a[0], (a[0] + a[1]) / 2, a[1]];
}
}
} else {
for (p in props) {
a = props[p];
all[p] = b = [];
if (a.length > 3) {
b[b.length] = [a[0], a[1], (a[1] + a[2]) / 2];
for (i = 2; i < a.length - 2; i++) {
b[b.length] = [b[i - 2][2], a[i], (a[i] + a[i + 1]) / 2];
}
b[b.length] = [b[b.length - 1][2], a[a.length - 2], a[a.length - 1]];
} else if (a.length == 3) {
b[b.length] = [a[0], a[1], a[2]];
} else if (a.length == 2) {
b[b.length] = [a[0], (a[0] + a[1]) / 2, a[1]];
}
}
}
return all;
}
/** @private **/
override public function killProps(lookup:Object):void {
for (var p:String in _beziers) {
if (p in lookup) {
delete _beziers[p];
}
}
super.killProps(lookup);
}
/** @private **/
override public function set changeFactor(n:Number):void {
var i:int, p:String, b:Object, t:Number, segments:uint, val:Number;
_changeFactor = n;
if (n == 1) { //to make sure the end values are EXACTLY what they need to be.
for (p in _beziers) {
i = _beziers[p].length - 1;
_target[p] = _beziers[p][i][2];
}
} else {
for (p in _beziers) {
segments = _beziers[p].length;
if (n < 0) {
i = 0;
} else if (n >= 1) {
i = segments - 1;
} else {
i = int(segments * n);
}
t = (n - (i * (1 / segments))) * segments;
b = _beziers[p][i];
if (this.round) {
val = b[0] + t * (2 * (1 - t) * (b[1] - b[0]) + t * (b[2] - b[0]));
_target[p] = (val > 0) ? int(val + 0.5) : int(val - 0.5); //4 times as fast as Math.round()
} else {
_target[p] = b[0] + t * (2 * (1 - t) * (b[1] - b[0]) + t * (b[2] - b[0]));
}
}
}
if (_orient) {
i = _orientData.length;
var curVals:Object = {}, dx:Number, dy:Number, cotb:Array, toAdd:Number;
while (i--) {
cotb = _orientData[i]; //current orientToBezier Array
curVals[cotb[0]] = _target[cotb[0]];
curVals[cotb[1]] = _target[cotb[1]];
}
var oldTarget:Object = _target, oldRound:Boolean = this.round;
_target = _future;
this.round = false;
_orient = false;
i = _orientData.length;
while (i--) {
cotb = _orientData[i]; //current orientToBezier Array
this.changeFactor = n + (cotb[4] || 0.01);
toAdd = cotb[3] || 0;
dx = _future[cotb[0]] - curVals[cotb[0]];
dy = _future[cotb[1]] - curVals[cotb[1]];
oldTarget[cotb[2]] = Math.atan2(dy, dx) * _RAD2DEG + toAdd;
}
_target = oldTarget;
this.round = oldRound;
_orient = true;
}
}
}
}
\ No newline at end of file
/**
* VERSION: 1.12
* DATE: 10/2/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import com.greensock.*;
/**
* Identical to bezier except that instead of defining bezier control point values, you
* define points through which the bezier values should move. This can be more intuitive
* than using control points. Simply pass as many objects in the bezier Array as you'd like,
* one for each point through which the values should travel. For example, if you want the
* curved motion path to travel through the coordinates x:250, y:100 and x:50, y:200 and then
* end up at 500, 100, you'd do: <br /><br />
*
* <code>TweenLite.to(mc, 2, {bezierThrough:[{x:250, y:100}, {x:50, y:200}, {x:500, y:200}]});</code><br /><br />
*
* Keep in mind that you can bezierThrough tween ANY properties, not just x/y. <br /><br />
*
* Also, if you'd like to rotate the target in the direction of the bezier path,
* use the orientToBezier special property. In order to alter a rotation property accurately,
* TweenLite/Max needs 5 pieces of information:
* <ol>
* <li> Position property 1 (typically <code>"x"</code>)</li>
* <li> Position property 2 (typically <code>"y"</code>)</li>
* <li> Rotational property (typically <code>"rotation"</code>)</li>
* <li> Number of degrees to add (optional - makes it easy to orient your MovieClip properly)</li>
* <li> Tolerance (default is 0.01, but increase this if the rotation seems to jitter during the tween)</li>
* </ol><br />
*
* The orientToBezier property should be an Array containing one Array for each set of these values.
* For maximum flexibility, you can pass in any number of arrays inside the container array, one
* for each rotational property. This can be convenient when working in 3D because you can rotate
* on multiple axis. If you're doing a standard 2D x/y tween on a bezier, you can simply pass
* in a boolean value of true and TweenLite/Max will use a typical setup, <code>[["x", "y", "rotation", 0, 0.01]]</code>.
* Hint: Don't forget the container Array (notice the double outer brackets) <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.BezierThroughPlugin; <br />
* TweenPlugin.activate([BezierThroughPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 2, {bezierThrough:[{x:250, y:100}, {x:50, y:200}, {x:500, y:200}]}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class BezierThroughPlugin extends BezierPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
public function BezierThroughPlugin() {
super();
this.propName = "bezierThrough"; //name of the special property that the plugin should intercept/manage
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!(value is Array)) {
return false;
}
init(tween, value as Array, true);
return true;
}
}
}
\ No newline at end of file
/**
* VERSION: 2.0
* DATE: 8/18/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import flash.filters.*;
import flash.display.*;
import com.greensock.*;
/**
* Tweens a BlurFilter. The following properties are available (you only need to define the ones you want to tween):
* <code>
* <ul>
* <li> blurX : Number [0]</li>
* <li> blurY : Number [0]</li>
* <li> quality : uint [2]</li>
* <li> index : uint</li>
* <li> addFilter : Boolean [false]</li>
* <li> remove : Boolean [false]</li>
* </ul>
* </code>
*
* Set <code>remove</code> to true if you want the filter to be removed when the tween completes. <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.BlurFilterPlugin; <br />
* TweenPlugin.activate([BlurFilterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {blurFilter:{blurX:10, blurY:10}}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class BlurFilterPlugin extends FilterPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
private static var _propNames:Array = ["blurX","blurY","quality"];
/** @private **/
public function BlurFilterPlugin() {
super();
this.propName = "blurFilter";
this.overwriteProps = ["blurFilter"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target;
_type = BlurFilter;
initFilter(value, new BlurFilter(0, 0, value.quality || 2), _propNames);
return true;
}
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 2010-06-29
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import com.greensock.*;
import flash.display.DisplayObject;
/**
* Forces the <code>cacheAsBitmap</code> property of a DisplayObject to be a certain value (<code>true</code> or <code>false</code>)
* during the tween and then sets it back to whatever it was before the tween was rendered for the first time. This <i>can</i> improve
* performance in certain situations, like when the DisplayObject <strong>NOT</strong> tweening its rotation, scaleX, scaleY, or similar
* things with its <code>transform.matrix</code>. See Adobe's docs for details about when it is appropriate to set <code>cacheAsBitmap</code>
* to <code>true</code>. Also beware that whenever a DisplayObject's <code>cacheAsBitmap</code> is <code>true</code>, it will ONLY be
* rendered on whole pixel values which can lead to animation that looks "choppy" at slow speeds.<br /><br />
*
* For example, if you want to set <code>cacheAsBitmap</code> to <code>true</code> while the tween is running, do:<br /><br /><code>
*
* TweenLite.to(mc, 1, {x:100, cacheAsBitmap:true});<br /><br /></code>
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.CacheAsBitmapPlugin; <br />
* TweenPlugin.activate([CacheAsBitmapPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {x:100, cacheAsBitmap:true}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class CacheAsBitmapPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
protected var _target:DisplayObject;
/** @private **/
protected var _tween:TweenLite;
/** @private **/
protected var _cacheAsBitmap:Boolean;
/** @private **/
protected var _initVal:Boolean;
/** @private **/
public function CacheAsBitmapPlugin() {
super();
this.propName = "cacheAsBitmap";
this.overwriteProps = ["cacheAsBitmap"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target as DisplayObject;
_tween = tween;
_initVal = _target.cacheAsBitmap;
_cacheAsBitmap = Boolean(value);
return true;
}
/** @private **/
override public function set changeFactor(n:Number):void {
if (_tween.cachedDuration == _tween.cachedTime || _tween.cachedTime == 0) { //a changeFactor of 1 doesn't necessarily mean the tween is done - if the ease is Elastic.easeOut or Back.easeOut for example, they could hit 1 mid-tween.
_target.cacheAsBitmap = _initVal;
} else if (_target.cacheAsBitmap != _cacheAsBitmap) {
_target.cacheAsBitmap = _cacheAsBitmap;
}
}
}
}
\ No newline at end of file
/**
* VERSION: 0.2 (beta)
* DATE: 2010-04-16
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.GreenSock.com
**/
package com.greensock.plugins {
import com.greensock.*;
import com.greensock.motionPaths.CirclePath2D;
import com.greensock.motionPaths.PathFollower;
import flash.display.*;
import flash.geom.Matrix;
/**
* Tweens an object along a CirclePath2D motion path in any direction (clockwise, counter-clockwise, or shortest).
* The plugin recognizes the following properties:
* <ul>
* <li><b>path</b> : CirclePath2D - The CirclePath2D instance to follow (com.greensock.motionPaths.CirclePath2D)</li>
* <li><b>startAngle</b> : Number - The position at which the target should begin its rotation (described
* in degrees unless useRadians is true in which case it is described in radians).
* For example, to begin at the top of the circle, use 270 or -90 as the startAngle.</li>
* <li><b>endAngle</b> : Number - The position at which the target should end its rotation (described in
* degrees unless useRadians is true in which case it is described in radians).
* For example, to end at the bottom of the circle, use 90 as the endAngle</li>
* <li><b>autoRotate</b> : Boolean - When <code>autoRotate</code> is <code>true</code>, the target will automatically
* be rotated so that it is oriented to the angle of the path. To offset this value (like to always add
* 90 degrees for example), use the <code>rotationOffset</code> property.</li>
* <li><b>rotationOffset</b> : Number - When <code>autoRotate</code> is <code>true</code>, this value will always
* be added to the resulting <code>rotation</code> of the target.</li>
* <li><b>direction</b> : String - The direction in which the target should travel around the path. Options are
* <code>Direction.CLOCKWISE</code> ("clockwise"), <code>Direction.COUNTER_CLOCKWISE</code>
* ("counterClockwise"), or <code>Direction.SHORTEST</code> ("shortest").</li>
* <li><b>extraRevolutions</b> : uint - If instead of going directly to the endAngle, you want the target to
* travel one or more extra revolutions around the path before going to the endAngle,
* define that number of revolutions here. </li>
* <li><b>useRadians</b> : Boolean - If you prefer to define values in radians instead of degrees, set useRadians to true.</li>
* </ul>
*
* <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.~~; <br />
* import com.greensock.plugins.~~; <br />
* import com.greensock.motionPaths.~~<br />
* TweenPlugin.activate([CirclePath2DPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* var circle:CirclePath2D = new CirclePath2D(150, 150, 100);
* TweenLite.to(mc, 2, {circlePath2D:{path:circle, startAngle:90, endAngle:270, direction:Direction.CLOCKWISE, extraRevolutions:2}}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class CirclePath2DPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
private static const _2PI:Number = Math.PI * 2;
/** @private **/
private static const _RAD2DEG:Number = 180 / Math.PI;
/** @private **/
protected var _target:Object;
/** @private **/
protected var _autoRemove:Boolean;
/** @private **/
protected var _start:Number;
/** @private **/
protected var _change:Number;
/** @private **/
protected var _circle:CirclePath2D;
/** @private **/
protected var _autoRotate:Boolean;
/** @private **/
protected var _rotationOffset:Number;
/** @private **/
public function CirclePath2DPlugin() {
super();
this.propName = "circlePath2D";
this.overwriteProps = ["x","y"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!("path" in value) || !(value.path is CirclePath2D)) {
trace("CirclePath2DPlugin error: invalid 'path' property. Please define a CirclePath2D instance.");
return false;
}
_target = target;
_circle = value.path as CirclePath2D;
_autoRotate = Boolean(value.autoRotate == true);
_rotationOffset = value.rotationOffset || 0;
var f:PathFollower = _circle.getFollower(target);
if (f != null && !("startAngle" in value)) {
_start = f.progress;
} else {
_start = _circle.angleToProgress(value.startAngle || 0, value.useRadians);
_circle.renderObjectAt(_target, _start);
}
_change = Number(_circle.anglesToProgressChange(_circle.progressToAngle(_start), value.endAngle || 0, value.direction || "clockwise", value.extraRevolutions || 0, Boolean(value.useRadians)));
return true;
}
/** @private **/
override public function killProps(lookup:Object):void {
super.killProps(lookup);
if (("x" in lookup) || ("y" in lookup)) {
this.overwriteProps = [];
}
}
/** @private **/
override public function set changeFactor(n:Number):void {
var angle:Number = (_start + (_change * n)) * _2PI;
var radius:Number = _circle.radius;
var m:Matrix = _circle.transform.matrix;
var px:Number = Math.cos(angle) * radius;
var py:Number = Math.sin(angle) * radius;
_target.x = px * m.a + py * m.c + m.tx;
_target.y = px * m.b + py * m.d + m.ty;
if (_autoRotate) {
angle += Math.PI / 2;
px = Math.cos(angle) * _circle.radius;
py = Math.sin(angle) * _circle.radius;
_target.rotation = Math.atan2(px * m.b + py * m.d, px * m.a + py * m.c) * _RAD2DEG + _rotationOffset;
}
}
}
}
\ No newline at end of file
/**
* VERSION: 2.0
* DATE: 8/18/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import flash.display.*;
import flash.filters.*;
import com.greensock.*;
/**
* ColorMatrixFilter tweening offers an easy way to tween a DisplayObject's saturation, hue, contrast,
* brightness, and colorization. The following properties are available (you only need to define the ones you want to tween):
* <ul>
* <li><code> colorize : uint </code> (colorizing a DisplayObject makes it look as though you're seeing it through a colored piece of glass whereas tinting it makes every pixel exactly that color. You can control the amount of colorization using the "amount" value where 1 is full strength, 0.5 is half-strength, and 0 has no colorization effect.)</li>
* <li><code> amount : Number [1] </code> (only used in conjunction with "colorize")</li>
* <li><code> contrast : Number </code> (1 is normal contrast, 0 has no contrast, and 2 is double the normal contrast, etc.)</li>
* <li><code> saturation : Number </code> (1 is normal saturation, 0 makes the DisplayObject look black and white, and 2 would be double the normal saturation)</li>
* <li><code> hue : Number </code> (changes the hue of every pixel. Think of it as degrees, so 180 would be rotating the hue to be exactly opposite as normal, 360 would be the same as 0, etc.)</li>
* <li><code> brightness : Number </code> (1 is normal brightness, 0 is much darker than normal, and 2 is twice the normal brightness, etc.)</li>
* <li><code> threshold : Number </code> (number from 0 to 255 that controls the threshold of where the pixels turn white or black)</li>
* <li><code> matrix : Array </code> (If you already have a matrix from a ColorMatrixFilter that you want to tween to, pass it in with the "matrix" property. This makes it possible to match effects created in the Flash IDE.)</li>
* <li><code> index : Number </code> (only necessary if you already have a filter applied and you want to target it with the tween.)</li>
* <li><code> addFilter : Boolean [false] </code></li>
* <li><code> remove : Boolean [false] </code> (Set remove to true if you want the filter to be removed when the tween completes.)</li>
* </ul>
* HINT: If you'd like to match the ColorMatrixFilter values you created in the Flash IDE on a particular object, you can get its matrix like this:<br /><br /><code>
*
* import flash.display.DisplayObject; <br />
* import flash.filters.ColorMatrixFilter; <br /><br />
*
* function getColorMatrix(mc:DisplayObject):Array { <br />
* var f:Array = mc.filters, i:uint; <br />
* for (i = 0; i &lt; f.length; i++) { <br />
* if (f[i] is ColorMatrixFilter) { <br />
* return f[i].matrix; <br />
* } <br />
* } <br />
* return null; <br />
* } <br /><br />
*
* var myOriginalMatrix:Array = getColorMatrix(my_mc); //store it so you can tween back to it anytime like TweenMax.to(my_mc, 1, {colorMatrixFilter:{matrix:myOriginalMatrix}});
* </code>
* <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.ColorMatrixFilterPlugin; <br />
* TweenPlugin.activate([ColorMatrixFilterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {colorMatrixFilter:{colorize:0xFF0000}}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class ColorMatrixFilterPlugin extends FilterPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
private static var _propNames:Array = [];
/** @private **/
protected static var _idMatrix:Array = [1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0];
/** @private **/
protected static var _lumR:Number = 0.212671; //Red constant - used for a few color matrix filter functions
/** @private **/
protected static var _lumG:Number = 0.715160; //Green constant - used for a few color matrix filter functions
/** @private **/
protected static var _lumB:Number = 0.072169; //Blue constant - used for a few color matrix filter functions
/** @private **/
protected var _matrix:Array;
/** @private **/
protected var _matrixTween:EndArrayPlugin;
/** @private **/
public function ColorMatrixFilterPlugin() {
super();
this.propName = "colorMatrixFilter";
this.overwriteProps = ["colorMatrixFilter"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target;
_type = ColorMatrixFilter;
var cmf:Object = value;
initFilter({remove:value.remove, index:value.index, addFilter:value.addFilter}, new ColorMatrixFilter(_idMatrix.slice()), _propNames);
_matrix = ColorMatrixFilter(_filter).matrix;
var endMatrix:Array = [];
if (cmf.matrix != null && (cmf.matrix is Array)) {
endMatrix = cmf.matrix;
} else {
if (cmf.relative == true) {
endMatrix = _matrix.slice();
} else {
endMatrix = _idMatrix.slice();
}
endMatrix = setBrightness(endMatrix, cmf.brightness);
endMatrix = setContrast(endMatrix, cmf.contrast);
endMatrix = setHue(endMatrix, cmf.hue);
endMatrix = setSaturation(endMatrix, cmf.saturation);
endMatrix = setThreshold(endMatrix, cmf.threshold);
if (!isNaN(cmf.colorize)) {
endMatrix = colorize(endMatrix, cmf.colorize, cmf.amount);
}
}
_matrixTween = new EndArrayPlugin();
_matrixTween.init(_matrix, endMatrix);
return true;
}
/** @private **/
override public function set changeFactor(n:Number):void {
_matrixTween.changeFactor = n;
ColorMatrixFilter(_filter).matrix = _matrix;
super.changeFactor = n;
}
//---- MATRIX OPERATIONS --------------------------------------------------------------------------------
/** @private **/
public static function colorize(m:Array, color:Number, amount:Number = 1):Array {
if (isNaN(color)) {
return m;
} else if (isNaN(amount)) {
amount = 1;
}
var r:Number = ((color >> 16) & 0xff) / 255;
var g:Number = ((color >> 8) & 0xff) / 255;
var b:Number = (color & 0xff) / 255;
var inv:Number = 1 - amount;
var temp:Array = [inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0,
amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0,
amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0,
0, 0, 0, 1, 0];
return applyMatrix(temp, m);
}
/** @private **/
public static function setThreshold(m:Array, n:Number):Array {
if (isNaN(n)) {
return m;
}
var temp:Array = [_lumR * 256, _lumG * 256, _lumB * 256, 0, -256 * n,
_lumR * 256, _lumG * 256, _lumB * 256, 0, -256 * n,
_lumR * 256, _lumG * 256, _lumB * 256, 0, -256 * n,
0, 0, 0, 1, 0];
return applyMatrix(temp, m);
}
/** @private **/
public static function setHue(m:Array, n:Number):Array {
if (isNaN(n)) {
return m;
}
n *= Math.PI / 180;
var c:Number = Math.cos(n);
var s:Number = Math.sin(n);
var temp:Array = [(_lumR + (c * (1 - _lumR))) + (s * (-_lumR)), (_lumG + (c * (-_lumG))) + (s * (-_lumG)), (_lumB + (c * (-_lumB))) + (s * (1 - _lumB)), 0, 0, (_lumR + (c * (-_lumR))) + (s * 0.143), (_lumG + (c * (1 - _lumG))) + (s * 0.14), (_lumB + (c * (-_lumB))) + (s * -0.283), 0, 0, (_lumR + (c * (-_lumR))) + (s * (-(1 - _lumR))), (_lumG + (c * (-_lumG))) + (s * _lumG), (_lumB + (c * (1 - _lumB))) + (s * _lumB), 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1];
return applyMatrix(temp, m);
}
/** @private **/
public static function setBrightness(m:Array, n:Number):Array {
if (isNaN(n)) {
return m;
}
n = (n * 100) - 100;
return applyMatrix([1,0,0,0,n,
0,1,0,0,n,
0,0,1,0,n,
0,0,0,1,0,
0,0,0,0,1], m);
}
/** @private **/
public static function setSaturation(m:Array, n:Number):Array {
if (isNaN(n)) {
return m;
}
var inv:Number = 1 - n;
var r:Number = inv * _lumR;
var g:Number = inv * _lumG;
var b:Number = inv * _lumB;
var temp:Array = [r + n, g , b , 0, 0,
r , g + n, b , 0, 0,
r , g , b + n, 0, 0,
0 , 0 , 0 , 1, 0];
return applyMatrix(temp, m);
}
/** @private **/
public static function setContrast(m:Array, n:Number):Array {
if (isNaN(n)) {
return m;
}
n += 0.01;
var temp:Array = [n,0,0,0,128 * (1 - n),
0,n,0,0,128 * (1 - n),
0,0,n,0,128 * (1 - n),
0,0,0,1,0];
return applyMatrix(temp, m);
}
/** @private **/
public static function applyMatrix(m:Array, m2:Array):Array {
if (!(m is Array) || !(m2 is Array)) {
return m2;
}
var temp:Array = [], i:int = 0, z:int = 0, y:int, x:int;
for (y = 0; y < 4; y++) {
for (x = 0; x < 5; x++) {
if (x == 4) {
z = m[i + 4];
} else {
z = 0;
}
temp[i + x] = m[i] * m2[x] +
m[i+1] * m2[x + 5] +
m[i+2] * m2[x + 10] +
m[i+3] * m2[x + 15] +
z;
}
i += 5;
}
return temp;
}
}
}
\ No newline at end of file
/**
* VERSION: 1.52
* DATE: 10/2/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import flash.display.*;
import flash.geom.ColorTransform;
import com.greensock.*;
/**
* Ever wanted to tween ColorTransform properties of a DisplayObject to do advanced effects like overexposing, altering
* the brightness or setting the percent/amount of tint? Or maybe tween individual ColorTransform
* properties like redMultiplier, redOffset, blueMultiplier, blueOffset, etc. ColorTransformPlugin gives you an easy way to
* do just that. <br /><br />
*
* <b>PROPERTIES:</b><br />
* <ul>
* <li><code> tint (or color) : uint</code> - Color of the tint. Use a hex value, like 0xFF0000 for red.</li>
* <li><code> tintAmount : Number</code> - Number between 0 and 1. Works with the "tint" property and indicats how much of an effect the tint should have. 0 makes the tint invisible, 0.5 is halfway tinted, and 1 is completely tinted.</li>
* <li><code> brightness : Number</code> - Number between 0 and 2 where 1 is normal brightness, 0 is completely dark/black, and 2 is completely bright/white</li>
* <li><code> exposure : Number</code> - Number between 0 and 2 where 1 is normal exposure, 0, is completely underexposed, and 2 is completely overexposed. Overexposing an object is different then changing the brightness - it seems to almost bleach the image and looks more dynamic and interesting (subjectively speaking).</li>
* <li><code> redOffset : Number</code></li>
* <li><code> greenOffset : Number</code></li>
* <li><code> blueOffset : Number</code></li>
* <li><code> alphaOffset : Number</code></li>
* <li><code> redMultiplier : Number</code></li>
* <li><code> greenMultiplier : Number</code></li>
* <li><code> blueMultiplier : Number</code></li>
* <li><code> alphaMultiplier : Number</code> </li>
* </ul><br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.ColorTransformPlugin; <br />
* TweenPlugin.activate([ColorTransformPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {colorTransform:{tint:0xFF0000, tintAmount:0.5}}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class ColorTransformPlugin extends TintPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
public function ColorTransformPlugin() {
super();
this.propName = "colorTransform";
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!(target is DisplayObject)) {
return false;
}
var end:ColorTransform = target.transform.colorTransform;
for (var p:String in value) {
if (p == "tint" || p == "color") {
if (value[p] != null) {
end.color = int(value[p]);
}
} else if (p == "tintAmount" || p == "exposure" || p == "brightness") {
//handle this later...
} else {
end[p] = value[p];
}
}
if (!isNaN(value.tintAmount)) {
var ratio:Number = value.tintAmount / (1 - ((end.redMultiplier + end.greenMultiplier + end.blueMultiplier) / 3));
end.redOffset *= ratio;
end.greenOffset *= ratio;
end.blueOffset *= ratio;
end.redMultiplier = end.greenMultiplier = end.blueMultiplier = 1 - value.tintAmount;
} else if (!isNaN(value.exposure)) {
end.redOffset = end.greenOffset = end.blueOffset = 255 * (value.exposure - 1);
end.redMultiplier = end.greenMultiplier = end.blueMultiplier = 1;
} else if (!isNaN(value.brightness)) {
end.redOffset = end.greenOffset = end.blueOffset = Math.max(0, (value.brightness - 1) * 255);
end.redMultiplier = end.greenMultiplier = end.blueMultiplier = 1 - Math.abs(value.brightness - 1);
}
_ignoreAlpha = Boolean(tween.vars.alpha != undefined && value.alphaMultiplier == undefined);
init(target as DisplayObject, end);
return true;
}
}
}
\ No newline at end of file
/**
* VERSION: 2.0
* DATE: 8/18/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import flash.filters.*;
import flash.display.*;
import com.greensock.*;
/**
* Tweens a DropShadowFilter. The following properties are available (you only need to define the ones you want to tween):
* <code>
* <ul>
* <li> distance : Number [0]</li>
* <li> angle : Number [45]</li>
* <li> color : uint [0x000000]</li>
* <li> alpha :Number [0]</li>
* <li> blurX : Number [0]</li>
* <li> blurY : Number [0]</li>
* <li> strength : Number [1]</li>
* <li> quality : uint [2]</li>
* <li> inner : Boolean [false]</li>
* <li> knockout : Boolean [false]</li>
* <li> hideObject : Boolean [false]</li>
* <li> index : uint</li>
* <li> addFilter : Boolean [false]</li>
* <li> remove : Boolean [false]</li>
* </ul>
* </code>
* Set <code>remove</code> to true if you want the filter to be removed when the tween completes. <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.DropShadowFilterPlugin; <br />
* TweenPlugin.activate([DropShadowFilterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* TweenLite.to(mc, 1, {dropShadowFilter:{blurX:5, blurY:5, distance:5, alpha:0.6}}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class DropShadowFilterPlugin extends FilterPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
private static var _propNames:Array = ["distance","angle","color","alpha","blurX","blurY","strength","quality","inner","knockout","hideObject"];
/** @private **/
public function DropShadowFilterPlugin() {
super();
this.propName = "dropShadowFilter";
this.overwriteProps = ["dropShadowFilter"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
_target = target;
_type = DropShadowFilter;
initFilter(value, new DropShadowFilter(0, 45, 0x000000, 0, 0, 0, 1, value.quality || 2, value.inner, value.knockout, value.hideObject), _propNames);
return true;
}
}
}
\ No newline at end of file
/**
* VERSION: 1.6
* DATE: 10/19/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://www.TweenMax.com
**/
package com.greensock.plugins {
import com.greensock.*;
import flash.display.*;
/**
* Tweens numbers in an Array. <br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.EndArrayPlugin; <br />
* TweenPlugin.activate([EndArrayPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* var myArray:Array = [1,2,3,4];<br />
* TweenLite.to(myArray, 1.5, {endArray:[10,20,30,40]}); <br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class EndArrayPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
protected var _a:Array;
/** @private **/
protected var _info:Array = [];
/** @private **/
public function EndArrayPlugin() {
super();
this.propName = "endArray"; //name of the special property that the plugin should intercept/manage
this.overwriteProps = ["endArray"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!(target is Array) || !(value is Array)) {
return false;
}
init(target as Array, value);
return true;
}
/** @private **/
public function init(start:Array, end:Array):void {
_a = start;
var i:int = end.length;
while (i--) {
if (start[i] != end[i] && start[i] != null) {
_info[_info.length] = new ArrayTweenInfo(i, _a[i], end[i] - _a[i]);
}
}
}
/** @private **/
override public function set changeFactor(n:Number):void {
var i:int = _info.length, ti:ArrayTweenInfo;
if (this.round) {
var val:Number;
while (i--) {
ti = _info[i];
val = ti.start + (ti.change * n);
_a[ti.index] = (val > 0) ? int(val + 0.5) : int(val - 0.5); //4 times as fast as Math.round()
}
} else {
while (i--) {
ti = _info[i];
_a[ti.index] = ti.start + (ti.change * n);
}
}
}
}
}
internal class ArrayTweenInfo {
public var index:uint;
public var start:Number;
public var change:Number;
public function ArrayTweenInfo(index:uint, start:Number, change:Number) {
this.index = index;
this.start = start;
this.change = change;
}
}
\ No newline at end of file
/**
* VERSION: 0.9
* DATE: 10/22/2009
* ACTIONSCRIPT VERSION: 3.0
* UPDATES AND DOCUMENTATION AT: http://blog.greensock.com
**/
package com.greensock.plugins {
import com.greensock.*;
import flash.display.*;
/**
* Tweens numbers in an Vector.<Number>. Remember, Vectors require that you publish to <strong>Flash Player 10</strong> or later.<br /><br />
*
* <b>USAGE:</b><br /><br />
* <code>
* import com.greensock.TweenLite; <br />
* import com.greensock.plugins.TweenPlugin; <br />
* import com.greensock.plugins.EndVectorPlugin; <br />
* TweenPlugin.activate([EndVectorPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.<br /><br />
*
* var v:Vector.<Number> = new Vector.<Number>();<br />
* v[0] = 0;<br />
* v[1] = 1;<br />
* v[2] = 2;<br />
* var end:Vector.<Number> = new Vector.<Number>();<br />
* end[0] = 100;<br />
* end[1] = 250;<br />
* end[2] = 500;<br />
* TweenLite.to(v, 3, {endVector:end, onUpdate:report}); <br />
* function report():void {<br />
* trace(v);<br />
* }<br /><br />
* </code>
*
* <b>Copyright 2010, GreenSock. All rights reserved.</b> This work is subject to the terms in <a href="http://www.greensock.com/terms_of_use.html">http://www.greensock.com/terms_of_use.html</a> or for corporate Club GreenSock members, the software agreement that was issued with the corporate membership.
*
* @author Jack Doyle, jack@greensock.com
*/
public class EndVectorPlugin extends TweenPlugin {
/** @private **/
public static const API:Number = 1.0; //If the API/Framework for plugins changes in the future, this number helps determine compatibility
/** @private **/
protected var _v:Vector.<Number>;
/** @private **/
protected var _info:Vector.<VectorInfo> = new Vector.<VectorInfo>();
/** @private **/
public function EndVectorPlugin() {
super();
this.propName = "endVector"; //name of the special property that the plugin should intercept/manage
this.overwriteProps = ["endVector"];
}
/** @private **/
override public function onInitTween(target:Object, value:*, tween:TweenLite):Boolean {
if (!(target is Vector.<Number>) || !(value is Vector.<Number>)) {
return false;
}
init(target as Vector.<Number>, value as Vector.<Number>);
return true;
}
/** @private **/
public function init(start:Vector.<Number>, end:Vector.<Number>):void {
_v = start;
var i:int = end.length, cnt:uint = 0;
while (i--) {
if (_v[i] != end[i]) {
_info[cnt++] = new VectorInfo(i, _v[i], end[i] - _v[i]);
}
}
}
/** @private **/
override public function set changeFactor(n:Number):void {
var i:int = _info.length, vi:VectorInfo;
if (this.round) {
var val:Number;
while (i--) {
vi = _info[i];
val = vi.start + (vi.change * n);
_v[vi.index] = (val > 0) ? int(val + 0.5) : int(val - 0.5); //4 times as fast as Math.round()
}
} else {
while (i--) {
vi = _info[i];
_v[vi.index] = vi.start + (vi.change * n);
}
}
}
}
}
internal class VectorInfo {
public var index:uint;
public var start:Number;
public var change:Number;
public function VectorInfo(index:uint, start:Number, change:Number) {
this.index = index;
this.start = start;
this.change = change;
}
}
\ No newline at end of file
No preview for this file type
No preview for this file type
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
No preview for this file type
This file is too large to display.
No preview for this file type
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.
This diff is collapsed. Click to expand it.

32.8 KB

1.51 KB