home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / org / efflex / mx / viewStackEffects / effectClasses / ViewStackTweenEffectInstance.as < prev   
Encoding:
Text File  |  2010-06-23  |  21.0 KB  |  686 lines
  1. package org.efflex.mx.viewStackEffects.effectClasses
  2. {
  3.    import flash.display.Bitmap;
  4.    import flash.display.BitmapData;
  5.    import flash.display.BlendMode;
  6.    import flash.display.DisplayObject;
  7.    import flash.display.DisplayObjectContainer;
  8.    import flash.display.Sprite;
  9.    import flash.events.Event;
  10.    import flash.geom.Matrix;
  11.    import flash.geom.Point;
  12.    import flash.geom.Rectangle;
  13.    import flash.utils.Dictionary;
  14.    import mx.containers.ViewStack;
  15.    import mx.core.UIComponent;
  16.    import mx.core.mx_internal;
  17.    import mx.effects.effectClasses.TweenEffectInstance;
  18.    import mx.events.FlexEvent;
  19.    import mx.managers.PopUpManager;
  20.    import org.efflex.viewStackHelpers.IViewStackEffectHelper;
  21.    
  22.    use namespace mx_internal;
  23.    
  24.    public class ViewStackTweenEffectInstance extends TweenEffectInstance
  25.    {
  26.       private var _effectType:String;
  27.       
  28.       private var _prevBlendMode:String;
  29.       
  30.       public var modalTransparency:Number;
  31.       
  32.       protected var _indicesRequired:Array;
  33.       
  34.       public var modalTransparencyBlur:Number;
  35.       
  36.       public var modal:Boolean;
  37.       
  38.       private var _wasInterrupted:Boolean;
  39.       
  40.       public var modalTransparencyColor:Number;
  41.       
  42.       private var _contentPane:ViewStackInstanceContainer;
  43.       
  44.       public var popUp:Boolean;
  45.       
  46.       private var _helper:IViewStackEffectHelper;
  47.       
  48.       public var transparent:Boolean;
  49.       
  50.       public var modalTransparencyDuration:Number;
  51.       
  52.       private var _waitingForCreation:Boolean;
  53.       
  54.       private var _viewStack:ViewStack;
  55.       
  56.       public var hideTarget:Boolean;
  57.       
  58.       public function ViewStackTweenEffectInstance(param1:UIComponent)
  59.       {
  60.          super(param1);
  61.          if(param1.parent is ViewStack)
  62.          {
  63.             _viewStack = ViewStack(param1.parent);
  64.             return;
  65.          }
  66.          throw new Error("ViewStackInstance must have a target with a parent property that is a ViewStack or is a subclass of ViewStack");
  67.       }
  68.       
  69.       final public function get bitmapDatum() : Array
  70.       {
  71.          return _contentPane.bitmapDatum;
  72.       }
  73.       
  74.       protected function createBitmapDatum() : void
  75.       {
  76.          var _loc1_:BitmapData = null;
  77.          var _loc4_:UIComponent = null;
  78.          var _loc6_:uint = 0;
  79.          var _loc2_:Number = viewStack.getStyle("backgroundColor");
  80.          if(isNaN(_loc2_))
  81.          {
  82.             _loc2_ = 16777215;
  83.          }
  84.          var _loc3_:int = transparent ? 0 : int(_loc2_);
  85.          var _loc5_:uint = _indicesRequired.length;
  86.          while(_loc6_ < _loc5_)
  87.          {
  88.             _loc1_ = bitmapDatum[_indicesRequired[_loc6_]] as BitmapData;
  89.             if(!_loc1_)
  90.             {
  91.                _loc4_ = UIComponent(viewStack.getChildAt(_indicesRequired[_loc6_]));
  92.                _loc1_ = new BitmapData(_loc4_.width,_loc4_.height,transparent,_loc3_);
  93.                _loc1_.draw(_loc4_);
  94.                bitmapDatum[_indicesRequired[_loc6_]] = _loc1_;
  95.             }
  96.             _loc6_++;
  97.          }
  98.       }
  99.       
  100.       final protected function get contentY() : Number
  101.       {
  102.          return _helper.contentY;
  103.       }
  104.       
  105.       protected function takeSnapShot() : void
  106.       {
  107.          var _loc1_:BitmapData = _contentPane.hideDisplay.bitmapData;
  108.          var _loc2_:Number = viewStack.getStyle("backgroundColor");
  109.          if(isNaN(_loc2_))
  110.          {
  111.             _loc2_ = 16777215;
  112.          }
  113.          var _loc3_:int = transparent ? 0 : int(_loc2_);
  114.          var _loc4_:BitmapData = new BitmapData(contentWidth,contentHeight,transparent,_loc3_);
  115.          if(wasInterrupted)
  116.          {
  117.             _loc4_.draw(_contentPane);
  118.          }
  119.          else
  120.          {
  121.             _loc4_.draw(viewStack,new Matrix(1,0,0,1,-(contentX + viewStack.borderMetrics.left),-(contentY + viewStack.borderMetrics.top)));
  122.          }
  123.          _contentPane.hideDisplay.bitmapData = _loc4_;
  124.          if(_loc1_)
  125.          {
  126.             _loc1_.dispose();
  127.          }
  128.       }
  129.       
  130.       final protected function get contentHeight() : Number
  131.       {
  132.          return _helper.contentHeight;
  133.       }
  134.       
  135.       override public function startEffect() : void
  136.       {
  137.          if(!_contentPane.containerResizeAndCreator.complete)
  138.          {
  139.             _waitingForCreation = true;
  140.          }
  141.          else
  142.          {
  143.             _waitingForCreation = false;
  144.             super.startEffect();
  145.          }
  146.       }
  147.       
  148.       final protected function get wasInterrupted() : Boolean
  149.       {
  150.          return _contentPane.wasInterrupted;
  151.       }
  152.       
  153.       override public function finishEffect() : void
  154.       {
  155.          super.finishEffect();
  156.          if(_prevBlendMode)
  157.          {
  158.             applyEraseBlendMode(false);
  159.          }
  160.          if(_wasInterrupted)
  161.          {
  162.             return;
  163.          }
  164.          if(_effectType == FlexEvent.SHOW)
  165.          {
  166.             if(display)
  167.             {
  168.                if(_contentPane.contains(display))
  169.                {
  170.                   _contentPane.removeChild(display);
  171.                }
  172.             }
  173.             if(_contentPane)
  174.             {
  175.                if(_contentPane.hideDisplay)
  176.                {
  177.                   if(_contentPane.contains(_contentPane.hideDisplay))
  178.                   {
  179.                      _contentPane.removeChild(_contentPane.hideDisplay);
  180.                   }
  181.                   if(_contentPane.hideDisplay.bitmapData)
  182.                   {
  183.                      _contentPane.hideDisplay.bitmapData.dispose();
  184.                   }
  185.                }
  186.                if(_contentPane.mask)
  187.                {
  188.                   if(_contentPane.contains(_contentPane.mask))
  189.                   {
  190.                      _contentPane.removeChild(_contentPane.mask);
  191.                   }
  192.                }
  193.                if(_viewStack.rawChildren.contains(_contentPane))
  194.                {
  195.                   _viewStack.rawChildren.removeChild(_contentPane);
  196.                }
  197.                if(_contentPane.popUp)
  198.                {
  199.                   if(_contentPane.popUp.contains(display))
  200.                   {
  201.                      _contentPane.popUp.removeChild(display);
  202.                   }
  203.                   if(_contentPane.popUp.contains(_contentPane.hideDisplay))
  204.                   {
  205.                      _contentPane.popUp.removeChild(_contentPane.hideDisplay);
  206.                   }
  207.                   if(_contentPane.popUp.mask)
  208.                   {
  209.                      _contentPane.popUp.removeChild(_contentPane.popUp.mask);
  210.                   }
  211.                   PopUpManager.removePopUp(_contentPane.popUp);
  212.                }
  213.             }
  214.             removeChildren();
  215.             destroyBitmapDatum();
  216.             _contentPane.data = null;
  217.             _contentPane.bitmapDatum = null;
  218.             _contentPane.containerResizeAndCreator = null;
  219.             _contentPane.display = null;
  220.             _contentPane.hideDisplay = null;
  221.             _contentPane.popUp = null;
  222.             _contentPane = null;
  223.          }
  224.       }
  225.       
  226.       public function get hideDisplay() : Bitmap
  227.       {
  228.          return _contentPane.hideDisplay;
  229.       }
  230.       
  231.       protected function removeChildren() : void
  232.       {
  233.          var _loc1_:int = display.numChildren;
  234.          var _loc2_:int = _loc1_ - 1;
  235.          while(_loc2_ > -1)
  236.          {
  237.             display.removeChild(DisplayObject(display.getChildAt(_loc2_)));
  238.             _loc2_--;
  239.          }
  240.       }
  241.       
  242.       public function get data() : Object
  243.       {
  244.          return _contentPane.data;
  245.       }
  246.       
  247.       protected function createContainers() : void
  248.       {
  249.          var _loc2_:Point = null;
  250.          var _loc3_:Sprite = null;
  251.          var _loc4_:DisplayObjectContainer = null;
  252.          var _loc1_:Sprite = _viewStack.mx_internal::contentPane;
  253.          _contentPane = new ViewStackInstanceContainer();
  254.          _contentPane.name = "ViewStackInstance";
  255.          _contentPane.bitmapDatum = new Array(_viewStack.numChildren);
  256.          _contentPane.selectedIndexFrom = _viewStack.getChildIndex(DisplayObject(target));
  257.          _contentPane.x = contentX + viewStack.borderMetrics.left;
  258.          _contentPane.y = contentY + viewStack.borderMetrics.top;
  259.          _contentPane.data = new Object();
  260.          _contentPane.display = new Sprite();
  261.          _contentPane.hideDisplay = new Bitmap();
  262.          _contentPane.hideDisplay.visible = false;
  263.          _contentPane.containerResizeAndCreator = new ContainerResizeAndCreator();
  264.          _contentPane.containerResizeAndCreator.addEventListener(Event.COMPLETE,onContainerResizeAndCreatorComplete,false,0,true);
  265.          if(popUp)
  266.          {
  267.             _contentPane.popUp = new UIComponent();
  268.             _loc2_ = viewStack.parent.localToGlobal(new Point(viewStack.x + contentX,viewStack.y + contentY));
  269.             _contentPane.popUp.x = _loc2_.x;
  270.             _contentPane.popUp.y = _loc2_.y;
  271.             _contentPane.popUp.setStyle("modalTransparency",modalTransparency);
  272.             _contentPane.popUp.setStyle("modalTransparencyColor",modalTransparencyColor);
  273.             _contentPane.popUp.setStyle("modalTransparencyBlur",modalTransparencyBlur);
  274.             _contentPane.popUp.setStyle("modalTransparencyDuration",modalTransparencyDuration);
  275.             _contentPane.popUp.addChild(_contentPane.hideDisplay);
  276.             _contentPane.popUp.addChild(_contentPane.display);
  277.             PopUpManager.addPopUp(_contentPane.popUp,viewStack,modal);
  278.          }
  279.          else
  280.          {
  281.             _contentPane.addChild(_contentPane.hideDisplay);
  282.             _contentPane.addChild(_contentPane.display);
  283.          }
  284.          if(_viewStack.clipContent)
  285.          {
  286.             _loc3_ = new Sprite();
  287.             _loc3_.graphics.beginFill(6710886,1);
  288.             _loc3_.graphics.drawRect(0,0,contentWidth,contentHeight);
  289.             _loc4_ = popUp ? _contentPane.popUp : _contentPane;
  290.             _loc4_.mask = _loc3_;
  291.             _loc4_.addChild(_loc3_);
  292.          }
  293.          _viewStack.rawChildren.addChild(_contentPane);
  294.       }
  295.       
  296.       private function onContainerResizeAndCreatorComplete(param1:Event) : void
  297.       {
  298.          if(_waitingForCreation)
  299.          {
  300.             startEffect();
  301.          }
  302.       }
  303.       
  304.       protected function destroyBitmapDatum() : void
  305.       {
  306.          var _loc1_:BitmapData = null;
  307.          if(!bitmapDatum)
  308.          {
  309.             return;
  310.          }
  311.          var _loc2_:int = int(bitmapDatum.length);
  312.          var _loc3_:int = 0;
  313.          while(_loc3_ < _loc2_)
  314.          {
  315.             _loc1_ = BitmapData(bitmapDatum[_loc3_]);
  316.             if(_loc1_)
  317.             {
  318.                _loc1_.dispose();
  319.             }
  320.             _loc3_++;
  321.          }
  322.       }
  323.       
  324.       protected function playViewStackEffect() : void
  325.       {
  326.       }
  327.       
  328.       override public function play() : void
  329.       {
  330.          super.play();
  331.          switch(_effectType)
  332.          {
  333.             case FlexEvent.HIDE:
  334.                takeSnapShot();
  335.                removeChildren();
  336.                _contentPane.hideDisplay.visible = true;
  337.                if(hideTarget)
  338.                {
  339.                   applyEraseBlendMode(true);
  340.                }
  341.                viewStack.callLater(finishRepeat);
  342.                break;
  343.             case FlexEvent.SHOW:
  344.                removeChildren();
  345.                createBitmapDatum();
  346.                playViewStackEffect();
  347.                _contentPane.hideDisplay.visible = false;
  348.                if(hideTarget)
  349.                {
  350.                   applyEraseBlendMode(true);
  351.                }
  352.          }
  353.       }
  354.       
  355.       protected function setIndicesRequired() : void
  356.       {
  357.       }
  358.       
  359.       protected function setInturruptionParams() : void
  360.       {
  361.       }
  362.       
  363.       final public function get selectedIndexFrom() : int
  364.       {
  365.          return _contentPane.selectedIndexFrom;
  366.       }
  367.       
  368.       public function get display() : DisplayObjectContainer
  369.       {
  370.          return _contentPane.display;
  371.       }
  372.       
  373.       override public function initEffect(param1:Event) : void
  374.       {
  375.          var _loc2_:int = 0;
  376.          var _loc3_:int = 0;
  377.          super.initEffect(param1);
  378.          _contentPane = _viewStack.rawChildren.getChildByName("ViewStackInstance") as ViewStackInstanceContainer;
  379.          if(!_contentPane)
  380.          {
  381.             createContainers();
  382.          }
  383.          _indicesRequired = new Array();
  384.          _contentPane.selectedIndexTo = _viewStack.selectedIndex;
  385.          _effectType = param1.type;
  386.          switch(_effectType)
  387.          {
  388.             case FlexEvent.HIDE:
  389.                addRequiredIndex(selectedIndexFrom);
  390.                break;
  391.             case FlexEvent.SHOW:
  392.                setIndicesRequired();
  393.          }
  394.          if(!_indicesRequired.length)
  395.          {
  396.             addRequiredIndex(selectedIndexFrom);
  397.             addRequiredIndex(selectedIndexTo);
  398.          }
  399.          else if(_indicesRequired.length == 1 && _indicesRequired[0] == -1)
  400.          {
  401.             _indicesRequired = new Array();
  402.             _loc2_ = viewStack.numChildren;
  403.             _loc3_ = 0;
  404.             while(_loc3_ < _loc2_)
  405.             {
  406.                addRequiredIndex(_loc3_);
  407.                _loc3_++;
  408.             }
  409.          }
  410.          _indicesRequired = removeDuplicatesFromArray(_indicesRequired);
  411.          _contentPane.containerResizeAndCreator.initialize(_indicesRequired,viewStack,new Rectangle(contentX,contentY,contentWidth,contentHeight));
  412.       }
  413.       
  414.       final protected function get contentWidth() : Number
  415.       {
  416.          return _helper.contentWidth;
  417.       }
  418.       
  419.       private function applyEraseBlendMode(param1:Boolean) : void
  420.       {
  421.          if(param1)
  422.          {
  423.             _prevBlendMode = target.blendMode;
  424.             target.blendMode = BlendMode.ERASE;
  425.          }
  426.          else
  427.          {
  428.             target.blendMode = !!_prevBlendMode ? _prevBlendMode : BlendMode.NORMAL;
  429.          }
  430.       }
  431.       
  432.       override public function end() : void
  433.       {
  434.          if(!_contentPane)
  435.          {
  436.             return;
  437.          }
  438.          if(_effectType == FlexEvent.SHOW && _contentPane && !_wasInterrupted)
  439.          {
  440.             _wasInterrupted = _contentPane.wasInterrupted = true;
  441.             setInturruptionParams();
  442.          }
  443.          _contentPane.containerResizeAndCreator.cancel();
  444.          mx_internal::stopRepeat = true;
  445.          if(mx_internal::delayTimer)
  446.          {
  447.             mx_internal::delayTimer.reset();
  448.          }
  449.          if(tween)
  450.          {
  451.             tween.stop();
  452.             tween = null;
  453.          }
  454.          finishRepeat();
  455.       }
  456.       
  457.       final public function set helper(param1:Class) : void
  458.       {
  459.          _helper = IViewStackEffectHelper(new param1(_viewStack));
  460.       }
  461.       
  462.       final public function get viewStack() : ViewStack
  463.       {
  464.          return _viewStack;
  465.       }
  466.       
  467.       final public function get snapShot() : BitmapData
  468.       {
  469.          return _contentPane.hideDisplay.bitmapData;
  470.       }
  471.       
  472.       final protected function removeDuplicatesFromArray(param1:Array) : Array
  473.       {
  474.          var _loc4_:* = undefined;
  475.          var _loc2_:Dictionary = new Dictionary(true);
  476.          var _loc3_:Array = new Array();
  477.          var _loc5_:int = int(param1.length);
  478.          var _loc6_:int = 0;
  479.          while(_loc6_ < _loc5_)
  480.          {
  481.             _loc4_ = param1[_loc6_];
  482.             if(_loc2_[_loc4_] == undefined)
  483.             {
  484.                _loc2_[_loc4_] = true;
  485.                _loc3_.push(_loc4_);
  486.             }
  487.             _loc6_++;
  488.          }
  489.          return _loc3_;
  490.       }
  491.       
  492.       final protected function addRequiredIndex(param1:int) : void
  493.       {
  494.          _indicesRequired.push(param1);
  495.       }
  496.       
  497.       final public function get selectedIndexTo() : int
  498.       {
  499.          return _contentPane.selectedIndexTo;
  500.       }
  501.       
  502.       final protected function get contentX() : Number
  503.       {
  504.          return _helper.contentX;
  505.       }
  506.    }
  507. }
  508.  
  509. import flash.display.Bitmap;
  510. import flash.display.Sprite;
  511. import flash.events.Event;
  512. import flash.events.EventDispatcher;
  513. import flash.geom.Rectangle;
  514. import mx.containers.ViewStack;
  515. import mx.core.Container;
  516. import mx.core.UIComponent;
  517. import mx.core.mx_internal;
  518. import mx.events.FlexEvent;
  519.  
  520. use namespace mx_internal;
  521.  
  522. class ContainerResizeAndCreator extends EventDispatcher
  523. {
  524.    private var _complete:Boolean;
  525.    
  526.    private var _creatingContainers:Array;
  527.    
  528.    private var _creationCount:int;
  529.    
  530.    private var _creationCompleteCount:int;
  531.    
  532.    public function ContainerResizeAndCreator()
  533.    {
  534.       super();
  535.    }
  536.    
  537.    private function checkCreationStatus() : void
  538.    {
  539.       if(_creationCompleteCount == _creationCount && !_complete)
  540.       {
  541.          _complete = true;
  542.          dispatchEvent(new Event(Event.COMPLETE));
  543.       }
  544.    }
  545.    
  546.    private function onContainerCreationComplete(param1:FlexEvent) : void
  547.    {
  548.       var _loc2_:Container = Container(param1.currentTarget);
  549.       _loc2_.removeEventListener(FlexEvent.CREATION_COMPLETE,onContainerCreationComplete,false);
  550.       ++_creationCompleteCount;
  551.       checkCreationStatus();
  552.    }
  553.    
  554.    public function get complete() : Boolean
  555.    {
  556.       return _complete;
  557.    }
  558.    
  559.    public function cancel() : void
  560.    {
  561.       var _loc1_:Container = null;
  562.       var _loc2_:int = 0;
  563.       _complete = true;
  564.       var _loc3_:int = 0;
  565.       while(_loc3_ < _loc2_)
  566.       {
  567.          _loc1_ = Container(_creatingContainers[_loc3_]);
  568.          _loc1_.removeEventListener(FlexEvent.CREATION_COMPLETE,onContainerCreationComplete,false);
  569.          _loc3_++;
  570.       }
  571.    }
  572.    
  573.    public function initialize(param1:Array, param2:ViewStack, param3:Rectangle) : void
  574.    {
  575.       var _loc4_:int = 0;
  576.       var _loc5_:uint = 0;
  577.       var _loc7_:Number = NaN;
  578.       var _loc8_:Number = NaN;
  579.       var _loc9_:Container = null;
  580.       var _loc10_:int = 0;
  581.       _complete = false;
  582.       _creationCount = 0;
  583.       _creationCompleteCount = 0;
  584.       var _loc6_:int = param2.numChildren;
  585.       _creatingContainers = new Array();
  586.       _loc5_ = param1.length;
  587.       _loc4_ = 0;
  588.       while(_loc4_ < _loc5_)
  589.       {
  590.          _loc10_ = Number(param1[_loc4_]);
  591.          if(_loc10_ >= 0 && _loc10_ < _loc6_)
  592.          {
  593.             _loc9_ = param2.getChildAt(_loc10_) as Container;
  594.             if(_loc9_.mx_internal::numChildrenCreated == -1 && _loc9_.numChildren != 0 || !_loc9_.initialized)
  595.             {
  596.                ++_creationCount;
  597.             }
  598.          }
  599.          _loc4_++;
  600.       }
  601.       _loc5_ = param1.length;
  602.       _loc4_ = 0;
  603.       while(_loc4_ < _loc5_)
  604.       {
  605.          _loc10_ = Number(param1[_loc4_]);
  606.          if(_loc10_ >= 0 && _loc10_ < _loc6_ && !isNaN(_loc10_))
  607.          {
  608.             _loc9_ = param2.getChildAt(_loc10_) as Container;
  609.             if(_loc9_.mx_internal::numChildrenCreated == -1 && _loc9_.numChildren != 0 || !_loc9_.initialized)
  610.             {
  611.                _creatingContainers.push(_loc9_);
  612.                _loc9_.addEventListener(FlexEvent.CREATION_COMPLETE,onContainerCreationComplete,false,0,true);
  613.                _loc9_.createComponentsFromDescriptors(true);
  614.             }
  615.             _loc7_ = param3.width;
  616.             _loc8_ = param3.height;
  617.             if(!isNaN(_loc9_.percentWidth))
  618.             {
  619.                if(_loc7_ > _loc9_.maxWidth)
  620.                {
  621.                   _loc7_ = _loc9_.maxWidth;
  622.                }
  623.             }
  624.             else if(_loc7_ > _loc9_.explicitWidth)
  625.             {
  626.                _loc7_ = _loc9_.explicitWidth;
  627.             }
  628.             if(!isNaN(_loc9_.percentHeight))
  629.             {
  630.                if(_loc8_ > _loc9_.maxHeight)
  631.                {
  632.                   _loc8_ = _loc9_.maxHeight;
  633.                }
  634.             }
  635.             else if(_loc8_ > _loc9_.explicitHeight)
  636.             {
  637.                _loc8_ = _loc9_.explicitHeight;
  638.             }
  639.             if(_loc9_.x != param3.x || _loc9_.y != param3.y)
  640.             {
  641.                _loc9_.move(param3.x,param3.y);
  642.             }
  643.             if(_loc9_.width != _loc7_ || _loc9_.height != _loc8_)
  644.             {
  645.                _loc9_.setActualSize(_loc7_,_loc8_);
  646.             }
  647.             if(Boolean(_loc9_.mx_internal::invalidateDisplayListFlag) || Boolean(_loc9_.mx_internal::invalidateSizeFlag) || Boolean(_loc9_.mx_internal::invalidatePropertiesFlag))
  648.             {
  649.                _loc9_.validateNow();
  650.             }
  651.          }
  652.          _loc4_++;
  653.       }
  654.       if(_creationCount == 0)
  655.       {
  656.          checkCreationStatus();
  657.       }
  658.    }
  659. }
  660.  
  661. class ViewStackInstanceContainer extends Sprite
  662. {
  663.    public var bitmapDatum:Array;
  664.    
  665.    public var selectedIndexFrom:int;
  666.    
  667.    public var display:Sprite;
  668.    
  669.    public var data:Object;
  670.    
  671.    public var popUp:UIComponent;
  672.    
  673.    public var hideDisplay:Bitmap;
  674.    
  675.    public var containerResizeAndCreator:ContainerResizeAndCreator;
  676.    
  677.    public var selectedIndexTo:int;
  678.    
  679.    public var wasInterrupted:Boolean;
  680.    
  681.    public function ViewStackInstanceContainer()
  682.    {
  683.       super();
  684.    }
  685. }
  686.