Provides an easy way to change the default easing equation.

Target object whose properties this tween affects. This can be ANY object, not just a DisplayObject.

Constructor

Provides a simple way to call a function after a set amount of time (or frames). You can optionally pass any number of parameters to the function too. For example:

TweenLite.delayedCall(1, myFunction, ["param1", 2]);
function myFunction(param1:String, param2:Number):void {
trace("called myFunction and passed params: " + param1 + ", " + param2);
}

Static method for creating a TweenLite instance that tweens in the opposite direction compared to a TweenLite.to() tween. In other words, you define the START values in the vars object instead of the end values, and the tween will use the current values as the end values. This can be very useful for animating things into place on the stage because you can build them in their end positions and do some simple TweenLite.from() calls to animate them into place. NOTE: By default, immediateRender is true in from() tweens, meaning that they immediately render their starting state regardless of any delay that is specified. You can override this behavior by passing immediateRender:false in the vars object so that it will wait to render until the tween actually begins (often the desired behavior when inserting into timelines). To illustrate the default behavior, the following code will immediately set the alpha of mc to 0 and then wait 2 seconds before tweening the alpha back to 1 over the course of 1.5 seconds:

TweenLite.from(mc, 1.5, {alpha:0, delay:2});

Clears any initialization data (like starting values in tweens) which can be useful if, for example, you want to restart it without reverting to any previously recorded starting values. When you invalidate() a tween/timeline, it will be re-initialized the next time it renders and its vars object will be re-parsed. The timing of the tween/timeline (duration, startTime, delay) will NOT be affected. Another example would be if you have a TweenMax(mc, 1, {x:100, y:100}) that ran when mc.x and mc.y were initially at 0, but now mc.x and mc.y are 200 and you want them tween to 100 again, you could simply invalidate() the tween and restart() it. Without invalidating first, restarting it would cause the values jump back to 0 immediately (where they started when the tween originally began). When you invalidate a timeline, it automatically invalidates all of its children.

Kills all the tweens (or certain tweening properties) of a particular object, optionally completing them first. If, for example, you want to kill all tweens of the "mc" object, you'd do:

TweenLite.killTweensOf(mc);

But if you only want to kill all the "alpha" and "x" portions of mc's tweens, you'd do:

TweenLite.killTweensOf(mc, false, {alpha:true, x:true});

killTweensOf() affects tweens that haven't begun yet too. If, for example, a tween of object "mc" has a delay of 5 seconds and TweenLite.killTweensOf(mc) is called 2 seconds after the tween was created, it will still be killed even though it hasn't started yet.

Allows particular properties of the tween to be killed. For example, if a tween is affecting the "x", "y", and "alpha" properties and you want to kill just the "x" and "y" parts of the tween, you'd do myTween.killVars({x:true, y:true});

Static method for creating a TweenLite instance. This can be more intuitive for some developers and shields them from potential garbage collection issues that could arise when assigning a tween instance to a variable that persists. The following lines of code produce exactly the same result:

var myTween:TweenLite = new TweenLite(mc, 1, {x:100});
TweenLite.to(mc, 1, {x:100});
var myTween:TweenLite = TweenLite.to(mc, 1, {x:100});