home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / effects / EffectInstance.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  9.8 KB  |  357 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.TimerEvent;
  6.    import flash.utils.Timer;
  7.    import flash.utils.getQualifiedClassName;
  8.    import flash.utils.getTimer;
  9.    import mx.core.IUIComponent;
  10.    import mx.core.mx_internal;
  11.    import mx.effects.effectClasses.PropertyChanges;
  12.    import mx.events.EffectEvent;
  13.    import mx.events.FlexEvent;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class EffectInstance extends EventDispatcher implements IEffectInstance
  18.    {
  19.       
  20.       mx_internal static const VERSION:String = "2.0.1.0";
  21.        
  22.       
  23.       private var delayStartTime:Number = 0;
  24.       
  25.       private var playCount:int = 0;
  26.       
  27.       mx_internal var stopRepeat:Boolean = false;
  28.       
  29.       private var _repeatCount:int;
  30.       
  31.       private var _suspendBackgroundProcessing:Boolean = false;
  32.       
  33.       mx_internal var delayTimer:Timer;
  34.       
  35.       private var _triggerEvent:Event;
  36.       
  37.       mx_internal var parentCompositeEffectInstance:EffectInstance;
  38.       
  39.       mx_internal var durationExplicitlySet:Boolean = false;
  40.       
  41.       private var _effect:Effect;
  42.       
  43.       private var _target:Object;
  44.       
  45.       mx_internal var hideOnEffectEnd:Boolean = false;
  46.       
  47.       private var _startDelay:int = 0;
  48.       
  49.       private var delayElapsedTime:Number = 0;
  50.       
  51.       private var _repeatDelay:int = 0;
  52.       
  53.       private var _propertyChanges:PropertyChanges;
  54.       
  55.       private var _duration:Number = 500;
  56.       
  57.       private var _playReversed:Boolean;
  58.       
  59.       public function EffectInstance(param1:Object)
  60.       {
  61.          delayStartTime = 0;
  62.          delayElapsedTime = 0;
  63.          mx_internal::durationExplicitlySet = false;
  64.          mx_internal::hideOnEffectEnd = false;
  65.          playCount = 0;
  66.          mx_internal::stopRepeat = false;
  67.          _duration = 500;
  68.          _repeatDelay = 0;
  69.          _startDelay = 0;
  70.          _suspendBackgroundProcessing = false;
  71.          super();
  72.          this.target = param1;
  73.       }
  74.       
  75.       public function get playheadTime() : Number
  76.       {
  77.          return Math.max(playCount - 1,0) * duration + Math.max(playCount - 2,0) * repeatDelay + (mx_internal::playReversed ? 0 : startDelay);
  78.       }
  79.       
  80.       public function finishEffect() : void
  81.       {
  82.          playCount = 0;
  83.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  84.          if(target)
  85.          {
  86.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  87.          }
  88.          if(target is IUIComponent)
  89.          {
  90.             Object(target).effectFinished(this);
  91.          }
  92.       }
  93.       
  94.       public function finishRepeat() : void
  95.       {
  96.          if(!mx_internal::stopRepeat && playCount != 0 && (playCount < repeatCount || repeatCount == 0))
  97.          {
  98.             if(repeatDelay > 0)
  99.             {
  100.                mx_internal::delayTimer = new Timer(repeatDelay,1);
  101.                delayStartTime = getTimer();
  102.                mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  103.                mx_internal::delayTimer.start();
  104.             }
  105.             else
  106.             {
  107.                play();
  108.             }
  109.          }
  110.          else
  111.          {
  112.             finishEffect();
  113.          }
  114.       }
  115.       
  116.       mx_internal function get playReversed() : Boolean
  117.       {
  118.          return _playReversed;
  119.       }
  120.       
  121.       public function set effect(param1:Effect) : void
  122.       {
  123.          _effect = param1;
  124.       }
  125.       
  126.       public function get className() : String
  127.       {
  128.          var _loc1_:String = null;
  129.          var _loc2_:int = 0;
  130.          _loc1_ = getQualifiedClassName(this);
  131.          _loc2_ = _loc1_.indexOf("::");
  132.          if(_loc2_ != -1)
  133.          {
  134.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  135.          }
  136.          return _loc1_;
  137.       }
  138.       
  139.       public function set duration(param1:Number) : void
  140.       {
  141.          mx_internal::durationExplicitlySet = true;
  142.          _duration = param1;
  143.       }
  144.       
  145.       mx_internal function set playReversed(param1:Boolean) : void
  146.       {
  147.          _playReversed = param1;
  148.       }
  149.       
  150.       public function resume() : void
  151.       {
  152.          if(mx_internal::delayTimer && !mx_internal::delayTimer.running && !isNaN(delayElapsedTime))
  153.          {
  154.             mx_internal::delayTimer.delay = !mx_internal::playReversed ? mx_internal::delayTimer.delay - delayElapsedTime : delayElapsedTime;
  155.             mx_internal::delayTimer.start();
  156.          }
  157.       }
  158.       
  159.       public function get propertyChanges() : PropertyChanges
  160.       {
  161.          return _propertyChanges;
  162.       }
  163.       
  164.       public function set target(param1:Object) : void
  165.       {
  166.          _target = param1;
  167.       }
  168.       
  169.       public function get repeatCount() : int
  170.       {
  171.          return _repeatCount;
  172.       }
  173.       
  174.       mx_internal function playWithNoDuration() : void
  175.       {
  176.          duration = 0;
  177.          repeatCount = 1;
  178.          repeatDelay = 0;
  179.          startDelay = 0;
  180.          startEffect();
  181.       }
  182.       
  183.       public function get startDelay() : int
  184.       {
  185.          return _startDelay;
  186.       }
  187.       
  188.       mx_internal function get actualDuration() : Number
  189.       {
  190.          var _loc1_:Number = NaN;
  191.          _loc1_ = NaN;
  192.          if(repeatCount > 0)
  193.          {
  194.             _loc1_ = duration * repeatCount + (repeatDelay * repeatCount - 1) + startDelay;
  195.          }
  196.          return _loc1_;
  197.       }
  198.       
  199.       public function get suspendBackgroundProcessing() : Boolean
  200.       {
  201.          return _suspendBackgroundProcessing;
  202.       }
  203.       
  204.       public function play() : void
  205.       {
  206.          ++playCount;
  207.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  208.          if(target)
  209.          {
  210.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  211.          }
  212.       }
  213.       
  214.       public function set repeatDelay(param1:int) : void
  215.       {
  216.          _repeatDelay = param1;
  217.       }
  218.       
  219.       public function set propertyChanges(param1:PropertyChanges) : void
  220.       {
  221.          _propertyChanges = param1;
  222.       }
  223.       
  224.       mx_internal function eventHandler(param1:Event) : void
  225.       {
  226.          if(param1.type == FlexEvent.SHOW && mx_internal::hideOnEffectEnd == true)
  227.          {
  228.             mx_internal::hideOnEffectEnd = false;
  229.             param1.target.removeEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  230.          }
  231.       }
  232.       
  233.       public function set repeatCount(param1:int) : void
  234.       {
  235.          _repeatCount = param1;
  236.       }
  237.       
  238.       private function delayTimerHandler(param1:TimerEvent) : void
  239.       {
  240.          mx_internal::delayTimer.reset();
  241.          delayStartTime = NaN;
  242.          delayElapsedTime = NaN;
  243.          play();
  244.       }
  245.       
  246.       public function set suspendBackgroundProcessing(param1:Boolean) : void
  247.       {
  248.          _suspendBackgroundProcessing = param1;
  249.       }
  250.       
  251.       public function set triggerEvent(param1:Event) : void
  252.       {
  253.          _triggerEvent = param1;
  254.       }
  255.       
  256.       public function set startDelay(param1:int) : void
  257.       {
  258.          _startDelay = param1;
  259.       }
  260.       
  261.       public function get effect() : Effect
  262.       {
  263.          return _effect;
  264.       }
  265.       
  266.       public function get duration() : Number
  267.       {
  268.          if(!mx_internal::durationExplicitlySet && Boolean(mx_internal::parentCompositeEffectInstance))
  269.          {
  270.             return mx_internal::parentCompositeEffectInstance.duration;
  271.          }
  272.          return _duration;
  273.       }
  274.       
  275.       public function get target() : Object
  276.       {
  277.          return _target;
  278.       }
  279.       
  280.       public function startEffect() : void
  281.       {
  282.          if(target is IUIComponent)
  283.          {
  284.             Object(target).effectStarted(this);
  285.             Object(target).drawFocus(false);
  286.          }
  287.          if(startDelay > 0 && !mx_internal::playReversed)
  288.          {
  289.             mx_internal::delayTimer = new Timer(startDelay,1);
  290.             delayStartTime = getTimer();
  291.             mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  292.             mx_internal::delayTimer.start();
  293.          }
  294.          else
  295.          {
  296.             play();
  297.          }
  298.       }
  299.       
  300.       public function get repeatDelay() : int
  301.       {
  302.          return _repeatDelay;
  303.       }
  304.       
  305.       public function initEffect(param1:Event) : void
  306.       {
  307.          triggerEvent = param1;
  308.          switch(param1.type)
  309.          {
  310.             case "resizeStart":
  311.             case "resizeEnd":
  312.                if(!mx_internal::durationExplicitlySet)
  313.                {
  314.                   duration = 250;
  315.                }
  316.                break;
  317.             case FlexEvent.HIDE:
  318.                target.setVisible(true,true);
  319.                mx_internal::hideOnEffectEnd = true;
  320.                target.addEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  321.          }
  322.       }
  323.       
  324.       public function get triggerEvent() : Event
  325.       {
  326.          return _triggerEvent;
  327.       }
  328.       
  329.       public function end() : void
  330.       {
  331.          if(mx_internal::delayTimer)
  332.          {
  333.             mx_internal::delayTimer.reset();
  334.          }
  335.          mx_internal::stopRepeat = true;
  336.          finishEffect();
  337.       }
  338.       
  339.       public function reverse() : void
  340.       {
  341.          if(repeatCount > 0)
  342.          {
  343.             playCount = repeatCount - playCount + 1;
  344.          }
  345.       }
  346.       
  347.       public function pause() : void
  348.       {
  349.          if(mx_internal::delayTimer && mx_internal::delayTimer.running && !isNaN(delayStartTime))
  350.          {
  351.             mx_internal::delayTimer.stop();
  352.             delayElapsedTime = getTimer() - delayStartTime;
  353.          }
  354.       }
  355.    }
  356. }
  357.