The currently active Ticker object.

Indicates whether the tween should automatically play when an end value is changed.

When true, the tween will always rotate in the shortest direction to reach an end rotation value. For example, rotating from 355 degress to 5 degrees will rotate 10 degrees clockwise with .autoRotation set to true. It would rotate 350 degrees counter-clockwise with .autoRotation set to false. This affects all properties specified in the static .rotationProperties hash table.

Indicates whether the target's visible property should automatically be set to false when its alpha value is tweened to 0 or less. Only affects objects with a visible property.

Allows you to associate arbitrary data with your tween. For example, you might use this to reference specific data when handling events from tweens.

Specifies the default easing function to use with new tweens. If null, GTween.linearEase will be used.

The length of the delay in frames or seconds (depending on the timingMode). The delay occurs before a tween reads initial values or starts playing.

The length of the tween in frames or seconds (depending on the timingMode). Setting this will also update any child transitions that have synchDuration set to true.

The easing function to use for calculating the tween. This can be any standard tween function, such as the tween functions in fl.motion.easing.that come with Flash CS3. New tweens will have this set to the defaultTween. Setting this to null will cause GTween to throw null reference errors.

If set to true, this prevents the tween from reinitializing its start properties automatically (ex. when end properties change). If start properties have not already been initialized, this will also cause the tween to immediate initialize them. Note that this will prevent new start property values from being initialized when invalidating, so it could cause unexpected behaviour if you modify the tween while it is playing.

Specifies another GTween instance that will have paused=false called on it when this tween completes.

Setting this to true pauses all tween instances. This does not affect individual tweens' .paused property.

Indicates whether the tween is currently paused. See play() and pause() for more information.

Gets and sets the position in the tween in frames or seconds (depending on the timingMode). This value can be any number, and will be resolved to a tweenPosition value prior to being applied to the tweened values. See tweenPosition for more information.

Negative values
Values below 0 will always resolve to a tweenPosition of 0. Negative values can be used to set up a delay on the tween, as the tween will have to count up to 0 before initing.

Positive values
Positive values are resolved based on the duration, repeat, reflect, and reversed properties.

Returns the object that will have its property tweened. In a standard GTween, this will usually be the same as target, except if an assignmentTarget was set. This also makes it easy for subclasses like GTweenFilter can divert the property target.

The proxy object allows you to work with the properties and methods of the target object directly through GTween. Numeric property assignments will be used by GTween as end values. The proxy will return GTween end values when they are set, or the target's property values if they are not. Delete operations on properties will result in a deleteProperty call. All other property access and method execution through proxy will be passed directly to the target object.

Example 1: Equivalent to calling myGTween.setProperty("scaleY",2.5):
myGTween.proxy.scaleY = 2.5;

