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