home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / Frizzle_fraz.swf / scripts / mx / effects / Effect.as next >
Encoding:
Text File  |  2008-09-26  |  20.0 KB  |  660 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.getQualifiedClassName;
  6.    import mx.core.IFlexDisplayObject;
  7.    import mx.core.mx_internal;
  8.    import mx.effects.effectClasses.AddRemoveEffectTargetFilter;
  9.    import mx.effects.effectClasses.HideShowEffectTargetFilter;
  10.    import mx.effects.effectClasses.PropertyChanges;
  11.    import mx.events.EffectEvent;
  12.    import mx.managers.LayoutManager;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public class Effect extends EventDispatcher
  17.    {
  18.       
  19.       mx_internal static const VERSION:String = "2.0.1.0";
  20.        
  21.       
  22.       mx_internal var applyActualDimensions:Boolean = true;
  23.       
  24.       private var _instances:Array;
  25.       
  26.       private var _filter:String;
  27.       
  28.       private var _customFilter:EffectTargetFilter;
  29.       
  30.       mx_internal var durationExplicitlySet:Boolean = false;
  31.       
  32.       public var repeatCount:int = 1;
  33.       
  34.       public var repeatDelay:int = 0;
  35.       
  36.       public var suspendBackgroundProcessing:Boolean = false;
  37.       
  38.       public var startDelay:int = 0;
  39.       
  40.       private var _targets:Array;
  41.       
  42.       mx_internal var propertyChangesArray:Array;
  43.       
  44.       private var _relevantProperties:Array;
  45.       
  46.       mx_internal var filterObject:EffectTargetFilter;
  47.       
  48.       private var _callValidateNow:Boolean = false;
  49.       
  50.       mx_internal var initEvent:Event;
  51.       
  52.       public var instanceClass:Class;
  53.       
  54.       private var _duration:Number = 500;
  55.       
  56.       private var _relevantStyles:Array;
  57.       
  58.       private var isPaused:Boolean = false;
  59.       
  60.       public function Effect(param1:Object = null)
  61.       {
  62.          _instances = [];
  63.          _callValidateNow = false;
  64.          isPaused = false;
  65.          mx_internal::applyActualDimensions = true;
  66.          _duration = 500;
  67.          mx_internal::durationExplicitlySet = false;
  68.          _relevantStyles = [];
  69.          instanceClass = IEffectInstance;
  70.          repeatCount = 1;
  71.          repeatDelay = 0;
  72.          startDelay = 0;
  73.          suspendBackgroundProcessing = false;
  74.          _targets = [];
  75.          super();
  76.          this.target = param1;
  77.       }
  78.       
  79.       private static function mergeArrays(param1:Array, param2:Array) : Array
  80.       {
  81.          var _loc3_:int = 0;
  82.          var _loc4_:Boolean = false;
  83.          var _loc5_:int = 0;
  84.          if(param2)
  85.          {
  86.             _loc3_ = 0;
  87.             while(_loc3_ < param2.length)
  88.             {
  89.                _loc4_ = true;
  90.                _loc5_ = 0;
  91.                while(_loc5_ < param1.length)
  92.                {
  93.                   if(param1[_loc5_] == param2[_loc3_])
  94.                   {
  95.                      _loc4_ = false;
  96.                      break;
  97.                   }
  98.                   _loc5_++;
  99.                }
  100.                if(_loc4_)
  101.                {
  102.                   param1.push(param2[_loc3_]);
  103.                }
  104.                _loc3_++;
  105.             }
  106.          }
  107.          return param1;
  108.       }
  109.       
  110.       private static function stripUnchangedValues(param1:Array) : Array
  111.       {
  112.          var _loc2_:int = 0;
  113.          var _loc3_:Object = null;
  114.          _loc2_ = 0;
  115.          while(_loc2_ < param1.length)
  116.          {
  117.             for(_loc3_ in param1[_loc2_].start)
  118.             {
  119.                if(param1[_loc2_].start[_loc3_] == param1[_loc2_].end[_loc3_] || typeof param1[_loc2_].start[_loc3_] == "number" && typeof param1[_loc2_].end[_loc3_] == "number" && isNaN(param1[_loc2_].start[_loc3_]) && isNaN(param1[_loc2_].end[_loc3_]))
  120.                {
  121.                   delete param1[_loc2_].start[_loc3_];
  122.                   delete param1[_loc2_].end[_loc3_];
  123.                }
  124.             }
  125.             _loc2_++;
  126.          }
  127.          return param1;
  128.       }
  129.       
  130.       public function set targets(param1:Array) : void
  131.       {
  132.          var _loc2_:int = 0;
  133.          var _loc3_:int = 0;
  134.          _loc2_ = int(param1.length);
  135.          _loc3_ = _loc2_ - 1;
  136.          while(_loc3_ > 0)
  137.          {
  138.             if(param1[_loc3_] == null)
  139.             {
  140.                param1.splice(_loc3_,1);
  141.             }
  142.             _loc3_--;
  143.          }
  144.          _targets = param1;
  145.       }
  146.       
  147.       public function end(param1:IEffectInstance = null) : void
  148.       {
  149.          var _loc2_:int = 0;
  150.          var _loc3_:int = 0;
  151.          var _loc4_:IEffectInstance = null;
  152.          if(param1)
  153.          {
  154.             param1.end();
  155.          }
  156.          else
  157.          {
  158.             _loc2_ = int(_instances.length);
  159.             _loc3_ = _loc2_;
  160.             while(_loc3_ >= 0)
  161.             {
  162.                if(_loc4_ = IEffectInstance(_instances[_loc3_]))
  163.                {
  164.                   _loc4_.end();
  165.                }
  166.                _loc3_--;
  167.             }
  168.          }
  169.       }
  170.       
  171.       protected function filterInstance(param1:Array, param2:Object) : Boolean
  172.       {
  173.          if(mx_internal::filterObject)
  174.          {
  175.             return mx_internal::filterObject.filterFunction(param1,param2);
  176.          }
  177.          return true;
  178.       }
  179.       
  180.       public function get target() : Object
  181.       {
  182.          if(_targets.length > 0)
  183.          {
  184.             return _targets[0];
  185.          }
  186.          return null;
  187.       }
  188.       
  189.       public function get duration() : Number
  190.       {
  191.          return _duration;
  192.       }
  193.       
  194.       protected function getValueFromTarget(param1:Object, param2:String) : *
  195.       {
  196.          if(param2 in param1)
  197.          {
  198.             return param1[param2];
  199.          }
  200.          return undefined;
  201.       }
  202.       
  203.       public function set customFilter(param1:EffectTargetFilter) : void
  204.       {
  205.          _customFilter = param1;
  206.          mx_internal::filterObject = param1;
  207.       }
  208.       
  209.       public function get targets() : Array
  210.       {
  211.          return _targets;
  212.       }
  213.       
  214.       public function captureStartValues() : void
  215.       {
  216.          var _loc1_:int = 0;
  217.          var _loc2_:int = 0;
  218.          if(targets.length > 0)
  219.          {
  220.             mx_internal::propertyChangesArray = [];
  221.             _callValidateNow = true;
  222.             _loc1_ = int(targets.length);
  223.             _loc2_ = 0;
  224.             while(_loc2_ < _loc1_)
  225.             {
  226.                mx_internal::propertyChangesArray.push(new PropertyChanges(targets[_loc2_]));
  227.                _loc2_++;
  228.             }
  229.             mx_internal::propertyChangesArray = mx_internal::captureValues(mx_internal::propertyChangesArray,true);
  230.          }
  231.       }
  232.       
  233.       public function set target(param1:Object) : void
  234.       {
  235.          _targets.splice(0);
  236.          if(param1)
  237.          {
  238.             _targets[0] = param1;
  239.          }
  240.       }
  241.       
  242.       public function get className() : String
  243.       {
  244.          var _loc1_:String = null;
  245.          var _loc2_:int = 0;
  246.          _loc1_ = getQualifiedClassName(this);
  247.          _loc2_ = _loc1_.indexOf("::");
  248.          if(_loc2_ != -1)
  249.          {
  250.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  251.          }
  252.          return _loc1_;
  253.       }
  254.       
  255.       public function get isPlaying() : Boolean
  256.       {
  257.          return Boolean(_instances) && _instances.length > 0;
  258.       }
  259.       
  260.       mx_internal function captureValues(param1:Array, param2:Boolean) : Array
  261.       {
  262.          var _loc3_:Array = null;
  263.          var _loc4_:Object = null;
  264.          var _loc5_:Object = null;
  265.          var _loc6_:int = 0;
  266.          var _loc7_:int = 0;
  267.          var _loc8_:int = 0;
  268.          var _loc9_:int = 0;
  269.          var _loc10_:Array = null;
  270.          _loc3_ = !mx_internal::filterObject ? relevantProperties : mergeArrays(relevantProperties,mx_internal::filterObject.filterProperties);
  271.          if(Boolean(_loc3_) && _loc3_.length > 0)
  272.          {
  273.             _loc6_ = int(param1.length);
  274.             _loc7_ = 0;
  275.             while(_loc7_ < _loc6_)
  276.             {
  277.                _loc5_ = param1[_loc7_].target;
  278.                _loc4_ = param2 ? param1[_loc7_].start : param1[_loc7_].end;
  279.                _loc8_ = int(_loc3_.length);
  280.                _loc9_ = 0;
  281.                while(_loc9_ < _loc8_)
  282.                {
  283.                   _loc4_[_loc3_[_loc9_]] = getValueFromTarget(_loc5_,_loc3_[_loc9_]);
  284.                   _loc9_++;
  285.                }
  286.                _loc7_++;
  287.             }
  288.          }
  289.          if((Boolean(_loc10_ = !mx_internal::filterObject ? relevantStyles : mergeArrays(relevantStyles,mx_internal::filterObject.filterStyles))) && _loc10_.length > 0)
  290.          {
  291.             _loc6_ = int(param1.length);
  292.             _loc7_ = 0;
  293.             while(_loc7_ < _loc6_)
  294.             {
  295.                _loc5_ = param1[_loc7_].target;
  296.                _loc4_ = param2 ? param1[_loc7_].start : param1[_loc7_].end;
  297.                _loc8_ = int(_loc10_.length);
  298.                _loc9_ = 0;
  299.                while(_loc9_ < _loc8_)
  300.                {
  301.                   _loc4_[_loc10_[_loc9_]] = _loc5_.getStyle(_loc10_[_loc9_]);
  302.                   _loc9_++;
  303.                }
  304.                _loc7_++;
  305.             }
  306.          }
  307.          return param1;
  308.       }
  309.       
  310.       public function set duration(param1:Number) : void
  311.       {
  312.          mx_internal::durationExplicitlySet = true;
  313.          _duration = param1;
  314.       }
  315.       
  316.       public function get relevantProperties() : Array
  317.       {
  318.          if(_relevantProperties)
  319.          {
  320.             return _relevantProperties;
  321.          }
  322.          return getAffectedProperties();
  323.       }
  324.       
  325.       public function createInstance(param1:Object = null) : IEffectInstance
  326.       {
  327.          var _loc2_:IEffectInstance = null;
  328.          var _loc3_:PropertyChanges = null;
  329.          var _loc4_:Boolean = false;
  330.          var _loc5_:Boolean = false;
  331.          var _loc6_:int = 0;
  332.          var _loc7_:int = 0;
  333.          if(!param1)
  334.          {
  335.             param1 = this.target;
  336.          }
  337.          _loc2_ = null;
  338.          _loc3_ = null;
  339.          _loc4_ = true;
  340.          _loc5_ = false;
  341.          if(mx_internal::propertyChangesArray)
  342.          {
  343.             _loc5_ = true;
  344.             _loc4_ = filterInstance(mx_internal::propertyChangesArray,param1);
  345.          }
  346.          if(_loc4_)
  347.          {
  348.             _loc2_ = IEffectInstance(new instanceClass(param1));
  349.             initInstance(_loc2_);
  350.             if(_loc5_)
  351.             {
  352.                _loc6_ = int(mx_internal::propertyChangesArray.length);
  353.                _loc7_ = 0;
  354.                while(_loc7_ < _loc6_)
  355.                {
  356.                   if(mx_internal::propertyChangesArray[_loc7_].target == param1)
  357.                   {
  358.                      _loc2_.propertyChanges = mx_internal::propertyChangesArray[_loc7_];
  359.                   }
  360.                   _loc7_++;
  361.                }
  362.             }
  363.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  364.             EventDispatcher(_loc2_).addEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  365.             _instances.push(_loc2_);
  366.             if(mx_internal::initEvent)
  367.             {
  368.                _loc2_.initEffect(mx_internal::initEvent);
  369.             }
  370.          }
  371.          return _loc2_;
  372.       }
  373.       
  374.       protected function applyValueToTarget(param1:Object, param2:String, param3:*, param4:Object) : void
  375.       {
  376.          var target:Object = param1;
  377.          var property:String = param2;
  378.          var value:* = param3;
  379.          var props:Object = param4;
  380.          if(property in target)
  381.          {
  382.             try
  383.             {
  384.                if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "height")
  385.                {
  386.                   target.setActualSize(target.width,value);
  387.                }
  388.                else if(mx_internal::applyActualDimensions && target is IFlexDisplayObject && property == "width")
  389.                {
  390.                   target.setActualSize(value,target.height);
  391.                }
  392.                else
  393.                {
  394.                   target[property] = value;
  395.                }
  396.             }
  397.             catch(e:Error)
  398.             {
  399.             }
  400.          }
  401.       }
  402.       
  403.       protected function effectStartHandler(param1:EffectEvent) : void
  404.       {
  405.          dispatchEvent(param1);
  406.       }
  407.       
  408.       public function play(param1:Array = null, param2:Boolean = false) : Array
  409.       {
  410.          var _loc3_:Array = null;
  411.          var _loc4_:int = 0;
  412.          var _loc5_:int = 0;
  413.          var _loc6_:IEffectInstance = null;
  414.          if(param1 == null && mx_internal::propertyChangesArray != null)
  415.          {
  416.             if(_callValidateNow)
  417.             {
  418.                LayoutManager.getInstance().validateNow();
  419.             }
  420.             mx_internal::propertyChangesArray = mx_internal::captureValues(mx_internal::propertyChangesArray,false);
  421.             mx_internal::propertyChangesArray = stripUnchangedValues(mx_internal::propertyChangesArray);
  422.             mx_internal::applyStartValues(mx_internal::propertyChangesArray,this.targets);
  423.          }
  424.          _loc3_ = createInstances(param1);
  425.          _loc4_ = int(_loc3_.length);
  426.          _loc5_ = 0;
  427.          while(_loc5_ < _loc4_)
  428.          {
  429.             _loc6_ = IEffectInstance(_loc3_[_loc5_]);
  430.             Object(_loc6_).playReversed = param2;
  431.             _loc6_.startEffect();
  432.             _loc5_++;
  433.          }
  434.          return _loc3_;
  435.       }
  436.       
  437.       public function resume() : void
  438.       {
  439.          var _loc1_:int = 0;
  440.          var _loc2_:int = 0;
  441.          if(isPlaying && isPaused)
  442.          {
  443.             isPaused = false;
  444.             _loc1_ = int(_instances.length);
  445.             _loc2_ = 0;
  446.             while(_loc2_ < _loc1_)
  447.             {
  448.                IEffectInstance(_instances[_loc2_]).resume();
  449.                _loc2_++;
  450.             }
  451.          }
  452.       }
  453.       
  454.       public function set relevantStyles(param1:Array) : void
  455.       {
  456.          _relevantStyles = param1;
  457.       }
  458.       
  459.       public function getAffectedProperties() : Array
  460.       {
  461.          return [];
  462.       }
  463.       
  464.       protected function initInstance(param1:IEffectInstance) : void
  465.       {
  466.          param1.duration = duration;
  467.          Object(param1).durationExplicitlySet = mx_internal::durationExplicitlySet;
  468.          param1.effect = this;
  469.          param1.repeatCount = repeatCount;
  470.          param1.repeatDelay = repeatDelay;
  471.          param1.startDelay = startDelay;
  472.          param1.suspendBackgroundProcessing = suspendBackgroundProcessing;
  473.       }
  474.       
  475.       public function get customFilter() : EffectTargetFilter
  476.       {
  477.          return _customFilter;
  478.       }
  479.       
  480.       mx_internal function applyStartValues(param1:Array, param2:Array) : void
  481.       {
  482.          var _loc3_:Array = null;
  483.          var _loc4_:int = 0;
  484.          var _loc5_:int = 0;
  485.          var _loc6_:int = 0;
  486.          var _loc7_:int = 0;
  487.          var _loc8_:Object = null;
  488.          var _loc9_:Boolean = false;
  489.          _loc3_ = relevantProperties;
  490.          _loc4_ = int(param1.length);
  491.          _loc5_ = 0;
  492.          while(_loc5_ < _loc4_)
  493.          {
  494.             _loc8_ = param1[_loc5_].target;
  495.             _loc9_ = false;
  496.             _loc6_ = int(param2.length);
  497.             _loc7_ = 0;
  498.             while(_loc7_ < _loc6_)
  499.             {
  500.                if(param2[_loc7_] == _loc8_)
  501.                {
  502.                   _loc9_ = filterInstance(param1,_loc8_);
  503.                   break;
  504.                }
  505.                _loc7_++;
  506.             }
  507.             if(_loc9_)
  508.             {
  509.                _loc6_ = int(_loc3_.length);
  510.                _loc7_ = 0;
  511.                while(_loc7_ < _loc6_)
  512.                {
  513.                   if(_loc3_[_loc7_] in param1[_loc5_].start && _loc3_[_loc7_] in _loc8_)
  514.                   {
  515.                      applyValueToTarget(_loc8_,_loc3_[_loc7_],param1[_loc5_].start[_loc3_[_loc7_]],param1[_loc5_].start);
  516.                   }
  517.                   _loc7_++;
  518.                }
  519.                _loc6_ = int(relevantStyles.length);
  520.                _loc7_ = 0;
  521.                while(_loc7_ < _loc6_)
  522.                {
  523.                   if(relevantStyles[_loc7_] in param1[_loc5_].start)
  524.                   {
  525.                      _loc8_.setStyle(relevantStyles[_loc7_],param1[_loc5_].start[relevantStyles[_loc7_]]);
  526.                   }
  527.                   _loc7_++;
  528.                }
  529.             }
  530.             _loc5_++;
  531.          }
  532.       }
  533.       
  534.       public function get relevantStyles() : Array
  535.       {
  536.          return _relevantStyles;
  537.       }
  538.       
  539.       public function set relevantProperties(param1:Array) : void
  540.       {
  541.          _relevantProperties = param1;
  542.       }
  543.       
  544.       public function createInstances(param1:Array = null) : Array
  545.       {
  546.          var _loc2_:Array = null;
  547.          var _loc3_:int = 0;
  548.          var _loc4_:int = 0;
  549.          var _loc5_:IEffectInstance = null;
  550.          if(!param1)
  551.          {
  552.             param1 = this.targets;
  553.          }
  554.          _loc2_ = [];
  555.          _loc3_ = int(param1.length);
  556.          _loc4_ = 0;
  557.          while(_loc4_ < _loc3_)
  558.          {
  559.             if(_loc5_ = createInstance(param1[_loc4_]))
  560.             {
  561.                _loc2_.push(_loc5_);
  562.             }
  563.             _loc4_++;
  564.          }
  565.          mx_internal::initEvent = null;
  566.          return _loc2_;
  567.       }
  568.       
  569.       protected function effectEndHandler(param1:EffectEvent) : void
  570.       {
  571.          var _loc2_:IEffectInstance = null;
  572.          var _loc3_:int = 0;
  573.          var _loc4_:int = 0;
  574.          _loc2_ = IEffectInstance(param1.effectInstance);
  575.          EventDispatcher(_loc2_).removeEventListener(EffectEvent.EFFECT_START,effectStartHandler);
  576.          EventDispatcher(_loc2_).removeEventListener(EffectEvent.EFFECT_END,effectEndHandler);
  577.          _loc3_ = int(_instances.length);
  578.          _loc4_ = 0;
  579.          while(_loc4_ < _loc3_)
  580.          {
  581.             if(_instances[_loc4_] === _loc2_)
  582.             {
  583.                _instances.splice(_loc4_,1);
  584.             }
  585.             _loc4_++;
  586.          }
  587.          dispatchEvent(param1);
  588.       }
  589.       
  590.       public function reverse() : void
  591.       {
  592.          var _loc1_:int = 0;
  593.          var _loc2_:int = 0;
  594.          if(isPlaying)
  595.          {
  596.             _loc1_ = int(_instances.length);
  597.             _loc2_ = 0;
  598.             while(_loc2_ < _loc1_)
  599.             {
  600.                IEffectInstance(_instances[_loc2_]).reverse();
  601.                _loc2_++;
  602.             }
  603.          }
  604.       }
  605.       
  606.       public function set filter(param1:String) : void
  607.       {
  608.          if(!customFilter)
  609.          {
  610.             _filter = param1;
  611.             switch(param1)
  612.             {
  613.                case "add":
  614.                case "remove":
  615.                   mx_internal::filterObject = new AddRemoveEffectTargetFilter();
  616.                   AddRemoveEffectTargetFilter(mx_internal::filterObject).add = param1 == "add";
  617.                   break;
  618.                case "hide":
  619.                case "show":
  620.                   mx_internal::filterObject = new HideShowEffectTargetFilter();
  621.                   HideShowEffectTargetFilter(mx_internal::filterObject).show = param1 == "show";
  622.                   break;
  623.                case "move":
  624.                   mx_internal::filterObject = new EffectTargetFilter();
  625.                   mx_internal::filterObject.filterProperties = ["x","y"];
  626.                   break;
  627.                case "resize":
  628.                   mx_internal::filterObject = new EffectTargetFilter();
  629.                   mx_internal::filterObject.filterProperties = ["width","height"];
  630.                   break;
  631.                default:
  632.                   mx_internal::filterObject = null;
  633.             }
  634.          }
  635.       }
  636.       
  637.       public function pause() : void
  638.       {
  639.          var _loc1_:int = 0;
  640.          var _loc2_:int = 0;
  641.          if(isPlaying && !isPaused)
  642.          {
  643.             isPaused = true;
  644.             _loc1_ = int(_instances.length);
  645.             _loc2_ = 0;
  646.             while(_loc2_ < _loc1_)
  647.             {
  648.                IEffectInstance(_instances[_loc2_]).pause();
  649.                _loc2_++;
  650.             }
  651.          }
  652.       }
  653.       
  654.       public function get filter() : String
  655.       {
  656.          return _filter;
  657.       }
  658.    }
  659. }
  660.