Example 2: Gets the current rotation value from the target object (because it hasn't been set yet on the GTween), adds 100 to it, and then calls setProperty on the GTween instance with the appropriate value:
myGTween.proxy.rotation += 100;

Example 3: Sets an end property value (through setProperty) for scaleX, then retrieves it from GTween (because it will always return end values when available):
trace(myGTween.proxy.scaleX); // 1 (value from target, because no end value is set)
myGTween.proxy.scaleX = 2; // set a end value
trace(myGTween.proxy.scaleX); // 2 (end value from GTween)
trace(myGTween.target.scaleX); // 1 (current value from target)

Example 4: Property deletions only affect end properties on GTween, not the target object:
myGTween.proxy.rotation = 50; // set a end value
trace(myGTween.proxy.rotation); // 50 (end value from GTween)
delete(myGTween.proxy.rotation); // delete the end value
trace(myGTween.proxy.rotation); // 0 (current value from target)

Example 5: Non-numeric property access is passed through to the target:
myGTween.proxy.blendMode = "multiply"; // passes value assignment through to the target
trace(myGTween.target.blendMode); // "multiply" (value from target)
trace(myGTween.proxy.blendMode); // "multiply" (value passed through from target)

Example 6: Method calls are passed through to target:
myGTween.proxy.gotoAndStop(30); // gotoAndStop(30) will be called on the target

Indicates whether the tween should use the reflect mode when repeating. If reflect is set to true, then the tween will play backwards on every other repeat. This has similar effects to reversed, but the properties are exclusive of one another. For instance, with reversed set to false, reflected set to true, and a repeat of 1, the tween will play from start to end, then repeat and reflect to play from end to start. If in the previous example reversed was instead set to true, the tween would play from end to start, then repeat and reflect to play from start to end. Finally, with reversed set to false, reflected set to false, and a repeat of 1, the tween will play from start to end, then repeat from start to end

The number of times this tween will repeat. If 0, the tween will only run once. If 1 or more, the tween will repeat that many times. If -1, the tween will repeat forever.

Indicates whether a tween should run in reverse. In the simplest examples this means that the tween will play from its end values to its start values. See "reflect" for more information on how these two related properties interact. Also see reverse().

A hash table specifying properties that should be affected by autoRotation.

If set to true, tweened values specified by snappingProperties will be rounded (snapped) before they are assigned to the target.

A hash table specifying properties that should have their value rounded (snapped) before being applied. This can be toggled for each tween instance basis with the .snapping property.

Returns the current positional state of the tween. This does not indicate if the tween is paused - use the .paused property for this. Possible values are: GTween.START, GTween.DELAY, GTween.TWEEN, GTween.END
The beginning state indicates the tween either has not been played. The tween's position will equal -delay.
The delayPhase state indicates that the tween is active (running), but is currently delaying prior to initing. The tween's position is less than 0. Note that it may be paused.
The tweenPhase state indicates that the tween has inited, and is tweening the property values. Note that it may be paused.
The end state indicates that the tween has completed playing. Setting any new properties on the tween will reset it, and set its state to beginning.

New tweens with autoplay set to false start with a state of START. When first played, a tween will have a state of either DELAY (if delay > 0) or TWEEN (if delay == 0). When the delay ends, and tweening begins, the state will change to TWEEN. When the tween reaches its end position == durationrepeat+1), the state will be set to END. If you change any end properties on an ended tween, its state will be set back to START.

The target object to tween. This can be any kind of object.

Sets the time in milliseconds between updates when timingMode is set to GTween.TIME ("time"). Setting this to a lower number will generally result in smoother animations but higher CPU usage. Defaults to 40ms (~25 updates per second).

Indicates how GTween should deal with timing. This can be set to GTween.TIME, GTween.FRAME, or GTween.HYBRID.

In frame mode, GTween will update once every frame, and all positional values are specified in frames (duration, position, delay, etc).

In time mode, updates will occur at an interval specified by the timeInterval property, independent of the frame rate, and all positional values are specified in seconds.

In hybrid mode, all updates occur on a frame, but all positional values are specified in seconds. Each frame the tween will calculate it's position based on the elapsed time. This offers lower CPU usage, and a more familiar time-based interface, but can result in choppy animations in high CPU situations.

The hybrid mode generally provides the smoothest results. The frame mode makes it easy to synch tweens with timeline animations. You can change modes at any time, but existing tweens will continue to use the mode that was active when they were created.

Returns the calculated absolute position in the tween. This is a deterministic value between 0 and duration calculated from the current position based on the duration, repeat, reflect, and reversed properties.

For example, a tween with a position of 5 on a tween with a duration of 3, and repeat set to true would have a tweenPosition of 2 (2 seconds into the first repeat). The same tween with reflect set to true would have a tweenPosition of 1 (because it would be 2 seconds into the first repeat which is playing backwards). With reflect and reversed set to true it would have a tweenPosition of 2.

Tweens with a position less than 0 will have a tweenPosition of 0. Tweens with a position greater than durationrepeat+1) (the total length of the tween) will have a tweenPosition equal to duration.

