GreenSock

1. target: Target object whose properties we're tweening. This can be ANY object, not just DisplayObjects/MovieClips
2. duration: Duration (in seconds) of the tween
3. vars: An object containing the end values of all the properties you'd like to have tweened (or if you're using the TweenMax.from() method, these variables would define the BEGINNING values). Putting quotes around values will make the tween relative to the current value. For example, _x:"-20" will tween _x to whatever it currently is minus 20 whereas _x:-20 will tween _x to exactly -20. To tween the _xscale and _yscale to 50, you'd do TweenMax.to(mc, 1, {_xscale:50, _yscale:50}); There are also some "special properties" that you can include in your vars object which perform special tasks, as described below:

   Special Properties:

   • delay : Number - The number of seconds you'd like to delay before the tween begins. This is very useful when sequencing tweens
   • ease : Function - You can specify a function to use for the easing with this variable. For example, gs.easing.Elastic.easeOut. The Default is a regular easeOut. To build a custom ease, check out the GreenSock CustomEase Builder tool.
   • easeParams : Array - An Array of extra parameter values to feed the easing equation. This can be useful when you use an equation like Elastic and want to control extra parameters like the amplitude and period. Most easing equations, however, don't require extra parameters so you won't need to pass in any easeParams.
   • onStart : Function - If you'd like to call a function as soon as the tween begins, pass in a reference to it here. This can be useful when there's a delay and you want something to happen just as the tween begins.
   • onStartParams : Array - An array of parameters to pass the onStart function.
   • onStartScope : Object - Defines the scope of the onStart call
   • onUpdate : Function - If you'd like to call a function every time the property values are updated (on every frame during the time the tween is active), pass a reference to it here.
   • onUpdateParams : Array - An array of parameters to pass the onUpdate function
   • onUpdateScope : Object - Defines the scope of the onUpdate call
   • onComplete : Function - If you'd like to call a function when the tween has finished, use this.
   onCompleteParams : Array - An array of parameters to pass the onComplete function
   • onCompleteScope : Object - Defines the scope of the onComplete call
   • persist : Boolean - if true, the TweenMax instance will NOT automatically be removed by the garbage collector when it is complete. However, it is still eligible to be overwritten by new tweens even if persist is true. By default, it is false.
   • renderOnStart : Boolean - If you're using TweenMax.from() (or runBackwards:true) with a delay and want to prevent the tween from rendering until it actually begins, set this special property to true. By default, it's false which causes TweenMax.from() to render its values immediately, even before the delay has expired.
   • runBackwards : Boolean - Flips the start and end values in a tween. The from() method automatically sets this value to true.
   • overwrite : int - Controls how other tweens of the same object are handled when this tween is created. You can set a default value to be used with ALL tweens in your SWF using the OverwriteManager's init() method, or control them individually with this overwrite property. Here are the options:
     1. 0 (NONE): No tweens are overwritten. This is the fastest mode, but you need to be careful not to create any tweens with overlapping properties, otherwise they'll conflict with each other.
     2. 1 (ALL): (this is the default unless OverwriteManager.init() has been called) All tweens of the same object are completely overwritten immediately when the tween is created.
        TweenMax.to(mc, 1, {_x:100, _y:200});
        TweenMax.to(mc, 1, {_x:300, delay:2, overwrite:1}); //immediately overwrites the previous tween
     3. 2 (AUTO): (used by default if OverwriteManager.init() has been called) Searches for and overwrites only individual overlapping properties in tweens that are active when the tween begins.
        TweenMax.to(mc, 1, {_x:100, _y:200});
        TweenMax.to(mc, 1, {_x:300, overwrite:2}); //only overwrites the "_x" property in the previous tween
     4. 3 (CONCURRENT): Overwrites all tweens of the same object that are active when the tween begins.
        TweenMax.to(mc, 1, {_x:100, _y:200});
        TweenMax.to(mc, 1, {_x:300, delay:2, overwrite:3}); //does NOT overwrite the previous tween because the first tween will have finished by the time this one begins.
   • startAt : Object - By default, TweenMax uses whatever a target's current properties are at the beginning of the tween as the starting values, but if you prefer to manually define starting values, use "startAt". For example, if you want mc to tween from x/y coordinates of 0,0 to 100,100, do TweenMax.to(mc, 2, {_x:100, _y:100, startAt:{_x:0, _y:0}});
   • timeScale : Number - Multiplier for controlling the speed of the tween. 0.5 = half speed, 1 = normal speed, 2 = double speed, etc. (hint: if you want to gradually speed up or slow down a tween, you could get fancy and use another tween to tween the timeScale propety!). NOTE: There is also a static TweenMax.globalTimeScale property that affects ALL TweenMax and TweenFilterLite tweens (not TweenLite though)
   • roundProps : Array - If you'd like the inbetween values in a tween to always get rounded to the nearest integer, use the roundProps special property. Just pass in an Array containing the property names that you'd like rounded. For example, if you're tweening the x, y, and alpha properties of mc and you want to round the x and y values (not alpha) every time the tween is rendered, you'd do: TweenMax.to(mc, 2, {_x:300, _y:200, alpha:0.5, roundProps:["_x","_y"]});
   • yoyo : Number - To make the tween reverse when it completes (like a yoyo) any number of times, set this to the number of cycles you'd like the tween to yoyo. A value of zero causes the tween to yoyo endlessly.
   • loop : Number - To make the tween repeat when it completes any number of times, set this to the number of cycles you'd like the tween to loop. A value of zero causes the tween to loop endlessly.

