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