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

The current calculated position of the tween. This is a deterministic value between 0 and duration calculated from the current position based on the duration, repeatCount, and reflect properties. This is always a value between 0 and duration, whereas .position can range between -delay and repeatCounturation. This should not be set directly.

The previous calculated position of the tween. See .calculatedPosition for more information. This should not be set directly.

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

Sets the default value of dispatchEvents for new instances.

Specifies the default easing function to use with new tweens. Set to GTween.linearEase by default.

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

If true, it will dispatch init, change, and complete events in addition to calling the onInit, onChange, and onComplete callbacks. Callbacks provide significantly better performance, whereas events are more standardized and flexible (allowing multiple listeners, for example).

By default this will use the value of defaultDispatchEvents.

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 defaultTween. Setting this to null will cause GTween to throw null reference errors.

Specifies another GTween instance that will have paused=false set on it when this tween completes. This happens immediately before onComplete is called.

Callback for the change event. Any function assigned to this callback will be called each frame while the tween is active with a single parameter containing a reference to the tween.

Callback for the complete event. Any function assigned to this callback will be called when the tween finishes with a single parameter containing a reference to the tween.

Ex.

myTween.onComplete = myFunction;
  function myFunction(tween:GTween):void {
  trace("tween completed");
  }

Callback for the init event. Any function assigned to this callback will be called when the tween inits with a single parameter containing a reference to the tween. Init is usually triggered when a tween finishes its delay period and becomes active, but it can also be triggered by other features that require the tween to read the initial values, like calling .swapValues().

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

Plays or pauses a tween. You can still change the position value externally on a paused tween, but it will not be updated automatically. While paused is false, the tween is also prevented from being garbage collected while it is active. This is achieved in one of two ways:
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 a global list, to prevent collection until it is paused or completes.
Note that pausing all tweens via the GTween.pauseAll static property will not free the tweens for collection.

Stores data for plugins specific to this instance. Some plugins may allow you to set properties on this object that they use. Check the documentation for your plugin to see if any properties are supported. Most plugins also support a property on this object in the form PluginNameEnabled to enable or disable the plugin for this tween (ex. BlurEnabled for BlurPlugin). Many plugins will also store internal data in this object.

Gets and sets the position of the tween in frames or seconds (depending on .useFrames). This value will be constrained between -delay and repeatCounturation. It will be resolved to a calculatedPosition before being applied.

Negative values
Values below 0 will always resolve to a calculatedPosition 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, repeatCount, and reflect properties.

The position of the tween at the previous change. This should not be set directly.

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 an 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 proxy from target)

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

The eased ratio (generally between 0-1) of the tween at the current position. This should not be set directly.

The eased ratio (generally between 0-1) of the tween at the previous position. This should not be set directly.

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.

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

If true, events/callbacks will not be called. As well as allowing for more control over events, and providing flexibility for extension, this results in a slight performance increase, particularly if useCallbacks is false.

The target object to tween. This can be any kind of object. You can retarget a tween at any time, but changing the target in mid-tween may result in unusual behaviour.

Allows you to scale the passage of time for a tween. For example, a tween with a duration of 5 seconds, and a timeScale of 2 will complete in 2.5 seconds. With a timeScale of 0.5 the same tween would complete in 10 seconds.

Sets the time scale for all tweens. For example to run all tweens at half speed, you can set timeScaleAll to 0.5. It is multiplied against each tweens timeScale. For example a tween with timeScale=2 will play back at normal speed if timeScaleAll is set to 0.5.

If true, durations and positions can be set in frames. If false, they are specified in seconds.

Indicates the version number for this build. The numeric value will always increase with the version number for easy comparison (ex. GTween.version >= 2.12). Currently, it incorporates the major version as the integer value, and the two digit build number as the decimal value. For example, the fourth build of version 3 would have version=3.04.

Constructs a new GTween instance.

Jumps the tween to its beginning and pauses it. This is the same as setting position=0 and paused=true.

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

Jumps the tween to its end and pauses it. This is roughly the same as setting position=repeatCounturation.

Returns the initial value for the specified property. Note that the value will not be available until the tween inits.

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

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.

Reads all of the initial values from target and calls the onInit callback. This is called automatically when a tween becomes active (finishes delaying) and when .swapValues() is called. It would rarely be used directly but is exposed for possible use by plugin developers or power users.

Installs a plugin for the specified property. Plugins with high priority will always be called before other plugins for the same property. This method is primarily used by plugin developers. Plugins are normally installed by calling the install method on them, such as BlurPlugin.install().

Plugins can register to be associated with a specific property name, or to be called for all tweens by registering for the " property name. The latter will be called after all properties are inited or tweened for a particular GTween instance.

The default easing function used by GTween.

Similar to .setValues(), but clears all previous end values before setting the new ones.

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.setValue("x",400).

Shorthand method for making multiple setProperty calls quickly. This adds the specified properties to the values list. Passing a property with a value of null will delete that value from the list.

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

Swaps the init and end values for the tween, effectively reversing it. This should generally only be called before the tween starts playing. This will force the tween to init if it hasn't already done so, which may result in an onInit call. It will also force a render (so the target immediately jumps to the new values immediately) which will result in the onChange callback being called.

You can also use the special "swapValues" property on the props parameter of the GTween constructor to call swapValues() after the values are set.

The following example would tween the target from 100,100 to its current position:
new GTween(ball, 2, {x:100, y:100}, {swapValues:true});