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