Returns the number of updates that have occured since start.

This update-count property does not necessarily correspond to the actual player framerate, just the instance's pulseInterval.

This property is set up to mirror the flash timeline. Imagine a timeline layer with a delay being a set of blank frames followed by the tween, followed by subsequent cycles as additional tweens: this is the way the currentFrame property works. Its first value is 1 by default, which can be changed to 0 in setupUseFramesMode(). This differs significantly from timePosition, which places the start of a single instance of the tween at frame 1 and steps its values from negative during delay then cycling through the single tween.

See also

Class default for the instance property delay.

The default value is 0.

See also

Class default for the instance property duration.

The default value is 1.

See also

Class default for the instance property easing. Note that this property is left null until the first LinearGo is instantiated, at which time it is set to Quintic.easeOut.

The default value is fl.motion.easing.Quintic.easeOut.

See also

Number of seconds after start() call that the LinearGo begins processing.

If not set manually, the class default defaultDelay is adopted.

See also

Number of seconds the LinearGo takes to process.

If not set manually, the class default defaultDuration is adopted.

See also

Any standard easing-equation function such as the ones found in the Flash package fl.motion.easing or the flex package mx.effects.easing.

If not set manually, the class default defaultEasing is adopted. An error is thrown if the function does not follow the typical format. For easings that accept more than four parameters use extraEasingParams.

See also

Additional parameters to pass to easing functions that accept more than four.

See also

A number between 0 and 1 representing the current tween value.

Use this number as a multiplier to apply values to targets across time.

Here's an example of what an overridden update method might contain:

   super.update(currentTime);
   target[ propName ] = super.correctValue(startValue + changeposition);
   

See also

A LinearGoRepeater instance that defines options for repeated or back-and-forth cycling animation.

You may pass a LinearGoRepeater instance to the constructor's repeater parameter to set all options at instantiation. The repeater's cycles property can be set to an integer, or to Repeater.INFINITE or 0 to repeat indefinitely, and checked using linearGo.repeater.currentCycle. LinearGoRepeater's reverseOnCycle flag is true by default, which causes animation to cycle back and forth. In that mode you can also specify a separate easing function (plus extraEasingParams) to use for the reverse animation cycle. For example, an easeOut easing with an easeIn easingOnCycle will produce a more natural-looking result. If reverseOnCycle is disabled, the animation will repeat its play forward each time.

(The repeater property replaces the cycles, easeOnCycle and currentCycle parameters in earlier releases of LinearGo).

See also

For time-based tweens, returns a time value which is negative during delay then spans the tween duration in positive values, ignoring repeat cycles.

In useFrames mode, this getter differs from currentFrame significantly. Instead of constantly increasing through all cycles as if tweens were back-to-back in a timeline layer, this method acts more like a single tween placed at frame 1, with a timeline playhead that scans back and forth or loops during cycles. So for a 10-frame tween with a 5-frame delay and 2 repeater cycles with reverseOnCycle set to true, this method will return values starting at -5, start the animation at 1, play to 10 then step backward to 1 again.

See also

The inputs here are not a convention, subclasses should design their own constructors appropriate to usage. They are provided here primarily as a convenience for subclasses. However, do not omit calling super() from subclass constructors: LinearGo's constructor sets and validates class defaults and sets up the repeater instance.

An alternative to subscribing to events is to store callbacks. You can associate any number of callbacks with the primary GoEvent types START, UPDATE, COMPLETE, and STOP (only fired if the tween is stopped before it completes).

Note that there is little difference between using callbacks and events. Both are common techniques used in many various modern tweening APIs. Callbacks are slightly faster, but this won't normally be noticeable unless thousands of tweens are being run at once.

See also

An alternative default easing with no acceleration. (The two default easings in this class are included because there's currently no single easing classpath shared between Flash & Flex.)

Normal default easing, this is Quintic.easeOut. (The two default easings in this class are included because there's currently no single easing classpath shared between Flash & Flex.)

Subclass this method (instead of the update method) for simplicity.

Use this method to manipulate targets based on the current _position setting, which is a 0-1 multiplier precalculated to the tween's position based on its easing style and the current time in the tween.

CONVENTION ALERT: To implement the Go convention useRounding, always call GoItem's correctValue() method on each calculated tween value before you apply it to a target. This corrects NaN to 0 and rounds the value if useRounding is true.

   override protected function onUpdate(type:String):void
   {
       target[ propName ] = super.correctValue(startValue + changeposition);
   }
   

See also

Pauses play (including delay) for this LinearGo instance. This method does not typically require subclassing.

See also

Removes a method closure previously stored using addCallback.

See also

Resumes previously paused play, including delay. This method does not typically require subclassing.

See also

A quick one-time setup command that lets you turn on useFrames mode as a default for all new tweens and adjust some related settings. (Note that useFrames mode is normally only used for specialty situations.)

See also

Skips to a point in the tween's duration and plays, from any state. This method does not typically require subclassing.

If GoItem.timeMultiplier is set to a custom value, you should still pass a seconds value based on the tween's real duration setting.

See also

Starts play for this LinearGo instance using GoEngine.

CONVENTION ALERT: If useRelative is true, calculate tween values relative to the target object's existing value as in the example below.

Most typically you should also store the tween's start and change values for later use in onUpdate.

   protected var _target : DisplayObject;
   protected var _width : Number;
   protected var _changeWidth : Number;
   
   public function start():Boolean 
   {
       if (!_target || !_width || isNaN(_width))
           return false;
   
       _startWidth = _target.width;
   
       if (useRelative) {
           _changeWidth = _width;
       } else {
           _changeWidth = (_width - _startWidth);
       }
       
       return (super.start());
   }
   

See also

Ends play for this LinearGo instance and dispatches a GoEvent.STOP event if the tween is incomplete. This method does not typically require subclassing.

Performs tween calculations on GoEngine pulse.

Subclass onUpdate instead of this method. Parameters

See also

Dispatched on an animation's final update, just after the last update event. Any number of callbacks may also be associated with this event using addCallback.

Dispatched at the end of each cycle if the tween has more than one. Any number of callbacks may also be associated with this event using addCallback.

Dispatched when pause() is called successfully. Any number of callbacks may also be associated with this event using addCallback.

Dispatched when resume() is called successfully. Any number of callbacks may also be associated with this event using addCallback.

Dispatched during an animation's first update after the delay has completed, if one was set. Any number of callbacks may also be associated with this event using addCallback.

Dispatched if an animation is manually stopped. Any number of callbacks may also be associated with this event using addCallback.

Dispatched on the animation's update pulse. Any number of callbacks may also be associated with this event using addCallback.