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