The closest label that is at or before the current time.

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

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

Duration of the timeline 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 timeline 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 timeline's duration which does not include repeats and repeatDelays. For example, if a TimelineMax 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 timeline 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.

SPECIAL PROPERTIES
The following special properties may be passed in via the constructor's vars parameter, like new TimelineMax({paused:true, onComplete:myFunction, repeat:2, yoyo:true})

• delay : Number Amount of delay in seconds (or frames for frames-based timelines) before the timeline should begin.
• useFrames : Boolean If useFrames is set to true, the timeline's timing mode will be based on frames. Otherwise, it will be based on seconds/time. NOTE: a TimelineLite's timing mode is always determined by its parent timeline.
• paused : Boolean Sets the initial paused state of the timeline (by default, timelines automatically begin playing immediately)
• reversed : Boolean If true, the timeline will be reversed initially. This does NOT force it to the very end and start playing backwards. It simply affects the orientation of the timeline, so if reversed is set to true initially, it will appear not to play because it is already at the beginning. To cause it to play backwards from the end, set reversed to true and then set the currentProgress property to 1 immediately after creating the timeline.
• tweens : Array To immediately insert several tweens into the timeline, use the tweens special property to pass in an Array of TweenLite/TweenMax/TimelineLite/TimelineMax instances. You can use this in conjunction with the align and stagger special properties to set up complex sequences with minimal code. These values simply get passed to the insertMultiple() method.
• align : String Only used in conjunction with the tweens special property when multiple tweens are to be inserted immediately through the constructor. The value simply gets passed to the insertMultiple() method. The default is TweenAlign.NORMAL. Options are:
  • TweenAlign.SEQUENCE: aligns the tweens one-after-the-other in a sequence
  • TweenAlign.START: aligns the start times of all of the tweens (ignores delays)
  • TweenAlign.NORMAL: aligns the start times of all the tweens (honors delays)
  The align special property does not force all child tweens/timelines to maintain relative positioning, so for example, if you use TweenAlign.SEQUENCE and then later change the duration of one of the nested tweens, it does not force all subsequent timelines to change their position on the timeline. The align special property only affects the alignment of the tweens that are initially placed into the timeline through the tweens special property of the vars object.
