The generic object populated by all of the method calls in the TweenLiteVars instance. This is the raw data that gets passed to the tween.

Constructor

Same as changing the "alpha" property but with the additional feature of toggling the "visible" property to false whenever alpha is 0, thus improving rendering performance in the Flash Player.

Parameters

Tweens a BevelFilter

Parameters

Bezier tweening allows you to tween in a non-linear way. For example, you may want to tween a MovieClip's position from the origin (0,0) 500 pixels to the right (500,0) but curve downwards through the middle of the tween. Simply pass as many objects in the bezier Array as you'd like, one for each "control point" (see documentation on Flash's curveTo() drawing method for more about how control points work).

Keep in mind that you can bezier tween ANY properties, not just x/y.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars;
import com.greensock.plugins.TweenPlugin;
import com.greensock.plugins.BezierPlugin; 
TweenPlugin.activate([BezierPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 3, new TweenLiteVars().bezier([{x:250, y:50}, {x:500, y:0}])); //makes my_mc travel through 250,50 and end up at 500,0.

Parameters

See also

Identical to bezier except that instead of passing Bezier control point values, you pass values through which the Bezier values should move. This can be more intuitive than using control points.

Parameters

See also

Tweens a BlurFilter

Parameters

Tweens an object along a CirclePath2D motion path in any direction (clockwise, counter-clockwise, or shortest).

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.*; 
import com.greensock.motionPaths.*
TweenPlugin.activate([CirclePath2DPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
var circle:CirclePath2D = new CirclePath2D(150, 150, 100);
TweenLite.to(mc, 2, new TweenLiteVars().circlePath2D(circle, 90, 270, false, Direction.CLOCKWISE, 2)); 

Parameters

ColorMatrixFilter tweening offers an easy way to tween a DisplayObject's saturation, hue, contrast, brightness, and colorization.

HINT: If you'd like to match the ColorMatrixFilter values you created in the Flash IDE on a particular object, you can get its matrix like this:

import flash.display.DisplayObject; 
import flash.filters.ColorMatrixFilter;
function getColorMatrix(mc:DisplayObject):Array {
    var f:Array = mc.filters, i:uint; 
    for (i = 0; i < f.length; i++) { 
        if (f[i] is ColorMatrixFilter) {
            return f[i].matrix; 
        } 
    } 
    return null; 
}
var myOriginalMatrix:Array = getColorMatrix(my_mc); //store it so you can tween back to it anytime

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.ColorMatrixFilterPlugin; 
TweenPlugin.activate([ColorMatrixFilterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().colorMatrixFilter(0xFF0000));

Parameters

Tweens ColorTransform properties of a DisplayObject to do advanced effects like overexposing, altering the brightness or setting the percent/amount of tint.

Parameters

Any generic data that you'd like associated with your tween.

Parameters

The number of seconds (or frames for frames-based tweens) to delay before the tween begins.

Parameters

Tweens a DropShadowFilter.

Parameters

If you'd like to tween something to a destination value that may change at any time, dynamicProps allows you to simply associate a function with a property so that every time the tween is rendered, it calls that function to get the new destination value for the associated property. For example, if you want a MovieClip to tween to wherever the mouse happens to be, you could do:

TweenLite.to(mc, 3, new TweenLiteVars().dynamicProps({x:getMouseX, y:getMouseY})); 
function getMouseX():Number {
    return this.mouseX;
}
function getMouseY():Number {
    return this.mouseY;
}

Of course you can get as complex as you want inside your custom function, as long as it returns the destination value, TweenLite/Max will take care of adjusting things on the fly.

You can optionally pass any number of parameters to functions using the "params" parameter like so:

TweenLite.to(mc, 3, new TweenLiteVars().dynamicProps({x:myFunction, y:myFunction}, {x:[mc2, "x"], y:[mc2, "y"]})); 
function myFunction(object:MovieClip, propName:String):Number {
    return object[propName];
}

DynamicPropsPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.*; 
TweenPlugin.activate([DynamicPropsPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(my_mc, 3, new TweenLiteVars().dynamicProps({x:getMouseX, y:getMouseY}));
    
function getMouseX():Number {
    return this.mouseX;
}
function getMouseY():Number {
    return this.mouseY;
}

Parameters

Controls the rate of change. Use any standard easing equation like ElasticOut.ease. The Default is QuadOut.ease.

Parameters

An Array containing numeric end values of the target Array. Keep in mind that the target of the tween must be an Array with at least the same length as the endArray.

Parameters

Tweens a MovieClip to a particular frame.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.FramePlugin; 
TweenPlugin.activate([FramePlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().frame(125)); 

Note: When tweening the frames of a MovieClip, any audio that is embedded on the MovieClip's timeline (as "stream") will not be played. Doing so would be impossible because the tween might speed up or slow down the MovieClip to any degree.

Parameters

Tweens a MovieClip backward to a particular frame number, wrapping it if/when it reaches the beginning of the timeline. For example, if your MovieClip has 20 frames total and it is currently at frame 10 and you want tween to frame 15, a normal frame tween would go forward from 10 to 15, but a frameBackward would go from 10 to 1 (the beginning) and wrap to the end and continue tweening from 20 to 15.

Parameters

Tweens a MovieClip forward to a particular frame number, wrapping it if/when it reaches the end of the timeline. For example, if your MovieClip has 20 frames total and it is currently at frame 10 and you want tween to frame 5, a normal frame tween would go backwards from 10 to 5, but a frameForward would go from 10 to 20 (the end) and wrap to the beginning and continue tweening from 1 to 5.

Parameters

Tweens a MovieClip to a particular frame.

Parameters

Tweens a GlowFilter

Parameters

Tweens the "height" property of the target

Parameters

Although hex colors are technically numbers, if you try to tween them conventionally, you'll notice that they don't tween smoothly. To tween them properly, the red, green, and blue components must be extracted and tweened independently. The HexColorsPlugin makes it easy. To tween a property of your object that's a hex color to another hex color, just pass a hexColors Object with properties named the same as your object's hex color properties. For example, if myObject has a "myHexColor" property that you'd like to tween to red (0xFF0000) over the course of 2 seconds, you'd do:

TweenMax.to(myObject, 2, new TweenLiteVars().hexColors({myHexColor:0xFF0000}));

You can pass in any number of hexColor properties.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.HexColorsPlugin; 
TweenPlugin.activate([HexColorsPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(myObject, 2, new TweenLiteVars().hexColors({myHexColor:0xFF0000}));

Or if you just want to tween a color and apply it somewhere on every frame, you could do:

var myColor:Object = {hex:0xFF0000};
TweenLite.to(myColor, 2, new TweenLiteVars().hexColors({hex:0x0000FF}).onUpdate(applyColor));
function applyColor():void {
    mc.graphics.clear();
    mc.graphics.beginFill(myColor.hex, 1);
    mc.graphics.drawRect(0, 0, 100, 100);
    mc.graphics.endFill();
}

Parameters

Normally when you create a tween, it begins rendering on the very next frame (when the Flash Player dispatches an ENTER_FRAME event) unless you specify a delay. This allows you to insert tweens into timelines and perform other actions that may affect its timing. However, if you prefer to force the tween to render immediately when it is created, set immediateRender to true. from() tweens render immediately by default, so to prevent that behavior, set immediateRender to false.

Parameters

MotionBlurPlugin provides an easy way to apply a directional blur to a DisplayObject based on its velocity and angle of movement in 2D (x/y). This creates a much more realistic effect than a standard BlurFilter for several reasons:

1. A regular BlurFilter is limited to blurring horizontally and/or vertically whereas the motionBlur gets applied at the angle at which the object is moving.
2. A BlurFilter tween has static start/end values whereas a motionBlur tween dynamically adjusts the values on-the-fly during the tween based on the velocity of the object. So if you use a Strong.easeInOut for example, the strength of the blur will start out low, then increase as the object moves faster, and reduce again towards the end of the tween.

motionBlur even works on bezier/bezierThrough tweens!

To accomplish the effect, MotionBlurPlugin creates a Bitmap that it places over the original object, changing alpha of the original to [almost] zero during the course of the tween. The original DisplayObject still follows the course of the tween, so MouseEvents are properly dispatched. You shouldn't notice any loss of interactivity. The DisplayObject can also have animated contents - MotionBlurPlugin automatically updates on every frame. Be aware, however, that as with most filter effects, MotionBlurPlugin is somewhat CPU-intensive, so it is not recommended that you tween large quantities of objects simultaneously. You can activate fastMode to significantly speed up rendering if the object's contents and size/color doesn't need to change during the course of the tween.

Parameters

Tweens the "x" and "y" properties of the target

Parameters

A function that should be called when the tween has completed.

Parameters

A function that should be called after the tween has completed and rendered its final state to the stage (waits for the next ENTER_FRAME event is dispatched after the tween finishes). Target must be a DisplayObject.

Parameters

A function that should be called when the tween has reached its starting point again after having been reversed.

Parameters

A function that should be called when the tween begins (when its time() is at 0 and changes to some other value which can happen more than once if the tween is restarted multiple times).

Parameters

A function to call whenever the tweening values are updated (on every frame during the time the tween is active).

Parameters

A common effect that designers/developers want is for a MovieClip/Sprite to orient itself in the direction of a Bezier path (alter its rotation). orientToBezier makes it easy. In order to alter a rotation property accurately, TweenLite/Max needs 4 pieces of information:

1. Position property 1 (typically "x")
2. Position property 2 (typically "y")
3. Rotational property (typically "rotation")
4. Number of degrees to add (optional - makes it easy to orient your MovieClip/Sprite properly)

The orientToBezier property should be an Array containing one Array for each set of these values. For maximum flexibility, you can pass in any number of Arrays inside the container Array, one for each rotational property. This can be convenient when working in 3D because you can rotate on multiple axis. If you're doing a standard 2D x/y tween on a bezier, you can simply pass in a boolean value of true and TweenMax will use a typical setup, [["x", "y", "rotation", 0]]. Hint: Don't forget the container Array (notice the double outer brackets)

To use the default value ([["x", "y", "rotation", 0]]), you can simply leave the values parameter as null.

Parameters

Controls how (and if) other tweens of the same target are overwritten. There are several modes to choose from, but "auto" is the default (although you can change the default mode using the TweenLite.defaultOverwrite property):

• "none" - no overwriting will occur.
• "all" - immediately overwrites all existing tweens of the same target even if they haven't started yet or don't have conflicting properties.
• "auto" - when the tween renders for the first time, it will analyze tweens of the same target that are currently active/running and only overwrite individual tweening properties that overlap/conflict. Tweens that haven't begun yet are ignored. For example, if another active tween is found that is tweening 3 properties, only 1 of which it shares in common with the new tween, the other 2 properties will be left alone. Only the conflicting property gets overwritten/killed. This is the default mode and typically the most intuitive for developers.
• "concurrent" - when the tween renders for the first time, it kills only the active (in-progress) tweens of the same target regardless of whether or not they contain conflicting properties. Like a mix of "all" and "auto". Good for situations where you only want one tween controling the target at a time.
• "allOnStart" - Identical to "all" but waits to run the overwrite logic until the tween begins (after any delay). Kills tweens of the same target even if they don't contain conflicting properties or haven't started yet.
• "preexisting" - when the tween renders for the first time, it kills only the tweens of the same target that existed BEFORE this tween was created regardless of their scheduled start times. So, for example, if you create a tween with a delay of 10 and then a tween with a delay of 1 and then a tween with a delay of 2 (all of the same target), the 2nd tween would overwrite the first but not the second even though scheduling might seem to dictate otherwise. "preexisting" only cares about the order in which the instances were actually created. This can be useful when the order in which your code runs plays a critical role.

Parameters

Controls the paused state of the tween - if true, the tween will be paused initially.

Parameters

Provides simple physics functionality for tweening a DisplayObject's x and y coordinates based on a combination of velocity, angle, gravity, acceleration, accelerationAngle, and/or friction. It is not intended to replace a full-blown physics engine and does not offer collision detection, but serves as a way to easily create interesting physics-based effects with the GreenSock tweening platform. Parameters are not intended to be dynamically updateable, but one unique convenience is that everything is reverseable. So if you spawn a bunch of particle tweens, for example, and throw them into a TimelineLite, you could simply call reverse() on the timeline to watch the particles retrace their steps right back to the beginning. Keep in mind that any easing equation you define for your tween will be completely ignored for these properties.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.Physics2DPlugin; 
TweenPlugin.activate([Physics2DPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 2, new TweenLiteVars().physics2D(300, -60, 400)); 

Physics2DPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

Parameters

See also

Sometimes you want to tween a property (or several) but you don't have a specific end value in mind - instead, you'd rather describe the movement in terms of physics concepts, like velocity, acceleration, and/or friction. physicsProps allows you to tween any numeric property of any object based on these concepts. Keep in mind that any easing equation you define for your tween will be completely ignored for these properties. Instead, the physics parameters will determine the movement/easing. These parameters, by the way, are not intended to be dynamically updateable, but one unique convenience is that everything is reverseable. So if you create several physics-based tweens, for example, and throw them into a TimelineLite, you could simply call reverse() on the timeline to watch the objects retrace their steps right back to the beginning. Here are the parameters you can define (note that friction and acceleration are both completely optional):

• velocity : Number - the initial velocity of the object measured in units per time unit (usually seconds, but for tweens where useFrames is true, it would be measured in frames). The default is zero.
• acceleration : Number [optional] - the amount of acceleration applied to the object, measured in units per time unit (usually seconds, but for tweens where useFrames is true, it would be measured in frames). The default is zero.
• friction : Number [optional] - a value between 0 and 1 where 0 is no friction, 0.08 is a small amount of friction, and 1 will completely prevent any movement. This is not meant to be precise or scientific in any way, but rather serves as an easy way to apply a friction-like physics effect to your tween. Generally it is best to experiment with this number a bit. Also note that friction requires more processing than physics tweens without any friction.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.PhysicsPropsPlugin; 
TweenPlugin.activate([PhysicsPropsPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 2, new TweenLiteVars().physicsProps({
                x:{velocity:100, acceleration:200},
                y:{velocity:-200, friction:0.1}
            }
)); 

PhysicsPropsPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

Parameters

See also

Adds a dynamic property for tweening and allows you to indicate whether the value is relative or not. For example, to tween "x" to 50 less than whatever it currently is:

prop("x", -50, true);

Parameters

An object with properties that correspond to the quaternion properties of the target object. For example, if your my3DObject has "orientation" and "childOrientation" properties that contain quaternions, and you'd like to tween them both, you'd do: {orientation:myTargetQuaternion1, childOrientation:myTargetQuaternion2}. Quaternions must have the following properties: x, y, z, and w.

Parameters

Removes the tint of a DisplayObject over time.

Parameters

Tweens the "rotation" property of the target

Parameters

When true, the tween will flip the start and end values which is exactly what TweenLite.from() does.

Parameters

Tweens the "scaleX" and "scaleY" properties of the target

Parameters

Tweens the "scaleX" property of the target

Parameters

Tweens the "scaleY" property of the target

Parameters

Tweens the scrollRect property of a DisplayObject. You can define any (or all) of the following properties:

• x : Number
• y : Number
• width : Number
• height : Number
• top : Number
• bottom : Number
• left : Number
• right : Number

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.ScrollRectPlugin; 
TweenPlugin.activate([ScrollRectPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().scrollRect({x:50, y:300, width:100, height:100})); 

Parameters

Some components require resizing with setSize() instead of standard tweens of width/height in order to scale properly. The SetSizePlugin accommodates this easily. You can define the width, height, or both.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.SetSizePlugin; 
TweenPlugin.activate([SetSizePlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(myComponent, 1, new TweenLiteVars().setSize(200, 30)); 

Parameters

To tween any rotation property of the target object in the shortest direction, use "shortRotation" For example, if myObject.rotation is currently 170 degrees and you want to tween it to -170 degrees, a normal rotation tween would travel a total of 340 degrees in the counter-clockwise direction, but if you use shortRotation, it would travel 20 degrees in the clockwise direction instead. You can define any number of rotation properties in the shortRotation object which makes 3D tweening easier, like:

TweenLite.to(mc, 2, new TweenLiteVars().shortRotation({rotationX:-170, rotationY:35, rotationZ:200}));

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.ShortRotationPlugin; 
TweenPlugin.activate([ShortRotationPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().shortRotation({rotation:-170}));
//or for a 3D tween with multiple rotation values...
TweenLite.to(mc, 1, new TweenLiteVars().shortRotation({rotationX:-170, rotationY:35, rotationZ:10})); 

Parameters

Tweens properties of an object's soundTransform property (like the volume, pan, leftToRight, etc. of a MovieClip/SoundChannel/NetStream).

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.SoundTransformPlugin; 
TweenPlugin.activate([SoundTransformPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().soundTransform(0.2, 0.5)); 

Parameters

Sets the stage's quality to a particular value during a tween and another value after the tween which can be useful for improving rendering performance in the Flash Player while things are animating.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.StageQualityPlugin; 
import flash.display.StageQuality; 
TweenPlugin.activate([StageQualityPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().prop("x", 100).stageQuality(this.stage, StageQuality.LOW, StageQuality.HIGH)); 

Parameters

Allows you to define an initial velocity at which a property (or multiple properties) will start tweening, as well as [optional] maximum and/or minimum end values and then it will calculate the appropriate landing position and plot a smooth course to it based on the easing equation you define (Quad.easeOut by default, as set in TweenLite). This is perfect for flick-scrolling or animating things as though they are being thrown.

In its simplest form, you can pass just the initial velocity for each property like this: {x:500, y:-300}

In the above example, x will animate at 500 pixels per second initially and y will animate at -300 pixels per second. Both will decelerate smoothly until they come to rest based on the tween's duration.

To impose maximum and minimum boundaries on the end values, use the nested object syntax with the max and min special properties like this: {x:{velocity:500, max:1024, min:0}, y:{velocity:-300, max:720, min:0}};

Notice the nesting of the objects ({}). The max and min values refer to the range for the final resting position (coordinates in this case), NOT the velocity. So x would always land between 0 and 1024 in this case, and y would always land between 0 and 720. If you want the target object to land on a specific value rather than within a range, simply set max and min to identical values. Also notice that you must define a velocity value for each property in the object syntax.

throwProps isn't just for tweening x and y coordinates. It works with any numeric property, so you could use it for spinning the rotation of an object as well. Or the scaleX/scaleY properties. Maybe the user drags to spin a wheel and lets go and you want it to continue increasing the rotation at that velocity, decelerating smoothly until it stops.

ThrowPropsPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

Parameters

To change a DisplayObject's tint, set this to the hex value of the color you'd like the DisplayObject to end up at (or begin at if you're using TweenLite.from()). An example hex value would be 0xFF0000. If you'd like to remove the tint from a DisplayObject, use the removeTint special property.

Parameters

See also

Normally, all transformations (scale, rotation, and position) are based on the DisplayObject's registration point (most often its upper left corner), but TransformAroundCenter allows you to make the transformations occur around the DisplayObject's center.

If you define an x or y value in the transformAroundCenter object, it will correspond to the center which makes it easy to position (as opposed to having to figure out where the original registration point should tween to). If you prefer to define the x/y in relation to the original registration point, do so outside the transformAroundCenter object, like:

TweenLite.to(mc, 3, new TweenLiteVars().prop("x", 50).prop("y", 40).transformAroundCenter({scale:0.5, rotation:30}));

TransformAroundCenterPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.TransformAroundCenterPlugin; 
TweenPlugin.activate([TransformAroundCenterPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().transformAroundCenter({scale:1.5, rotation:150})); 

Parameters

See also

Normally, all transformations (scale, rotation, and position) are based on the DisplayObject's registration point (most often its upper left corner), but TransformAroundPoint allows you to define ANY point around which transformations will occur during the tween. For example, you may have a dynamically-loaded image that you want to scale from its center or rotate around a particular point on the stage.

If you define an x or y value in the transformAroundPoint object, it will correspond to the custom registration point which makes it easy to position (as opposed to having to figure out where the original registration point should tween to). If you prefer to define the x/y in relation to the original registration point, do so outside the transformAroundPoint object, like:

TweenLite.to(mc, 3, new TweenLiteVars().prop("x", 50).prop("y", 40).transformAroundPoint(new Point(200, 300), {scale:0.5, rotation:30}));

TransformAroundPointPlugin is a Club GreenSock membership benefit. You must have a valid membership to use this class without violating the terms of use. Visit http://www.greensock.com/club/ to sign up or get more details.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.TransformAroundPointPlugin; 
TweenPlugin.activate([TransformAroundPointPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().transformAroundPoint(new Point(100, 300), {scaleX:2, scaleY:1.5, rotation:150})); 

Parameters

See also

transformMatrix tweens a DisplayObject's transform.matrix values directly either using the standard matrix properties (a, b, c, d, tx, and ty) or common properties like x, y, scaleX, scaleY, skewX, skewY, rotation and even shortRotation. To skew without adjusting scale visually, use skewX2 and skewY2 instead of skewX and skewY.

transformMatrix tween will affect all of the DisplayObject's transform properties, so do not use it in conjunction with regular x/y/scaleX/scaleY/rotation tweens concurrently.

USAGE:

import com.greensock.TweenLite; 
import com.greensock.data.TweenLiteVars; 
import com.greensock.plugins.TweenPlugin; 
import com.greensock.plugins.TransformMatrixPlugin; 
TweenPlugin.activate([TransformMatrixPlugin]); //activation is permanent in the SWF, so this line only needs to be run once.
TweenLite.to(mc, 1, new TweenLiteVars().transformMatrix({x:50, y:300, scaleX:2, scaleY:2})); 
    
//-OR-
TweenLite.to(mc, 1, new TweenLiteVars().transformMatrix({tx:50, ty:300, a:2, d:2})); 

Parameters

If useFrames is set to true, the tweens's timing mode will be based on frames. Otherwise, it will be based on seconds/time. NOTE: a tween's timing mode is always determined by its parent timeline.

Parameters

Sets a DisplayObject's "visible" property at the end of the tween.

Parameters

Changes the volume of any object that has a soundTransform property (MovieClip, SoundChannel, NetStream, etc.)

Parameters

Tweens the "width" property of the target

Parameters

Tweens the "x" property of the target

Parameters

Tweens the "y" property of the target

Parameters