Value between 0 and 1 indicating the progress of the timeline 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 timeline's totalDuration which includes repeats and repeatDelays (if there are any). Since TimelineLite doesn't offer "repeat" and "repeatDelay" functionality, currentProgress and totalProgress are always the same but in TimelineMax, they could be different. 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.

Duration of the timeline in seconds (or frames for frames-based timelines) not including any repeats or repeatDelays. totalDuration, by contrast, does include repeats and repeatDelays but since TimelineLite doesn't offer "repeat" and "repeatDelay" functionality, duration and totalDuration will always be the same. In TimelineMax, however, they could be different.

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 timeline in seconds (or frames for frames-based timelines) including any repeats or repeatDelays. duration, by contrast, does NOT include repeats and repeatDelays. Since TimelineLite doesn't offer "repeat" and "repeatDelay" functionality, duration and totalDuration will always be the same. In TimelineMax, however, they could be different.

Indicates whether or not the timeline's timing mode is frames-based as opposed to time-based. This can only be set via the vars object in the constructor, or by attaching it to a timeline with the desired timing mode (a timeline's timing mode is always determined by its parent timeline)

Constructor.

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

• delay : Number Amount of delay in seconds (or frames for frames-based timelines) before the timeline should begin.
• paused : Boolean Sets the initial paused state of the timeline (by default, timelines automatically begin playing immediately)
• 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.
• 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. 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
• 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.

Adds a label to the timeline, making it easy to mark important positions/times. gotoAndStop() and gotoAndPlay() allow you to skip directly to any label. This works just like timeline labels in the Flash IDE.

Inserts a TweenLite, TweenMax, TimelineLite, or TimelineMax instance at the end of the timeline, optionally offsetting its insertion point by a certain amount (to make it overlap with the end of the timeline or leave a gap before its insertion point). This makes it easy to build sequences by continuing to append() tweens or timelines.

Appends multiple tweens/timelines at the end of the timeline at once, optionally offsetting the insertion point by a certain amount, aligning them (as a sequence for example), and/or staggering their relative timing. This is one of the most powerful methods in TimelineLite because it accommodates advanced timing effects and builds complex sequences with relatively little code.

Empties the timeline of all child tweens/timelines, or you can optionally pass an Array containing specific tweens/timelines to remove. So myTimeline.clear() would remove all children whereas myTimeline.clear([tween1, tween2]) would only remove tween1 and tween2. You could even clear only the tweens of a particular object with myTimeline.clear(myTimeline.getTweensOf(myObject));

Provides an easy way to get all of the tweens and/or timelines nested in this timeline (as an Array).

Returns the time associated with a particular label. If the label isn't found, -1 is returned.

Returns the tweens of a particular object that are inside this timeline.

Skips to a particular time, frame, or label without changing the paused state of the timeline

Skips to a particular time, frame, or label and plays the timeline forwards from there (unpausing it)

Skips to a particular time, frame, or label and stops the timeline (pausing it)

Inserts a TweenLite, TweenMax, TimelineLite, or TimelineMax instance into the timeline at a specific time, frame, or label. If you insert at a label that doesn't exist yet, one is created at the end of the timeline.

Inserts multiple tweens/timelines into the timeline at once, optionally aligning them (as a sequence for example) and/or staggering the timing. This is one of the most powerful methods in TimelineLite because it accommodates advanced timing effects and builds complex sequences with relatively little code.

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 inside this TimelineLite, optionally completing them first. If, for example, you want to kill all tweens of the "mc" object, you'd do:

myTimeline.killTweensOf(mc);

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

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

Killing a tween also removes it from the timeline.

Inserts a TweenLite, TweenMax, TimelineLite, or TimelineMax instance at the beginning of the timeline, pushing all existing tweens back in time to make room for the newly inserted one. You can optionally affect the positions of labels too.

Prepends multiple tweens/timelines to the beginning of the timeline at once, moving all existing children back to make room, and optionally aligning the new children (as a sequence for example) and/or staggering the timing.

Removes a TweenLite, TweenMax, TimelineLite, or TimelineMax instance from the timeline.

Removes a label from the timeline and returns the time of that label.

Shifts the startTime of the timeline's children by a certain amount and optionally adjusts labels too. This can be useful when you want to prepend children or splice them into a certain spot, moving existing ones back to make room for the new ones.

Pauses the timeline (same as pause() - added stop() for consistency with Flash's MovieClip.stop() functionality)