Value between 0 and 1 indicating the progress of the tween according to its duration where 0 is at the beginning, 0.5 is halfway finished, and 1 is finished. totalProgress, by contrast, describes the overall progress according to the tween's totalDuration which includes repeats and repeatDelays (if there are any). For example, if a TweenMax instance is set to repeat once, at the end of the first cycle totalProgress would only be 0.5 whereas currentProgress would be 1. If you tracked both properties over the course of the tween, you'd see currentProgress go from 0 to 1 twice (once for each cycle) in the same time it takes the totalProgress property to go from 0 to 1 once.

Most recently rendered time (or frame for frames-based timelines) according to the tween's duration. totalTime, by contrast, is based on the totalDuration which includes repeats and repeatDelays. For example, if a TweenMax instance has a duration of 5 a repeat of 1 (meaning its totalDuration is 10), at the end of the second cycle, currentTime would be 5 whereas totalTime would be 10. If you tracked both properties over the course of the tween, you'd see currentTime go from 0 to 5 twice (one for each cycle) in the same time it takes totalTime go from 0 to 10.

Multiplier describing the speed of the root timelines where 1 is normal speed, 0.5 is half-speed, 2 is double speed, etc. The lowest globalTimeScale possible is 0.0001.

Kills all the tweens of a particular object, optionally completing them first.

Number of times that the tween should repeat; -1 repeats indefinitely.

Amount of time in seconds (or frames for frames-based tweens) between repeats

Multiplier describing the speed of the timeline where 1 is normal speed, 0.5 is half-speed, 2 is double speed, etc.

Duration of the tween in seconds (or frames for frames-based timelines) including any repeats or repeatDelays. duration, by contrast, does NOT include repeats and repeatDelays.

Value between 0 and 1 indicating the overall progress of the tween according to its totalDuration where 0 is at the beginning, 0.5 is halfway finished, and 1 is finished. currentProgress, by contrast, describes the progress according to the tween's duration which does not include repeats and repeatDelays. For example, if a TweenMax instance is set to repeat once, at the end of the first cycle totalProgress would only be 0.5 whereas currentProgress would be 1. If you tracked both properties over the course of the tween, you'd see currentProgress go from 0 to 1 twice (once for each cycle) in the same time it takes the totalProgress property to go from 0 to 1 once.

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). So if repeat is 2 and yoyo is false, it will look like: start - 1 - 2 - 3 - 1 - 2 - 3 - 1 - 2 - 3 - end. But if repeat is 2 and yoyo is true, it will look like: start - 1 - 2 - 3 - 3 - 2 - 1 - 1 - 2 - 3 - end.

Constructor

Exactly the same as TweenMax.allTo(), but instead of tweening the properties from where they're at currently to whatever you define, this tweens them the opposite way - from where you define TO where ever they are when the tweens begin. This is useful when things are set up on the stage the way they should end up and you just want to tween them into place. NOTE: By default, immediateRender is true for allFrom() tweens, meaning that they immediately render their starting state regardless of any delay or stagger that is specified. You can override this behavior by passing immediateRender:false in the vars object so that each tween will wait to render until any delay/stagger has passed (often the desired behavior when inserting into timelines). To illustrate the default behavior, the following code will immediately set the alpha of mc1, mc2, and mc3 to 0 and then wait 2 seconds before tweening each alpha back to 1 over the course of 1.5 seconds with 0.1 seconds lapsing between the start times of each:

TweenMax.allFrom([mc1, mc2, mc3], 1.5, {alpha:0, delay:2}, 0.1);

Tweens multiple targets from a common set of starting values to a common set of ending values; exactly the same as TweenMax.allTo(), but adds the ability to define the starting values. NOTE: Only put starting values in the fromVars parameter - all special properties for the tween (like onComplete, onUpdate, delay, etc.) belong in the toVars parameter.

Tween multiple objects to the same end values. The "stagger" parameter staggers the start time of each tween. For example, you might want to have 5 MovieClips move down 100 pixels while fading out, and stagger the start times slightly by 0.2 seconds:

TweenMax.allTo([mc1, mc2, mc3, mc4, mc5], 1, {y:"100", alpha:0}, 0.2);

Note: You can easily add a group of tweens to a TimelineLite/Max instance using allTo() in conjunction with the insertMultipe() method of a timeline, like:

myTimeline.insertMultiple(TweenMax.allTo([mc1, mc2, mc3], 1, {alpha:0, y:"100"}, 0.1));

Forces the tween to completion.

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:

TweenMax.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 TweenMax instance that tweens in the opposite direction compared to a TweenMax.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 TweenMax.from() calls to animate them into place. NOTE: By default, immediateRender is true for 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:

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

Static method for creating a TweenMax instance that tweens from a particular set of values to another set of values, as opposed to a normal to() or from() tween which are based on the target's current values. NOTE: Only put starting values in the fromVars parameter - all special properties for the tween (like onComplete, onUpdate, delay, etc.) belong in the toVars parameter.

Returns all tweens that are in the masterList. Tweens are automatically removed from the masterList when they complete and are not attached to a timeline that has autoRemoveChildren set to true.

Gets all the tweens of a particular object.

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.

Determines whether or not a particular object is actively tweening. If a tween is paused or hasn't started yet, it doesn't count as active.

Kills all tweens and/or delayedCalls/callbacks, optionally forcing them to completion first. The various parameters provide a way to distinguish between delayedCalls and tweens, so if you want to kill EVERYTHING (tweens and delayedCalls), you'd do:

TweenMax.killAll(false, true, true);

But if you want to kill only the tweens but allow the delayedCalls to continue, you'd do:

TweenMax.killAll(false, false, true);

And if you want to kill only the delayedCalls but not the tweens, you'd do:

TweenMax.killAll(false, true, false);


Kills all tweens of the children of a particular DisplayObjectContainer, optionally forcing them to completion first.

Allows particular properties of the tween to be killed, much like the killVars() method except that killProperties() accepts an Array of property names.

Pauses all tweens and/or delayedCalls/callbacks.

Resumes all paused tweens and/or delayedCalls/callbacks.

Adjusts a destination value on the fly, optionally adjusting the start values so that it appears to redirect seamlessly without skipping/jerking (this method has been deprecated in favor of updateTo()). If you plan to constantly update values, please look into using the DynamicPropsPlugin.

Static method for creating a TweenMax 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:TweenMax = new TweenMax(mc, 1, {x:100});
TweenMax.to(mc, 1, {x:100});
var myTween:TweenMax = TweenMax.to(mc, 1, {x:100});



Updates tweening values on the fly so that they appear to seamlessly change course even if the tween is in-progress. Think of it as dynamically updating the vars object that you passed in to the tween when it was originally created. You do NOT need to redefine all of the vars values - only the ones that you want to update. You can even define new properties that you didn't define in the original vars object. If the resetDuration parameter is true and the tween has already started (or finished), updateTo() will restart the tween. Otherwise, the tween's timing will be honored. And if resetDuration is false and the tween is in-progress, the starting values of each property will be adjusted so that the tween appears to seamlessly redirect to the new destination values. For example:

//create the tween
var tween:TweenMax = new TweenMax(mc, 2, {x:100, y:200, alpha:0.5});

//then later, update the destination x and y values, restarting the tween
tween.updateTo({x:300, y:0}, true);

//or to update the values mid-tween while keeping the end time the same (don't restart the tween), do this:
tween.updateTo({x:300, y:0}, false);

Note: If you plan to constantly update values, please look into using the DynamicPropsPlugin.