mako 0.0.0

data/lib/mako/data/flash_widget_dev_core/src/gs/utils/tween/TweenLiteVars.as

@@ -0,0 +1,269 @@
+/*
+VERSION: 1.0
+DATE: 8/24/2008
+ACTIONSCRIPT VERSION: 3.0
+DESCRIPTION:
+	There are 2 primary benefits of using this utility to define your TweenLite variables:
+		1) In most code editors, code hinting will be activated which helps remind you which special properties are available in TweenLite
+		2) It allows you to code using strict datatyping (although it doesn't force you to).
+USAGE:
+	Instead of TweenLite.to(my_mc, 1, {x:300, tint:0xFF0000, onComplete:myFunction}), you could use this utility like:
+		var myVars:TweenLiteVars = new TweenLiteVars();
+		myVars.addProp("x", 300); // use addProp() to add any property that doesn't already exist in the TweenLiteVars instance.
+		myVars.tint = 0xFF0000;
+		myVars.onComplete = myFunction;
+		TweenLite.to(my_mc, 1, myVars);
+	Or if you just want to add multiple properties with one function, you can add up to 15 with the addProps() function, like:
+		var myVars:TweenLiteVars = new TweenLiteVars();
+		myVars.addProps("x", 300, false, "y", 100, false, "scaleX", 1.5, false, "scaleY", 1.5, false);
+		myVars.onComplete = myFunction;
+		TweenLite.to(my_mc, 1, myVars);
+NOTES:
+	- This class adds about 1.5 Kb to your published SWF.
+	- This utility is completely optional. If you prefer the shorter synatax in the regular TweenLite class, feel
+	  free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict datatyping.
+	- You may add custom properties to this class if you want, but in order to expose them to TweenLite, make sure
+	  you also add a getter and a setter that adds the property to the _exposedInternalProps Object.
+	- You can reuse a single TweenLiteVars Object for multiple tweens if you want, but be aware that there are a few
+	  properties that must be handled in a special way, and once you set them, you cannot remove them. Those properties
+	  are: frame, visible, tint, and volume. If you are altering these values, it might be better to avoid reusing a TweenLiteVars
+	  Object.
+CODED BY: Jack Doyle, jack@greensock.com
+Copyright 2008, GreenSock (This work is subject to the terms in http://www.greensock.com/terms_of_use.html.)
+*/
+package gs.utils.tween {
+	import gs.TweenLite;
+	dynamic public class TweenLiteVars {
+		public static const version:Number = 1.0;
+		public const isTV:Boolean = true; // (stands for "isTweenVars") - Just gives us a way to check inside TweenLite to see if the Object is a TweenLiteVars without having to embed the class. This is helpful when handling tint, visible, and other properties that the user didn't necessarily define, but this utility class forces to be present.
+		/**
+		 * Same as changing the "alpha" property but with the additional feature of toggling the "visible" property to false when alpha is 0.
+		 */
+		public var autoAlpha:Number;
+		/**
+		 * The number of seconds to delay before the tween begins.
+		 */
+		public var delay:Number = 0;
+		/**
+		 * An easing function (i.e. fl.motion.easing.Elastic.easeOut) The default is Regular.easeOut.
+		 */
+		public var ease:Function;
+		/**
+		 * An Array of extra parameter values to feed the easing equation (beyond the standard 4). This can be useful with easing equations like Elastic that accept 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.
+		 */
+		public var easeParams:Array;
+		/**
+		 * 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.
+		 */
+		public var endArray:Array;
+		/**
+		 * A function to call when the tween begins. This can be useful when there's a delay and you want something to happen just as the tween begins.
+		 */
+		public var onStart:Function;
+		/**
+		 * An Array of parameters to pass the onStart function.
+		 */
+		public var onStartParams:Array;
+		/**
+		 * A function to call whenever the tweening values are updated (on every frame during the time the tween is active).
+		 */
+		public var onUpdate:Function;
+		/**
+		 * An Array of parameters to pass the onUpdate function
+		 */
+		public var onUpdateParams:Array;
+		/**
+		 * A function to call when the tween has completed.
+		 */
+		public var onComplete:Function;
+		/**
+		 * An Array of parameters to pass the onComplete function
+		 */
+		public var onCompleteParams:Array;
+		/**
+		 * NONE = 0, ALL = 1, AUTO* = 2, CONCURRENT* = 3  *Only available with the optional OverwriteManager add-on class which must be initted once for TweenLite or TweenFilterLite, like OverwriteManager.init(). TweenMax automatically inits OverwriteManager.
+		 */
+		public var overwrite:int = 2;
+		/**
+		 * To prevent a tween from getting garbage collected after it completes, set persist to true. This does NOT, however, prevent teh tween from getting overwritten by other tweens of the same target.
+		 */
+		public var persist:Boolean = false;
+		/**
+		 * To remove the tint from a DisplayObject, set removeTint to true.
+		 */
+		public var removeTint:Boolean;
+		/**
+		 * If you're using TweenLite.from() with a delay and you want to prevent the tween from rendering until it actually begins, set this special property to true. By default, it's false which causes TweenLite.from() to render its values immediately, even before the delay has expired.
+		 */
+		public var renderOnStart:Boolean = false;
+		/**
+		 * Primarily used in from() calls - forces the values to get flipped.
+		 */
+		public var runBackwards:Boolean = false;
+		protected var _exposedInternalProps:Object; // Gives us a way to make certain non-dynamic properties enumerable.
+		protected var _frame:int;
+		protected var _tint:uint;
+		protected var _visible:Boolean = true;
+		protected var _volume:Number;
+		/**
+		 *
+		 * @param $vars An Object containing properties that correspond to the properties you'd like to add to this TweenLiteVars Object. For example, TweenLiteVars({x:300, onComplete:myFunction})
+		 *
+		 */
+		public function TweenLiteVars($vars:Object = null) {
+			_exposedInternalProps = {};
+			if ($vars != null) {
+				for (var p:String in $vars) {
+					if (p == "blurFilter" || p == "glowFilter" || p == "colorMatrixFilter" || p == "bevelFilter" || p == "dropShadowFilter") {
+						//ignore filters - they must be handled differently in the TweenFilterLiteVars subclass
+					} else {
+						this[p] = $vars[p];
+					}
+				}
+			}
+			if (TweenLite.version < 7.0) {
+				////trace("TweenLiteVars error! Please update your TweenLite class or try deleting your ASO files. TweenLiteVars requires a more recent version. Download updates at http://www.TweenLite.com.");
+			}
+		}
+		/**
+		 *
+		 * Adds a dynamic property for tweening and allows you to set whether the end value is relative or not
+		 * @param $name Property name
+		 * @param $value Numeric end value (or beginning value for from() calls)
+		 * @param $relative If true, the value will be relative to the target's current value. For example, if my_mc.x is currently 300 and you do addProp("x", 200, true), the end value will be 500.
+		 *
+		 */
+		public function addProp($name:String, $value:Number, $relative:Boolean = false):void {
+			if ($relative) {
+				this[$name] = String($value);
+			} else {
+				this[$name] = $value;
+			}
+		}
+		/**
+		 *
+		 * Adds up to 15 dynamic properties at once (just like doing addProp() multiple times). Saves time and reduces code.
+		 *
+		 */
+		public function addProps($name1:String, $value1:Number, $relative1:Boolean = false,
+								 $name2:String = null, $value2:Number = 0, $relative2:Boolean = false,
+								 $name3:String = null, $value3:Number = 0, $relative3:Boolean = false,
+								 $name4:String = null, $value4:Number = 0, $relative4:Boolean = false,
+								 $name5:String = null, $value5:Number = 0, $relative5:Boolean = false,
+								 $name6:String = null, $value6:Number = 0, $relative6:Boolean = false,
+								 $name7:String = null, $value7:Number = 0, $relative7:Boolean = false,
+								 $name8:String = null, $value8:Number = 0, $relative8:Boolean = false,
+								 $name9:String = null, $value9:Number = 0, $relative9:Boolean = false,
+								 $name10:String = null, $value10:Number = 0, $relative10:Boolean = false,
+								 $name11:String = null, $value11:Number = 0, $relative11:Boolean = false,
+								 $name12:String = null, $value12:Number = 0, $relative12:Boolean = false,
+								 $name13:String = null, $value13:Number = 0, $relative13:Boolean = false,
+								 $name14:String = null, $value14:Number = 0, $relative14:Boolean = false,
+								 $name15:String = null, $value15:Number = 0, $relative15:Boolean = false):void {
+			addProp($name1, $value1, $relative1);
+			if ($name2 != null) {
+				addProp($name2, $value2, $relative2);
+			}
+			if ($name3 != null) {
+				addProp($name3, $value3, $relative3);
+			}
+			if ($name4 != null) {
+				addProp($name4, $value4, $relative4);
+			}
+			if ($name5 != null) {
+				addProp($name5, $value5, $relative5);
+			}
+			if ($name6 != null) {
+				addProp($name6, $value6, $relative6);
+			}
+			if ($name7 != null) {
+				addProp($name7, $value7, $relative7);
+			}
+			if ($name8 != null) {
+				addProp($name8, $value8, $relative8);
+			}
+			if ($name9 != null) {
+				addProp($name9, $value9, $relative9);
+			}
+			if ($name10 != null) {
+				addProp($name10, $value10, $relative10);
+			}
+			if ($name11 != null) {
+				addProp($name11, $value11, $relative11);
+			}
+			if ($name12 != null) {
+				addProp($name12, $value12, $relative12);
+			}
+			if ($name13 != null) {
+				addProp($name13, $value13, $relative13);
+			}
+			if ($name14 != null) {
+				addProp($name14, $value14, $relative14);
+			}
+			if ($name15 != null) {
+				addProp($name15, $value15, $relative15);
+			}
+		}
+//---- GETTERS / SETTERS -------------------------------------------------------------------------------------------------------------
+		/**
+		 *
+		 * @return Exposes enumerable properties.
+		 *
+		 */
+		public function get exposedProps():Object {
+			var o:Object = {};
+			var p:String;
+			for (p in _exposedInternalProps) {
+				o[p] = _exposedInternalProps[p];
+			}
+			for (p in this) {
+				o[p] = this[p]; //add all the dynamic properties.
+			}
+			return o;
+		}
+		public function get visible():Boolean {
+			return _visible;
+		}
+		/**
+		 *
+		 * @param $b To set a DisplayObject's "visible" property at the end of the tween, use this special property.
+		 *
+		 */
+		public function set visible($b:Boolean):void {
+			_visible = _exposedInternalProps.visible = $b;
+		}
+		public function get frame():int {
+			return _frame;
+		}
+		/**
+		 *
+		 * @param $n Tweens a MovieClip to a particular frame.
+		 *
+		 */
+		public function set frame($n:int):void {
+			_frame = _exposedInternalProps.frame = $n;
+		}
+		public function get tint():uint {
+			return _tint;
+		}
+		/**
+		 *
+		 * @param $n 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.
+		 *
+		 */
+		public function set tint($n:uint):void {
+			_tint = _exposedInternalProps.tint = $n;
+		}
+		public function get volume():Number {
+			return _volume;
+		}
+		/**
+		 *
+		 * @param $n To change a MovieClip's (or SoundChannel's) volume, just set this to the value you'd like the MovieClip to end up at (or begin at if you're using TweenLite.from()).
+		 *
+		 */
+		public function set volume($n:Number):void {
+			_volume = _exposedInternalProps.volume = $n;
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/gs/utils/tween/TweenMaxVars.as

@@ -0,0 +1,103 @@
+/*
+VERSION: 0.92
+DATE: 8/15/2008
+ACTIONSCRIPT VERSION: 3.0
+DESCRIPTION:
+	There are 2 primary benefits of using this utility to define your TweenMax variables:
+		1) In most code editors, code hinting will be activated which helps remind you which special properties are available in TweenMax
+		2) It allows you to code using strict datatyping (although it doesn't force you to).
+USAGE:
+	Instead of TweenMax.to(my_mc, 1, {x:300, tint:0xFF0000, onComplete:myFunction}), you could use this utility like:
+		var myVars:TweenMaxVars = new TweenMaxVars();
+		myVars.addProp("x", 300); // use addProp() to add any property that doesn't already exist in the TweenMaxVars instance.
+		myVars.tint = 0xFF0000;
+		myVars.onComplete = myFunction;
+		TweenMax.to(my_mc, 1, myVars);
+	Or if you just want to add multiple properties with one function, you can add up to 15 with the addProps() function, like:
+		var myVars:TweenMaxVars = new TweenMaxVars();
+		myVars.addProps("x", 300, false, "y", 100, false, "scaleX", 1.5, false, "scaleY", 1.5, false);
+		myVars.onComplete = myFunction;
+		TweenMax.to(my_mc, 1, myVars);
+NOTES:
+	- This class adds about 4 Kb to your published SWF.
+	- This utility is completely optional. If you prefer the shorter synatax in the regular TweenMax class, feel
+	  free to use it. The purpose of this utility is simply to enable code hinting and to allow for strict datatyping.
+	- You may add custom properties to this class if you want, but in order to expose them to TweenMax, make sure
+	  you also add a getter and a setter that adds the property to the _exposedInternalProps Object.
+	- You can reuse a single TweenMaxVars Object for multiple tweens if you want, but be aware that there are a few
+	  properties that must be handled in a special way, and once you set them, you cannot remove them. Those properties
+	  are: frame, visible, tint, and volume. If you are altering these values, it might be better to avoid reusing a TweenMaxVars
+	  Object.
+CODED BY: Jack Doyle, jack@greensock.com
+Copyright 2008, GreenSock (This work is subject to the terms in http://www.greensock.com/terms_of_use.html.)
+*/
+package gs.utils.tween {
+	import gs.utils.tween.TweenFilterLiteVars;
+	dynamic public class TweenMaxVars extends TweenFilterLiteVars {
+		public static const version:Number = 0.91;
+		/**
+		 * Array of Objects, one for each "control point" (see documentation on Flash's curveTo() drawing method for more about how control points work). In this example, let's say the control point would be at x/y coordinates 250,50. Just make sure your my_mc is at coordinates 0,0 and then do: TweenMax.to(my_mc, 3, {_x:500, _y:0, bezier:[{_x:250, _y:50}]});
+		 */
+		public var bezier:Array;
+		/**
+		 * 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.
+		 */
+		public var bezierThrough:Array;
+		/**
+		 * 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, TweenMax 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)
+		 */
+		public var orientToBezier:Array;
+		/**
+		 * 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. TweenMax makes it easy. To tween a property of your object that's a hex color to another hex color, use this special hexColors property of TweenMax. It must be an OBJECT with properties named the same as your object's hex color properties. For example, if your my_obj object has a "myHexColor" property that you'd like to tween to red (0xFF0000) over the course of 2 seconds, do: TweenMax.to(my_obj, 2, {hexColors:{myHexColor:0xFF0000}}); You can pass in any number of hexColor properties.
+		 */
+		public var hexColors:Object;
+		/**
+		 * A function to which the TweenMax instance should dispatch a TweenEvent when it begins. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.START, myFunction);
+		 */
+		public var onStartListener:Function;
+		/**
+		 * A function to which the TweenMax instance should dispatch a TweenEvent every time it updates values. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.UPDATE, myFunction);
+		 */
+		public var onUpdateListener:Function;
+		/**
+		 * A function to which the TweenMax instance should dispatch a TweenEvent when it completes. This is the same as doing myTweenMaxInstance.addEventListener(TweenEvent.COMPLETE, myFunction);
+		 */
+		public var onCompleteListener:Function;
+		/**
+		 * A function to which the TweenMax instance should dispatch a TweenEvent when it completes the allTo() or allFrom() tweens. ONLY used with allTo() and allFrom() methods!
+		 */
+		public var onCompleteAllListener:Function;
+		/**
+		 * A function that should be called when the allTo() or allFrom() tweens have completed. ONLY used with allTo() and allFrom() methods!
+		 */
+		public var onCompleteAll:Function;
+		/**
+		 * An Array of parameters to pass the onCompleteAll function when the allTo() or allFrom() tweens have completed. ONLY used with allTo() and allFrom() methods!
+		 */
+		public var onCompleteAllParams:Array;
+		/**
+		 * To make the tween continuously loop backwards and forwards like a yoyo, set this to true.
+		 */
+		public var yoyo:Boolean;
+		/**
+		 * To make the tween continuously loop itself, set this to true.
+		 */
+		public var loop:Boolean;
+		//public var quaternions:Object;
+		/**
+		 *
+		 * @param $vars An Object containing properties that correspond to the properties you'd like to add to this TweenMaxVars Object. For example, TweenMaxVars({blurFilter:{blurX:10, blurY:20}, onComplete:myFunction})
+		 *
+		 */
+		public function TweenMaxVars($vars:Object = null) {
+			super($vars);
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/TweenEvent.as

@@ -0,0 +1,17 @@
+package it.animation {
+	import flash.events.Event;
+	public class TweenEvent extends Event {
+		    public var tweenTarget:Object;
+    		public var aspect:String;
+            // Public constructor.
+            public function TweenEvent(target:Object, aspect:String, type:String){
+                super(type);
+				tweenTarget = target;
+				this.aspect = aspect
+            }
+            // Override the inherited clone() method.
+            override public function clone():Event {
+                return new TweenEvent(tweenTarget, aspect, type);
+            }
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/TweenObject.as

@@ -0,0 +1,27 @@
+package it.animation {
+	import it.animation.methods.FastSlow // default animation method
+	public class TweenObject {
+		public var targ:Object
+		public var asp:String
+		public var bv:Number
+		public var ev:Number
+		public var t:uint
+		public var cnt:uint
+		public var d:Number
+		public var s:uint
+		public var m:Function
+		public var eN:String
+		public function TweenObject(target:Object, aspect:String, endValue:Number, time:uint, strength:uint, method:Function = null, eventName:String = null){
+			targ = target;
+			asp = aspect;
+			bv = targ[aspect]
+			ev = endValue;
+			d = ev - bv;
+			t = time;
+			cnt = 0;
+			s = strength;
+			m = (method != null ? method : FastSlow.Method)
+			eN = (eventName != null ? eventName : 'tweenEnd');
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/TweenSingleton.as

@@ -0,0 +1,86 @@
+package it.animation {
+	import flash.events.EventDispatcher	// class extends EventDispatcher
+	import flash.events.*			// onenterframe constant
+	import it.animation.TweenEvent			// custom event returned
+	import flash.display.DisplayObject		// want to specifically require a DisplayObject type for root reference
+	import it.animation.TweenObject		// the base object that represents and holds all the tweening data
+	import flash.display.Sprite			// we're going to create our own sprite for onenterframe event firing
+	public class TweenSingleton extends EventDispatcher{
+		public static var _instance:TweenSingleton;
+		private var tA:Object	;					// Tween Storage Object
+		private var len:uint;						// Number of items in the Tween Storage Object
+		private var oefSource:Sprite				// Movieclip host for onEnterFrame events
+		_instance = new TweenSingleton();
+		_instance.init();
+		/****************** Public Funtions *********************/
+		public static function addTween(targ:DisplayObject, aspect:String, endValue:Number, time:uint, strength:uint, aniMethod:Function = null, eventName:String = null):void{
+			if(_instance == null){
+				 _instance = new TweenSingleton();
+				_instance.init();
+			}
+			_instance._addTween(targ, aspect, endValue, time, strength, aniMethod, eventName);
+		}
+		public function _addTween(targ:DisplayObject, aspect:String, endValue:Number, time:uint, strength:uint, aniMethod:Function = null, eventName:String = null):void{
+			if(targ== null || targ[aspect] == null) return;
+			if(len == 0) oefSource.addEventListener(Event.ENTER_FRAME, animate,false,0,true); // add the listener if this is the first item animating
+			if(tA[targ.name+aspect] == undefined) len ++	// incriment length if this object isnt already being animated
+			else{
+				var nTO:TweenObject = new TweenObject(targ, aspect, endValue, time, strength, aniMethod, eventName);
+				var eTO:TweenObject = tA[targ.name+aspect];
+				if(eTO.ev == nTO.ev && eTO.t == nTO.t && eTO.s == nTO.s && eTO.m == nTO.m && eTO.eN == nTO.eN) return;
+			}
+			tA[targ.name+aspect] = new TweenObject(targ, aspect, endValue, time, strength, aniMethod, eventName);
+		}
+		public static function remTween(targ:Object, aspect:String, toEndVal:Boolean = false):void{
+			var ref:Object = _instance.tA[targ.name+aspect]
+			if(toEndVal == true) ref.targ[ref.asp] = ref.ev;
+			_instance._remTween(targ.name+aspect);
+			_instance.checkLength();
+		}
+		public static function isTween(targ:Object, aspect:String):Boolean{
+			if (aspect) return (_instance.tA[targ + aspect] != undefined);
+			else return false;
+		}
+		/****************** Privagte Funtions *********************/
+		private function init():void{
+			tA = new Object();
+			len = 0;
+			oefSource = new Sprite();
+		}
+		private function animate(eObj:Object):void{
+			for(var i:String in tA){
+				var c:Object = tA[i];
+				// if the object is gone delete it
+				if(c.targ[c.asp] == undefined)	 _remTween(i);
+				else{
+					c.targ[c.asp] = c.m(c.cnt++, c.bv, c.d, c.t, c.s)
+					// if the targ is == to its target value or has been deleted, get rid of it
+					if(c.targ[c.asp] == c.ev) _remTween(i);
+					else if(c.cnt >= c.t){
+						c.targ[c.asp] = c.ev;
+						_remTween(i);
+					}
+				}
+			}
+			if(checkLength()){
+				return;
+			}
+		}
+		private function checkLength():Boolean{
+			if(len < 1){
+				oefSource.removeEventListener(Event.ENTER_FRAME, animate);
+				init();
+				return true
+			}
+			return false
+		}
+		private function _remTween(tweenObj:String):void{
+			var c:TweenObject = tA[tweenObj]
+			len --;
+			var tEvent:TweenEvent = new TweenEvent(c.targ, c.asp, c.eN)
+			tA[tweenObj] = null; // this line might not be needed
+			delete tA[tweenObj] // must remove the reference to the object as well as the object itself
+			dispatchEvent(tEvent);
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/Constant.as

@@ -0,0 +1,7 @@
+package it.animation.methods{
+	public class Constant {
+		static public function Method(c:Number,b:Number,d:Number,t:uint, s:uint):Number{
+			return b + c*(d/t);
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/FastSlow.as

@@ -0,0 +1,7 @@
+package it.animation.methods{
+	public class FastSlow {
+		static public function Method(c:Number,b:Number,d:Number,t:uint,s:uint):Number{
+			return b+d*(1-Math.pow(1-c/t,s));
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/FastSlowFast.as

@@ -0,0 +1,8 @@
+package it.animation.methods{
+	public class FastSlowFast {
+		static public function Method(c:Number,b:Number,d:Number,t:uint,s:uint):Number{
+			if(c<=(t/2))return b+d/2*(1-Math.pow(1-c/(t/2),s));
+			else return b+d/2*(1+Math.pow(c/(t/2)-1,s));
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/Shake.as

@@ -0,0 +1,12 @@
+package it.animation.methods{
+	public class Shake{
+		public static function method(c:Number,b:Number,d:Number,t:Number, s:Number):Number{
+			if((c & 1) == 0){ //even
+				return b-s;
+			}
+			else{ //odd
+				return b+s;
+			}
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/SlowFast.as

@@ -0,0 +1,7 @@
+package it.animation.methods{
+	public class SlowFast {
+		static public function Method(c:Number,b:Number,d:Number,t:uint,s:uint):Number{
+			return b+d*Math.pow((c/t),s);
+		}
+	}
+}

data/lib/mako/data/flash_widget_dev_core/src/it/animation/methods/SlowFastSlow.as

@@ -0,0 +1,8 @@
+package it.animation.methods{
+	public class SlowFastSlow {
+		static public function Method(c:Number,b:Number,d:Number,t:uint,s:uint):Number{
+			if(c<=(t/2)) return b+d/2*Math.pow(c/(t/2),s);
+			else return b+d-d/2*Math.pow(2-c/(t/2),s);
+		}
+	}
+}