1. includeDelay: Normally, restart() immediately starts the tween from the beginning (not including any delays), but if you'd like to include the delay in the calculations, set includeDelay to true.

1. adjustDuration: Let's say you have a menu that tweens open when the user rolls over it, but then when the user takes some other action, the menu needs to snap back closed again. Setting adjustDuration to true causes the duration to adjust so that it takes the same amount of time to play the reversed tween as has already transpired. So if the menu tween had a duration of 2 seconds, but you reverse() it 1.5 seconds in, it will change the overall duration so that it takes 1.5 seconds to go back to the starting point. If adjustDuration is false, it would take 0.5 seconds to complete.
2. forcePlay: Ensures that the tween plays immediately. If it is paused, it will resume. If it has finished, it will restart.

This has a similar effect to changing the variables you pass into the TweenMax instance, but setDestination() can be used anytime whereas changing the vars object won't have any affect after the tween has begun and the start/end values are calculated. setDestination() is similar to Grant Skinner's "proxy" in gTween (which he did a GREAT job on as usual), but there are a few key differences: I believe that every time you change a property via gTween's proxy, the time resets. So if you have a 3-second tween, and then 2.5 seconds into it, you change the destination value, it'll tween for another 3 seconds and the easing will start over again as well. That's not necessarily bad at all - just something to keep in mind. TweenMax's setDestination() honors duration and continues the easing. Also, you can choose to have TweenMax adjust the start values of an in-progress tween to make it look seamless when the destination changes, or keep the start values and only update the end values (which can cause a sudden shift). And again, Grant's gTween is awesome - I hope my explanation of the differences in its "proxy" and TweenMax's setDestination() isn't perceived as me saying one is "better" than the other. Just different. I've got massive amounts of respect for Grant and all his work.

1. property: The name of the property
2. value: The new destination value
3. adjustStart: Tweening basically takes a value from a start value to an end value over time. If a tween hasn't already begun, setting adjustStart to true or false will have the same effect. However, if the tween has already begun and you only update the destination values (adjustStart set to false), it can appear to suddenly jump to a new value. Think of it this way: If you're tweening "_x" from 0 to 100 with a Linear ease over the course of 10 seconds, at 5 seconds into the tween, "_x" would be 50. However, if you suddenly change the destination value from 100 to 10 and don't adjust the starting values, it will jump to a value of 5 because that's the new halfway point between the start (0) and destination (10). By default, setDestination() assumes you prefer a smooth change instead so that when you change the destination from 100 to 10 and it's halfway through the tween, it appears to smoothly continue the tween from 50 to 10. It will automatically adjust the starting values to do so. IMPORTANT: since the tween is half-way done in this example, it cannot simply use 50 as the starting value - it must shift it to 100 to offset it enough to aVoid the sudden jump. Since various easing equations can be used in your tween that new start value may be very different, though. It's easy to figure out with a Linear equation, but if you setDestination() when the tween is 90% done and it uses a Strong.easeIn equation, the new start value will be significantly offset. Beware of this if you setDestination() and then reverse() or yoyo() or loop()!