Package	com.greensock
Class	public class TweenNano
Inheritance	TweenNano Object

[AS3/AS2 only] TweenNano is a super-lightweight (2k in AS3 and 2.6k in AS2) version of TweenLite and is only recommended for situations where you absolutely cannot afford the extra 4.7k that the normal TweenLite engine would cost and your project doesn't require any plugins. Normally, it is much better to use TweenLite because of the additional flexibility it provides via plugins and its compatibility with TimelineLite and TimelineMax. TweenNano can do everything TweenLite can do with the following exceptions:

• No Plugins - One of the great things about TweenLite is that you can activate plugins in order to add features (like autoAlpha, tint, blurFilter, etc.). TweenNano, however, doesn't work with plugins.
• Incompatible with TimelineLite and TimelineMax - Complex sequencing and management of groups of tweens is much easier with TimelineLite and TimelineMax, but TweenNano instances cannot be inserted into TimelineLite or TimelineMax instances.
• Limited overwrite modes - By default, TweenNano doesn't overwrite any tweens but you can pass overwrite:"all" in the vars parameter to have it kill all tweens of the same target immediately. TweenLite, however, offers much more robust overwrite management, recognizing advanced modes like "auto" (which only overwrites individual tweening properties that overlap), "concurrent", "allOnStart", and "preexisting". See TweenLite's documentation for details.
• Fewer methods and properties TweenNano instances aren't meant to be altered on-the-fly, so they don't have methods like pause(), resume(), reverse(), seek(), restart(), etc. The essentials are covered, though, like to(), from(), delayedCall(), killTweensOf(), and kill().

USAGE

The most common type of tween is a to() tween which allows you to define the destination values:

TweenNano.to(myObject, 2, {x:100, y:200});

The above code will tween myObject.x from whatever it currently is to 100 and myObject.y property to 200 over the course of 2 seconds. Notice the x and y values are defined inside a generic object (between curly braces). Put as many properties there as you want.

Tweens begin immediately.

The target can also be an array of objects. For example, the following tween will tween the alpha property to 0.5 and y property to 100 for obj1, obj2, and obj3:

TweenNano.to([obj1, obj2, obj3], 1, {alpha:0.5, y:100});

You can also use a from() tween if you want to define the starting values instead of the ending values so that the target tweens from the defined values to wherever they currently are.

Although the to() and from() static methods are popular because they're quick and can avoid some garbage collection hassles, you can also use the more object-oriented syntax like this:

var tween = new TweenNano(myObject, 2, {x:100, y:200});

or even:

var tween = TweenNano.to(myObject, 2, {x:100, y:200});

EXAMPLES:

Please see http://www.greensock.com/tweennano/ for examples, tutorials, and interactive demos.

SPECIAL PROPERTIES:

Typically the vars parameter is used to define ending values for tweening properties of the target (or beginning values for from() tweens) like {x:100, y:200, alpha:0}, but the following optional special properties serve other purposes:

• delay : Number - Amount of delay in seconds (or frames for frames-based tweens) before the tween should begin.
• ease : Ease (or Function) - You can choose from various eases to control the rate of change during the animation, giving it a specific "feel". For example, ElasticOut.ease or StrongInOut.ease. TweenNano works with not only the easing equations in the com.greensock.easing package, but also standard easing equation that uses the typical 4 parameters (time, start, change, duration) like Adobe's fl.motion.easing eases. The default is QuadOut.ease. For linear animation, use the GreenSock Linear.ease ease.
• onComplete : Function - A function that should be called when the tween has completed
• onCompleteParams : Array - An Array of parameters to pass the onComplete function. For example, TweenNano.to(mc, 1, {x:100, onComplete:myFunction, onCompleteParams:[mc, "param2"]});
• useFrames : Boolean - If useFrames is true, the tweens's timing will be based on frames instead of seconds. This causes both its duration and delay to be based on frames.
• immediateRender : Boolean - Normally when you create a tween, it begins rendering on the very next frame (update cycle) unless you specify a delay. However, if you prefer to force the tween to render immediately when it is created, set immediateRender to true. Or to prevent a from() from rendering immediately, set immediateRender to false.
• onUpdate : Function - A function that should be called every time the tween updates (on every frame while the tween is active)
• onUpdateParams : Array - An Array of parameters to pass the onUpdate function. For example, TweenNano.to(mc, 1, {x:100, onUpdate:myFunction, onUpdateParams:[mc, "param2"]});
• overwrite : String - Controls how (and if) other tweens of the same target are overwritten. By default, no tweens are overwritten, but if you'd like to immediately overwrite other tweens of the same target, use overwrite:"all"

NOTES:

• The base TweenNano class adds about 2k to your Flash file.
• Passing values as Strings and a preceding "+=" or "-=" will make the tween relative to the current value. For example, if you do TweenNano.to(mc, 2, {x:"-=20"}); it'll tween mc.x to the left 20 pixels. {x:"+=20"} would move it to the right.
• You can change the TweenNano.defaultEase if you prefer something other than QuadOut.ease.
• Kill all tweens of a particular object anytime with TweenNano.killTweensOf(myObject);
• You can kill all delayedCalls to a particular function using TweenNano.killTweensOf(myFunction);
• Use the TweenNano.from() method to animate things into place. For example, if you have things set up on the stage in the spot where they should end up, and you just want to animate them into place, you can pass in the beginning x and/or y and/or alpha (or whatever properties you want).
• If you find this class useful, please consider joining Club GreenSock which not only helps to sustain ongoing development, but also gets you bonus plugins, classes and other benefits that are ONLY available to members. Learn more at http://www.greensock.com/club/

Copyright 2008-2013, GreenSock. All rights reserved. This work is subject to the terms in http://www.greensock.com/terms_of_use.html or for Club GreenSock members, the software agreement that was issued with the membership.

---

//add listener
TweenNano.ticker.addEventListener("tick", myFunction);
 
function myFunction(event) {
     //executes on every tick after the core engine updates
}
 
//to remove the listener later...
TweenNano.ticker.removeEventListener("tick", myFunction);

//add listener that requests an event object parameter, binds scope to the current scope (this), and sets priority to 1 so that it is called before any other listeners that had a priority lower than 1...
TweenNano.ticker.addEventListener("tick", myFunction, this, true, 1);
 
function myFunction(event) {
    //executes on every tick after the core engine updates
}
 
//to remove the listener later...
TweenNano.ticker.removeEventListener("tick", myFunction);

import flash.events.Event;
         
//add listener with weak reference (standard syntax - notice the 5th parameter is true)
TweenNano.ticker.addEventListener("tick", myFunction, false, 0, true);
         
function myFunction(event:Event):void {
    //executes on every tick after the core engine updates
}
         
//to remove the listener later...
TweenNano.ticker.removeEventListener("tick", myFunction);

//calls myFunction after 1 second and passes 2 parameters:
TweenNano.delayedCall(1, myFunction, ["param1", 2]);
         
function myFunction(param1, param2) {
    //do stuff
}

TweenNano.from([mc1, mc2, mc3], 1.5, {alpha:0});

TweenNano.to(mc, 1, {x:100});
var myTween = new TweenNano(mc, 1, {x:100});
var myTween = TweenNano.to(mc, 1, {x:100});

TweenNano.to([mc1, mc2, mc3], 1, {x:100});