• stagger : Number Only used in conjunction with the tweens special property when multiple tweens are to be inserted immediately. It staggers the tweens by a set amount of time (in seconds) (or in frames if useFrames is true). For example, if the stagger value is 0.5 and the align property is set to TweenAlign.START, the second tween will start 0.5 seconds after the first one starts, then 0.5 seconds later the third one will start, etc. If the align property is TweenAlign.SEQUENCE, there would be 0.5 seconds added between each tween. This value simply gets passed to the insertMultiple() method. Default is 0.
• onStart : Function A function that should be called when the timeline begins (the currentProgress won't necessarily be zero when onStart is called. For example, if the timeline is created and then its currentProgress property is immediately set to 0.5 or if its currentTime property is set to something other than zero, onStart will still get fired because it is the first time the timeline is getting rendered.)
• onStartParams : Array An Array of parameters to pass the onStart function.
• onUpdate : Function A function that should be called every time the timeline's time/position is updated (on every frame while the timeline is active)
• onUpdateParams : Array An Array of parameters to pass the onUpdate function
• onComplete : Function A function that should be called when the timeline has finished
• onCompleteParams : Array An Array of parameters to pass the onComplete function
• onReverseComplete : Function A function that should be called when the timeline has reached its starting point again after having been reversed
• onReverseCompleteParams : Array An Array of parameters to pass the onReverseComplete functions
• onRepeat : Function A function that should be called every time the timeline repeats
• onRepeatParams : Array An Array of parameters to pass the onRepeat function
• autoRemoveChildren : Boolean If autoRemoveChildren is set to true, as soon as child tweens/timelines complete, they will automatically get killed/removed. This is normally undesireable because it prevents going backwards in time (like if you want to reverse() or set the currentProgress value to a lower value, etc.). It can, however, improve speed and memory management. TweenLite's root timelines use autoRemoveChildren:true.
• repeat : int Number of times that the timeline should repeat. To repeat indefinitely, use -1.
• repeatDelay : Number Amount of time in seconds (or frames for frames-based timelines) between repeats.
• yoyo : Boolean Works in conjunction with the repeat property, determining the behavior of each cycle. When yoyo is true, the timeline 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.
• onStartListener : Function A function to which the TimelineMax instance should dispatch a TweenEvent when it begins. This is the same as doing myTimeline.addEventListener(TweenEvent.START, myFunction);
• onUpdateListener : Function A function to which the TimelineMax instance should dispatch a TweenEvent every time it updates values. This is the same as doing myTimeline.addEventListener(TweenEvent.UPDATE, myFunction);
• onCompleteListener : Function A function to which the TimelineMax instance should dispatch a TweenEvent when it completes. This is the same as doing myTimeline.addEventListener(TweenEvent.COMPLETE, myFunction);

If you want a function to be called at a particular time or label, use addCallback. When you add a callback, it is technically considered a zero-duration tween, so if you getChildren() there will be a tween returned for each callback. You can discern a callback from other tweens by the fact that their target is a function and the duration is zero.

Forces the timeline to completion.

Returns the tweens/timelines that are currently active in the timeline.

Returns the next label (if any) that occurs AFTER the time parameter. It makes no difference if the timeline is reversed. A label that is positioned exactly at the same time as the time parameter will be ignored.

Returns the previous label (if any) that occurs BEFORE the time parameter. It makes no difference if the timeline is reversed. A label that is positioned exactly at the same time as the time parameter will be ignored.

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.

Removes a callback from a particular time or label. If timeOrLabel is null, all callbacks of that particular function are removed from the timeline.

Creates a linear tween that essentially scrubs the playhead from a particular time or label to another time or label and then stops. If you plan to sequence multiple playhead tweens one-after-the-other, tweenFromTo() is better to use than tweenTo() because it allows the duration to be determined immediately, ensuring that subsequent tweens that are appended to a sequence are positioned appropriately. For example, to make the TimelineMax play from the label "myLabel1" to the "myLabel2" label, and then from "myLabel2" back to the beginning (a time of 0), simply do:

var playheadTweens:TimelineMax = new TimelineMax();
playheadTweens.append( myTimeline.tweenFromTo("myLabel1", "myLabel2") );
playheadTweens.append( myTimeline.tweenFromTo("myLabel2", 0);

If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, just pass in a vars object with the appropriate properties. For example, to tween from the start (0) to the 5-second point on the timeline and then call a function named myFunction and pass in a parameter that's references this TimelineMax and use a Strong.easeOut ease, you'd do:

myTimeline.tweenFromTo(0, 5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});

Remember, this method simply creates a TweenLite instance that tweens the currentTime property of your timeline. So you can store a reference to that tween if you want, and you can kill() it anytime. Also note that tweenFromTo() does NOT affect the timeline's reversed property. So if your timeline is oriented normally (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards but the reversed property will not change to true. Also note that tweenFromTo() pauses the timeline immediately before tweening its currentTime property, and it stays paused after the tween completes. If you need to resume playback, you could always use an onComplete to call the resume() method.

See also

Creates a linear tween that essentially scrubs the playhead to a particular time or label and then stops. For example, to make the TimelineMax play to the "myLabel2" label, simply do:

myTimeline.tweenTo("myLabel2");

If you want advanced control over the tween, like adding an onComplete or changing the ease or adding a delay, just pass in a vars object with the appropriate properties. For example, to tween to the 5-second point on the timeline and then call a function named myFunction and pass in a parameter that's references this TimelineMax and use a Strong.easeOut ease, you'd do:

myTimeline.tweenTo(5, {onComplete:myFunction, onCompleteParams:[myTimeline], ease:Strong.easeOut});

Remember, this method simply creates a TweenLite instance that tweens the currentTime property of your timeline. So you can store a reference to that tween if you want, and you can kill() it anytime. Also note that tweenTo() does NOT affect the timeline's reversed property. So if your timeline is oriented normally (not reversed) and you tween to a time/label that precedes the current time, it will appear to go backwards but the reversed property will not change to true. Also note that tweenTo() pauses the timeline immediately before tweening its currentTime property, and it stays paused after the tween completes. If you need to resume playback, you could always use an onComplete to call the resume() method.

If you plan to sequence multiple playhead tweens one-after-the-other, it is typically better to use tweenFromTo() so that you can define the starting point and ending point, allowing the duration to be accurately determined immediately.

See also