API Documentation | All Packages | All Classes | Index | Frames No Frames |
Class TweenCore

Package | com.greensock.core
Class | public class TweenCore
Subclasses | SimpleTimeline, TweenLite

TweenCore is the base class for all TweenLite, TweenMax, TimelineLite, and TimelineMax classes and provides core functionality and properties. There is no reason to use this class directly.
Copyright 2011, 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.

Public Properties

| Property | Defined by
--- | --- | ---
|  | currentTime : Number Most recently rendered time (or frame for frames-based tweens/timelines) according to its `duration`. | TweenCore
|  | data : * Place to store any data you want. | TweenCore
|  | delay : Number Length of time in seconds (or frames for frames-based tweens/timelines) before the tween should begin. | TweenCore
|  | duration : Number Duration of the tween in seconds (or frames for frames-based tweens/timelines) not including any repeats or repeatDelays. | TweenCore
|  | paused : Boolean Indicates the paused state of the tween/timeline. | TweenCore
|  | reversed : Boolean Indicates the reversed state of the tween/timeline. | TweenCore
|  | startTime : Number Start time in seconds (or frames for frames-based tweens/timelines), according to its position on its parent timeline | TweenCore
|  | timeline : SimpleTimeline The parent timeline on which the tween/timeline is placed. | TweenCore
|  | totalDuration : Number Duration of the tween in seconds (or frames for frames-based tweens/timelines) including any repeats or repeatDelays (which are only available on TweenMax and TimelineMax). | TweenCore
|  | totalTime : Number Most recently rendered time (or frame for frames-based tweens/timelines) according to its `totalDuration`. | TweenCore
|  | vars : Object Stores variables (things like alpha, y or whatever we're tweening as well as special properties like "onComplete"). | TweenCore

Public Methods

| Method | Defined by
--- | --- | ---
|  | TweenCore(duration:Number = 0, vars:Object = null) | TweenCore
|  | complete(skipRender:Boolean = false, suppressEvents:Boolean = false):void Forces the tween/timeline to completion. | TweenCore
|  | invalidate():void 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. | TweenCore
|  | kill():void Kills the tween/timeline, stopping it immediately. | TweenCore
|  | pause():void Pauses the tween/timeline | TweenCore
|  | play():void Starts playing forward from the current position. | TweenCore
|  | restart(includeDelay:Boolean = false, suppressEvents:Boolean = true):void Restarts and begins playing forward. | TweenCore
|  | resume():void Starts playing from the current position without altering direction (forward or reversed). | TweenCore
|  | reverse(forceResume:Boolean = true):void Reverses smoothly, adjusting the startTime to avoid any skipping. | TweenCore

Property detail

currentTime | property

`currentTime:Number` [read-write]

Most recently rendered time (or frame for frames-based tweens/timelines) according to its `duration`. `totalTime`, by contrast, is based on its `totalDuration` which includes repeats and repeatDelays. Since TweenLite and TimelineLite don't offer `repeat` and `repeatDelay` functionality, `currentTime` and `totalTime` will always be the same but in TweenMax or TimelineMax, they could be different. For example, if a TimelineMax 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.

Implementation
`public function get currentTime():Number`
`public function set currentTime(value:Number):void`

data | property |

`public var data:*`

Place to store any data you want.

delay | property |

`delay:Number` [read-write]

Length of time in seconds (or frames for frames-based tweens/timelines) before the tween should begin. The tween's starting values are not determined until after the delay has expired (except in from() tweens)

Implementation
`public function get delay():Number`
`public function set delay(value:Number):void`

duration | property |

`duration:Number` [read-write]

Duration of the tween in seconds (or frames for frames-based tweens/timelines) not including any repeats or repeatDelays. `totalDuration`, by contrast, does include repeats and repeatDelays. If you alter the `duration` of a tween while it is in-progress (active), its `startTime` will automatically be adjusted in order to make the transition smoothly (without a sudden skip).

Implementation
`public function get duration():Number`
`public function set duration(value:Number):void`

paused | property |

`paused:Boolean` [read-write]

Indicates the paused state of the tween/timeline. This does not take into account anscestor timelines. So for example, a tween that is not paused might appear paused if its parent timeline (or any ancenstor timeline) is paused.

Implementation
`public function get paused():Boolean`
`public function set paused(value:Boolean):void`

reversed | property |

`reversed:Boolean` [read-write]

Indicates the reversed state of the tween/timeline. This value is not affected by `yoyo` repeats and it does not take into account the reversed state of anscestor timelines. So for example, a tween that is not reversed might appear reversed if its parent timeline (or any ancenstor timeline) is reversed.

Implementation
`public function get reversed():Boolean`
`public function set reversed(value:Boolean):void`

startTime | property |

`startTime:Number` [read-write]

Start time in seconds (or frames for frames-based tweens/timelines), according to its position on its parent timeline

Implementation
`public function get startTime():Number`
`public function set startTime(value:Number):void`

timeline | property |

`public var timeline:SimpleTimeline`

The parent timeline on which the tween/timeline is placed. By default, it uses the TweenLite.rootTimeline (or TweenLite.rootFramesTimeline for frames-based tweens/timelines).

totalDuration | property |

`totalDuration:Number` [read-write]

Duration of the tween in seconds (or frames for frames-based tweens/timelines) including any repeats or repeatDelays (which are only available on TweenMax and TimelineMax). `duration`, by contrast, does NOT include repeats and repeatDelays. So if a TweenMax's `duration` is 1 and it has a repeat of 2, the `totalDuration` would be 3.

Implementation
`public function get totalDuration():Number`
`public function set totalDuration(value:Number):void`

totalTime | property |

`totalTime:Number` [read-write]

Most recently rendered time (or frame for frames-based tweens/timelines) according to its `totalDuration`. `currentTime`, by contrast, is based on its `duration` which does NOT include repeats and repeatDelays. Since TweenLite and TimelineLite don't offer `repeat` and `repeatDelay` functionality, `currentTime` and `totalTime` will always be the same but in TweenMax or TimelineMax, they could be different. For example, if a TimelineMax 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.

Implementation
`public function get totalTime():Number`
`public function set totalTime(value:Number):void`

vars | property |

`public var vars:Object`

Stores variables (things like alpha, y or whatever we're tweening as well as special properties like "onComplete").

Constructor detail

TweenCore | () | constructor

`public function TweenCore(duration:Number = 0, vars:Object = null)`Parameters

| `duration:Number` (default = `0`)``
| `vars:Object` (default = `null`)``

Method detail

complete | () | method

`public function complete(skipRender:Boolean = false, suppressEvents:Boolean = false):void`

Forces the tween/timeline to completion.

Parameters

| `skipRender:Boolean` (default = `false`)`` — to skip rendering the final state of the tween, set skipRender to true.
| `suppressEvents:Boolean` (default = `false`)`` — If true, no events or callbacks will be triggered for this render (like onComplete, onUpdate, onReverseComplete, etc.)

invalidate | () | method |

`public function invalidate():void`

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.

kill | () | method |

`public function kill():void`

Kills the tween/timeline, stopping it immediately.

pause | () | method |

`public function pause():void`

Pauses the tween/timeline

play | () | method |

`public function play():void`

Starts playing forward from the current position. (essentially unpauses and makes sure that it is not reversed)

restart | () | method |

`public function restart(includeDelay:Boolean = false, suppressEvents:Boolean = true):void`

Restarts and begins playing forward.

Parameters

| `includeDelay:Boolean` (default = `false`)`` — Determines whether or not the delay (if any) is honored in the restart()
| `suppressEvents:Boolean` (default = `true`)`` — If true, no events or callbacks will be triggered as the "virtual playhead" moves to the new position (onComplete, onUpdate, onReverseComplete, etc. of this tween/timeline and any of its child tweens/timelines won't be triggered, nor will any of the associated events be dispatched)

resume | () | method |

`public function resume():void`

Starts playing from the current position without altering direction (forward or reversed).

reverse | () | method |

`public function reverse(forceResume:Boolean = true):void`

Reverses smoothly, adjusting the startTime to avoid any skipping. After being reversed, it will play backwards, exactly opposite from its forward orientation, meaning that, for example, a tween's easing equation will appear reversed as well. If a tween/timeline plays for 2 seconds and gets reversed, it will play for another 2 seconds to return to the beginning.

Parameters

| `forceResume:Boolean` (default = `true`)`` — If true, it will resume() immediately upon reversing. Otherwise its paused state will remain unchanged.