Constructs a new GTween instance.

Jumps the tween to its beginning. This is the same as setting position=-delay.

Removes a end value from the tween. This prevents the GTween instance from tweening the property.

Jumps the tween to its end. This is the same as setting position=(repeat+1)uration.

Returns the hash table of all end properties and their values. This is a copy of the internal hash of values, so modifying the returned object will not affect the tween.

Returns the end value for the specified property if one exists.

Returns the hash table of all start properties and their values. This is a copy of the internal hash of values, so modifying the returned object will not affect the tween.

Invalidate forces the tween to repopulate all of the initial properties from the target object, and start playing if autoplay is set to true. If the tween is currently playing, then it will also set the position to 0. For example, if you changed the x and y position of a the target object while the tween was playing, you could call invalidate on it to force it to resume the tween with the new property values.

The default easing function used by GTween.

Pauses the tween by stopping tick from being automatically called. This also releases the tween for garbage collection if it is not referenced externally.

Plays a tween by incrementing the position property each frame. This also prevents the tween from being garbage collected while it is active. This is achieved by way of two methods:
1. If the target object is an IEventDispatcher, then the tween will subscribe to a dummy event using a hard reference. This allows the tween to be garbage collected if its target is also collected, and there are no other external references to it.
2. If the target object is not an IEventDispatcher, then the tween is placed in the activeTweens list, to prevent collection until it is paused or reaches the end of the transition). Note that pausing all tweens via the GTween.pauseAll static property will not free the tweens for collection.

Toggles the reversed property and inverts the current tween position. This will cause a tween to reverse playing visually. There is currently an issue with this functionality for tweens with a repeat of -1

Allows you to tween objects that require re-assignment whenever they are modified by reassigning the target object to a specified property of another object. For example, in order for changes to a colorTransform object to be visible, it must be assigned back to the .transform.colorTransform property of a display object. To make this work, you would call myTween.setAssignment(myDisplayObject.transform,"colorTransform"); This will also cause GTween to retrieve the target each time it copies its initial values.

Note: this does not work with filters, as they must be assigned to an array first, and then to the filters property. Use GTweenFilter instead.

Sets the position of the tween. Using the position property will always suppress events and callbacks, whereas the setPosition method allows you to manually set the position and specify whether to suppress events or not.

Shorthand method for making multiple setProperty calls quickly. This removes any existing target property values on the tween.

Example: set x and y end values:
myGTween.setProperties({x:200, y:400});

Sets the numeric end value for a property on the target object that you would like to tween. For example, if you wanted to tween to a new x position, you could use: myGTween.setProperty("x",400). Non-numeric values are ignored.

Allows you to manually assign the start property values for a tween. These are the properties that will be applied when the tween is at tween position 0. Normally these are automatically copied from the target object on initialization, or whenever a end value changes. You can also use the lockStartProperties property to ensure your start properties are not reinitialized after you set them.

Shortcut method for setting multiple properties on the tween instance quickly. This does not set end values (ie. the value to tween to). This method also provides you with a quick method for adding listeners to specific events, using the special properties: initListener, completeListener, changeListener.

Example: This will set the duration, reflect, and nextTween properties of a tween, and add a listener for the complete event:
myTween.setTweenProperties({duration:4, reflect:true, nextTween:anotherTween, completeListener:completeHandlerFunction});

This event is dispatched each time the tween updates properties on its target. It will be dispatched each "tick" during the TWEEN.

Dispatched when a tween ends (its position equals its duration).

Dispatched when a tween copies its initial properties and starts tweening. In tweens with a delay of 0, this event will fire immediately when it starts playing. In tweens with a delay set, this will fire when the delay state is ended, and the tween state is entered.

Constant for the DELAY state.

Constant for the END state.

Constant for the FRAME timingMode.

Constant for the HYBRID timingMode.

Constant for the START state.

Constant for the TIME timingMode.

Constant for the TWEEN state.