home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / effects / Tween.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  9.5 KB  |  349 lines
  1. package mx.effects
  2. {
  3.    import flash.events.EventDispatcher;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import flash.utils.getTimer;
  7.    import mx.core.UIComponentGlobals;
  8.    import mx.core.mx_internal;
  9.    import mx.events.TweenEvent;
  10.    
  11.    use namespace mx_internal;
  12.    
  13.    public class Tween extends EventDispatcher
  14.    {
  15.       
  16.       private static var timer:Timer = null;
  17.       
  18.       private static var interval:Number = 10;
  19.       
  20.       private static var activeTweens:Array = [];
  21.       
  22.       mx_internal static var intervalTime:Number = NaN;
  23.       
  24.       mx_internal static const VERSION:String = "2.0.1.0";
  25.        
  26.       
  27.       private var started:Boolean = false;
  28.       
  29.       public var duration:Number = 3000;
  30.       
  31.       private var id:int;
  32.       
  33.       private var arrayMode:Boolean;
  34.       
  35.       private var _isPlaying:Boolean = true;
  36.       
  37.       private var startValue:Object;
  38.       
  39.       public var listener:Object;
  40.       
  41.       private var userEquation:Function;
  42.       
  43.       private var previousUpdateTime:Number;
  44.       
  45.       mx_internal var needToLayout:Boolean = false;
  46.       
  47.       private var updateFunction:Function;
  48.       
  49.       private var _doSeek:Boolean = false;
  50.       
  51.       mx_internal var startTime:Number;
  52.       
  53.       private var endFunction:Function;
  54.       
  55.       private var endValue:Object;
  56.       
  57.       private var _doReverse:Boolean = false;
  58.       
  59.       private var _playheadTime:Number = 0;
  60.       
  61.       private var _invertValues:Boolean = false;
  62.       
  63.       private var maxDelay:Number = 87.5;
  64.       
  65.       public function Tween(param1:Object, param2:Object, param3:Object, param4:Number = -1, param5:Number = -1)
  66.       {
  67.          mx_internal::needToLayout = false;
  68.          maxDelay = 87.5;
  69.          _doSeek = false;
  70.          _isPlaying = true;
  71.          _doReverse = false;
  72.          userEquation = defaultEasingFunction;
  73.          started = false;
  74.          duration = 3000;
  75.          _playheadTime = 0;
  76.          _invertValues = false;
  77.          super();
  78.          if(!param1)
  79.          {
  80.             return;
  81.          }
  82.          if(param2 is Array)
  83.          {
  84.             arrayMode = true;
  85.          }
  86.          this.listener = param1;
  87.          this.startValue = param2;
  88.          this.endValue = param3;
  89.          if(!isNaN(param4) && param4 != -1)
  90.          {
  91.             this.duration = param4;
  92.          }
  93.          if(!isNaN(param5) && param5 != -1)
  94.          {
  95.             maxDelay = 1000 / param5;
  96.          }
  97.          if(param4 == 0)
  98.          {
  99.             endTween();
  100.          }
  101.          else
  102.          {
  103.             Tween.addTween(this);
  104.          }
  105.       }
  106.       
  107.       mx_internal static function removeTween(param1:Tween) : void
  108.       {
  109.          removeTweenAt(param1.id);
  110.       }
  111.       
  112.       private static function addTween(param1:Tween) : void
  113.       {
  114.          param1.id = activeTweens.length;
  115.          activeTweens.push(param1);
  116.          if(!timer)
  117.          {
  118.             timer = new Timer(interval);
  119.             timer.addEventListener(TimerEvent.TIMER,timerHandler);
  120.             timer.start();
  121.          }
  122.          else
  123.          {
  124.             timer.start();
  125.          }
  126.          if(isNaN(mx_internal::intervalTime))
  127.          {
  128.             mx_internal::intervalTime = getTimer();
  129.          }
  130.          param1.mx_internal::startTime = param1.previousUpdateTime = mx_internal::intervalTime;
  131.       }
  132.       
  133.       private static function timerHandler(param1:TimerEvent) : void
  134.       {
  135.          var _loc2_:Boolean = false;
  136.          var _loc3_:Number = NaN;
  137.          var _loc4_:int = 0;
  138.          var _loc5_:int = 0;
  139.          var _loc6_:Tween = null;
  140.          _loc2_ = false;
  141.          _loc3_ = mx_internal::intervalTime;
  142.          mx_internal::intervalTime = getTimer();
  143.          _loc5_ = _loc4_ = int(activeTweens.length);
  144.          while(_loc5_ >= 0)
  145.          {
  146.             if(_loc6_ = Tween(activeTweens[_loc5_]))
  147.             {
  148.                _loc6_.mx_internal::needToLayout = false;
  149.                _loc6_.mx_internal::doInterval();
  150.                if(_loc6_.mx_internal::needToLayout)
  151.                {
  152.                   _loc2_ = true;
  153.                }
  154.             }
  155.             _loc5_--;
  156.          }
  157.          if(_loc2_)
  158.          {
  159.             UIComponentGlobals.mx_internal::layoutManager.validateNow();
  160.          }
  161.          param1.updateAfterEvent();
  162.       }
  163.       
  164.       private static function removeTweenAt(param1:int) : void
  165.       {
  166.          var _loc2_:int = 0;
  167.          var _loc3_:int = 0;
  168.          var _loc4_:Tween = null;
  169.          if(param1 >= activeTweens.length || param1 < 0)
  170.          {
  171.             return;
  172.          }
  173.          activeTweens.splice(param1,1);
  174.          _loc2_ = int(activeTweens.length);
  175.          _loc3_ = param1;
  176.          while(_loc3_ < _loc2_)
  177.          {
  178.             --(_loc4_ = Tween(activeTweens[_loc3_])).id;
  179.             _loc3_++;
  180.          }
  181.          if(_loc2_ == 0)
  182.          {
  183.             mx_internal::intervalTime = NaN;
  184.             timer.reset();
  185.          }
  186.       }
  187.       
  188.       public function pause() : void
  189.       {
  190.          _isPlaying = false;
  191.       }
  192.       
  193.       mx_internal function get playheadTime() : Number
  194.       {
  195.          return _playheadTime;
  196.       }
  197.       
  198.       mx_internal function get playReversed() : Boolean
  199.       {
  200.          return _invertValues;
  201.       }
  202.       
  203.       public function resume() : void
  204.       {
  205.          _isPlaying = true;
  206.          mx_internal::startTime = mx_internal::intervalTime - _playheadTime;
  207.          if(_doReverse)
  208.          {
  209.             reverse();
  210.             _doReverse = false;
  211.          }
  212.       }
  213.       
  214.       public function setTweenHandlers(param1:Function, param2:Function) : void
  215.       {
  216.          this.updateFunction = param1;
  217.          this.endFunction = param2;
  218.       }
  219.       
  220.       mx_internal function set playReversed(param1:Boolean) : void
  221.       {
  222.          _invertValues = param1;
  223.       }
  224.       
  225.       public function set easingFunction(param1:Function) : void
  226.       {
  227.          userEquation = param1;
  228.       }
  229.       
  230.       private function defaultEasingFunction(param1:Number, param2:Number, param3:Number, param4:Number) : Number
  231.       {
  232.          return param3 / 2 * (Math.sin(Math.PI * (param1 / param4 - 0.5)) + 1) + param2;
  233.       }
  234.       
  235.       public function endTween() : void
  236.       {
  237.          var _loc1_:TweenEvent = null;
  238.          var _loc2_:Object = null;
  239.          _loc1_ = new TweenEvent(TweenEvent.TWEEN_END);
  240.          _loc2_ = mx_internal::getCurrentValue(duration);
  241.          _loc1_.value = _loc2_;
  242.          dispatchEvent(_loc1_);
  243.          if(endFunction != null)
  244.          {
  245.             endFunction(_loc2_);
  246.          }
  247.          else
  248.          {
  249.             listener.onTweenEnd(_loc2_);
  250.          }
  251.          Tween.removeTweenAt(id);
  252.       }
  253.       
  254.       public function reverse() : void
  255.       {
  256.          if(_isPlaying)
  257.          {
  258.             _doReverse = false;
  259.             seek(duration - _playheadTime);
  260.             _invertValues = !_invertValues;
  261.          }
  262.          else
  263.          {
  264.             _doReverse = !_doReverse;
  265.          }
  266.       }
  267.       
  268.       mx_internal function doInterval() : Boolean
  269.       {
  270.          var _loc1_:Boolean = false;
  271.          var _loc2_:Number = NaN;
  272.          var _loc3_:Object = null;
  273.          var _loc4_:TweenEvent = null;
  274.          var _loc5_:TweenEvent = null;
  275.          _loc1_ = false;
  276.          previousUpdateTime = mx_internal::intervalTime;
  277.          if(_isPlaying || _doSeek)
  278.          {
  279.             _loc2_ = mx_internal::intervalTime - mx_internal::startTime;
  280.             _playheadTime = _loc2_;
  281.             _loc3_ = mx_internal::getCurrentValue(_loc2_);
  282.             if(_loc2_ >= duration && !_doSeek)
  283.             {
  284.                endTween();
  285.                _loc1_ = true;
  286.             }
  287.             else
  288.             {
  289.                if(!started)
  290.                {
  291.                   _loc5_ = new TweenEvent(TweenEvent.TWEEN_START);
  292.                   dispatchEvent(_loc5_);
  293.                   started = true;
  294.                }
  295.                (_loc4_ = new TweenEvent(TweenEvent.TWEEN_UPDATE)).value = _loc3_;
  296.                dispatchEvent(_loc4_);
  297.                if(updateFunction != null)
  298.                {
  299.                   updateFunction(_loc3_);
  300.                }
  301.                else
  302.                {
  303.                   listener.onTweenUpdate(_loc3_);
  304.                }
  305.             }
  306.             _doSeek = false;
  307.          }
  308.          return _loc1_;
  309.       }
  310.       
  311.       public function seek(param1:Number) : void
  312.       {
  313.          var _loc2_:Number = NaN;
  314.          _loc2_ = mx_internal::intervalTime;
  315.          previousUpdateTime = _loc2_;
  316.          mx_internal::startTime = _loc2_ - param1;
  317.          _doSeek = true;
  318.       }
  319.       
  320.       mx_internal function getCurrentValue(param1:Number) : Object
  321.       {
  322.          var _loc2_:Array = null;
  323.          var _loc3_:int = 0;
  324.          var _loc4_:int = 0;
  325.          if(duration == 0)
  326.          {
  327.             return endValue;
  328.          }
  329.          if(_invertValues)
  330.          {
  331.             param1 = duration - param1;
  332.          }
  333.          if(arrayMode)
  334.          {
  335.             _loc2_ = [];
  336.             _loc3_ = int(startValue.length);
  337.             _loc4_ = 0;
  338.             while(_loc4_ < _loc3_)
  339.             {
  340.                _loc2_[_loc4_] = userEquation(param1,startValue[_loc4_],endValue[_loc4_] - startValue[_loc4_],duration);
  341.                _loc4_++;
  342.             }
  343.             return _loc2_;
  344.          }
  345.          return userEquation(param1,startValue,Number(endValue) - Number(startValue),duration);
  346.       }
  347.    }
  348. }
  349.