home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / core / Container.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  85.2 KB  |  2,469 lines
  1. package mx.core
  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.Shape;
  9.    import flash.display.Sprite;
  10.    import flash.events.Event;
  11.    import flash.events.KeyboardEvent;
  12.    import flash.events.MouseEvent;
  13.    import flash.geom.Point;
  14.    import flash.geom.Rectangle;
  15.    import flash.text.TextField;
  16.    import flash.text.TextLineMetrics;
  17.    import flash.ui.Keyboard;
  18.    import flash.utils.getDefinitionByName;
  19.    import mx.binding.BindingManager;
  20.    import mx.controls.HScrollBar;
  21.    import mx.controls.VScrollBar;
  22.    import mx.controls.listClasses.IListItemRenderer;
  23.    import mx.controls.scrollClasses.ScrollBar;
  24.    import mx.events.ChildExistenceChangedEvent;
  25.    import mx.events.FlexEvent;
  26.    import mx.events.IndexChangedEvent;
  27.    import mx.events.ScrollEvent;
  28.    import mx.events.ScrollEventDetail;
  29.    import mx.events.ScrollEventDirection;
  30.    import mx.graphics.RoundedRectangle;
  31.    import mx.managers.IFocusManager;
  32.    import mx.managers.IFocusManagerContainer;
  33.    import mx.managers.ILayoutManagerClient;
  34.    import mx.managers.ISystemManager;
  35.    import mx.styles.CSSStyleDeclaration;
  36.    import mx.styles.ISimpleStyleClient;
  37.    import mx.styles.IStyleClient;
  38.    import mx.styles.StyleManager;
  39.    import mx.styles.StyleProtoChain;
  40.    
  41.    use namespace mx_internal;
  42.    
  43.    public class Container extends UIComponent implements IContainer, IDataRenderer, IFocusManagerContainer, IListItemRenderer, IRawChildrenContainer
  44.    {
  45.       mx_internal static const VERSION:String = "3.2.0.3958";
  46.       
  47.       private static const MULTIPLE_PROPERTIES:String = "<MULTIPLE>";
  48.       
  49.       private var forceLayout:Boolean = false;
  50.       
  51.       private var _numChildrenCreated:int = -1;
  52.       
  53.       private var _horizontalLineScrollSize:Number = 5;
  54.       
  55.       mx_internal var border:IFlexDisplayObject;
  56.       
  57.       protected var actualCreationPolicy:String;
  58.       
  59.       private var _viewMetricsAndPadding:EdgeMetrics;
  60.       
  61.       private var _creatingContentPane:Boolean = false;
  62.       
  63.       private var _childRepeaters:Array;
  64.       
  65.       private var scrollableWidth:Number = 0;
  66.       
  67.       private var _childDescriptors:Array;
  68.       
  69.       private var _rawChildren:ContainerRawChildrenList;
  70.       
  71.       private var _data:Object;
  72.       
  73.       private var _verticalPageScrollSize:Number = 0;
  74.       
  75.       private var _viewMetrics:EdgeMetrics;
  76.       
  77.       private var _verticalScrollBar:ScrollBar;
  78.       
  79.       private var scrollPropertiesChanged:Boolean = false;
  80.       
  81.       private var changedStyles:String = null;
  82.       
  83.       private var scrollPositionChanged:Boolean = true;
  84.       
  85.       private var _defaultButton:IFlexDisplayObject;
  86.       
  87.       private var mouseEventReferenceCount:int = 0;
  88.       
  89.       private var _focusPane:Sprite;
  90.       
  91.       protected var whiteBox:Shape;
  92.       
  93.       private var _forceClippingCount:int;
  94.       
  95.       private var _horizontalPageScrollSize:Number = 0;
  96.       
  97.       private var _creationPolicy:String;
  98.       
  99.       private var _creationIndex:int = -1;
  100.       
  101.       private var _clipContent:Boolean = true;
  102.       
  103.       private var _verticalScrollPosition:Number = 0;
  104.       
  105.       private var _autoLayout:Boolean = true;
  106.       
  107.       private var _icon:Class = null;
  108.       
  109.       mx_internal var doingLayout:Boolean = false;
  110.       
  111.       private var _horizontalScrollBar:ScrollBar;
  112.       
  113.       private var numChildrenBefore:int;
  114.       
  115.       private var viewableHeight:Number = 0;
  116.       
  117.       private var viewableWidth:Number = 0;
  118.       
  119.       mx_internal var contentPane:Sprite = null;
  120.       
  121.       private var _createdComponents:Array;
  122.       
  123.       private var _firstChildIndex:int = 0;
  124.       
  125.       private var scrollableHeight:Number = 0;
  126.       
  127.       private var _verticalLineScrollSize:Number = 5;
  128.       
  129.       private var _horizontalScrollPosition:Number = 0;
  130.       
  131.       mx_internal var _horizontalScrollPolicy:String = "auto";
  132.       
  133.       private var verticalScrollPositionPending:Number;
  134.       
  135.       mx_internal var _verticalScrollPolicy:String = "auto";
  136.       
  137.       private var horizontalScrollPositionPending:Number;
  138.       
  139.       mx_internal var _numChildren:int = 0;
  140.       
  141.       private var recursionFlag:Boolean = true;
  142.       
  143.       private var _label:String = "";
  144.       
  145.       mx_internal var blocker:Sprite;
  146.       
  147.       public function Container()
  148.       {
  149.          super();
  150.          tabChildren = true;
  151.          tabEnabled = false;
  152.          showInAutomationHierarchy = false;
  153.       }
  154.       
  155.       public function set verticalScrollPolicy(param1:String) : void
  156.       {
  157.          if(mx_internal::_verticalScrollPolicy != param1)
  158.          {
  159.             mx_internal::_verticalScrollPolicy = param1;
  160.             invalidateDisplayList();
  161.             dispatchEvent(new Event("verticalScrollPolicyChanged"));
  162.          }
  163.       }
  164.       
  165.       private function createContentPaneAndScrollbarsIfNeeded() : Boolean
  166.       {
  167.          var _loc1_:Rectangle = null;
  168.          var _loc2_:Boolean = false;
  169.          if(_clipContent)
  170.          {
  171.             _loc1_ = mx_internal::getScrollableRect();
  172.             _loc2_ = createScrollbarsIfNeeded(_loc1_);
  173.             if(mx_internal::border)
  174.             {
  175.                updateBackgroundImageRect();
  176.             }
  177.             return _loc2_;
  178.          }
  179.          _loc2_ = createOrDestroyScrollbars(false,false,false);
  180.          _loc1_ = mx_internal::getScrollableRect();
  181.          scrollableWidth = _loc1_.right;
  182.          scrollableHeight = _loc1_.bottom;
  183.          if(_loc2_ && Boolean(mx_internal::border))
  184.          {
  185.             updateBackgroundImageRect();
  186.          }
  187.          return _loc2_;
  188.       }
  189.       
  190.       override protected function initializationComplete() : void
  191.       {
  192.       }
  193.       
  194.       mx_internal function rawChildren_getObjectsUnderPoint(param1:Point) : Array
  195.       {
  196.          return super.getObjectsUnderPoint(param1);
  197.       }
  198.       
  199.       public function set creatingContentPane(param1:Boolean) : void
  200.       {
  201.          _creatingContentPane = param1;
  202.       }
  203.       
  204.       public function set clipContent(param1:Boolean) : void
  205.       {
  206.          if(_clipContent != param1)
  207.          {
  208.             _clipContent = param1;
  209.             invalidateDisplayList();
  210.          }
  211.       }
  212.       
  213.       protected function scrollChildren() : void
  214.       {
  215.          if(!mx_internal::contentPane)
  216.          {
  217.             return;
  218.          }
  219.          var _loc1_:EdgeMetrics = viewMetrics;
  220.          var _loc2_:Number = 0;
  221.          var _loc3_:Number = 0;
  222.          var _loc4_:Number = unscaledWidth - _loc1_.left - _loc1_.right;
  223.          var _loc5_:Number = unscaledHeight - _loc1_.top - _loc1_.bottom;
  224.          if(_clipContent)
  225.          {
  226.             _loc2_ += _horizontalScrollPosition;
  227.             if(horizontalScrollBar)
  228.             {
  229.                _loc4_ = viewableWidth;
  230.             }
  231.             _loc3_ += _verticalScrollPosition;
  232.             if(verticalScrollBar)
  233.             {
  234.                _loc5_ = viewableHeight;
  235.             }
  236.          }
  237.          else
  238.          {
  239.             _loc4_ = scrollableWidth;
  240.             _loc5_ = scrollableHeight;
  241.          }
  242.          var _loc6_:Rectangle = mx_internal::getScrollableRect();
  243.          if(_loc2_ == 0 && _loc3_ == 0 && _loc4_ >= _loc6_.right && _loc5_ >= _loc6_.bottom && _loc6_.left >= 0 && _loc6_.top >= 0 && _forceClippingCount <= 0)
  244.          {
  245.             mx_internal::contentPane.scrollRect = null;
  246.             mx_internal::contentPane.opaqueBackground = null;
  247.             mx_internal::contentPane.cacheAsBitmap = false;
  248.          }
  249.          else
  250.          {
  251.             mx_internal::contentPane.scrollRect = new Rectangle(_loc2_,_loc3_,_loc4_,_loc5_);
  252.          }
  253.          if(focusPane)
  254.          {
  255.             focusPane.scrollRect = mx_internal::contentPane.scrollRect;
  256.          }
  257.          if(mx_internal::border && mx_internal::border is IRectangularBorder && IRectangularBorder(mx_internal::border).hasBackgroundImage)
  258.          {
  259.             IRectangularBorder(mx_internal::border).layoutBackgroundImage();
  260.          }
  261.       }
  262.       
  263.       override public function set doubleClickEnabled(param1:Boolean) : void
  264.       {
  265.          var _loc2_:int = 0;
  266.          var _loc3_:int = 0;
  267.          var _loc4_:InteractiveObject = null;
  268.          super.doubleClickEnabled = param1;
  269.          if(mx_internal::contentPane)
  270.          {
  271.             _loc2_ = mx_internal::contentPane.numChildren;
  272.             _loc3_ = 0;
  273.             while(_loc3_ < _loc2_)
  274.             {
  275.                _loc4_ = mx_internal::contentPane.getChildAt(_loc3_) as InteractiveObject;
  276.                if(_loc4_)
  277.                {
  278.                   _loc4_.doubleClickEnabled = param1;
  279.                }
  280.                _loc3_++;
  281.             }
  282.          }
  283.       }
  284.       
  285.       override public function notifyStyleChangeInChildren(param1:String, param2:Boolean) : void
  286.       {
  287.          var _loc5_:ISimpleStyleClient = null;
  288.          var _loc3_:int = super.numChildren;
  289.          var _loc4_:int = 0;
  290.          while(_loc4_ < _loc3_)
  291.          {
  292.             if(mx_internal::contentPane || _loc4_ < _firstChildIndex || _loc4_ >= _firstChildIndex + mx_internal::_numChildren)
  293.             {
  294.                _loc5_ = super.getChildAt(_loc4_) as ISimpleStyleClient;
  295.                if(_loc5_)
  296.                {
  297.                   _loc5_.styleChanged(param1);
  298.                   if(_loc5_ is IStyleClient)
  299.                   {
  300.                      IStyleClient(_loc5_).notifyStyleChangeInChildren(param1,param2);
  301.                   }
  302.                }
  303.             }
  304.             _loc4_++;
  305.          }
  306.          if(param2)
  307.          {
  308.             changedStyles = changedStyles != null || param1 == null ? MULTIPLE_PROPERTIES : param1;
  309.             invalidateProperties();
  310.          }
  311.       }
  312.       
  313.       mx_internal function get createdComponents() : Array
  314.       {
  315.          return _createdComponents;
  316.       }
  317.       
  318.       public function get childDescriptors() : Array
  319.       {
  320.          return _childDescriptors;
  321.       }
  322.       
  323.       override public function get contentMouseY() : Number
  324.       {
  325.          if(mx_internal::contentPane)
  326.          {
  327.             return mx_internal::contentPane.mouseY;
  328.          }
  329.          return super.contentMouseY;
  330.       }
  331.       
  332.       mx_internal function get childRepeaters() : Array
  333.       {
  334.          return _childRepeaters;
  335.       }
  336.       
  337.       override public function contains(param1:DisplayObject) : Boolean
  338.       {
  339.          if(mx_internal::contentPane)
  340.          {
  341.             return mx_internal::contentPane.contains(param1);
  342.          }
  343.          return super.contains(param1);
  344.       }
  345.       
  346.       override public function get contentMouseX() : Number
  347.       {
  348.          if(mx_internal::contentPane)
  349.          {
  350.             return mx_internal::contentPane.mouseX;
  351.          }
  352.          return super.contentMouseX;
  353.       }
  354.       
  355.       mx_internal function set createdComponents(param1:Array) : void
  356.       {
  357.          _createdComponents = param1;
  358.       }
  359.       
  360.       public function get horizontalScrollBar() : ScrollBar
  361.       {
  362.          return _horizontalScrollBar;
  363.       }
  364.       
  365.       override public function validateSize(param1:Boolean = false) : void
  366.       {
  367.          var _loc2_:int = 0;
  368.          var _loc3_:int = 0;
  369.          var _loc4_:DisplayObject = null;
  370.          if(autoLayout == false && forceLayout == false)
  371.          {
  372.             if(param1)
  373.             {
  374.                _loc2_ = super.numChildren;
  375.                _loc3_ = 0;
  376.                while(_loc3_ < _loc2_)
  377.                {
  378.                   _loc4_ = super.getChildAt(_loc3_);
  379.                   if(_loc4_ is ILayoutManagerClient)
  380.                   {
  381.                      ILayoutManagerClient(_loc4_).validateSize(true);
  382.                   }
  383.                   _loc3_++;
  384.                }
  385.             }
  386.             mx_internal::adjustSizesForScaleChanges();
  387.          }
  388.          else
  389.          {
  390.             super.validateSize(param1);
  391.          }
  392.       }
  393.       
  394.       public function get rawChildren() : IChildList
  395.       {
  396.          if(!_rawChildren)
  397.          {
  398.             _rawChildren = new ContainerRawChildrenList(this);
  399.          }
  400.          return _rawChildren;
  401.       }
  402.       
  403.       override public function getChildAt(param1:int) : DisplayObject
  404.       {
  405.          if(mx_internal::contentPane)
  406.          {
  407.             return mx_internal::contentPane.getChildAt(param1);
  408.          }
  409.          return super.getChildAt(_firstChildIndex + param1);
  410.       }
  411.       
  412.       override protected function attachOverlay() : void
  413.       {
  414.          mx_internal::rawChildren_addChild(mx_internal::overlay);
  415.       }
  416.       
  417.       override public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  418.       {
  419.          super.addEventListener(param1,param2,param3,param4,param5);
  420.          if(param1 == MouseEvent.CLICK || param1 == MouseEvent.DOUBLE_CLICK || param1 == MouseEvent.MOUSE_DOWN || param1 == MouseEvent.MOUSE_MOVE || param1 == MouseEvent.MOUSE_OVER || param1 == MouseEvent.MOUSE_OUT || param1 == MouseEvent.MOUSE_UP || param1 == MouseEvent.MOUSE_WHEEL)
  421.          {
  422.             if(mouseEventReferenceCount < 2147483647 && mouseEventReferenceCount++ == 0)
  423.             {
  424.                setStyle("mouseShield",true);
  425.                setStyle("mouseShieldChildren",true);
  426.             }
  427.          }
  428.       }
  429.       
  430.       override public function localToContent(param1:Point) : Point
  431.       {
  432.          if(!mx_internal::contentPane)
  433.          {
  434.             return param1;
  435.          }
  436.          param1 = localToGlobal(param1);
  437.          return globalToContent(param1);
  438.       }
  439.       
  440.       public function executeChildBindings(param1:Boolean) : void
  441.       {
  442.          var _loc4_:IUIComponent = null;
  443.          var _loc2_:int = numChildren;
  444.          var _loc3_:int = 0;
  445.          while(_loc3_ < _loc2_)
  446.          {
  447.             _loc4_ = IUIComponent(getChildAt(_loc3_));
  448.             if(_loc4_ is IDeferredInstantiationUIComponent)
  449.             {
  450.                IDeferredInstantiationUIComponent(_loc4_).executeBindings(param1);
  451.             }
  452.             _loc3_++;
  453.          }
  454.       }
  455.       
  456.       protected function createBorder() : void
  457.       {
  458.          var _loc1_:Class = null;
  459.          if(!mx_internal::border && isBorderNeeded())
  460.          {
  461.             _loc1_ = getStyle("borderSkin");
  462.             if(_loc1_ != null)
  463.             {
  464.                mx_internal::border = new _loc1_();
  465.                mx_internal::border.name = "border";
  466.                if(mx_internal::border is IUIComponent)
  467.                {
  468.                   IUIComponent(mx_internal::border).enabled = enabled;
  469.                }
  470.                if(mx_internal::border is ISimpleStyleClient)
  471.                {
  472.                   ISimpleStyleClient(mx_internal::border).styleName = this;
  473.                }
  474.                rawChildren.addChildAt(DisplayObject(mx_internal::border),0);
  475.                invalidateDisplayList();
  476.             }
  477.          }
  478.       }
  479.       
  480.       [Bindable("viewChanged")]
  481.       [Bindable("scroll")]
  482.       public function get verticalScrollPosition() : Number
  483.       {
  484.          if(!isNaN(verticalScrollPositionPending))
  485.          {
  486.             return verticalScrollPositionPending;
  487.          }
  488.          return _verticalScrollPosition;
  489.       }
  490.       
  491.       [Bindable("viewChanged")]
  492.       [Bindable("scroll")]
  493.       public function get horizontalScrollPosition() : Number
  494.       {
  495.          if(!isNaN(horizontalScrollPositionPending))
  496.          {
  497.             return horizontalScrollPositionPending;
  498.          }
  499.          return _horizontalScrollPosition;
  500.       }
  501.       
  502.       protected function layoutChrome(param1:Number, param2:Number) : void
  503.       {
  504.          if(mx_internal::border)
  505.          {
  506.             updateBackgroundImageRect();
  507.             mx_internal::border.move(0,0);
  508.             mx_internal::border.setActualSize(param1,param2);
  509.          }
  510.       }
  511.       
  512.       mx_internal function set childRepeaters(param1:Array) : void
  513.       {
  514.          _childRepeaters = param1;
  515.       }
  516.       
  517.       override public function get focusPane() : Sprite
  518.       {
  519.          return _focusPane;
  520.       }
  521.       
  522.       public function set creationIndex(param1:int) : void
  523.       {
  524.          _creationIndex = param1;
  525.       }
  526.       
  527.       public function get viewMetrics() : EdgeMetrics
  528.       {
  529.          var _loc1_:EdgeMetrics = borderMetrics;
  530.          var _loc2_:Boolean = verticalScrollBar != null && (mx_internal::doingLayout || verticalScrollPolicy == ScrollPolicy.ON);
  531.          var _loc3_:Boolean = horizontalScrollBar != null && (mx_internal::doingLayout || horizontalScrollPolicy == ScrollPolicy.ON);
  532.          if(!_loc2_ && !_loc3_)
  533.          {
  534.             return _loc1_;
  535.          }
  536.          if(!_viewMetrics)
  537.          {
  538.             _viewMetrics = _loc1_.clone();
  539.          }
  540.          else
  541.          {
  542.             _viewMetrics.left = _loc1_.left;
  543.             _viewMetrics.right = _loc1_.right;
  544.             _viewMetrics.top = _loc1_.top;
  545.             _viewMetrics.bottom = _loc1_.bottom;
  546.          }
  547.          if(_loc2_)
  548.          {
  549.             _viewMetrics.right += verticalScrollBar.minWidth;
  550.          }
  551.          if(_loc3_)
  552.          {
  553.             _viewMetrics.bottom += horizontalScrollBar.minHeight;
  554.          }
  555.          return _viewMetrics;
  556.       }
  557.       
  558.       public function set verticalScrollBar(param1:ScrollBar) : void
  559.       {
  560.          _verticalScrollBar = param1;
  561.       }
  562.       
  563.       public function set verticalScrollPosition(param1:Number) : void
  564.       {
  565.          if(_verticalScrollPosition == param1)
  566.          {
  567.             return;
  568.          }
  569.          _verticalScrollPosition = param1;
  570.          scrollPositionChanged = true;
  571.          if(!initialized)
  572.          {
  573.             verticalScrollPositionPending = param1;
  574.          }
  575.          invalidateDisplayList();
  576.          dispatchEvent(new Event("viewChanged"));
  577.       }
  578.       
  579.       private function createOrDestroyScrollbars(param1:Boolean, param2:Boolean, param3:Boolean) : Boolean
  580.       {
  581.          var _loc5_:IFocusManager = null;
  582.          var _loc6_:String = null;
  583.          var _loc7_:String = null;
  584.          var _loc8_:Graphics = null;
  585.          var _loc4_:Boolean = false;
  586.          if(param1 || param2 || param3)
  587.          {
  588.             mx_internal::createContentPane();
  589.          }
  590.          if(param1)
  591.          {
  592.             if(!horizontalScrollBar)
  593.             {
  594.                horizontalScrollBar = new HScrollBar();
  595.                horizontalScrollBar.name = "horizontalScrollBar";
  596.                _loc6_ = getStyle("horizontalScrollBarStyleName");
  597.                if((Boolean(_loc6_)) && horizontalScrollBar is ISimpleStyleClient)
  598.                {
  599.                   ISimpleStyleClient(horizontalScrollBar).styleName = _loc6_;
  600.                }
  601.                rawChildren.addChild(DisplayObject(horizontalScrollBar));
  602.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  603.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  604.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  605.                horizontalScrollBar.enabled = enabled;
  606.                if(horizontalScrollBar is IInvalidating)
  607.                {
  608.                   IInvalidating(horizontalScrollBar).validateNow();
  609.                }
  610.                invalidateDisplayList();
  611.                mx_internal::invalidateViewMetricsAndPadding();
  612.                _loc4_ = true;
  613.                if(!verticalScrollBar)
  614.                {
  615.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  616.                }
  617.             }
  618.          }
  619.          else if(horizontalScrollBar)
  620.          {
  621.             horizontalScrollBar.removeEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  622.             rawChildren.removeChild(DisplayObject(horizontalScrollBar));
  623.             horizontalScrollBar = null;
  624.             viewableWidth = scrollableWidth = 0;
  625.             if(_horizontalScrollPosition != 0)
  626.             {
  627.                _horizontalScrollPosition = 0;
  628.                scrollPositionChanged = true;
  629.             }
  630.             invalidateDisplayList();
  631.             mx_internal::invalidateViewMetricsAndPadding();
  632.             _loc4_ = true;
  633.             _loc5_ = focusManager;
  634.             if(!verticalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  635.             {
  636.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  637.             }
  638.          }
  639.          if(param2)
  640.          {
  641.             if(!verticalScrollBar)
  642.             {
  643.                verticalScrollBar = new VScrollBar();
  644.                verticalScrollBar.name = "verticalScrollBar";
  645.                _loc7_ = getStyle("verticalScrollBarStyleName");
  646.                if((Boolean(_loc7_)) && verticalScrollBar is ISimpleStyleClient)
  647.                {
  648.                   ISimpleStyleClient(verticalScrollBar).styleName = _loc7_;
  649.                }
  650.                rawChildren.addChild(DisplayObject(verticalScrollBar));
  651.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  652.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  653.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  654.                verticalScrollBar.enabled = enabled;
  655.                if(verticalScrollBar is IInvalidating)
  656.                {
  657.                   IInvalidating(verticalScrollBar).validateNow();
  658.                }
  659.                invalidateDisplayList();
  660.                mx_internal::invalidateViewMetricsAndPadding();
  661.                _loc4_ = true;
  662.                if(!horizontalScrollBar)
  663.                {
  664.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  665.                }
  666.                addEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  667.             }
  668.          }
  669.          else if(verticalScrollBar)
  670.          {
  671.             verticalScrollBar.removeEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  672.             rawChildren.removeChild(DisplayObject(verticalScrollBar));
  673.             verticalScrollBar = null;
  674.             viewableHeight = scrollableHeight = 0;
  675.             if(_verticalScrollPosition != 0)
  676.             {
  677.                _verticalScrollPosition = 0;
  678.                scrollPositionChanged = true;
  679.             }
  680.             invalidateDisplayList();
  681.             mx_internal::invalidateViewMetricsAndPadding();
  682.             _loc4_ = true;
  683.             _loc5_ = focusManager;
  684.             if(!horizontalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  685.             {
  686.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  687.             }
  688.             removeEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  689.          }
  690.          if(Boolean(horizontalScrollBar) && Boolean(verticalScrollBar))
  691.          {
  692.             if(!whiteBox)
  693.             {
  694.                whiteBox = new FlexShape();
  695.                whiteBox.name = "whiteBox";
  696.                _loc8_ = whiteBox.graphics;
  697.                _loc8_.beginFill(16777215);
  698.                _loc8_.drawRect(0,0,verticalScrollBar.minWidth,horizontalScrollBar.minHeight);
  699.                _loc8_.endFill();
  700.                rawChildren.addChild(whiteBox);
  701.             }
  702.          }
  703.          else if(whiteBox)
  704.          {
  705.             rawChildren.removeChild(whiteBox);
  706.             whiteBox = null;
  707.          }
  708.          return _loc4_;
  709.       }
  710.       
  711.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  712.       {
  713.          var _loc3_:String = null;
  714.          var _loc4_:Number = NaN;
  715.          var _loc2_:Object = getFocus();
  716.          if(_loc2_ is TextField)
  717.          {
  718.             return;
  719.          }
  720.          if(verticalScrollBar)
  721.          {
  722.             _loc3_ = ScrollEventDirection.VERTICAL;
  723.             _loc4_ = verticalScrollPosition;
  724.             switch(param1.keyCode)
  725.             {
  726.                case Keyboard.DOWN:
  727.                   verticalScrollPosition += verticalLineScrollSize;
  728.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_DOWN);
  729.                   param1.stopPropagation();
  730.                   break;
  731.                case Keyboard.UP:
  732.                   verticalScrollPosition -= verticalLineScrollSize;
  733.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_UP);
  734.                   param1.stopPropagation();
  735.                   break;
  736.                case Keyboard.PAGE_UP:
  737.                   verticalScrollPosition -= verticalPageScrollSize;
  738.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_UP);
  739.                   param1.stopPropagation();
  740.                   break;
  741.                case Keyboard.PAGE_DOWN:
  742.                   verticalScrollPosition += verticalPageScrollSize;
  743.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_DOWN);
  744.                   param1.stopPropagation();
  745.                   break;
  746.                case Keyboard.HOME:
  747.                   verticalScrollPosition = verticalScrollBar.minScrollPosition;
  748.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_TOP);
  749.                   param1.stopPropagation();
  750.                   break;
  751.                case Keyboard.END:
  752.                   verticalScrollPosition = verticalScrollBar.maxScrollPosition;
  753.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_BOTTOM);
  754.                   param1.stopPropagation();
  755.             }
  756.          }
  757.          if(horizontalScrollBar)
  758.          {
  759.             _loc3_ = ScrollEventDirection.HORIZONTAL;
  760.             _loc4_ = horizontalScrollPosition;
  761.             switch(param1.keyCode)
  762.             {
  763.                case Keyboard.LEFT:
  764.                   horizontalScrollPosition -= horizontalLineScrollSize;
  765.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_LEFT);
  766.                   param1.stopPropagation();
  767.                   break;
  768.                case Keyboard.RIGHT:
  769.                   horizontalScrollPosition += horizontalLineScrollSize;
  770.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_RIGHT);
  771.                   param1.stopPropagation();
  772.             }
  773.          }
  774.       }
  775.       
  776.       [Bindable("iconChanged")]
  777.       public function get icon() : Class
  778.       {
  779.          return _icon;
  780.       }
  781.       
  782.       private function createOrDestroyBlocker() : void
  783.       {
  784.          var _loc1_:DisplayObject = null;
  785.          var _loc2_:ISystemManager = null;
  786.          if(enabled)
  787.          {
  788.             if(mx_internal::blocker)
  789.             {
  790.                rawChildren.removeChild(mx_internal::blocker);
  791.                mx_internal::blocker = null;
  792.             }
  793.          }
  794.          else if(!mx_internal::blocker)
  795.          {
  796.             mx_internal::blocker = new FlexSprite();
  797.             mx_internal::blocker.name = "blocker";
  798.             mx_internal::blocker.mouseEnabled = true;
  799.             rawChildren.addChild(mx_internal::blocker);
  800.             mx_internal::blocker.addEventListener(MouseEvent.CLICK,blocker_clickHandler);
  801.             _loc1_ = !!focusManager ? DisplayObject(focusManager.getFocus()) : null;
  802.             while(_loc1_)
  803.             {
  804.                if(_loc1_ == this)
  805.                {
  806.                   _loc2_ = systemManager;
  807.                   if(Boolean(_loc2_) && Boolean(_loc2_.stage))
  808.                   {
  809.                      _loc2_.stage.focus = null;
  810.                   }
  811.                   break;
  812.                }
  813.                _loc1_ = _loc1_.parent;
  814.             }
  815.          }
  816.       }
  817.       
  818.       private function horizontalScrollBar_scrollHandler(param1:Event) : void
  819.       {
  820.          var _loc2_:Number = NaN;
  821.          if(param1 is ScrollEvent)
  822.          {
  823.             _loc2_ = horizontalScrollPosition;
  824.             horizontalScrollPosition = horizontalScrollBar.scrollPosition;
  825.             dispatchScrollEvent(ScrollEventDirection.HORIZONTAL,_loc2_,horizontalScrollPosition,ScrollEvent(param1).detail);
  826.          }
  827.       }
  828.       
  829.       public function createComponentFromDescriptor(param1:ComponentDescriptor, param2:Boolean) : IFlexDisplayObject
  830.       {
  831.          var _loc7_:String = null;
  832.          var _loc10_:IRepeaterClient = null;
  833.          var _loc11_:IStyleClient = null;
  834.          var _loc12_:String = null;
  835.          var _loc13_:String = null;
  836.          var _loc3_:UIComponentDescriptor = UIComponentDescriptor(param1);
  837.          var _loc4_:Object = _loc3_.properties;
  838.          if((numChildrenBefore != 0 || mx_internal::numChildrenCreated != -1) && _loc3_.mx_internal::instanceIndices == null && hasChildMatchingDescriptor(_loc3_))
  839.          {
  840.             return null;
  841.          }
  842.          UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
  843.          var _loc5_:Class = _loc3_.type;
  844.          var _loc6_:IDeferredInstantiationUIComponent = new _loc5_();
  845.          _loc6_.id = _loc3_.id;
  846.          if(Boolean(_loc6_.id) && _loc6_.id != "")
  847.          {
  848.             _loc6_.name = _loc6_.id;
  849.          }
  850.          _loc6_.descriptor = _loc3_;
  851.          if(Boolean(_loc4_.childDescriptors) && _loc6_ is Container)
  852.          {
  853.             Container(_loc6_)._childDescriptors = _loc4_.childDescriptors;
  854.             delete _loc4_.childDescriptors;
  855.          }
  856.          for(_loc7_ in _loc4_)
  857.          {
  858.             _loc6_[_loc7_] = _loc4_[_loc7_];
  859.          }
  860.          if(_loc6_ is Container)
  861.          {
  862.             Container(_loc6_).recursionFlag = param2;
  863.          }
  864.          if(_loc3_.mx_internal::instanceIndices)
  865.          {
  866.             if(_loc6_ is IRepeaterClient)
  867.             {
  868.                _loc10_ = IRepeaterClient(_loc6_);
  869.                _loc10_.instanceIndices = _loc3_.mx_internal::instanceIndices;
  870.                _loc10_.repeaters = _loc3_.mx_internal::repeaters;
  871.                _loc10_.repeaterIndices = _loc3_.mx_internal::repeaterIndices;
  872.             }
  873.          }
  874.          if(_loc6_ is IStyleClient)
  875.          {
  876.             _loc11_ = IStyleClient(_loc6_);
  877.             if(_loc3_.stylesFactory != null)
  878.             {
  879.                if(!_loc11_.styleDeclaration)
  880.                {
  881.                   _loc11_.styleDeclaration = new CSSStyleDeclaration();
  882.                }
  883.                _loc11_.styleDeclaration.factory = _loc3_.stylesFactory;
  884.             }
  885.          }
  886.          var _loc8_:Object = _loc3_.events;
  887.          if(_loc8_)
  888.          {
  889.             for(_loc12_ in _loc8_)
  890.             {
  891.                _loc13_ = _loc8_[_loc12_];
  892.                _loc6_.addEventListener(_loc12_,_loc3_.document[_loc13_]);
  893.             }
  894.          }
  895.          var _loc9_:Array = _loc3_.effects;
  896.          if(_loc9_)
  897.          {
  898.             _loc6_.registerEffects(_loc9_);
  899.          }
  900.          if(_loc6_ is IRepeaterClient)
  901.          {
  902.             IRepeaterClient(_loc6_).initializeRepeaterArrays(this);
  903.          }
  904.          _loc6_.createReferenceOnParentDocument(IFlexDisplayObject(_loc3_.document));
  905.          if(!_loc6_.document)
  906.          {
  907.             _loc6_.document = _loc3_.document;
  908.          }
  909.          if(_loc6_ is IRepeater)
  910.          {
  911.             if(!mx_internal::childRepeaters)
  912.             {
  913.                mx_internal::childRepeaters = [];
  914.             }
  915.             mx_internal::childRepeaters.push(_loc6_);
  916.             _loc6_.executeBindings();
  917.             IRepeater(_loc6_).initializeRepeater(this,param2);
  918.          }
  919.          else
  920.          {
  921.             addChild(DisplayObject(_loc6_));
  922.             _loc6_.executeBindings();
  923.             if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  924.             {
  925.                _loc6_.addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  926.             }
  927.          }
  928.          return _loc6_;
  929.       }
  930.       
  931.       override public function set enabled(param1:Boolean) : void
  932.       {
  933.          super.enabled = param1;
  934.          if(horizontalScrollBar)
  935.          {
  936.             horizontalScrollBar.enabled = param1;
  937.          }
  938.          if(verticalScrollBar)
  939.          {
  940.             verticalScrollBar.enabled = param1;
  941.          }
  942.          invalidateProperties();
  943.       }
  944.       
  945.       public function set horizontalScrollBar(param1:ScrollBar) : void
  946.       {
  947.          _horizontalScrollBar = param1;
  948.       }
  949.       
  950.       mx_internal function get usePadding() : Boolean
  951.       {
  952.          return true;
  953.       }
  954.       
  955.       override public function get baselinePosition() : Number
  956.       {
  957.          var _loc2_:IUIComponent = null;
  958.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  959.          {
  960.             if(getStyle("verticalAlign") == "top" && numChildren > 0)
  961.             {
  962.                _loc2_ = getChildAt(0) as IUIComponent;
  963.                if(_loc2_)
  964.                {
  965.                   return _loc2_.y + _loc2_.baselinePosition;
  966.                }
  967.             }
  968.             return super.baselinePosition;
  969.          }
  970.          if(!mx_internal::validateBaselinePosition())
  971.          {
  972.             return NaN;
  973.          }
  974.          var _loc1_:TextLineMetrics = measureText("Wj");
  975.          if(height < 2 * viewMetrics.top + 4 + _loc1_.ascent)
  976.          {
  977.             return int(height + (_loc1_.ascent - height) / 2);
  978.          }
  979.          return viewMetrics.top + 2 + _loc1_.ascent;
  980.       }
  981.       
  982.       override public function getChildByName(param1:String) : DisplayObject
  983.       {
  984.          var _loc2_:DisplayObject = null;
  985.          var _loc3_:int = 0;
  986.          if(mx_internal::contentPane)
  987.          {
  988.             return mx_internal::contentPane.getChildByName(param1);
  989.          }
  990.          _loc2_ = super.getChildByName(param1);
  991.          if(!_loc2_)
  992.          {
  993.             return null;
  994.          }
  995.          _loc3_ = super.getChildIndex(_loc2_) - _firstChildIndex;
  996.          if(_loc3_ < 0 || _loc3_ >= mx_internal::_numChildren)
  997.          {
  998.             return null;
  999.          }
  1000.          return _loc2_;
  1001.       }
  1002.       
  1003.       [Bindable("verticalLineScrollSizeChanged")]
  1004.       public function get verticalLineScrollSize() : Number
  1005.       {
  1006.          return _verticalLineScrollSize;
  1007.       }
  1008.       
  1009.       [Bindable("horizontalScrollPolicyChanged")]
  1010.       public function get horizontalScrollPolicy() : String
  1011.       {
  1012.          return mx_internal::_horizontalScrollPolicy;
  1013.       }
  1014.       
  1015.       override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  1016.       {
  1017.          var _loc3_:DisplayObjectContainer = param1.parent;
  1018.          if(Boolean(_loc3_) && !(_loc3_ is Loader))
  1019.          {
  1020.             if(_loc3_ == this)
  1021.             {
  1022.                param2 = param2 == numChildren ? param2 - 1 : param2;
  1023.             }
  1024.             _loc3_.removeChild(param1);
  1025.          }
  1026.          mx_internal::addingChild(param1);
  1027.          if(mx_internal::contentPane)
  1028.          {
  1029.             mx_internal::contentPane.addChildAt(param1,param2);
  1030.          }
  1031.          else
  1032.          {
  1033.             mx_internal::$addChildAt(param1,_firstChildIndex + param2);
  1034.          }
  1035.          mx_internal::childAdded(param1);
  1036.          if(param1 is UIComponent && UIComponent(param1).isDocument)
  1037.          {
  1038.             BindingManager.setEnabled(param1,true);
  1039.          }
  1040.          return param1;
  1041.       }
  1042.       
  1043.       public function get maxVerticalScrollPosition() : Number
  1044.       {
  1045.          return !!verticalScrollBar ? verticalScrollBar.maxScrollPosition : Math.max(scrollableHeight - viewableHeight,0);
  1046.       }
  1047.       
  1048.       public function set horizontalScrollPosition(param1:Number) : void
  1049.       {
  1050.          if(_horizontalScrollPosition == param1)
  1051.          {
  1052.             return;
  1053.          }
  1054.          _horizontalScrollPosition = param1;
  1055.          scrollPositionChanged = true;
  1056.          if(!initialized)
  1057.          {
  1058.             horizontalScrollPositionPending = param1;
  1059.          }
  1060.          invalidateDisplayList();
  1061.          dispatchEvent(new Event("viewChanged"));
  1062.       }
  1063.       
  1064.       mx_internal function invalidateViewMetricsAndPadding() : void
  1065.       {
  1066.          _viewMetricsAndPadding = null;
  1067.       }
  1068.       
  1069.       [Bindable("horizontalLineScrollSizeChanged")]
  1070.       public function get horizontalLineScrollSize() : Number
  1071.       {
  1072.          return _horizontalLineScrollSize;
  1073.       }
  1074.       
  1075.       override public function set focusPane(param1:Sprite) : void
  1076.       {
  1077.          var _loc2_:Boolean = Boolean(mx_internal::invalidateSizeFlag);
  1078.          var _loc3_:Boolean = Boolean(mx_internal::invalidateDisplayListFlag);
  1079.          mx_internal::invalidateSizeFlag = true;
  1080.          mx_internal::invalidateDisplayListFlag = true;
  1081.          if(param1)
  1082.          {
  1083.             rawChildren.addChild(param1);
  1084.             param1.x = 0;
  1085.             param1.y = 0;
  1086.             param1.scrollRect = null;
  1087.             _focusPane = param1;
  1088.          }
  1089.          else
  1090.          {
  1091.             rawChildren.removeChild(_focusPane);
  1092.             _focusPane = null;
  1093.          }
  1094.          if(Boolean(param1) && Boolean(mx_internal::contentPane))
  1095.          {
  1096.             param1.x = mx_internal::contentPane.x;
  1097.             param1.y = mx_internal::contentPane.y;
  1098.             param1.scrollRect = mx_internal::contentPane.scrollRect;
  1099.          }
  1100.          mx_internal::invalidateSizeFlag = _loc2_;
  1101.          mx_internal::invalidateDisplayListFlag = _loc3_;
  1102.       }
  1103.       
  1104.       private function updateBackgroundImageRect() : void
  1105.       {
  1106.          var _loc1_:IRectangularBorder = mx_internal::border as IRectangularBorder;
  1107.          if(!_loc1_)
  1108.          {
  1109.             return;
  1110.          }
  1111.          if(viewableWidth == 0 && viewableHeight == 0)
  1112.          {
  1113.             _loc1_.backgroundImageBounds = null;
  1114.             return;
  1115.          }
  1116.          var _loc2_:EdgeMetrics = viewMetrics;
  1117.          var _loc3_:Number = !!viewableWidth ? viewableWidth : unscaledWidth - _loc2_.left - _loc2_.right;
  1118.          var _loc4_:Number = !!viewableHeight ? viewableHeight : unscaledHeight - _loc2_.top - _loc2_.bottom;
  1119.          if(getStyle("backgroundAttachment") == "fixed")
  1120.          {
  1121.             _loc1_.backgroundImageBounds = new Rectangle(_loc2_.left,_loc2_.top,_loc3_,_loc4_);
  1122.          }
  1123.          else
  1124.          {
  1125.             _loc1_.backgroundImageBounds = new Rectangle(_loc2_.left,_loc2_.top,Math.max(scrollableWidth,_loc3_),Math.max(scrollableHeight,_loc4_));
  1126.          }
  1127.       }
  1128.       
  1129.       private function blocker_clickHandler(param1:Event) : void
  1130.       {
  1131.          param1.stopPropagation();
  1132.       }
  1133.       
  1134.       private function mouseWheelHandler(param1:MouseEvent) : void
  1135.       {
  1136.          var _loc2_:int = 0;
  1137.          var _loc3_:int = 0;
  1138.          var _loc4_:Number = NaN;
  1139.          var _loc5_:Number = NaN;
  1140.          if(verticalScrollBar)
  1141.          {
  1142.             param1.stopPropagation();
  1143.             _loc2_ = param1.delta <= 0 ? 1 : -1;
  1144.             _loc3_ = !!verticalScrollBar ? int(verticalScrollBar.lineScrollSize) : 1;
  1145.             _loc4_ = Math.max(Math.abs(param1.delta),_loc3_);
  1146.             _loc5_ = verticalScrollPosition;
  1147.             verticalScrollPosition += 3 * _loc4_ * _loc2_;
  1148.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc5_,verticalScrollPosition,param1.delta <= 0 ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_DOWN);
  1149.          }
  1150.       }
  1151.       
  1152.       public function get defaultButton() : IFlexDisplayObject
  1153.       {
  1154.          return _defaultButton;
  1155.       }
  1156.       
  1157.       mx_internal function createContentPane() : void
  1158.       {
  1159.          var _loc3_:int = 0;
  1160.          var _loc5_:IUIComponent = null;
  1161.          if(mx_internal::contentPane)
  1162.          {
  1163.             return;
  1164.          }
  1165.          creatingContentPane = true;
  1166.          var _loc1_:int = numChildren;
  1167.          var _loc2_:Sprite = new FlexSprite();
  1168.          _loc2_.name = "contentPane";
  1169.          _loc2_.tabChildren = true;
  1170.          if(mx_internal::border)
  1171.          {
  1172.             _loc3_ = rawChildren.getChildIndex(DisplayObject(mx_internal::border)) + 1;
  1173.             if(mx_internal::border is IRectangularBorder && IRectangularBorder(mx_internal::border).hasBackgroundImage)
  1174.             {
  1175.                _loc3_++;
  1176.             }
  1177.          }
  1178.          else
  1179.          {
  1180.             _loc3_ = 0;
  1181.          }
  1182.          rawChildren.addChildAt(_loc2_,_loc3_);
  1183.          var _loc4_:int = 0;
  1184.          while(_loc4_ < _loc1_)
  1185.          {
  1186.             _loc5_ = IUIComponent(super.getChildAt(_firstChildIndex));
  1187.             _loc2_.addChild(DisplayObject(_loc5_));
  1188.             _loc5_.parentChanged(_loc2_);
  1189.             --mx_internal::_numChildren;
  1190.             _loc4_++;
  1191.          }
  1192.          mx_internal::contentPane = _loc2_;
  1193.          creatingContentPane = false;
  1194.          mx_internal::contentPane.visible = true;
  1195.       }
  1196.       
  1197.       public function set verticalPageScrollSize(param1:Number) : void
  1198.       {
  1199.          scrollPropertiesChanged = true;
  1200.          _verticalPageScrollSize = param1;
  1201.          invalidateDisplayList();
  1202.          dispatchEvent(new Event("verticalPageScrollSizeChanged"));
  1203.       }
  1204.       
  1205.       mx_internal function setDocumentDescriptor(param1:UIComponentDescriptor) : void
  1206.       {
  1207.          var _loc2_:String = null;
  1208.          if(processedDescriptors)
  1209.          {
  1210.             return;
  1211.          }
  1212.          if(Boolean(mx_internal::_documentDescriptor) && Boolean(mx_internal::_documentDescriptor.properties.childDescriptors))
  1213.          {
  1214.             if(param1.properties.childDescriptors)
  1215.             {
  1216.                _loc2_ = resourceManager.getString("core","multipleChildSets_ClassAndSubclass");
  1217.                throw new Error(_loc2_);
  1218.             }
  1219.          }
  1220.          else
  1221.          {
  1222.             mx_internal::_documentDescriptor = param1;
  1223.             mx_internal::_documentDescriptor.document = this;
  1224.          }
  1225.       }
  1226.       
  1227.       private function verticalScrollBar_scrollHandler(param1:Event) : void
  1228.       {
  1229.          var _loc2_:Number = NaN;
  1230.          if(param1 is ScrollEvent)
  1231.          {
  1232.             _loc2_ = verticalScrollPosition;
  1233.             verticalScrollPosition = verticalScrollBar.scrollPosition;
  1234.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc2_,verticalScrollPosition,ScrollEvent(param1).detail);
  1235.          }
  1236.       }
  1237.       
  1238.       public function get creationPolicy() : String
  1239.       {
  1240.          return _creationPolicy;
  1241.       }
  1242.       
  1243.       public function set icon(param1:Class) : void
  1244.       {
  1245.          _icon = param1;
  1246.          dispatchEvent(new Event("iconChanged"));
  1247.       }
  1248.       
  1249.       private function dispatchScrollEvent(param1:String, param2:Number, param3:Number, param4:String) : void
  1250.       {
  1251.          var _loc5_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  1252.          _loc5_.direction = param1;
  1253.          _loc5_.position = param3;
  1254.          _loc5_.delta = param3 - param2;
  1255.          _loc5_.detail = param4;
  1256.          dispatchEvent(_loc5_);
  1257.       }
  1258.       
  1259.       [Bindable("labelChanged")]
  1260.       public function get label() : String
  1261.       {
  1262.          return _label;
  1263.       }
  1264.       
  1265.       [Bindable("verticalScrollPolicyChanged")]
  1266.       public function get verticalScrollPolicy() : String
  1267.       {
  1268.          return mx_internal::_verticalScrollPolicy;
  1269.       }
  1270.       
  1271.       public function get borderMetrics() : EdgeMetrics
  1272.       {
  1273.          return Boolean(mx_internal::border) && mx_internal::border is IRectangularBorder ? IRectangularBorder(mx_internal::border).borderMetrics : EdgeMetrics.EMPTY;
  1274.       }
  1275.       
  1276.       private function creationCompleteHandler(param1:FlexEvent) : void
  1277.       {
  1278.          --mx_internal::numChildrenCreated;
  1279.          if(mx_internal::numChildrenCreated <= 0)
  1280.          {
  1281.             dispatchEvent(new FlexEvent("childrenCreationComplete"));
  1282.          }
  1283.       }
  1284.       
  1285.       override public function contentToLocal(param1:Point) : Point
  1286.       {
  1287.          if(!mx_internal::contentPane)
  1288.          {
  1289.             return param1;
  1290.          }
  1291.          param1 = contentToGlobal(param1);
  1292.          return globalToLocal(param1);
  1293.       }
  1294.       
  1295.       override public function removeChild(param1:DisplayObject) : DisplayObject
  1296.       {
  1297.          var _loc2_:int = 0;
  1298.          var _loc3_:int = 0;
  1299.          if(param1 is IDeferredInstantiationUIComponent && Boolean(IDeferredInstantiationUIComponent(param1).descriptor))
  1300.          {
  1301.             if(mx_internal::createdComponents)
  1302.             {
  1303.                _loc2_ = int(mx_internal::createdComponents.length);
  1304.                _loc3_ = 0;
  1305.                while(_loc3_ < _loc2_)
  1306.                {
  1307.                   if(mx_internal::createdComponents[_loc3_] === param1)
  1308.                   {
  1309.                      mx_internal::createdComponents.splice(_loc3_,1);
  1310.                   }
  1311.                   _loc3_++;
  1312.                }
  1313.             }
  1314.          }
  1315.          mx_internal::removingChild(param1);
  1316.          if(param1 is UIComponent && UIComponent(param1).isDocument)
  1317.          {
  1318.             BindingManager.setEnabled(param1,false);
  1319.          }
  1320.          if(mx_internal::contentPane)
  1321.          {
  1322.             mx_internal::contentPane.removeChild(param1);
  1323.          }
  1324.          else
  1325.          {
  1326.             mx_internal::$removeChild(param1);
  1327.          }
  1328.          mx_internal::childRemoved(param1);
  1329.          return param1;
  1330.       }
  1331.       
  1332.       final mx_internal function get $numChildren() : int
  1333.       {
  1334.          return super.numChildren;
  1335.       }
  1336.       
  1337.       mx_internal function get numRepeaters() : int
  1338.       {
  1339.          return !!mx_internal::childRepeaters ? int(mx_internal::childRepeaters.length) : 0;
  1340.       }
  1341.       
  1342.       mx_internal function set numChildrenCreated(param1:int) : void
  1343.       {
  1344.          _numChildrenCreated = param1;
  1345.       }
  1346.       
  1347.       public function get creatingContentPane() : Boolean
  1348.       {
  1349.          return _creatingContentPane;
  1350.       }
  1351.       
  1352.       public function get clipContent() : Boolean
  1353.       {
  1354.          return _clipContent;
  1355.       }
  1356.       
  1357.       mx_internal function rawChildren_getChildIndex(param1:DisplayObject) : int
  1358.       {
  1359.          return super.getChildIndex(param1);
  1360.       }
  1361.       
  1362.       override public function regenerateStyleCache(param1:Boolean) : void
  1363.       {
  1364.          var _loc2_:int = 0;
  1365.          var _loc3_:int = 0;
  1366.          var _loc4_:DisplayObject = null;
  1367.          super.regenerateStyleCache(param1);
  1368.          if(mx_internal::contentPane)
  1369.          {
  1370.             _loc2_ = mx_internal::contentPane.numChildren;
  1371.             _loc3_ = 0;
  1372.             while(_loc3_ < _loc2_)
  1373.             {
  1374.                _loc4_ = getChildAt(_loc3_);
  1375.                if(param1 && _loc4_ is UIComponent)
  1376.                {
  1377.                   if(UIComponent(_loc4_).inheritingStyles != UIComponent.mx_internal::STYLE_UNINITIALIZED)
  1378.                   {
  1379.                      UIComponent(_loc4_).regenerateStyleCache(param1);
  1380.                   }
  1381.                }
  1382.                else if(_loc4_ is IUITextField && Boolean(IUITextField(_loc4_).inheritingStyles))
  1383.                {
  1384.                   StyleProtoChain.initTextField(IUITextField(_loc4_));
  1385.                }
  1386.                _loc3_++;
  1387.             }
  1388.          }
  1389.       }
  1390.       
  1391.       override public function getChildIndex(param1:DisplayObject) : int
  1392.       {
  1393.          var _loc2_:int = 0;
  1394.          if(mx_internal::contentPane)
  1395.          {
  1396.             return mx_internal::contentPane.getChildIndex(param1);
  1397.          }
  1398.          return int(super.getChildIndex(param1) - _firstChildIndex);
  1399.       }
  1400.       
  1401.       mx_internal function rawChildren_contains(param1:DisplayObject) : Boolean
  1402.       {
  1403.          return super.contains(param1);
  1404.       }
  1405.       
  1406.       mx_internal function getScrollableRect() : Rectangle
  1407.       {
  1408.          var _loc9_:DisplayObject = null;
  1409.          var _loc1_:Number = 0;
  1410.          var _loc2_:Number = 0;
  1411.          var _loc3_:Number = 0;
  1412.          var _loc4_:Number = 0;
  1413.          var _loc5_:int = numChildren;
  1414.          var _loc6_:int = 0;
  1415.          while(_loc6_ < _loc5_)
  1416.          {
  1417.             _loc9_ = getChildAt(_loc6_);
  1418.             if(!(_loc9_ is IUIComponent && !IUIComponent(_loc9_).includeInLayout))
  1419.             {
  1420.                _loc1_ = Math.min(_loc1_,_loc9_.x);
  1421.                _loc2_ = Math.min(_loc2_,_loc9_.y);
  1422.                if(!isNaN(_loc9_.width))
  1423.                {
  1424.                   _loc3_ = Math.max(_loc3_,_loc9_.x + _loc9_.width);
  1425.                }
  1426.                if(!isNaN(_loc9_.height))
  1427.                {
  1428.                   _loc4_ = Math.max(_loc4_,_loc9_.y + _loc9_.height);
  1429.                }
  1430.             }
  1431.             _loc6_++;
  1432.          }
  1433.          var _loc7_:EdgeMetrics = viewMetrics;
  1434.          var _loc8_:Rectangle = new Rectangle();
  1435.          _loc8_.left = _loc1_;
  1436.          _loc8_.top = _loc2_;
  1437.          _loc8_.right = _loc3_;
  1438.          _loc8_.bottom = _loc4_;
  1439.          if(mx_internal::usePadding)
  1440.          {
  1441.             _loc8_.right += getStyle("paddingRight");
  1442.             _loc8_.bottom += getStyle("paddingBottom");
  1443.          }
  1444.          return _loc8_;
  1445.       }
  1446.       
  1447.       override protected function createChildren() : void
  1448.       {
  1449.          var _loc1_:Application = null;
  1450.          super.createChildren();
  1451.          createBorder();
  1452.          createOrDestroyScrollbars(horizontalScrollPolicy == ScrollPolicy.ON,verticalScrollPolicy == ScrollPolicy.ON,horizontalScrollPolicy == ScrollPolicy.ON || verticalScrollPolicy == ScrollPolicy.ON);
  1453.          if(creationPolicy != null)
  1454.          {
  1455.             actualCreationPolicy = creationPolicy;
  1456.          }
  1457.          else if(parent is Container)
  1458.          {
  1459.             if(Container(parent).actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  1460.             {
  1461.                actualCreationPolicy = ContainerCreationPolicy.AUTO;
  1462.             }
  1463.             else
  1464.             {
  1465.                actualCreationPolicy = Container(parent).actualCreationPolicy;
  1466.             }
  1467.          }
  1468.          if(actualCreationPolicy == ContainerCreationPolicy.NONE)
  1469.          {
  1470.             actualCreationPolicy = ContainerCreationPolicy.AUTO;
  1471.          }
  1472.          else if(actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  1473.          {
  1474.             _loc1_ = !!parentApplication ? Application(parentApplication) : Application(Application.application);
  1475.             _loc1_.addToCreationQueue(this,creationIndex,null,this);
  1476.          }
  1477.          else if(recursionFlag)
  1478.          {
  1479.             createComponentsFromDescriptors();
  1480.          }
  1481.          if(autoLayout == false)
  1482.          {
  1483.             forceLayout = true;
  1484.          }
  1485.          UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  1486.       }
  1487.       
  1488.       override public function executeBindings(param1:Boolean = false) : void
  1489.       {
  1490.          var _loc2_:Object = Boolean(descriptor) && Boolean(descriptor.document) ? descriptor.document : parentDocument;
  1491.          BindingManager.executeBindings(_loc2_,id,this);
  1492.          if(param1)
  1493.          {
  1494.             executeChildBindings(param1);
  1495.          }
  1496.       }
  1497.       
  1498.       override public function setChildIndex(param1:DisplayObject, param2:int) : void
  1499.       {
  1500.          var _loc3_:int = 0;
  1501.          var _loc4_:int = _loc3_;
  1502.          var _loc5_:int = param2;
  1503.          if(mx_internal::contentPane)
  1504.          {
  1505.             mx_internal::contentPane.setChildIndex(param1,param2);
  1506.             if(_autoLayout || forceLayout)
  1507.             {
  1508.                invalidateDisplayList();
  1509.             }
  1510.          }
  1511.          else
  1512.          {
  1513.             _loc3_ = super.getChildIndex(param1);
  1514.             param2 += _firstChildIndex;
  1515.             if(param2 == _loc3_)
  1516.             {
  1517.                return;
  1518.             }
  1519.             super.setChildIndex(param1,param2);
  1520.             invalidateDisplayList();
  1521.             _loc4_ = _loc3_ - _firstChildIndex;
  1522.             _loc5_ = param2 - _firstChildIndex;
  1523.          }
  1524.          var _loc6_:IndexChangedEvent = new IndexChangedEvent(IndexChangedEvent.CHILD_INDEX_CHANGE);
  1525.          _loc6_.relatedObject = param1;
  1526.          _loc6_.oldIndex = _loc4_;
  1527.          _loc6_.newIndex = _loc5_;
  1528.          dispatchEvent(_loc6_);
  1529.          dispatchEvent(new Event("childrenChanged"));
  1530.       }
  1531.       
  1532.       override public function globalToContent(param1:Point) : Point
  1533.       {
  1534.          if(mx_internal::contentPane)
  1535.          {
  1536.             return mx_internal::contentPane.globalToLocal(param1);
  1537.          }
  1538.          return globalToLocal(param1);
  1539.       }
  1540.       
  1541.       mx_internal function rawChildren_removeChild(param1:DisplayObject) : DisplayObject
  1542.       {
  1543.          var _loc2_:int = mx_internal::rawChildren_getChildIndex(param1);
  1544.          return mx_internal::rawChildren_removeChildAt(_loc2_);
  1545.       }
  1546.       
  1547.       mx_internal function rawChildren_setChildIndex(param1:DisplayObject, param2:int) : void
  1548.       {
  1549.          var _loc3_:int = super.getChildIndex(param1);
  1550.          super.setChildIndex(param1,param2);
  1551.          if(_loc3_ < _firstChildIndex && param2 >= _firstChildIndex)
  1552.          {
  1553.             --_firstChildIndex;
  1554.          }
  1555.          else if(_loc3_ >= _firstChildIndex && param2 <= _firstChildIndex)
  1556.          {
  1557.             ++_firstChildIndex;
  1558.          }
  1559.          dispatchEvent(new Event("childrenChanged"));
  1560.       }
  1561.       
  1562.       public function set verticalLineScrollSize(param1:Number) : void
  1563.       {
  1564.          scrollPropertiesChanged = true;
  1565.          _verticalLineScrollSize = param1;
  1566.          invalidateDisplayList();
  1567.          dispatchEvent(new Event("verticalLineScrollSizeChanged"));
  1568.       }
  1569.       
  1570.       mx_internal function rawChildren_getChildAt(param1:int) : DisplayObject
  1571.       {
  1572.          return super.getChildAt(param1);
  1573.       }
  1574.       
  1575.       public function get creationIndex() : int
  1576.       {
  1577.          return _creationIndex;
  1578.       }
  1579.       
  1580.       public function get verticalScrollBar() : ScrollBar
  1581.       {
  1582.          return _verticalScrollBar;
  1583.       }
  1584.       
  1585.       public function get viewMetricsAndPadding() : EdgeMetrics
  1586.       {
  1587.          if(_viewMetricsAndPadding && (!horizontalScrollBar || horizontalScrollPolicy == ScrollPolicy.ON) && (!verticalScrollBar || verticalScrollPolicy == ScrollPolicy.ON))
  1588.          {
  1589.             return _viewMetricsAndPadding;
  1590.          }
  1591.          if(!_viewMetricsAndPadding)
  1592.          {
  1593.             _viewMetricsAndPadding = new EdgeMetrics();
  1594.          }
  1595.          var _loc1_:EdgeMetrics = _viewMetricsAndPadding;
  1596.          var _loc2_:EdgeMetrics = viewMetrics;
  1597.          _loc1_.left = _loc2_.left + getStyle("paddingLeft");
  1598.          _loc1_.right = _loc2_.right + getStyle("paddingRight");
  1599.          _loc1_.top = _loc2_.top + getStyle("paddingTop");
  1600.          _loc1_.bottom = _loc2_.bottom + getStyle("paddingBottom");
  1601.          return _loc1_;
  1602.       }
  1603.       
  1604.       override public function addChild(param1:DisplayObject) : DisplayObject
  1605.       {
  1606.          return addChildAt(param1,numChildren);
  1607.       }
  1608.       
  1609.       public function set horizontalPageScrollSize(param1:Number) : void
  1610.       {
  1611.          scrollPropertiesChanged = true;
  1612.          _horizontalPageScrollSize = param1;
  1613.          invalidateDisplayList();
  1614.          dispatchEvent(new Event("horizontalPageScrollSizeChanged"));
  1615.       }
  1616.       
  1617.       override mx_internal function childAdded(param1:DisplayObject) : void
  1618.       {
  1619.          dispatchEvent(new Event("childrenChanged"));
  1620.          var _loc2_:ChildExistenceChangedEvent = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_ADD);
  1621.          _loc2_.relatedObject = param1;
  1622.          dispatchEvent(_loc2_);
  1623.          param1.dispatchEvent(new FlexEvent(FlexEvent.ADD));
  1624.          super.mx_internal::childAdded(param1);
  1625.       }
  1626.       
  1627.       public function set horizontalScrollPolicy(param1:String) : void
  1628.       {
  1629.          if(mx_internal::_horizontalScrollPolicy != param1)
  1630.          {
  1631.             mx_internal::_horizontalScrollPolicy = param1;
  1632.             invalidateDisplayList();
  1633.             dispatchEvent(new Event("horizontalScrollPolicyChanged"));
  1634.          }
  1635.       }
  1636.       
  1637.       private function layoutCompleteHandler(param1:FlexEvent) : void
  1638.       {
  1639.          UIComponentGlobals.mx_internal::layoutManager.removeEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler);
  1640.          forceLayout = false;
  1641.          var _loc2_:Boolean = false;
  1642.          if(!isNaN(horizontalScrollPositionPending))
  1643.          {
  1644.             if(horizontalScrollPositionPending < 0)
  1645.             {
  1646.                horizontalScrollPositionPending = 0;
  1647.             }
  1648.             else if(horizontalScrollPositionPending > maxHorizontalScrollPosition)
  1649.             {
  1650.                horizontalScrollPositionPending = maxHorizontalScrollPosition;
  1651.             }
  1652.             if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != horizontalScrollPositionPending)
  1653.             {
  1654.                _horizontalScrollPosition = horizontalScrollPositionPending;
  1655.                horizontalScrollBar.scrollPosition = horizontalScrollPositionPending;
  1656.                _loc2_ = true;
  1657.             }
  1658.             horizontalScrollPositionPending = NaN;
  1659.          }
  1660.          if(!isNaN(verticalScrollPositionPending))
  1661.          {
  1662.             if(verticalScrollPositionPending < 0)
  1663.             {
  1664.                verticalScrollPositionPending = 0;
  1665.             }
  1666.             else if(verticalScrollPositionPending > maxVerticalScrollPosition)
  1667.             {
  1668.                verticalScrollPositionPending = maxVerticalScrollPosition;
  1669.             }
  1670.             if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != verticalScrollPositionPending)
  1671.             {
  1672.                _verticalScrollPosition = verticalScrollPositionPending;
  1673.                verticalScrollBar.scrollPosition = verticalScrollPositionPending;
  1674.                _loc2_ = true;
  1675.             }
  1676.             verticalScrollPositionPending = NaN;
  1677.          }
  1678.          if(_loc2_)
  1679.          {
  1680.             scrollChildren();
  1681.          }
  1682.       }
  1683.       
  1684.       public function createComponentsFromDescriptors(param1:Boolean = true) : void
  1685.       {
  1686.          var _loc4_:IFlexDisplayObject = null;
  1687.          numChildrenBefore = numChildren;
  1688.          mx_internal::createdComponents = [];
  1689.          var _loc2_:int = !!childDescriptors ? int(childDescriptors.length) : 0;
  1690.          var _loc3_:int = 0;
  1691.          while(_loc3_ < _loc2_)
  1692.          {
  1693.             _loc4_ = createComponentFromDescriptor(childDescriptors[_loc3_],param1);
  1694.             mx_internal::createdComponents.push(_loc4_);
  1695.             _loc3_++;
  1696.          }
  1697.          if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  1698.          {
  1699.             UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = false;
  1700.          }
  1701.          mx_internal::numChildrenCreated = numChildren - numChildrenBefore;
  1702.          processedDescriptors = true;
  1703.       }
  1704.       
  1705.       override mx_internal function fillOverlay(param1:UIComponent, param2:uint, param3:RoundedRectangle = null) : void
  1706.       {
  1707.          var _loc4_:EdgeMetrics = viewMetrics;
  1708.          var _loc5_:Number = 0;
  1709.          if(!param3)
  1710.          {
  1711.             param3 = new RoundedRectangle(_loc4_.left,_loc4_.top,unscaledWidth - _loc4_.right - _loc4_.left,unscaledHeight - _loc4_.bottom - _loc4_.top,_loc5_);
  1712.          }
  1713.          if(isNaN(param3.x) || isNaN(param3.y) || isNaN(param3.width) || isNaN(param3.height) || isNaN(param3.cornerRadius))
  1714.          {
  1715.             return;
  1716.          }
  1717.          var _loc6_:Graphics = param1.graphics;
  1718.          _loc6_.clear();
  1719.          _loc6_.beginFill(param2);
  1720.          _loc6_.drawRoundRect(param3.x,param3.y,param3.width,param3.height,param3.cornerRadius * 2,param3.cornerRadius * 2);
  1721.          _loc6_.endFill();
  1722.       }
  1723.       
  1724.       override public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  1725.       {
  1726.          super.removeEventListener(param1,param2,param3);
  1727.          if(param1 == MouseEvent.CLICK || param1 == MouseEvent.DOUBLE_CLICK || param1 == MouseEvent.MOUSE_DOWN || param1 == MouseEvent.MOUSE_MOVE || param1 == MouseEvent.MOUSE_OVER || param1 == MouseEvent.MOUSE_OUT || param1 == MouseEvent.MOUSE_UP || param1 == MouseEvent.MOUSE_WHEEL)
  1728.          {
  1729.             if(mouseEventReferenceCount > 0 && --mouseEventReferenceCount == 0)
  1730.             {
  1731.                setStyle("mouseShield",false);
  1732.                setStyle("mouseShieldChildren",false);
  1733.             }
  1734.          }
  1735.       }
  1736.       
  1737.       mx_internal function rawChildren_removeChildAt(param1:int) : DisplayObject
  1738.       {
  1739.          var _loc2_:DisplayObject = super.getChildAt(param1);
  1740.          super.mx_internal::removingChild(_loc2_);
  1741.          mx_internal::$removeChildAt(param1);
  1742.          super.mx_internal::childRemoved(_loc2_);
  1743.          if(_firstChildIndex < param1 && param1 < _firstChildIndex + mx_internal::_numChildren)
  1744.          {
  1745.             --mx_internal::_numChildren;
  1746.          }
  1747.          else if(mx_internal::_numChildren == 0 || param1 < _firstChildIndex)
  1748.          {
  1749.             --_firstChildIndex;
  1750.          }
  1751.          invalidateSize();
  1752.          invalidateDisplayList();
  1753.          dispatchEvent(new Event("childrenChanged"));
  1754.          return _loc2_;
  1755.       }
  1756.       
  1757.       public function set data(param1:Object) : void
  1758.       {
  1759.          _data = param1;
  1760.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  1761.          invalidateDisplayList();
  1762.       }
  1763.       
  1764.       override public function removeChildAt(param1:int) : DisplayObject
  1765.       {
  1766.          return removeChild(getChildAt(param1));
  1767.       }
  1768.       
  1769.       private function isBorderNeeded() : Boolean
  1770.       {
  1771.          var v:Object;
  1772.          var c:Class = getStyle("borderSkin");
  1773.          try
  1774.          {
  1775.             if(c != getDefinitionByName("mx.skins.halo::HaloBorder"))
  1776.             {
  1777.                return true;
  1778.             }
  1779.          }
  1780.          catch(e:Error)
  1781.          {
  1782.             return true;
  1783.          }
  1784.          v = getStyle("borderStyle");
  1785.          if(v)
  1786.          {
  1787.             if(v != "none" || v == "none" && getStyle("mouseShield"))
  1788.             {
  1789.                return true;
  1790.             }
  1791.          }
  1792.          v = getStyle("backgroundColor");
  1793.          if(v !== null && v !== "")
  1794.          {
  1795.             return true;
  1796.          }
  1797.          v = getStyle("backgroundImage");
  1798.          return v != null && v != "";
  1799.       }
  1800.       
  1801.       public function set autoLayout(param1:Boolean) : void
  1802.       {
  1803.          var _loc2_:IInvalidating = null;
  1804.          _autoLayout = param1;
  1805.          if(param1)
  1806.          {
  1807.             invalidateSize();
  1808.             invalidateDisplayList();
  1809.             _loc2_ = parent as IInvalidating;
  1810.             if(_loc2_)
  1811.             {
  1812.                _loc2_.invalidateSize();
  1813.                _loc2_.invalidateDisplayList();
  1814.             }
  1815.          }
  1816.       }
  1817.       
  1818.       [Bindable("verticalPageScrollSizeChanged")]
  1819.       public function get verticalPageScrollSize() : Number
  1820.       {
  1821.          return _verticalPageScrollSize;
  1822.       }
  1823.       
  1824.       [Bindable("childrenChanged")]
  1825.       public function getChildren() : Array
  1826.       {
  1827.          var _loc1_:Array = [];
  1828.          var _loc2_:int = numChildren;
  1829.          var _loc3_:int = 0;
  1830.          while(_loc3_ < _loc2_)
  1831.          {
  1832.             _loc1_.push(getChildAt(_loc3_));
  1833.             _loc3_++;
  1834.          }
  1835.          return _loc1_;
  1836.       }
  1837.       
  1838.       private function createScrollbarsIfNeeded(param1:Rectangle) : Boolean
  1839.       {
  1840.          var _loc2_:Number = param1.right;
  1841.          var _loc3_:Number = param1.bottom;
  1842.          var _loc4_:Number = unscaledWidth;
  1843.          var _loc5_:Number = unscaledHeight;
  1844.          var _loc6_:Boolean = param1.left < 0 || param1.top < 0;
  1845.          var _loc7_:EdgeMetrics = viewMetrics;
  1846.          if(scaleX != 1)
  1847.          {
  1848.             _loc4_ += 1 / Math.abs(scaleX);
  1849.          }
  1850.          if(scaleY != 1)
  1851.          {
  1852.             _loc5_ += 1 / Math.abs(scaleY);
  1853.          }
  1854.          _loc4_ = Math.floor(_loc4_);
  1855.          _loc5_ = Math.floor(_loc5_);
  1856.          _loc2_ = Math.floor(_loc2_);
  1857.          _loc3_ = Math.floor(_loc3_);
  1858.          if(Boolean(horizontalScrollBar) && horizontalScrollPolicy != ScrollPolicy.ON)
  1859.          {
  1860.             _loc5_ -= horizontalScrollBar.minHeight;
  1861.          }
  1862.          if(Boolean(verticalScrollBar) && verticalScrollPolicy != ScrollPolicy.ON)
  1863.          {
  1864.             _loc4_ -= verticalScrollBar.minWidth;
  1865.          }
  1866.          _loc4_ -= _loc7_.left + _loc7_.right;
  1867.          _loc5_ -= _loc7_.top + _loc7_.bottom;
  1868.          var _loc8_:* = horizontalScrollPolicy == ScrollPolicy.ON;
  1869.          var _loc9_:* = verticalScrollPolicy == ScrollPolicy.ON;
  1870.          var _loc10_:Boolean = _loc8_ || _loc9_ || _loc6_ || mx_internal::overlay != null || _loc7_.left > 0 || _loc7_.top > 0;
  1871.          if(_loc4_ < _loc2_)
  1872.          {
  1873.             _loc10_ = true;
  1874.             if(horizontalScrollPolicy == ScrollPolicy.AUTO && unscaledHeight - _loc7_.top - _loc7_.bottom >= 18 && unscaledWidth - _loc7_.left - _loc7_.right >= 32)
  1875.             {
  1876.                _loc8_ = true;
  1877.             }
  1878.          }
  1879.          if(_loc5_ < _loc3_)
  1880.          {
  1881.             _loc10_ = true;
  1882.             if(verticalScrollPolicy == ScrollPolicy.AUTO && unscaledWidth - _loc7_.left - _loc7_.right >= 18 && unscaledHeight - _loc7_.top - _loc7_.bottom >= 32)
  1883.             {
  1884.                _loc9_ = true;
  1885.             }
  1886.          }
  1887.          if(_loc8_ && _loc9_ && horizontalScrollPolicy == ScrollPolicy.AUTO && verticalScrollPolicy == ScrollPolicy.AUTO && horizontalScrollBar && verticalScrollBar && _loc4_ + verticalScrollBar.minWidth >= _loc2_ && _loc5_ + horizontalScrollBar.minHeight >= _loc3_)
  1888.          {
  1889.             _loc8_ = _loc9_ = false;
  1890.          }
  1891.          else if(_loc8_ && !_loc9_ && verticalScrollBar && horizontalScrollPolicy == ScrollPolicy.AUTO && _loc4_ + verticalScrollBar.minWidth >= _loc2_)
  1892.          {
  1893.             _loc8_ = false;
  1894.          }
  1895.          var _loc11_:Boolean = createOrDestroyScrollbars(_loc8_,_loc9_,_loc10_);
  1896.          if(scrollableWidth != _loc2_ || viewableWidth != _loc4_ || _loc11_)
  1897.          {
  1898.             if(horizontalScrollBar)
  1899.             {
  1900.                horizontalScrollBar.setScrollProperties(_loc4_,0,_loc2_ - _loc4_,horizontalPageScrollSize);
  1901.                scrollPositionChanged = true;
  1902.             }
  1903.             viewableWidth = _loc4_;
  1904.             scrollableWidth = _loc2_;
  1905.          }
  1906.          if(scrollableHeight != _loc3_ || viewableHeight != _loc5_ || _loc11_)
  1907.          {
  1908.             if(verticalScrollBar)
  1909.             {
  1910.                verticalScrollBar.setScrollProperties(_loc5_,0,_loc3_ - _loc5_,verticalPageScrollSize);
  1911.                scrollPositionChanged = true;
  1912.             }
  1913.             viewableHeight = _loc5_;
  1914.             scrollableHeight = _loc3_;
  1915.          }
  1916.          return _loc11_;
  1917.       }
  1918.       
  1919.       override mx_internal function removingChild(param1:DisplayObject) : void
  1920.       {
  1921.          super.mx_internal::removingChild(param1);
  1922.          param1.dispatchEvent(new FlexEvent(FlexEvent.REMOVE));
  1923.          var _loc2_:ChildExistenceChangedEvent = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_REMOVE);
  1924.          _loc2_.relatedObject = param1;
  1925.          dispatchEvent(_loc2_);
  1926.       }
  1927.       
  1928.       mx_internal function get numChildrenCreated() : int
  1929.       {
  1930.          return _numChildrenCreated;
  1931.       }
  1932.       
  1933.       mx_internal function rawChildren_addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  1934.       {
  1935.          if(_firstChildIndex < param2 && param2 < _firstChildIndex + mx_internal::_numChildren + 1)
  1936.          {
  1937.             ++mx_internal::_numChildren;
  1938.          }
  1939.          else if(param2 <= _firstChildIndex)
  1940.          {
  1941.             ++_firstChildIndex;
  1942.          }
  1943.          super.mx_internal::addingChild(param1);
  1944.          mx_internal::$addChildAt(param1,param2);
  1945.          super.mx_internal::childAdded(param1);
  1946.          dispatchEvent(new Event("childrenChanged"));
  1947.          return param1;
  1948.       }
  1949.       
  1950.       private function hasChildMatchingDescriptor(param1:UIComponentDescriptor) : Boolean
  1951.       {
  1952.          var _loc4_:int = 0;
  1953.          var _loc5_:IUIComponent = null;
  1954.          var _loc2_:String = param1.id;
  1955.          if(_loc2_ != null && document[_loc2_] == null)
  1956.          {
  1957.             return false;
  1958.          }
  1959.          var _loc3_:int = numChildren;
  1960.          _loc4_ = 0;
  1961.          while(_loc4_ < _loc3_)
  1962.          {
  1963.             _loc5_ = IUIComponent(getChildAt(_loc4_));
  1964.             if(_loc5_ is IDeferredInstantiationUIComponent && IDeferredInstantiationUIComponent(_loc5_).descriptor == param1)
  1965.             {
  1966.                return true;
  1967.             }
  1968.             _loc4_++;
  1969.          }
  1970.          if(mx_internal::childRepeaters)
  1971.          {
  1972.             _loc3_ = int(mx_internal::childRepeaters.length);
  1973.             _loc4_ = 0;
  1974.             while(_loc4_ < _loc3_)
  1975.             {
  1976.                if(IDeferredInstantiationUIComponent(mx_internal::childRepeaters[_loc4_]).descriptor == param1)
  1977.                {
  1978.                   return true;
  1979.                }
  1980.                _loc4_++;
  1981.             }
  1982.          }
  1983.          return false;
  1984.       }
  1985.       
  1986.       mx_internal function rawChildren_getChildByName(param1:String) : DisplayObject
  1987.       {
  1988.          return super.getChildByName(param1);
  1989.       }
  1990.       
  1991.       override public function validateDisplayList() : void
  1992.       {
  1993.          var _loc1_:EdgeMetrics = null;
  1994.          var _loc2_:Number = NaN;
  1995.          var _loc3_:Number = NaN;
  1996.          var _loc4_:Object = null;
  1997.          var _loc5_:Number = NaN;
  1998.          var _loc6_:Number = NaN;
  1999.          var _loc7_:Number = NaN;
  2000.          if(_autoLayout || forceLayout)
  2001.          {
  2002.             mx_internal::doingLayout = true;
  2003.             super.validateDisplayList();
  2004.             mx_internal::doingLayout = false;
  2005.          }
  2006.          else
  2007.          {
  2008.             layoutChrome(unscaledWidth,unscaledHeight);
  2009.          }
  2010.          mx_internal::invalidateDisplayListFlag = true;
  2011.          if(createContentPaneAndScrollbarsIfNeeded())
  2012.          {
  2013.             if(_autoLayout || forceLayout)
  2014.             {
  2015.                mx_internal::doingLayout = true;
  2016.                super.validateDisplayList();
  2017.                mx_internal::doingLayout = false;
  2018.             }
  2019.             createContentPaneAndScrollbarsIfNeeded();
  2020.          }
  2021.          if(clampScrollPositions())
  2022.          {
  2023.             scrollChildren();
  2024.          }
  2025.          if(mx_internal::contentPane)
  2026.          {
  2027.             _loc1_ = viewMetrics;
  2028.             if(mx_internal::overlay)
  2029.             {
  2030.                mx_internal::overlay.x = 0;
  2031.                mx_internal::overlay.y = 0;
  2032.                mx_internal::overlay.width = unscaledWidth;
  2033.                mx_internal::overlay.height = unscaledHeight;
  2034.             }
  2035.             if(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar))
  2036.             {
  2037.                if(Boolean(verticalScrollBar) && verticalScrollPolicy == ScrollPolicy.ON)
  2038.                {
  2039.                   _loc1_.right -= verticalScrollBar.minWidth;
  2040.                }
  2041.                if(Boolean(horizontalScrollBar) && horizontalScrollPolicy == ScrollPolicy.ON)
  2042.                {
  2043.                   _loc1_.bottom -= horizontalScrollBar.minHeight;
  2044.                }
  2045.                if(horizontalScrollBar)
  2046.                {
  2047.                   _loc2_ = unscaledWidth - _loc1_.left - _loc1_.right;
  2048.                   if(verticalScrollBar)
  2049.                   {
  2050.                      _loc2_ -= verticalScrollBar.minWidth;
  2051.                   }
  2052.                   horizontalScrollBar.setActualSize(_loc2_,horizontalScrollBar.minHeight);
  2053.                   horizontalScrollBar.move(_loc1_.left,unscaledHeight - _loc1_.bottom - horizontalScrollBar.minHeight);
  2054.                }
  2055.                if(verticalScrollBar)
  2056.                {
  2057.                   _loc3_ = unscaledHeight - _loc1_.top - _loc1_.bottom;
  2058.                   if(horizontalScrollBar)
  2059.                   {
  2060.                      _loc3_ -= horizontalScrollBar.minHeight;
  2061.                   }
  2062.                   verticalScrollBar.setActualSize(verticalScrollBar.minWidth,_loc3_);
  2063.                   verticalScrollBar.move(unscaledWidth - _loc1_.right - verticalScrollBar.minWidth,_loc1_.top);
  2064.                }
  2065.                if(whiteBox)
  2066.                {
  2067.                   whiteBox.x = verticalScrollBar.x;
  2068.                   whiteBox.y = horizontalScrollBar.y;
  2069.                }
  2070.             }
  2071.             mx_internal::contentPane.x = _loc1_.left;
  2072.             mx_internal::contentPane.y = _loc1_.top;
  2073.             if(focusPane)
  2074.             {
  2075.                focusPane.x = _loc1_.left;
  2076.                focusPane.y = _loc1_.top;
  2077.             }
  2078.             scrollChildren();
  2079.          }
  2080.          mx_internal::invalidateDisplayListFlag = false;
  2081.          if(mx_internal::blocker)
  2082.          {
  2083.             _loc1_ = viewMetrics;
  2084.             _loc4_ = enabled ? null : getStyle("backgroundDisabledColor");
  2085.             if(_loc4_ === null || isNaN(Number(_loc4_)))
  2086.             {
  2087.                _loc4_ = getStyle("backgroundColor");
  2088.             }
  2089.             if(_loc4_ === null || isNaN(Number(_loc4_)))
  2090.             {
  2091.                _loc4_ = 16777215;
  2092.             }
  2093.             _loc5_ = getStyle("disabledOverlayAlpha");
  2094.             if(isNaN(_loc5_))
  2095.             {
  2096.                _loc5_ = 0.6;
  2097.             }
  2098.             mx_internal::blocker.x = _loc1_.left;
  2099.             mx_internal::blocker.y = _loc1_.top;
  2100.             _loc6_ = unscaledWidth - (_loc1_.left + _loc1_.right);
  2101.             _loc7_ = unscaledHeight - (_loc1_.top + _loc1_.bottom);
  2102.             mx_internal::blocker.graphics.clear();
  2103.             mx_internal::blocker.graphics.beginFill(uint(_loc4_),_loc5_);
  2104.             mx_internal::blocker.graphics.drawRect(0,0,_loc6_,_loc7_);
  2105.             mx_internal::blocker.graphics.endFill();
  2106.             rawChildren.setChildIndex(mx_internal::blocker,rawChildren.numChildren - 1);
  2107.          }
  2108.       }
  2109.       
  2110.       public function set horizontalLineScrollSize(param1:Number) : void
  2111.       {
  2112.          scrollPropertiesChanged = true;
  2113.          _horizontalLineScrollSize = param1;
  2114.          invalidateDisplayList();
  2115.          dispatchEvent(new Event("horizontalLineScrollSizeChanged"));
  2116.       }
  2117.       
  2118.       override public function initialize() : void
  2119.       {
  2120.          var _loc1_:* = undefined;
  2121.          var _loc2_:String = null;
  2122.          if(isDocument && mx_internal::documentDescriptor && !processedDescriptors)
  2123.          {
  2124.             _loc1_ = mx_internal::documentDescriptor.properties;
  2125.             if(_loc1_ && Boolean(_loc1_.childDescriptors))
  2126.             {
  2127.                if(_childDescriptors)
  2128.                {
  2129.                   _loc2_ = resourceManager.getString("core","multipleChildSets_ClassAndInstance");
  2130.                   throw new Error(_loc2_);
  2131.                }
  2132.                _childDescriptors = _loc1_.childDescriptors;
  2133.             }
  2134.          }
  2135.          super.initialize();
  2136.       }
  2137.       
  2138.       mx_internal function set forceClipping(param1:Boolean) : void
  2139.       {
  2140.          if(_clipContent)
  2141.          {
  2142.             if(param1)
  2143.             {
  2144.                ++_forceClippingCount;
  2145.             }
  2146.             else
  2147.             {
  2148.                --_forceClippingCount;
  2149.             }
  2150.             mx_internal::createContentPane();
  2151.             scrollChildren();
  2152.          }
  2153.       }
  2154.       
  2155.       public function removeAllChildren() : void
  2156.       {
  2157.          while(numChildren > 0)
  2158.          {
  2159.             removeChildAt(0);
  2160.          }
  2161.       }
  2162.       
  2163.       override public function contentToGlobal(param1:Point) : Point
  2164.       {
  2165.          if(mx_internal::contentPane)
  2166.          {
  2167.             return mx_internal::contentPane.localToGlobal(param1);
  2168.          }
  2169.          return localToGlobal(param1);
  2170.       }
  2171.       
  2172.       [Bindable("horizontalPageScrollSizeChanged")]
  2173.       public function get horizontalPageScrollSize() : Number
  2174.       {
  2175.          return _horizontalPageScrollSize;
  2176.       }
  2177.       
  2178.       override mx_internal function childRemoved(param1:DisplayObject) : void
  2179.       {
  2180.          super.mx_internal::childRemoved(param1);
  2181.          invalidateSize();
  2182.          invalidateDisplayList();
  2183.          if(!mx_internal::contentPane)
  2184.          {
  2185.             --mx_internal::_numChildren;
  2186.             if(mx_internal::_numChildren == 0)
  2187.             {
  2188.                _firstChildIndex = super.numChildren;
  2189.             }
  2190.          }
  2191.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  2192.          {
  2193.             forceLayout = true;
  2194.             UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  2195.          }
  2196.          dispatchEvent(new Event("childrenChanged"));
  2197.       }
  2198.       
  2199.       public function set defaultButton(param1:IFlexDisplayObject) : void
  2200.       {
  2201.          _defaultButton = param1;
  2202.          ContainerGlobals.focusedContainer = null;
  2203.       }
  2204.       
  2205.       [Bindable("dataChange")]
  2206.       public function get data() : Object
  2207.       {
  2208.          return _data;
  2209.       }
  2210.       
  2211.       override public function get numChildren() : int
  2212.       {
  2213.          return !!mx_internal::contentPane ? mx_internal::contentPane.numChildren : mx_internal::_numChildren;
  2214.       }
  2215.       
  2216.       public function get autoLayout() : Boolean
  2217.       {
  2218.          return _autoLayout;
  2219.       }
  2220.       
  2221.       override public function styleChanged(param1:String) : void
  2222.       {
  2223.          var _loc3_:String = null;
  2224.          var _loc4_:String = null;
  2225.          var _loc2_:Boolean = param1 == null || param1 == "styleName";
  2226.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2227.          {
  2228.             invalidateDisplayList();
  2229.          }
  2230.          if(_loc2_ || param1 == "borderSkin")
  2231.          {
  2232.             if(mx_internal::border)
  2233.             {
  2234.                rawChildren.removeChild(DisplayObject(mx_internal::border));
  2235.                mx_internal::border = null;
  2236.                createBorder();
  2237.             }
  2238.          }
  2239.          if(_loc2_ || param1 == "borderStyle" || param1 == "backgroundColor" || param1 == "backgroundImage" || param1 == "mouseShield" || param1 == "mouseShieldChildren")
  2240.          {
  2241.             createBorder();
  2242.          }
  2243.          super.styleChanged(param1);
  2244.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2245.          {
  2246.             mx_internal::invalidateViewMetricsAndPadding();
  2247.          }
  2248.          if(_loc2_ || param1 == "horizontalScrollBarStyleName")
  2249.          {
  2250.             if(Boolean(horizontalScrollBar) && horizontalScrollBar is ISimpleStyleClient)
  2251.             {
  2252.                _loc3_ = getStyle("horizontalScrollBarStyleName");
  2253.                ISimpleStyleClient(horizontalScrollBar).styleName = _loc3_;
  2254.             }
  2255.          }
  2256.          if(_loc2_ || param1 == "verticalScrollBarStyleName")
  2257.          {
  2258.             if(Boolean(verticalScrollBar) && verticalScrollBar is ISimpleStyleClient)
  2259.             {
  2260.                _loc4_ = getStyle("verticalScrollBarStyleName");
  2261.                ISimpleStyleClient(verticalScrollBar).styleName = _loc4_;
  2262.             }
  2263.          }
  2264.       }
  2265.       
  2266.       override protected function commitProperties() : void
  2267.       {
  2268.          var _loc1_:String = null;
  2269.          super.commitProperties();
  2270.          if(changedStyles)
  2271.          {
  2272.             _loc1_ = changedStyles == MULTIPLE_PROPERTIES ? null : changedStyles;
  2273.             super.notifyStyleChangeInChildren(_loc1_,true);
  2274.             changedStyles = null;
  2275.          }
  2276.          createOrDestroyBlocker();
  2277.       }
  2278.       
  2279.       override public function finishPrint(param1:Object, param2:IFlexDisplayObject) : void
  2280.       {
  2281.          if(param1)
  2282.          {
  2283.             mx_internal::contentPane.scrollRect = Rectangle(param1);
  2284.          }
  2285.          super.finishPrint(param1,param2);
  2286.       }
  2287.       
  2288.       public function get maxHorizontalScrollPosition() : Number
  2289.       {
  2290.          return !!horizontalScrollBar ? horizontalScrollBar.maxScrollPosition : Math.max(scrollableWidth - viewableWidth,0);
  2291.       }
  2292.       
  2293.       public function set creationPolicy(param1:String) : void
  2294.       {
  2295.          _creationPolicy = param1;
  2296.          mx_internal::setActualCreationPolicies(param1);
  2297.       }
  2298.       
  2299.       public function set label(param1:String) : void
  2300.       {
  2301.          _label = param1;
  2302.          dispatchEvent(new Event("labelChanged"));
  2303.       }
  2304.       
  2305.       private function clampScrollPositions() : Boolean
  2306.       {
  2307.          var _loc1_:Boolean = false;
  2308.          if(_horizontalScrollPosition < 0)
  2309.          {
  2310.             _horizontalScrollPosition = 0;
  2311.             _loc1_ = true;
  2312.          }
  2313.          else if(_horizontalScrollPosition > maxHorizontalScrollPosition)
  2314.          {
  2315.             _horizontalScrollPosition = maxHorizontalScrollPosition;
  2316.             _loc1_ = true;
  2317.          }
  2318.          if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != _horizontalScrollPosition)
  2319.          {
  2320.             horizontalScrollBar.scrollPosition = _horizontalScrollPosition;
  2321.          }
  2322.          if(_verticalScrollPosition < 0)
  2323.          {
  2324.             _verticalScrollPosition = 0;
  2325.             _loc1_ = true;
  2326.          }
  2327.          else if(_verticalScrollPosition > maxVerticalScrollPosition)
  2328.          {
  2329.             _verticalScrollPosition = maxVerticalScrollPosition;
  2330.             _loc1_ = true;
  2331.          }
  2332.          if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != _verticalScrollPosition)
  2333.          {
  2334.             verticalScrollBar.scrollPosition = _verticalScrollPosition;
  2335.          }
  2336.          return _loc1_;
  2337.       }
  2338.       
  2339.       override public function prepareToPrint(param1:IFlexDisplayObject) : Object
  2340.       {
  2341.          var _loc2_:Rectangle = Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect) ? mx_internal::contentPane.scrollRect : null;
  2342.          if(_loc2_)
  2343.          {
  2344.             mx_internal::contentPane.scrollRect = null;
  2345.          }
  2346.          super.prepareToPrint(param1);
  2347.          return _loc2_;
  2348.       }
  2349.       
  2350.       mx_internal function get firstChildIndex() : int
  2351.       {
  2352.          return _firstChildIndex;
  2353.       }
  2354.       
  2355.       mx_internal function rawChildren_addChild(param1:DisplayObject) : DisplayObject
  2356.       {
  2357.          if(mx_internal::_numChildren == 0)
  2358.          {
  2359.             ++_firstChildIndex;
  2360.          }
  2361.          super.mx_internal::addingChild(param1);
  2362.          mx_internal::$addChild(param1);
  2363.          super.mx_internal::childAdded(param1);
  2364.          dispatchEvent(new Event("childrenChanged"));
  2365.          return param1;
  2366.       }
  2367.       
  2368.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  2369.       {
  2370.          var _loc3_:Object = null;
  2371.          var _loc4_:Number = NaN;
  2372.          super.updateDisplayList(param1,param2);
  2373.          layoutChrome(param1,param2);
  2374.          if(scrollPositionChanged)
  2375.          {
  2376.             clampScrollPositions();
  2377.             scrollChildren();
  2378.             scrollPositionChanged = false;
  2379.          }
  2380.          if(scrollPropertiesChanged)
  2381.          {
  2382.             if(horizontalScrollBar)
  2383.             {
  2384.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  2385.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  2386.             }
  2387.             if(verticalScrollBar)
  2388.             {
  2389.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  2390.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  2391.             }
  2392.             scrollPropertiesChanged = false;
  2393.          }
  2394.          if(Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect))
  2395.          {
  2396.             _loc3_ = enabled ? null : getStyle("backgroundDisabledColor");
  2397.             if(_loc3_ === null || isNaN(Number(_loc3_)))
  2398.             {
  2399.                _loc3_ = getStyle("backgroundColor");
  2400.             }
  2401.             _loc4_ = getStyle("backgroundAlpha");
  2402.             if(!_clipContent || isNaN(Number(_loc3_)) || _loc3_ === "" || !(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar)) && !cacheAsBitmap)
  2403.             {
  2404.                _loc3_ = null;
  2405.             }
  2406.             else if(getStyle("backgroundImage") || getStyle("background"))
  2407.             {
  2408.                _loc3_ = null;
  2409.             }
  2410.             else if(_loc4_ != 1)
  2411.             {
  2412.                _loc3_ = null;
  2413.             }
  2414.             mx_internal::contentPane.opaqueBackground = _loc3_;
  2415.             mx_internal::contentPane.cacheAsBitmap = _loc3_ != null;
  2416.          }
  2417.       }
  2418.       
  2419.       override mx_internal function addingChild(param1:DisplayObject) : void
  2420.       {
  2421.          var _loc2_:IUIComponent = IUIComponent(param1);
  2422.          super.mx_internal::addingChild(param1);
  2423.          invalidateSize();
  2424.          invalidateDisplayList();
  2425.          if(!mx_internal::contentPane)
  2426.          {
  2427.             if(mx_internal::_numChildren == 0)
  2428.             {
  2429.                _firstChildIndex = super.numChildren;
  2430.             }
  2431.             ++mx_internal::_numChildren;
  2432.          }
  2433.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  2434.          {
  2435.             forceLayout = true;
  2436.             UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  2437.          }
  2438.       }
  2439.       
  2440.       mx_internal function setActualCreationPolicies(param1:String) : void
  2441.       {
  2442.          var _loc5_:IFlexDisplayObject = null;
  2443.          var _loc6_:Container = null;
  2444.          actualCreationPolicy = param1;
  2445.          var _loc2_:String = param1;
  2446.          if(param1 == ContainerCreationPolicy.QUEUED)
  2447.          {
  2448.             _loc2_ = ContainerCreationPolicy.AUTO;
  2449.          }
  2450.          var _loc3_:int = numChildren;
  2451.          var _loc4_:int = 0;
  2452.          while(_loc4_ < _loc3_)
  2453.          {
  2454.             _loc5_ = IFlexDisplayObject(getChildAt(_loc4_));
  2455.             if(_loc5_ is Container)
  2456.             {
  2457.                _loc6_ = Container(_loc5_);
  2458.                if(_loc6_.creationPolicy == null)
  2459.                {
  2460.                   _loc6_.mx_internal::setActualCreationPolicies(_loc2_);
  2461.                }
  2462.             }
  2463.             _loc4_++;
  2464.          }
  2465.       }
  2466.    }
  2467. }
  2468.  
  2469.