home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / effects / effectClasses / ParallelInstance.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  8.5 KB  |  290 lines
  1. package mx.effects.effectClasses
  2. {
  3.    import flash.events.TimerEvent;
  4.    import flash.utils.Timer;
  5.    import mx.core.UIComponent;
  6.    import mx.core.mx_internal;
  7.    import mx.effects.EffectInstance;
  8.    import mx.effects.IEffectInstance;
  9.    
  10.    use namespace mx_internal;
  11.    
  12.    public class ParallelInstance extends CompositeEffectInstance
  13.    {
  14.       mx_internal static const VERSION:String = "3.5.0.12683";
  15.       
  16.       private var timer:Timer;
  17.       
  18.       private var isReversed:Boolean = false;
  19.       
  20.       private var replayEffectQueue:Array;
  21.       
  22.       private var doneEffectQueue:Array;
  23.       
  24.       public function ParallelInstance(param1:Object)
  25.       {
  26.          super(param1);
  27.       }
  28.       
  29.       override public function stop() : void
  30.       {
  31.          var _loc1_:Array = null;
  32.          var _loc2_:int = 0;
  33.          var _loc3_:int = 0;
  34.          stopTimer();
  35.          if(mx_internal::activeEffectQueue)
  36.          {
  37.             _loc1_ = mx_internal::activeEffectQueue.concat();
  38.             mx_internal::activeEffectQueue = null;
  39.             _loc2_ = int(_loc1_.length);
  40.             _loc3_ = 0;
  41.             while(_loc3_ < _loc2_)
  42.             {
  43.                if(_loc1_[_loc3_])
  44.                {
  45.                   _loc1_[_loc3_].stop();
  46.                }
  47.                _loc3_++;
  48.             }
  49.          }
  50.          super.stop();
  51.       }
  52.       
  53.       private function startTimer() : void
  54.       {
  55.          if(!timer)
  56.          {
  57.             timer = new Timer(10);
  58.             timer.addEventListener(TimerEvent.TIMER,timerHandler);
  59.          }
  60.          timer.start();
  61.       }
  62.       
  63.       override mx_internal function get durationWithoutRepeat() : Number
  64.       {
  65.          var _loc4_:Array = null;
  66.          var _loc1_:Number = 0;
  67.          var _loc2_:int = int(mx_internal::childSets.length);
  68.          var _loc3_:int = 0;
  69.          while(_loc3_ < _loc2_)
  70.          {
  71.             _loc4_ = mx_internal::childSets[_loc3_];
  72.             _loc1_ = Math.max(_loc4_[0].actualDuration,_loc1_);
  73.             _loc3_++;
  74.          }
  75.          return _loc1_;
  76.       }
  77.       
  78.       private function timerHandler(param1:TimerEvent) : void
  79.       {
  80.          var _loc5_:EffectInstance = null;
  81.          var _loc2_:Number = mx_internal::durationWithoutRepeat - playheadTime;
  82.          var _loc3_:int = int(replayEffectQueue.length);
  83.          if(_loc3_ == 0)
  84.          {
  85.             stopTimer();
  86.             return;
  87.          }
  88.          var _loc4_:int = _loc3_ - 1;
  89.          while(_loc4_ >= 0)
  90.          {
  91.             _loc5_ = replayEffectQueue[_loc4_];
  92.             if(_loc2_ <= _loc5_.mx_internal::actualDuration)
  93.             {
  94.                mx_internal::activeEffectQueue.push(_loc5_);
  95.                replayEffectQueue.splice(_loc4_,1);
  96.                _loc5_.mx_internal::playReversed = mx_internal::playReversed;
  97.                _loc5_.startEffect();
  98.             }
  99.             _loc4_--;
  100.          }
  101.       }
  102.       
  103.       private function stopTimer() : void
  104.       {
  105.          if(timer)
  106.          {
  107.             timer.reset();
  108.          }
  109.       }
  110.       
  111.       override public function addChildSet(param1:Array) : void
  112.       {
  113.          var _loc2_:CompositeEffectInstance = null;
  114.          super.addChildSet(param1);
  115.          if(param1.length > 0)
  116.          {
  117.             _loc2_ = param1[0] as CompositeEffectInstance;
  118.             if(param1[0] is RotateInstance || _loc2_ != null && _loc2_.mx_internal::hasRotateInstance())
  119.             {
  120.                mx_internal::childSets.pop();
  121.                mx_internal::childSets.unshift(param1);
  122.             }
  123.          }
  124.       }
  125.       
  126.       override public function reverse() : void
  127.       {
  128.          var _loc1_:int = 0;
  129.          var _loc2_:int = 0;
  130.          super.reverse();
  131.          if(isReversed)
  132.          {
  133.             _loc1_ = int(mx_internal::activeEffectQueue.length);
  134.             _loc2_ = 0;
  135.             while(_loc2_ < _loc1_)
  136.             {
  137.                mx_internal::activeEffectQueue[_loc2_].reverse();
  138.                _loc2_++;
  139.             }
  140.             stopTimer();
  141.          }
  142.          else
  143.          {
  144.             replayEffectQueue = doneEffectQueue.splice(0);
  145.             _loc1_ = int(mx_internal::activeEffectQueue.length);
  146.             _loc2_ = 0;
  147.             while(_loc2_ < _loc1_)
  148.             {
  149.                mx_internal::activeEffectQueue[_loc2_].reverse();
  150.                _loc2_++;
  151.             }
  152.             startTimer();
  153.          }
  154.          isReversed = !isReversed;
  155.       }
  156.       
  157.       override public function end() : void
  158.       {
  159.          var _loc1_:Array = null;
  160.          var _loc2_:int = 0;
  161.          var _loc3_:int = 0;
  162.          mx_internal::endEffectCalled = true;
  163.          stopTimer();
  164.          if(mx_internal::activeEffectQueue)
  165.          {
  166.             _loc1_ = mx_internal::activeEffectQueue.concat();
  167.             mx_internal::activeEffectQueue = null;
  168.             _loc2_ = int(_loc1_.length);
  169.             _loc3_ = 0;
  170.             while(_loc3_ < _loc2_)
  171.             {
  172.                if(_loc1_[_loc3_])
  173.                {
  174.                   _loc1_[_loc3_].end();
  175.                }
  176.                _loc3_++;
  177.             }
  178.          }
  179.          super.end();
  180.       }
  181.       
  182.       override protected function onEffectEnd(param1:IEffectInstance) : void
  183.       {
  184.          if(Object(param1).suspendBackgroundProcessing)
  185.          {
  186.             UIComponent.resumeBackgroundProcessing();
  187.          }
  188.          if(Boolean(mx_internal::endEffectCalled) || mx_internal::activeEffectQueue == null)
  189.          {
  190.             return;
  191.          }
  192.          var _loc2_:int = int(mx_internal::activeEffectQueue.length);
  193.          var _loc3_:int = 0;
  194.          while(_loc3_ < _loc2_)
  195.          {
  196.             if(param1 == mx_internal::activeEffectQueue[_loc3_])
  197.             {
  198.                doneEffectQueue.push(param1);
  199.                mx_internal::activeEffectQueue.splice(_loc3_,1);
  200.                break;
  201.             }
  202.             _loc3_++;
  203.          }
  204.          if(_loc2_ == 1)
  205.          {
  206.             finishRepeat();
  207.          }
  208.       }
  209.       
  210.       override public function resume() : void
  211.       {
  212.          super.resume();
  213.          var _loc1_:int = int(mx_internal::activeEffectQueue.length);
  214.          var _loc2_:int = 0;
  215.          while(_loc2_ < _loc1_)
  216.          {
  217.             mx_internal::activeEffectQueue[_loc2_].resume();
  218.             _loc2_++;
  219.          }
  220.       }
  221.       
  222.       override public function play() : void
  223.       {
  224.          var _loc2_:int = 0;
  225.          var _loc3_:int = 0;
  226.          var _loc4_:Array = null;
  227.          var _loc5_:int = 0;
  228.          var _loc6_:int = 0;
  229.          var _loc7_:EffectInstance = null;
  230.          var _loc8_:Array = null;
  231.          doneEffectQueue = [];
  232.          mx_internal::activeEffectQueue = [];
  233.          replayEffectQueue = [];
  234.          var _loc1_:Boolean = false;
  235.          super.play();
  236.          _loc2_ = int(mx_internal::childSets.length);
  237.          _loc3_ = 0;
  238.          while(_loc3_ < _loc2_)
  239.          {
  240.             _loc4_ = mx_internal::childSets[_loc3_];
  241.             _loc5_ = int(_loc4_.length);
  242.             _loc6_ = 0;
  243.             while(_loc6_ < _loc5_ && mx_internal::activeEffectQueue != null)
  244.             {
  245.                _loc7_ = _loc4_[_loc6_];
  246.                if(Boolean(mx_internal::playReversed) && _loc7_.mx_internal::actualDuration < mx_internal::durationWithoutRepeat)
  247.                {
  248.                   replayEffectQueue.push(_loc7_);
  249.                   startTimer();
  250.                }
  251.                else
  252.                {
  253.                   _loc7_.mx_internal::playReversed = mx_internal::playReversed;
  254.                   mx_internal::activeEffectQueue.push(_loc7_);
  255.                }
  256.                if(_loc7_.suspendBackgroundProcessing)
  257.                {
  258.                   UIComponent.suspendBackgroundProcessing();
  259.                }
  260.                _loc6_++;
  261.             }
  262.             _loc3_++;
  263.          }
  264.          if(mx_internal::activeEffectQueue.length > 0)
  265.          {
  266.             _loc8_ = mx_internal::activeEffectQueue.slice(0);
  267.             _loc3_ = 0;
  268.             while(_loc3_ < _loc8_.length)
  269.             {
  270.                _loc8_[_loc3_].startEffect();
  271.                _loc3_++;
  272.             }
  273.          }
  274.       }
  275.       
  276.       override public function pause() : void
  277.       {
  278.          super.pause();
  279.          var _loc1_:int = int(mx_internal::activeEffectQueue.length);
  280.          var _loc2_:int = 0;
  281.          while(_loc2_ < _loc1_)
  282.          {
  283.             mx_internal::activeEffectQueue[_loc2_].pause();
  284.             _loc2_++;
  285.          }
  286.       }
  287.    }
  288. }
  289.  
  290.