home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / managers / SystemManager.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  46.8 KB  |  1,516 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.Graphics;
  6.    import flash.display.InteractiveObject;
  7.    import flash.display.Loader;
  8.    import flash.display.MovieClip;
  9.    import flash.display.Sprite;
  10.    import flash.display.Stage;
  11.    import flash.display.StageAlign;
  12.    import flash.display.StageScaleMode;
  13.    import flash.events.Event;
  14.    import flash.events.IEventDispatcher;
  15.    import flash.events.MouseEvent;
  16.    import flash.events.TimerEvent;
  17.    import flash.geom.Point;
  18.    import flash.geom.Rectangle;
  19.    import flash.system.ApplicationDomain;
  20.    import flash.text.Font;
  21.    import flash.text.TextFormat;
  22.    import flash.utils.Dictionary;
  23.    import flash.utils.Timer;
  24.    import flash.utils.getQualifiedClassName;
  25.    import mx.core.FlexSprite;
  26.    import mx.core.IChildList;
  27.    import mx.core.IFlexDisplayObject;
  28.    import mx.core.IFlexModuleFactory;
  29.    import mx.core.IInvalidating;
  30.    import mx.core.IRawChildrenContainer;
  31.    import mx.core.IUIComponent;
  32.    import mx.core.Singleton;
  33.    import mx.core.mx_internal;
  34.    import mx.events.FlexEvent;
  35.    import mx.messaging.config.LoaderConfig;
  36.    import mx.preloaders.DownloadProgressBar;
  37.    import mx.preloaders.Preloader;
  38.    import mx.styles.ISimpleStyleClient;
  39.    import mx.styles.IStyleClient;
  40.    
  41.    use namespace mx_internal;
  42.    
  43.    public class SystemManager extends MovieClip implements IChildList, IFlexDisplayObject, IFlexModuleFactory, ISystemManager
  44.    {
  45.       
  46.       private static const IDLE_THRESHOLD:Number = 1000;
  47.       
  48.       mx_internal static var lastSystemManager:SystemManager;
  49.       
  50.       private static const IDLE_INTERVAL:Number = 100;
  51.       
  52.       mx_internal static var allSystemManagers:Dictionary = new Dictionary(true);
  53.       
  54.       mx_internal static const VERSION:String = "2.0.1.0";
  55.        
  56.       
  57.       mx_internal var nestLevel:int = 0;
  58.       
  59.       private var forms:Array;
  60.       
  61.       private var mouseCatcher:Sprite;
  62.       
  63.       private var _height:Number;
  64.       
  65.       private var preloader:Preloader;
  66.       
  67.       private var _topLevelSystemManager:ISystemManager;
  68.       
  69.       private var _rawChildren:SystemRawChildrenList;
  70.       
  71.       private var _toolTipIndex:int = 0;
  72.       
  73.       private var _explicitHeight:Number;
  74.       
  75.       private var _document:Object;
  76.       
  77.       private var form:IFocusManagerContainer;
  78.       
  79.       private var _width:Number;
  80.       
  81.       private var _toolTipChildren:SystemChildrenList;
  82.       
  83.       private var initialized:Boolean = false;
  84.       
  85.       private var _focusPane:Sprite;
  86.       
  87.       private var isStageRoot:Boolean = true;
  88.       
  89.       private var rslSizes:Array = null;
  90.       
  91.       private var _fontList:Object = null;
  92.       
  93.       private var nextFrameTimer:Timer = null;
  94.       
  95.       private var topLevel:Boolean = true;
  96.       
  97.       private var _popUpChildren:SystemChildrenList;
  98.       
  99.       private var _cursorIndex:int = 0;
  100.       
  101.       private var _topMostIndex:int = 0;
  102.       
  103.       mx_internal var _mouseX:*;
  104.       
  105.       mx_internal var _mouseY:*;
  106.       
  107.       private var _numModalWindows:int = 0;
  108.       
  109.       private var _screen:Rectangle;
  110.       
  111.       mx_internal var idleCounter:int = 0;
  112.       
  113.       private var initCallbackFunctions:Array;
  114.       
  115.       private var _cursorChildren:SystemChildrenList;
  116.       
  117.       private var _noTopMostIndex:int = 0;
  118.       
  119.       private var _applicationIndex:int = 1;
  120.       
  121.       private var idleTimer:Timer;
  122.       
  123.       private var doneExecutingInitCallbacks:Boolean = false;
  124.       
  125.       private var _explicitWidth:Number;
  126.       
  127.       mx_internal var topLevelWindow:IUIComponent;
  128.       
  129.       public function SystemManager()
  130.       {
  131.          doneExecutingInitCallbacks = false;
  132.          initCallbackFunctions = [];
  133.          initialized = false;
  134.          topLevel = true;
  135.          isStageRoot = true;
  136.          mx_internal::nestLevel = 0;
  137.          rslSizes = null;
  138.          forms = [];
  139.          mx_internal::idleCounter = 0;
  140.          nextFrameTimer = null;
  141.          _applicationIndex = 1;
  142.          _cursorIndex = 0;
  143.          _fontList = null;
  144.          _noTopMostIndex = 0;
  145.          _numModalWindows = 0;
  146.          _toolTipIndex = 0;
  147.          _topMostIndex = 0;
  148.          super();
  149.          if(stage)
  150.          {
  151.             stage.scaleMode = StageScaleMode.NO_SCALE;
  152.             stage.align = StageAlign.TOP_LEFT;
  153.          }
  154.          if(SystemManagerGlobals.topLevelSystemManagers.length > 0 && !stage)
  155.          {
  156.             topLevel = false;
  157.          }
  158.          if(!stage)
  159.          {
  160.             isStageRoot = false;
  161.          }
  162.          if(topLevel)
  163.          {
  164.             SystemManagerGlobals.topLevelSystemManagers.push(this);
  165.          }
  166.          mx_internal::lastSystemManager = this;
  167.          executeCallbacks();
  168.          stop();
  169.          if(topLevel && currentFrame != 1)
  170.          {
  171.             throw new Error("The SystemManager constructor was called when the currentFrame was at " + currentFrame + " Please add this SWF to bug 129782.");
  172.          }
  173.          root.loaderInfo.addEventListener(Event.INIT,initHandler);
  174.       }
  175.       
  176.       public static function getSWFRoot(param1:Object) : DisplayObject
  177.       {
  178.          var className:String = null;
  179.          var p:* = undefined;
  180.          var sm:SystemManager = null;
  181.          var domain:ApplicationDomain = null;
  182.          var cls:Class = null;
  183.          var object:Object = param1;
  184.          className = getQualifiedClassName(object);
  185.          for(p in mx_internal::allSystemManagers)
  186.          {
  187.             sm = p as SystemManager;
  188.             domain = sm.loaderInfo.applicationDomain;
  189.             try
  190.             {
  191.                cls = Class(domain.getDefinition(className));
  192.                if(object is cls)
  193.                {
  194.                   return sm;
  195.                }
  196.             }
  197.             catch(e:Error)
  198.             {
  199.             }
  200.          }
  201.          return null;
  202.       }
  203.       
  204.       mx_internal static function registerInitCallback(param1:Function) : void
  205.       {
  206.          var _loc2_:SystemManager = null;
  207.          if(!mx_internal::allSystemManagers || !mx_internal::lastSystemManager)
  208.          {
  209.             return;
  210.          }
  211.          _loc2_ = mx_internal::lastSystemManager;
  212.          if(_loc2_.doneExecutingInitCallbacks)
  213.          {
  214.             param1(_loc2_);
  215.          }
  216.          else
  217.          {
  218.             _loc2_.initCallbackFunctions.push(param1);
  219.          }
  220.       }
  221.       
  222.       mx_internal function addingChild(param1:DisplayObject) : void
  223.       {
  224.          var _loc2_:int = 0;
  225.          var _loc3_:Class = null;
  226.          var _loc4_:DisplayObjectContainer = null;
  227.          _loc2_ = 1;
  228.          if(!topLevel)
  229.          {
  230.             _loc4_ = parent.parent;
  231.             while(_loc4_)
  232.             {
  233.                if(_loc4_ is ILayoutManagerClient)
  234.                {
  235.                   _loc2_ = ILayoutManagerClient(_loc4_).nestLevel + 1;
  236.                   break;
  237.                }
  238.                _loc4_ = _loc4_.parent;
  239.             }
  240.          }
  241.          mx_internal::nestLevel = _loc2_;
  242.          if(param1 is IUIComponent)
  243.          {
  244.             IUIComponent(param1).systemManager = this;
  245.          }
  246.          _loc3_ = Class(getDefinitionByName("mx.core.UIComponent"));
  247.          if(param1 is IUIComponent && !IUIComponent(param1).document)
  248.          {
  249.             IUIComponent(param1).document = document;
  250.          }
  251.          if(param1 is ILayoutManagerClient)
  252.          {
  253.             ILayoutManagerClient(param1).nestLevel = mx_internal::nestLevel + 1;
  254.          }
  255.          if(param1 is InteractiveObject)
  256.          {
  257.             if(doubleClickEnabled)
  258.             {
  259.                InteractiveObject(param1).doubleClickEnabled = true;
  260.             }
  261.          }
  262.          if(param1 is IUIComponent)
  263.          {
  264.             IUIComponent(param1).parentChanged(this);
  265.          }
  266.          if(param1 is IStyleClient)
  267.          {
  268.             IStyleClient(param1).regenerateStyleCache(true);
  269.          }
  270.          if(param1 is ISimpleStyleClient)
  271.          {
  272.             ISimpleStyleClient(param1).styleChanged(null);
  273.          }
  274.          if(param1 is IStyleClient)
  275.          {
  276.             IStyleClient(param1).notifyStyleChangeInChildren(null,true);
  277.          }
  278.          if(Boolean(_loc3_) && param1 is _loc3_)
  279.          {
  280.             _loc3_(param1).initThemeColor();
  281.          }
  282.          if(Boolean(_loc3_) && param1 is _loc3_)
  283.          {
  284.             _loc3_(param1).stylesInitialized();
  285.          }
  286.       }
  287.       
  288.       mx_internal function rawChildren_addChild(param1:DisplayObject) : DisplayObject
  289.       {
  290.          mx_internal::addingChild(param1);
  291.          super.addChild(param1);
  292.          mx_internal::childAdded(param1);
  293.          return param1;
  294.       }
  295.       
  296.       public function getExplicitOrMeasuredHeight() : Number
  297.       {
  298.          return !isNaN(explicitHeight) ? explicitHeight : measuredHeight;
  299.       }
  300.       
  301.       mx_internal function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  302.       {
  303.          var _loc3_:Boolean = false;
  304.          var _loc4_:int = 0;
  305.          var _loc5_:int = 0;
  306.          var _loc6_:IStyleClient = null;
  307.          _loc3_ = false;
  308.          _loc4_ = rawChildren.numChildren;
  309.          _loc5_ = 0;
  310.          while(_loc5_ < _loc4_)
  311.          {
  312.             if(_loc6_ = rawChildren.getChildAt(_loc5_) as IStyleClient)
  313.             {
  314.                _loc6_.styleChanged(param1);
  315.                _loc6_.notifyStyleChangeInChildren(param1,param2);
  316.             }
  317.             if(isTopLevelWindow(DisplayObject(_loc6_)))
  318.             {
  319.                _loc3_ = true;
  320.             }
  321.             _loc4_ = rawChildren.numChildren;
  322.             _loc5_++;
  323.          }
  324.          if(!_loc3_ && mx_internal::topLevelWindow is IStyleClient)
  325.          {
  326.             IStyleClient(mx_internal::topLevelWindow).styleChanged(param1);
  327.             IStyleClient(mx_internal::topLevelWindow).notifyStyleChangeInChildren(param1,param2);
  328.          }
  329.       }
  330.       
  331.       mx_internal function rawChildren_getObjectsUnderPoint(param1:Point) : Array
  332.       {
  333.          return super.getObjectsUnderPoint(param1);
  334.       }
  335.       
  336.       override public function contains(param1:DisplayObject) : Boolean
  337.       {
  338.          var _loc2_:int = 0;
  339.          var _loc3_:int = 0;
  340.          var _loc4_:DisplayObject = null;
  341.          if(super.contains(param1))
  342.          {
  343.             if(param1.parent == this)
  344.             {
  345.                _loc2_ = super.getChildIndex(param1);
  346.                if(_loc2_ < mx_internal::noTopMostIndex)
  347.                {
  348.                   return true;
  349.                }
  350.             }
  351.             else
  352.             {
  353.                _loc3_ = 0;
  354.                while(_loc3_ < mx_internal::noTopMostIndex)
  355.                {
  356.                   if((_loc4_ = super.getChildAt(_loc3_)) is IRawChildrenContainer)
  357.                   {
  358.                      if(IRawChildrenContainer(_loc4_).rawChildren.contains(param1))
  359.                      {
  360.                         return true;
  361.                      }
  362.                   }
  363.                   if(_loc4_ is DisplayObjectContainer)
  364.                   {
  365.                      if(DisplayObjectContainer(_loc4_).contains(param1))
  366.                      {
  367.                         return true;
  368.                      }
  369.                   }
  370.                   _loc3_++;
  371.                }
  372.             }
  373.          }
  374.          return false;
  375.       }
  376.       
  377.       private function idleTimer_timerHandler(param1:TimerEvent) : void
  378.       {
  379.          ++mx_internal::idleCounter;
  380.          if(mx_internal::idleCounter * IDLE_INTERVAL > IDLE_THRESHOLD)
  381.          {
  382.             dispatchEvent(new FlexEvent(FlexEvent.IDLE));
  383.          }
  384.       }
  385.       
  386.       private function initHandler(param1:Event) : void
  387.       {
  388.          var _loc2_:int = 0;
  389.          var _loc3_:int = 0;
  390.          mx_internal::allSystemManagers[this] = this.loaderInfo.url;
  391.          root.loaderInfo.removeEventListener(Event.INIT,initHandler);
  392.          _loc2_ = totalFrames == 1 ? 0 : 1;
  393.          addFrameScript(_loc2_,docFrameHandler);
  394.          _loc3_ = _loc2_ + 1;
  395.          while(_loc3_ < totalFrames)
  396.          {
  397.             addFrameScript(_loc3_,extraFrameHandler);
  398.             _loc3_++;
  399.          }
  400.          mx_internal::initialize();
  401.       }
  402.       
  403.       public function getDefinitionByName(param1:String) : Object
  404.       {
  405.          var _loc2_:ApplicationDomain = null;
  406.          var _loc3_:Object = null;
  407.          _loc2_ = !topLevel && parent is Loader ? Loader(parent).contentLoaderInfo.applicationDomain : info()["currentDomain"] as ApplicationDomain;
  408.          if(_loc2_.hasDefinition(param1))
  409.          {
  410.             _loc3_ = _loc2_.getDefinition(param1);
  411.          }
  412.          return _loc3_;
  413.       }
  414.       
  415.       public function get embeddedFontList() : Object
  416.       {
  417.          var _loc1_:Object = null;
  418.          var _loc2_:String = null;
  419.          var _loc3_:Object = null;
  420.          if(_fontList == null)
  421.          {
  422.             _fontList = {};
  423.             _loc1_ = info()["fonts"];
  424.             for(_loc2_ in _loc1_)
  425.             {
  426.                _fontList[_loc2_] = _loc1_[_loc2_];
  427.             }
  428.             if(!topLevel && Boolean(_topLevelSystemManager))
  429.             {
  430.                _loc3_ = _topLevelSystemManager.embeddedFontList;
  431.                for(_loc2_ in _loc3_)
  432.                {
  433.                   _fontList[_loc2_] = _loc3_[_loc2_];
  434.                }
  435.             }
  436.          }
  437.          return _fontList;
  438.       }
  439.       
  440.       mx_internal function set cursorIndex(param1:int) : void
  441.       {
  442.          var _loc2_:int = 0;
  443.          _loc2_ = param1 - _cursorIndex;
  444.          _cursorIndex = param1;
  445.       }
  446.       
  447.       override public function getChildAt(param1:int) : DisplayObject
  448.       {
  449.          return super.getChildAt(mx_internal::applicationIndex + param1);
  450.       }
  451.       
  452.       public function set document(param1:Object) : void
  453.       {
  454.          _document = param1;
  455.       }
  456.       
  457.       override public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  458.       {
  459.          if(param1 == FlexEvent.IDLE && !idleTimer)
  460.          {
  461.             idleTimer = new Timer(IDLE_INTERVAL);
  462.             idleTimer.addEventListener(TimerEvent.TIMER,idleTimer_timerHandler);
  463.             idleTimer.start();
  464.             addEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler,true);
  465.             addEventListener(MouseEvent.MOUSE_UP,mouseUpHandler,true);
  466.          }
  467.          super.addEventListener(param1,param2,param3,param4,param5);
  468.       }
  469.       
  470.       override public function get mouseX() : Number
  471.       {
  472.          if(mx_internal::_mouseX === undefined)
  473.          {
  474.             return super.mouseX;
  475.          }
  476.          return mx_internal::_mouseX;
  477.       }
  478.       
  479.       override public function get mouseY() : Number
  480.       {
  481.          if(mx_internal::_mouseY === undefined)
  482.          {
  483.             return super.mouseY;
  484.          }
  485.          return mx_internal::_mouseY;
  486.       }
  487.       
  488.       public function removeFocusManager(param1:IFocusManagerContainer) : void
  489.       {
  490.          var _loc2_:int = 0;
  491.          var _loc3_:int = 0;
  492.          _loc2_ = int(forms.length);
  493.          _loc3_ = 0;
  494.          while(_loc3_ < _loc2_)
  495.          {
  496.             if(forms[_loc3_] == param1)
  497.             {
  498.                if(form == param1)
  499.                {
  500.                   deactivate(param1);
  501.                }
  502.                forms.splice(_loc3_,1);
  503.                return;
  504.             }
  505.             _loc3_++;
  506.          }
  507.       }
  508.       
  509.       private function mouseMoveHandler(param1:MouseEvent) : void
  510.       {
  511.          mx_internal::idleCounter = 0;
  512.       }
  513.       
  514.       public function get rawChildren() : IChildList
  515.       {
  516.          if(!topLevel)
  517.          {
  518.             return _topLevelSystemManager.rawChildren;
  519.          }
  520.          if(!_rawChildren)
  521.          {
  522.             _rawChildren = new SystemRawChildrenList(this);
  523.          }
  524.          return _rawChildren;
  525.       }
  526.       
  527.       public function get focusPane() : Sprite
  528.       {
  529.          return _focusPane;
  530.       }
  531.       
  532.       private function mouseDownHandler(param1:MouseEvent) : void
  533.       {
  534.          var _loc2_:int = 0;
  535.          var _loc3_:DisplayObject = null;
  536.          var _loc4_:Boolean = false;
  537.          var _loc5_:int = 0;
  538.          var _loc6_:int = 0;
  539.          var _loc7_:int = 0;
  540.          var _loc8_:int = 0;
  541.          var _loc9_:IChildList = null;
  542.          mx_internal::idleCounter = 0;
  543.          if(numModalWindows == 0)
  544.          {
  545.             if(forms.length > 1)
  546.             {
  547.                _loc2_ = int(forms.length);
  548.                _loc3_ = DisplayObject(param1.target);
  549.                _loc4_ = Boolean(document.rawChildren.contains(_loc3_));
  550.                while(_loc3_)
  551.                {
  552.                   _loc5_ = 0;
  553.                   while(_loc5_ < _loc2_)
  554.                   {
  555.                      if(forms[_loc5_] == _loc3_)
  556.                      {
  557.                         _loc6_ = 0;
  558.                         if(_loc3_ != form && _loc3_ is IFocusManagerContainer)
  559.                         {
  560.                            activate(IFocusManagerContainer(_loc3_));
  561.                         }
  562.                         if(popUpChildren.contains(_loc3_))
  563.                         {
  564.                            _loc9_ = popUpChildren;
  565.                         }
  566.                         else
  567.                         {
  568.                            _loc9_ = this;
  569.                         }
  570.                         _loc8_ = _loc7_ = _loc9_.getChildIndex(_loc3_);
  571.                         _loc2_ = int(forms.length);
  572.                         _loc6_ = 0;
  573.                         while(_loc6_ < _loc2_)
  574.                         {
  575.                            if(_loc9_.contains(forms[_loc6_]))
  576.                            {
  577.                               if(_loc9_.getChildIndex(forms[_loc6_]) > _loc7_)
  578.                               {
  579.                                  _loc8_ = _loc9_.getChildIndex(forms[_loc6_]);
  580.                               }
  581.                            }
  582.                            _loc6_++;
  583.                         }
  584.                         if(_loc8_ > _loc7_ && !_loc4_)
  585.                         {
  586.                            _loc9_.setChildIndex(_loc3_,_loc8_);
  587.                         }
  588.                         return;
  589.                      }
  590.                      _loc5_++;
  591.                   }
  592.                   _loc3_ = _loc3_.parent;
  593.                }
  594.             }
  595.          }
  596.       }
  597.       
  598.       public function get screen() : Rectangle
  599.       {
  600.          if(!_screen)
  601.          {
  602.             Stage_resizeHandler();
  603.          }
  604.          return _screen;
  605.       }
  606.       
  607.       public function get preloaderBackgroundSize() : String
  608.       {
  609.          return info()["backgroundSize"];
  610.       }
  611.       
  612.       private function docFrameHandler(param1:Event = null) : void
  613.       {
  614.          var _loc2_:Array = null;
  615.          var _loc3_:int = 0;
  616.          var _loc4_:int = 0;
  617.          var _loc5_:Class = null;
  618.          Singleton.registerClass("mx.managers::ICursorManager",Class(getDefinitionByName("mx.managers::CursorManagerImpl")));
  619.          Singleton.registerClass("mx.managers::IDragManager",Class(getDefinitionByName("mx.managers::DragManagerImpl")));
  620.          Singleton.registerClass("mx.managers::IHistoryManager",Class(getDefinitionByName("mx.managers::HistoryManagerImpl")));
  621.          Singleton.registerClass("mx.managers::ILayoutManager",Class(getDefinitionByName("mx.managers::LayoutManager")));
  622.          Singleton.registerClass("mx.managers::IPopUpManager",Class(getDefinitionByName("mx.managers::PopUpManagerImpl")));
  623.          Singleton.registerClass("mx.styles::IStyleManager",Class(getDefinitionByName("mx.styles::StyleManagerImpl")));
  624.          Singleton.registerClass("mx.managers::IToolTipManager",Class(getDefinitionByName("mx.managers::ToolTipManagerImpl")));
  625.          executeCallbacks();
  626.          doneExecutingInitCallbacks = true;
  627.          _loc2_ = info()["mixins"];
  628.          if(Boolean(_loc2_) && _loc2_.length > 0)
  629.          {
  630.             _loc3_ = int(_loc2_.length);
  631.             _loc4_ = 0;
  632.             while(_loc4_ < _loc3_)
  633.             {
  634.                (_loc5_ = Class(getDefinitionByName(_loc2_[_loc4_])))["init"](this);
  635.                _loc4_++;
  636.             }
  637.          }
  638.          initializeTopLevelWindow(null);
  639.          deferredNextFrame();
  640.       }
  641.       
  642.       private function Stage_resizeHandler(param1:Event = null) : void
  643.       {
  644.          var _loc2_:Number = NaN;
  645.          var _loc3_:Number = NaN;
  646.          var _loc4_:Number = NaN;
  647.          var _loc5_:Number = NaN;
  648.          var _loc6_:Number = NaN;
  649.          var _loc7_:Number = NaN;
  650.          var _loc8_:String = null;
  651.          _loc2_ = stage.stageWidth;
  652.          _loc3_ = stage.stageHeight;
  653.          _loc4_ = loaderInfo.width;
  654.          _loc5_ = loaderInfo.height;
  655.          _loc6_ = (_loc4_ - _loc2_) / 2;
  656.          _loc7_ = (_loc5_ - _loc3_) / 2;
  657.          if((_loc8_ = stage.align) == StageAlign.TOP)
  658.          {
  659.             _loc7_ = 0;
  660.          }
  661.          else if(_loc8_ == StageAlign.BOTTOM)
  662.          {
  663.             _loc7_ = _loc5_ - _loc3_;
  664.          }
  665.          else if(_loc8_ == StageAlign.LEFT)
  666.          {
  667.             _loc6_ = 0;
  668.          }
  669.          else if(_loc8_ == StageAlign.RIGHT)
  670.          {
  671.             _loc6_ = _loc4_ - _loc2_;
  672.          }
  673.          else if(_loc8_ == StageAlign.TOP_LEFT || _loc8_ == "LT")
  674.          {
  675.             _loc7_ = 0;
  676.             _loc6_ = 0;
  677.          }
  678.          else if(_loc8_ == StageAlign.TOP_RIGHT)
  679.          {
  680.             _loc7_ = 0;
  681.             _loc6_ = _loc4_ - _loc2_;
  682.          }
  683.          else if(_loc8_ == StageAlign.BOTTOM_LEFT)
  684.          {
  685.             _loc7_ = _loc5_ - _loc3_;
  686.             _loc6_ = 0;
  687.          }
  688.          else if(_loc8_ == StageAlign.BOTTOM_RIGHT)
  689.          {
  690.             _loc7_ = _loc5_ - _loc3_;
  691.             _loc6_ = _loc4_ - _loc2_;
  692.          }
  693.          if(!_screen)
  694.          {
  695.             _screen = new Rectangle();
  696.          }
  697.          _screen.x = _loc6_;
  698.          _screen.y = _loc7_;
  699.          _screen.width = _loc2_;
  700.          _screen.height = _loc3_;
  701.          if(isStageRoot)
  702.          {
  703.             _width = stage.stageWidth;
  704.             _height = stage.stageHeight;
  705.          }
  706.          if(param1)
  707.          {
  708.             resizeMouseCatcher();
  709.             dispatchEvent(param1);
  710.          }
  711.       }
  712.       
  713.       public function get explicitHeight() : Number
  714.       {
  715.          return _explicitHeight;
  716.       }
  717.       
  718.       mx_internal function set topMostIndex(param1:int) : void
  719.       {
  720.          var _loc2_:int = 0;
  721.          _loc2_ = param1 - _topMostIndex;
  722.          _topMostIndex = param1;
  723.          mx_internal::toolTipIndex += _loc2_;
  724.       }
  725.       
  726.       override public function getChildByName(param1:String) : DisplayObject
  727.       {
  728.          return super.getChildByName(param1);
  729.       }
  730.       
  731.       override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  732.       {
  733.          ++mx_internal::noTopMostIndex;
  734.          return mx_internal::rawChildren_addChildAt(param1,mx_internal::applicationIndex + param2);
  735.       }
  736.       
  737.       public function isTopLevel() : Boolean
  738.       {
  739.          return topLevel;
  740.       }
  741.       
  742.       public function deactivate(param1:IFocusManagerContainer) : void
  743.       {
  744.          var _loc2_:IFocusManagerContainer = null;
  745.          var _loc3_:int = 0;
  746.          var _loc4_:int = 0;
  747.          var _loc5_:IFocusManagerContainer = null;
  748.          if(form)
  749.          {
  750.             if(form == param1 && forms.length > 1)
  751.             {
  752.                form.focusManager.deactivate();
  753.                _loc3_ = int(forms.length);
  754.                _loc4_ = 0;
  755.                while(_loc4_ < _loc3_)
  756.                {
  757.                   if((_loc5_ = forms[_loc4_]) == param1)
  758.                   {
  759.                      _loc4_ += 1;
  760.                      while(_loc4_ < _loc3_)
  761.                      {
  762.                         _loc5_ = forms[_loc4_];
  763.                         if(Sprite(_loc5_).visible == true && IUIComponent(_loc5_).enabled)
  764.                         {
  765.                            _loc2_ = _loc5_;
  766.                         }
  767.                         _loc4_++;
  768.                      }
  769.                      form = _loc2_;
  770.                      break;
  771.                   }
  772.                   if(Sprite(_loc5_).visible && IUIComponent(_loc5_).enabled)
  773.                   {
  774.                      _loc2_ = _loc5_;
  775.                   }
  776.                   _loc4_++;
  777.                }
  778.                if(form)
  779.                {
  780.                   form.focusManager.activate();
  781.                }
  782.             }
  783.          }
  784.       }
  785.       
  786.       public function getExplicitOrMeasuredWidth() : Number
  787.       {
  788.          return !isNaN(explicitWidth) ? explicitWidth : measuredWidth;
  789.       }
  790.       
  791.       public function info() : Object
  792.       {
  793.          return {};
  794.       }
  795.       
  796.       public function get measuredWidth() : Number
  797.       {
  798.          return !!mx_internal::topLevelWindow ? mx_internal::topLevelWindow.getExplicitOrMeasuredWidth() : loaderInfo.width;
  799.       }
  800.       
  801.       mx_internal function get toolTipIndex() : int
  802.       {
  803.          return _toolTipIndex;
  804.       }
  805.       
  806.       public function setActualSize(param1:Number, param2:Number) : void
  807.       {
  808.          if(isStageRoot)
  809.          {
  810.             return;
  811.          }
  812.          _width = param1;
  813.          _height = param2;
  814.          if(mouseCatcher)
  815.          {
  816.             mouseCatcher.width = param1;
  817.             mouseCatcher.height = param2;
  818.          }
  819.          dispatchEvent(new Event(Event.RESIZE));
  820.       }
  821.       
  822.       mx_internal function set applicationIndex(param1:int) : void
  823.       {
  824.          _applicationIndex = param1;
  825.       }
  826.       
  827.       public function set focusPane(param1:Sprite) : void
  828.       {
  829.          if(param1)
  830.          {
  831.             addChild(param1);
  832.             param1.x = 0;
  833.             param1.y = 0;
  834.             param1.scrollRect = null;
  835.             _focusPane = param1;
  836.          }
  837.          else
  838.          {
  839.             removeChild(_focusPane);
  840.             _focusPane = null;
  841.          }
  842.       }
  843.       
  844.       private function executeCallbacks() : void
  845.       {
  846.          var _loc1_:Function = null;
  847.          if(!parent)
  848.          {
  849.             return;
  850.          }
  851.          while(initCallbackFunctions.length > 0)
  852.          {
  853.             _loc1_ = initCallbackFunctions.shift();
  854.             _loc1_(this);
  855.          }
  856.       }
  857.       
  858.       override public function addChild(param1:DisplayObject) : DisplayObject
  859.       {
  860.          ++mx_internal::noTopMostIndex;
  861.          return mx_internal::rawChildren_addChildAt(param1,mx_internal::noTopMostIndex - 1);
  862.       }
  863.       
  864.       public function set explicitHeight(param1:Number) : void
  865.       {
  866.          _explicitHeight = param1;
  867.       }
  868.       
  869.       override public function removeChild(param1:DisplayObject) : DisplayObject
  870.       {
  871.          --mx_internal::noTopMostIndex;
  872.          return mx_internal::rawChildren_removeChild(param1);
  873.       }
  874.       
  875.       mx_internal function rawChildren_removeChild(param1:DisplayObject) : DisplayObject
  876.       {
  877.          mx_internal::removingChild(param1);
  878.          super.removeChild(param1);
  879.          mx_internal::childRemoved(param1);
  880.          return param1;
  881.       }
  882.       
  883.       final mx_internal function get $numChildren() : int
  884.       {
  885.          return super.numChildren;
  886.       }
  887.       
  888.       override public function get stage() : Stage
  889.       {
  890.          var _loc1_:Stage = null;
  891.          _loc1_ = super.stage;
  892.          if(_loc1_)
  893.          {
  894.             return _loc1_;
  895.          }
  896.          if(!topLevel && Boolean(_topLevelSystemManager))
  897.          {
  898.             return _topLevelSystemManager.stage;
  899.          }
  900.          return null;
  901.       }
  902.       
  903.       public function create(... rest) : Object
  904.       {
  905.          var _loc2_:String = null;
  906.          var _loc3_:Class = null;
  907.          var _loc4_:String = null;
  908.          var _loc5_:int = 0;
  909.          var _loc6_:int = 0;
  910.          _loc2_ = String(info()["mainClassName"]);
  911.          if(_loc2_ == null)
  912.          {
  913.             _loc5_ = (_loc4_ = loaderInfo.loaderURL).lastIndexOf(".");
  914.             _loc6_ = _loc4_.lastIndexOf("/");
  915.             _loc2_ = _loc4_.substring(_loc6_ + 1,_loc5_);
  916.          }
  917.          _loc3_ = Class(getDefinitionByName(_loc2_));
  918.          return !!_loc3_ ? new _loc3_() : null;
  919.       }
  920.       
  921.       override public function getChildIndex(param1:DisplayObject) : int
  922.       {
  923.          return super.getChildIndex(param1) - mx_internal::applicationIndex;
  924.       }
  925.       
  926.       public function get popUpChildren() : IChildList
  927.       {
  928.          if(!topLevel)
  929.          {
  930.             return _topLevelSystemManager.popUpChildren;
  931.          }
  932.          if(!_popUpChildren)
  933.          {
  934.             _popUpChildren = new SystemChildrenList(this,new QName(mx_internal,"noTopMostIndex"),new QName(mx_internal,"topMostIndex"));
  935.          }
  936.          return _popUpChildren;
  937.       }
  938.       
  939.       public function activate(param1:IFocusManagerContainer) : void
  940.       {
  941.          var _loc2_:IFocusManagerContainer = null;
  942.          if(form)
  943.          {
  944.             if(form != param1 && forms.length > 1)
  945.             {
  946.                _loc2_ = form;
  947.                _loc2_.focusManager.deactivate();
  948.             }
  949.          }
  950.          form = param1;
  951.          if(param1.focusManager)
  952.          {
  953.             param1.focusManager.activate();
  954.          }
  955.       }
  956.       
  957.       override public function setChildIndex(param1:DisplayObject, param2:int) : void
  958.       {
  959.          super.setChildIndex(param1,mx_internal::applicationIndex + param2);
  960.       }
  961.       
  962.       public function get toolTipChildren() : IChildList
  963.       {
  964.          if(!topLevel)
  965.          {
  966.             return _topLevelSystemManager.toolTipChildren;
  967.          }
  968.          if(!_toolTipChildren)
  969.          {
  970.             _toolTipChildren = new SystemChildrenList(this,new QName(mx_internal,"topMostIndex"),new QName(mx_internal,"toolTipIndex"));
  971.          }
  972.          return _toolTipChildren;
  973.       }
  974.       
  975.       private function deferredNextFrame() : void
  976.       {
  977.          if(currentFrame + 1 > totalFrames)
  978.          {
  979.             return;
  980.          }
  981.          if(currentFrame + 1 <= framesLoaded)
  982.          {
  983.             nextFrame();
  984.          }
  985.          else
  986.          {
  987.             nextFrameTimer = new Timer(100);
  988.             nextFrameTimer.addEventListener(TimerEvent.TIMER,nextFrameTimerHandler);
  989.             nextFrameTimer.start();
  990.          }
  991.       }
  992.       
  993.       mx_internal function get cursorIndex() : int
  994.       {
  995.          return _cursorIndex;
  996.       }
  997.       
  998.       override public function getObjectsUnderPoint(param1:Point) : Array
  999.       {
  1000.          var _loc2_:Array = null;
  1001.          var _loc3_:int = 0;
  1002.          var _loc4_:int = 0;
  1003.          var _loc5_:DisplayObject = null;
  1004.          var _loc6_:Array = null;
  1005.          _loc2_ = [];
  1006.          _loc3_ = mx_internal::topMostIndex;
  1007.          _loc4_ = 0;
  1008.          while(_loc4_ < _loc3_)
  1009.          {
  1010.             if((_loc5_ = super.getChildAt(_loc4_)) is DisplayObjectContainer)
  1011.             {
  1012.                if(_loc6_ = DisplayObjectContainer(_loc5_).getObjectsUnderPoint(param1))
  1013.                {
  1014.                   _loc2_ = _loc2_.concat(_loc6_);
  1015.                }
  1016.             }
  1017.             _loc4_++;
  1018.          }
  1019.          return _loc2_;
  1020.       }
  1021.       
  1022.       mx_internal function rawChildren_contains(param1:DisplayObject) : Boolean
  1023.       {
  1024.          return super.contains(param1);
  1025.       }
  1026.       
  1027.       public function get document() : Object
  1028.       {
  1029.          return _document;
  1030.       }
  1031.       
  1032.       private function resizeMouseCatcher() : void
  1033.       {
  1034.          var _loc1_:Graphics = null;
  1035.          if(mouseCatcher)
  1036.          {
  1037.             _loc1_ = mouseCatcher.graphics;
  1038.             _loc1_.clear();
  1039.             _loc1_.beginFill(0,0);
  1040.             _loc1_.drawRect(0,0,stage.stageWidth,stage.stageHeight);
  1041.             _loc1_.endFill();
  1042.          }
  1043.       }
  1044.       
  1045.       override public function get height() : Number
  1046.       {
  1047.          return _height;
  1048.       }
  1049.       
  1050.       mx_internal function rawChildren_getChildIndex(param1:DisplayObject) : int
  1051.       {
  1052.          return super.getChildIndex(param1);
  1053.       }
  1054.       
  1055.       mx_internal function get topMostIndex() : int
  1056.       {
  1057.          return _topMostIndex;
  1058.       }
  1059.       
  1060.       public function addFocusManager(param1:IFocusManagerContainer) : void
  1061.       {
  1062.          forms.push(param1);
  1063.       }
  1064.       
  1065.       mx_internal function set noTopMostIndex(param1:int) : void
  1066.       {
  1067.          var _loc2_:int = 0;
  1068.          _loc2_ = param1 - _noTopMostIndex;
  1069.          _noTopMostIndex = param1;
  1070.          mx_internal::topMostIndex += _loc2_;
  1071.       }
  1072.       
  1073.       mx_internal function rawChildren_setChildIndex(param1:DisplayObject, param2:int) : void
  1074.       {
  1075.          super.setChildIndex(param1,param2);
  1076.       }
  1077.       
  1078.       private function mouseUpHandler(param1:MouseEvent) : void
  1079.       {
  1080.          mx_internal::idleCounter = 0;
  1081.       }
  1082.       
  1083.       mx_internal function childAdded(param1:DisplayObject) : void
  1084.       {
  1085.          param1.dispatchEvent(new FlexEvent(FlexEvent.ADD));
  1086.          if(param1 is IUIComponent)
  1087.          {
  1088.             IUIComponent(param1).initialize();
  1089.          }
  1090.       }
  1091.       
  1092.       public function isFontFaceEmbedded(param1:TextFormat) : Boolean
  1093.       {
  1094.          var _loc2_:String = null;
  1095.          var _loc3_:Array = null;
  1096.          var _loc4_:int = 0;
  1097.          var _loc5_:Object = null;
  1098.          var _loc6_:Font = null;
  1099.          var _loc7_:String = null;
  1100.          _loc2_ = param1.font;
  1101.          _loc3_ = Font.enumerateFonts();
  1102.          _loc4_ = 0;
  1103.          while(_loc4_ < _loc3_.length)
  1104.          {
  1105.             if((_loc6_ = Font(_loc3_[_loc4_])).fontName == _loc2_)
  1106.             {
  1107.                _loc7_ = "regular";
  1108.                if(Boolean(param1.bold) && Boolean(param1.italic))
  1109.                {
  1110.                   _loc7_ = "boldItalic";
  1111.                }
  1112.                else if(param1.bold)
  1113.                {
  1114.                   _loc7_ = "bold";
  1115.                }
  1116.                else if(param1.italic)
  1117.                {
  1118.                   _loc7_ = "italic";
  1119.                }
  1120.                if(_loc6_.fontStyle == _loc7_)
  1121.                {
  1122.                   return true;
  1123.                }
  1124.             }
  1125.             _loc4_++;
  1126.          }
  1127.          if(!_loc2_ || !embeddedFontList || !embeddedFontList[_loc2_])
  1128.          {
  1129.             return false;
  1130.          }
  1131.          _loc5_ = embeddedFontList[_loc2_];
  1132.          return !(Boolean(param1.bold) && !_loc5_.bold || Boolean(param1.italic) && !_loc5_.italic || !param1.bold && !param1.italic && !_loc5_.regular);
  1133.       }
  1134.       
  1135.       mx_internal function rawChildren_getChildAt(param1:int) : DisplayObject
  1136.       {
  1137.          return super.getChildAt(param1);
  1138.       }
  1139.       
  1140.       override public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  1141.       {
  1142.          if(param1 == FlexEvent.IDLE)
  1143.          {
  1144.             super.removeEventListener(param1,param2,param3);
  1145.             if(!hasEventListener(FlexEvent.IDLE) && Boolean(idleTimer))
  1146.             {
  1147.                idleTimer.stop();
  1148.                idleTimer = null;
  1149.                removeEventListener(MouseEvent.MOUSE_MOVE,mouseMoveHandler);
  1150.                removeEventListener(MouseEvent.MOUSE_UP,mouseUpHandler);
  1151.             }
  1152.          }
  1153.          else
  1154.          {
  1155.             super.removeEventListener(param1,param2,param3);
  1156.          }
  1157.       }
  1158.       
  1159.       override public function removeChildAt(param1:int) : DisplayObject
  1160.       {
  1161.          --mx_internal::noTopMostIndex;
  1162.          return mx_internal::rawChildren_removeChildAt(mx_internal::applicationIndex + param1);
  1163.       }
  1164.       
  1165.       private function extraFrameHandler(param1:Event = null) : void
  1166.       {
  1167.          var _loc2_:Object = null;
  1168.          var _loc3_:Class = null;
  1169.          _loc2_ = info()["frames"];
  1170.          if(Boolean(_loc2_) && Boolean(_loc2_[currentLabel]))
  1171.          {
  1172.             _loc3_ = Class(getDefinitionByName(_loc2_[currentLabel]));
  1173.             _loc3_["frame"](this);
  1174.          }
  1175.          deferredNextFrame();
  1176.       }
  1177.       
  1178.       public function get application() : IUIComponent
  1179.       {
  1180.          return IUIComponent(_document);
  1181.       }
  1182.       
  1183.       mx_internal function rawChildren_removeChildAt(param1:int) : DisplayObject
  1184.       {
  1185.          var _loc2_:DisplayObject = null;
  1186.          _loc2_ = super.getChildAt(param1);
  1187.          mx_internal::removingChild(_loc2_);
  1188.          super.removeChildAt(param1);
  1189.          mx_internal::childRemoved(_loc2_);
  1190.          return _loc2_;
  1191.       }
  1192.       
  1193.       mx_internal function removingChild(param1:DisplayObject) : void
  1194.       {
  1195.          param1.dispatchEvent(new FlexEvent(FlexEvent.REMOVE));
  1196.       }
  1197.       
  1198.       mx_internal function get applicationIndex() : int
  1199.       {
  1200.          return _applicationIndex;
  1201.       }
  1202.       
  1203.       mx_internal function set toolTipIndex(param1:int) : void
  1204.       {
  1205.          var _loc2_:int = 0;
  1206.          _loc2_ = param1 - _toolTipIndex;
  1207.          _toolTipIndex = param1;
  1208.          mx_internal::cursorIndex += _loc2_;
  1209.       }
  1210.       
  1211.       public function get cursorChildren() : IChildList
  1212.       {
  1213.          if(!topLevel)
  1214.          {
  1215.             return _topLevelSystemManager.cursorChildren;
  1216.          }
  1217.          if(!_cursorChildren)
  1218.          {
  1219.             _cursorChildren = new SystemChildrenList(this,new QName(mx_internal,"toolTipIndex"),new QName(mx_internal,"cursorIndex"));
  1220.          }
  1221.          return _cursorChildren;
  1222.       }
  1223.       
  1224.       public function get preloaderBackgroundImage() : Object
  1225.       {
  1226.          return info()["backgroundImage"];
  1227.       }
  1228.       
  1229.       public function set numModalWindows(param1:int) : void
  1230.       {
  1231.          _numModalWindows = param1;
  1232.       }
  1233.       
  1234.       public function get preloaderBackgroundAlpha() : Number
  1235.       {
  1236.          return info()["backgroundAlpha"];
  1237.       }
  1238.       
  1239.       private function preloader_preloaderDoneHandler(param1:Event) : void
  1240.       {
  1241.          var _loc2_:IUIComponent = null;
  1242.          _loc2_ = mx_internal::topLevelWindow;
  1243.          preloader.removeEventListener(FlexEvent.PRELOADER_DONE,preloader_preloaderDoneHandler);
  1244.          _popUpChildren.removeChild(preloader);
  1245.          mouseCatcher = new FlexSprite();
  1246.          mouseCatcher.name = "mouseCatcher";
  1247.          ++mx_internal::noTopMostIndex;
  1248.          super.addChildAt(mouseCatcher,0);
  1249.          resizeMouseCatcher();
  1250.          if(!topLevel)
  1251.          {
  1252.             mouseCatcher.visible = false;
  1253.             mask = mouseCatcher;
  1254.          }
  1255.          ++mx_internal::noTopMostIndex;
  1256.          super.addChildAt(DisplayObject(_loc2_),1);
  1257.          _loc2_.dispatchEvent(new FlexEvent(FlexEvent.APPLICATION_COMPLETE));
  1258.          dispatchEvent(new FlexEvent(FlexEvent.APPLICATION_COMPLETE));
  1259.       }
  1260.       
  1261.       mx_internal function rawChildren_getChildByName(param1:String) : DisplayObject
  1262.       {
  1263.          return super.getChildByName(param1);
  1264.       }
  1265.       
  1266.       mx_internal function initialize() : void
  1267.       {
  1268.          var _loc1_:Array = null;
  1269.          var _loc2_:Array = null;
  1270.          var _loc3_:Array = null;
  1271.          var _loc4_:int = 0;
  1272.          var _loc5_:Boolean = false;
  1273.          var _loc6_:Class = null;
  1274.          if(isStageRoot)
  1275.          {
  1276.             _width = stage.stageWidth;
  1277.             _height = stage.stageHeight;
  1278.          }
  1279.          else
  1280.          {
  1281.             _width = loaderInfo.width;
  1282.             _height = loaderInfo.height;
  1283.          }
  1284.          preloader = new Preloader();
  1285.          preloader.addEventListener(FlexEvent.INIT_PROGRESS,preloader_initProgressHandler);
  1286.          preloader.addEventListener(FlexEvent.PRELOADER_DONE,preloader_preloaderDoneHandler);
  1287.          if(!_popUpChildren)
  1288.          {
  1289.             _popUpChildren = new SystemChildrenList(this,new QName(mx_internal,"noTopMostIndex"),new QName(mx_internal,"topMostIndex"));
  1290.          }
  1291.          _popUpChildren.addChild(preloader);
  1292.          _loc1_ = [];
  1293.          _loc2_ = [];
  1294.          _loc3_ = info()["rsls"];
  1295.          _loc4_ = 0;
  1296.          while(Boolean(_loc3_) && _loc4_ < _loc3_.length)
  1297.          {
  1298.             _loc1_[_loc4_] = _loc3_[_loc4_].url;
  1299.             _loc2_[_loc4_] = _loc3_[_loc4_].size;
  1300.             _loc4_++;
  1301.          }
  1302.          _loc5_ = true;
  1303.          if(info()["usePreloader"] != undefined)
  1304.          {
  1305.             _loc5_ = Boolean(info()["usePreloader"]);
  1306.          }
  1307.          _loc6_ = info()["preloader"] as Class;
  1308.          if(_loc5_ && !_loc6_)
  1309.          {
  1310.             _loc6_ = DownloadProgressBar;
  1311.          }
  1312.          preloader.initialize(_loc5_,_loc6_,preloaderBackgroundColor,preloaderBackgroundAlpha,preloaderBackgroundImage,preloaderBackgroundSize,isStageRoot ? stage.stageWidth : loaderInfo.width,isStageRoot ? stage.stageHeight : loaderInfo.height,_loc1_,_loc2_);
  1313.       }
  1314.       
  1315.       private function appCreationCompleteHandler(param1:FlexEvent) : void
  1316.       {
  1317.          var _loc2_:DisplayObjectContainer = null;
  1318.          if(!topLevel && Boolean(parent))
  1319.          {
  1320.             _loc2_ = parent.parent;
  1321.             while(_loc2_)
  1322.             {
  1323.                if(_loc2_ is IInvalidating)
  1324.                {
  1325.                   IInvalidating(_loc2_).invalidateSize();
  1326.                   IInvalidating(_loc2_).invalidateDisplayList();
  1327.                   return;
  1328.                }
  1329.                _loc2_ = _loc2_.parent;
  1330.             }
  1331.          }
  1332.       }
  1333.       
  1334.       public function get measuredHeight() : Number
  1335.       {
  1336.          return !!mx_internal::topLevelWindow ? mx_internal::topLevelWindow.getExplicitOrMeasuredHeight() : loaderInfo.height;
  1337.       }
  1338.       
  1339.       mx_internal function regenerateStyleCache(param1:Boolean) : void
  1340.       {
  1341.          var _loc2_:Boolean = false;
  1342.          var _loc3_:int = 0;
  1343.          var _loc4_:int = 0;
  1344.          var _loc5_:IStyleClient = null;
  1345.          _loc2_ = false;
  1346.          _loc3_ = rawChildren.numChildren;
  1347.          _loc4_ = 0;
  1348.          while(_loc4_ < _loc3_)
  1349.          {
  1350.             if(_loc5_ = rawChildren.getChildAt(_loc4_) as IStyleClient)
  1351.             {
  1352.                _loc5_.regenerateStyleCache(param1);
  1353.             }
  1354.             if(isTopLevelWindow(DisplayObject(_loc5_)))
  1355.             {
  1356.                _loc2_ = true;
  1357.             }
  1358.             _loc3_ = rawChildren.numChildren;
  1359.             _loc4_++;
  1360.          }
  1361.          if(!_loc2_ && mx_internal::topLevelWindow is IStyleClient)
  1362.          {
  1363.             IStyleClient(mx_internal::topLevelWindow).regenerateStyleCache(param1);
  1364.          }
  1365.       }
  1366.       
  1367.       public function get topLevelSystemManager() : ISystemManager
  1368.       {
  1369.          if(topLevel)
  1370.          {
  1371.             return this;
  1372.          }
  1373.          return _topLevelSystemManager;
  1374.       }
  1375.       
  1376.       private function nextFrameTimerHandler(param1:TimerEvent) : void
  1377.       {
  1378.          if(currentFrame + 1 <= framesLoaded)
  1379.          {
  1380.             nextFrame();
  1381.             nextFrameTimer.removeEventListener(TimerEvent.TIMER,nextFrameTimerHandler);
  1382.             nextFrameTimer.reset();
  1383.          }
  1384.       }
  1385.       
  1386.       public function get preloaderBackgroundColor() : uint
  1387.       {
  1388.          var _loc1_:* = undefined;
  1389.          _loc1_ = info()["backgroundColor"];
  1390.          if(_loc1_ == undefined)
  1391.          {
  1392.             return 4294967295;
  1393.          }
  1394.          return uint(_loc1_);
  1395.       }
  1396.       
  1397.       mx_internal function childRemoved(param1:DisplayObject) : void
  1398.       {
  1399.          if(param1 is IUIComponent)
  1400.          {
  1401.             IUIComponent(param1).parentChanged(null);
  1402.          }
  1403.       }
  1404.       
  1405.       override public function get numChildren() : int
  1406.       {
  1407.          return mx_internal::noTopMostIndex - mx_internal::applicationIndex;
  1408.       }
  1409.       
  1410.       mx_internal function get noTopMostIndex() : int
  1411.       {
  1412.          return _noTopMostIndex;
  1413.       }
  1414.       
  1415.       mx_internal function rawChildren_addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  1416.       {
  1417.          mx_internal::addingChild(param1);
  1418.          super.addChildAt(param1,param2);
  1419.          mx_internal::childAdded(param1);
  1420.          return param1;
  1421.       }
  1422.       
  1423.       public function get numModalWindows() : int
  1424.       {
  1425.          return _numModalWindows;
  1426.       }
  1427.       
  1428.       private function initializeTopLevelWindow(param1:Event) : void
  1429.       {
  1430.          var _loc2_:IUIComponent = null;
  1431.          var _loc3_:DisplayObjectContainer = null;
  1432.          initialized = true;
  1433.          if(!parent)
  1434.          {
  1435.             return;
  1436.          }
  1437.          if(!topLevel)
  1438.          {
  1439.             _loc3_ = parent.parent;
  1440.             if(!_loc3_)
  1441.             {
  1442.                return;
  1443.             }
  1444.             while(_loc3_)
  1445.             {
  1446.                if(_loc3_ is IUIComponent)
  1447.                {
  1448.                   _topLevelSystemManager = IUIComponent(_loc3_).systemManager;
  1449.                   break;
  1450.                }
  1451.                _loc3_ = _loc3_.parent;
  1452.             }
  1453.          }
  1454.          addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler,true);
  1455.          if(topLevel && Boolean(stage))
  1456.          {
  1457.             stage.addEventListener(Event.RESIZE,Stage_resizeHandler,false,0,true);
  1458.          }
  1459.          document = _loc2_ = mx_internal::topLevelWindow = IUIComponent(create());
  1460.          if(document)
  1461.          {
  1462.             IEventDispatcher(_loc2_).addEventListener(FlexEvent.CREATION_COMPLETE,appCreationCompleteHandler);
  1463.             if(topLevel && Boolean(stage))
  1464.             {
  1465.                LoaderConfig.mx_internal::_url = loaderInfo.url;
  1466.                LoaderConfig.mx_internal::_parameters = loaderInfo.parameters;
  1467.                _width = stage.stageWidth;
  1468.                _height = stage.stageHeight;
  1469.                IFlexDisplayObject(_loc2_).setActualSize(stage.stageWidth,stage.stageHeight);
  1470.             }
  1471.             else
  1472.             {
  1473.                IFlexDisplayObject(_loc2_).setActualSize(loaderInfo.width,loaderInfo.height);
  1474.             }
  1475.             preloader.registerApplication(_loc2_);
  1476.             mx_internal::addingChild(DisplayObject(_loc2_));
  1477.             mx_internal::childAdded(DisplayObject(_loc2_));
  1478.          }
  1479.          else
  1480.          {
  1481.             document = this;
  1482.          }
  1483.       }
  1484.       
  1485.       override public function get width() : Number
  1486.       {
  1487.          return _width;
  1488.       }
  1489.       
  1490.       public function isTopLevelWindow(param1:DisplayObject) : Boolean
  1491.       {
  1492.          return param1 is IUIComponent && IUIComponent(param1) == mx_internal::topLevelWindow;
  1493.       }
  1494.       
  1495.       public function move(param1:Number, param2:Number) : void
  1496.       {
  1497.       }
  1498.       
  1499.       public function set explicitWidth(param1:Number) : void
  1500.       {
  1501.          _explicitWidth = param1;
  1502.       }
  1503.       
  1504.       private function preloader_initProgressHandler(param1:Event) : void
  1505.       {
  1506.          preloader.removeEventListener(FlexEvent.INIT_PROGRESS,preloader_initProgressHandler);
  1507.          deferredNextFrame();
  1508.       }
  1509.       
  1510.       public function get explicitWidth() : Number
  1511.       {
  1512.          return _explicitWidth;
  1513.       }
  1514.    }
  1515. }
  1516.