home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / core / Container.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  85.7 KB  |  2,479 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.5.0.12683";
  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.       mx_internal function $addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  580.       {
  581.          super.addEventListener(param1,param2,param3,param4,param5);
  582.       }
  583.       
  584.       private function createOrDestroyScrollbars(param1:Boolean, param2:Boolean, param3:Boolean) : Boolean
  585.       {
  586.          var _loc5_:IFocusManager = null;
  587.          var _loc6_:String = null;
  588.          var _loc7_:String = null;
  589.          var _loc8_:Graphics = null;
  590.          var _loc4_:Boolean = false;
  591.          if(param1 || param2 || param3)
  592.          {
  593.             mx_internal::createContentPane();
  594.          }
  595.          if(param1)
  596.          {
  597.             if(!horizontalScrollBar)
  598.             {
  599.                horizontalScrollBar = new HScrollBar();
  600.                horizontalScrollBar.name = "horizontalScrollBar";
  601.                _loc6_ = getStyle("horizontalScrollBarStyleName");
  602.                if((Boolean(_loc6_)) && horizontalScrollBar is ISimpleStyleClient)
  603.                {
  604.                   ISimpleStyleClient(horizontalScrollBar).styleName = _loc6_;
  605.                }
  606.                rawChildren.addChild(DisplayObject(horizontalScrollBar));
  607.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  608.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  609.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  610.                horizontalScrollBar.enabled = enabled;
  611.                if(horizontalScrollBar is IInvalidating)
  612.                {
  613.                   IInvalidating(horizontalScrollBar).validateNow();
  614.                }
  615.                invalidateDisplayList();
  616.                mx_internal::invalidateViewMetricsAndPadding();
  617.                _loc4_ = true;
  618.                if(!verticalScrollBar)
  619.                {
  620.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  621.                }
  622.             }
  623.          }
  624.          else if(horizontalScrollBar)
  625.          {
  626.             horizontalScrollBar.removeEventListener(ScrollEvent.SCROLL,horizontalScrollBar_scrollHandler);
  627.             rawChildren.removeChild(DisplayObject(horizontalScrollBar));
  628.             horizontalScrollBar = null;
  629.             viewableWidth = scrollableWidth = 0;
  630.             if(_horizontalScrollPosition != 0)
  631.             {
  632.                _horizontalScrollPosition = 0;
  633.                scrollPositionChanged = true;
  634.             }
  635.             invalidateDisplayList();
  636.             mx_internal::invalidateViewMetricsAndPadding();
  637.             _loc4_ = true;
  638.             _loc5_ = focusManager;
  639.             if(!verticalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  640.             {
  641.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  642.             }
  643.          }
  644.          if(param2)
  645.          {
  646.             if(!verticalScrollBar)
  647.             {
  648.                verticalScrollBar = new VScrollBar();
  649.                verticalScrollBar.name = "verticalScrollBar";
  650.                _loc7_ = getStyle("verticalScrollBarStyleName");
  651.                if((Boolean(_loc7_)) && verticalScrollBar is ISimpleStyleClient)
  652.                {
  653.                   ISimpleStyleClient(verticalScrollBar).styleName = _loc7_;
  654.                }
  655.                rawChildren.addChild(DisplayObject(verticalScrollBar));
  656.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  657.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  658.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  659.                verticalScrollBar.enabled = enabled;
  660.                if(verticalScrollBar is IInvalidating)
  661.                {
  662.                   IInvalidating(verticalScrollBar).validateNow();
  663.                }
  664.                invalidateDisplayList();
  665.                mx_internal::invalidateViewMetricsAndPadding();
  666.                _loc4_ = true;
  667.                if(!horizontalScrollBar)
  668.                {
  669.                   addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  670.                }
  671.                addEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  672.             }
  673.          }
  674.          else if(verticalScrollBar)
  675.          {
  676.             verticalScrollBar.removeEventListener(ScrollEvent.SCROLL,verticalScrollBar_scrollHandler);
  677.             rawChildren.removeChild(DisplayObject(verticalScrollBar));
  678.             verticalScrollBar = null;
  679.             viewableHeight = scrollableHeight = 0;
  680.             if(_verticalScrollPosition != 0)
  681.             {
  682.                _verticalScrollPosition = 0;
  683.                scrollPositionChanged = true;
  684.             }
  685.             invalidateDisplayList();
  686.             mx_internal::invalidateViewMetricsAndPadding();
  687.             _loc4_ = true;
  688.             _loc5_ = focusManager;
  689.             if(!horizontalScrollBar && (!_loc5_ || _loc5_.getFocus() != this))
  690.             {
  691.                removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler);
  692.             }
  693.             removeEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  694.          }
  695.          if(Boolean(horizontalScrollBar) && Boolean(verticalScrollBar))
  696.          {
  697.             if(!whiteBox)
  698.             {
  699.                whiteBox = new FlexShape();
  700.                whiteBox.name = "whiteBox";
  701.                _loc8_ = whiteBox.graphics;
  702.                _loc8_.beginFill(16777215);
  703.                _loc8_.drawRect(0,0,verticalScrollBar.minWidth,horizontalScrollBar.minHeight);
  704.                _loc8_.endFill();
  705.                rawChildren.addChild(whiteBox);
  706.             }
  707.          }
  708.          else if(whiteBox)
  709.          {
  710.             rawChildren.removeChild(whiteBox);
  711.             whiteBox = null;
  712.          }
  713.          return _loc4_;
  714.       }
  715.       
  716.       override protected function keyDownHandler(param1:KeyboardEvent) : void
  717.       {
  718.          var _loc3_:String = null;
  719.          var _loc4_:Number = NaN;
  720.          var _loc2_:Object = getFocus();
  721.          if(_loc2_ is TextField)
  722.          {
  723.             return;
  724.          }
  725.          if(verticalScrollBar)
  726.          {
  727.             _loc3_ = ScrollEventDirection.VERTICAL;
  728.             _loc4_ = verticalScrollPosition;
  729.             switch(param1.keyCode)
  730.             {
  731.                case Keyboard.DOWN:
  732.                   verticalScrollPosition += verticalLineScrollSize;
  733.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_DOWN);
  734.                   param1.stopPropagation();
  735.                   break;
  736.                case Keyboard.UP:
  737.                   verticalScrollPosition -= verticalLineScrollSize;
  738.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.LINE_UP);
  739.                   param1.stopPropagation();
  740.                   break;
  741.                case Keyboard.PAGE_UP:
  742.                   verticalScrollPosition -= verticalPageScrollSize;
  743.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_UP);
  744.                   param1.stopPropagation();
  745.                   break;
  746.                case Keyboard.PAGE_DOWN:
  747.                   verticalScrollPosition += verticalPageScrollSize;
  748.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.PAGE_DOWN);
  749.                   param1.stopPropagation();
  750.                   break;
  751.                case Keyboard.HOME:
  752.                   verticalScrollPosition = verticalScrollBar.minScrollPosition;
  753.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_TOP);
  754.                   param1.stopPropagation();
  755.                   break;
  756.                case Keyboard.END:
  757.                   verticalScrollPosition = verticalScrollBar.maxScrollPosition;
  758.                   dispatchScrollEvent(_loc3_,_loc4_,verticalScrollPosition,ScrollEventDetail.AT_BOTTOM);
  759.                   param1.stopPropagation();
  760.             }
  761.          }
  762.          if(horizontalScrollBar)
  763.          {
  764.             _loc3_ = ScrollEventDirection.HORIZONTAL;
  765.             _loc4_ = horizontalScrollPosition;
  766.             switch(param1.keyCode)
  767.             {
  768.                case Keyboard.LEFT:
  769.                   horizontalScrollPosition -= horizontalLineScrollSize;
  770.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_LEFT);
  771.                   param1.stopPropagation();
  772.                   break;
  773.                case Keyboard.RIGHT:
  774.                   horizontalScrollPosition += horizontalLineScrollSize;
  775.                   dispatchScrollEvent(_loc3_,_loc4_,horizontalScrollPosition,ScrollEventDetail.LINE_RIGHT);
  776.                   param1.stopPropagation();
  777.             }
  778.          }
  779.       }
  780.       
  781.       [Bindable("iconChanged")]
  782.       public function get icon() : Class
  783.       {
  784.          return _icon;
  785.       }
  786.       
  787.       private function createOrDestroyBlocker() : void
  788.       {
  789.          var _loc1_:DisplayObject = null;
  790.          var _loc2_:ISystemManager = null;
  791.          if(enabled)
  792.          {
  793.             if(mx_internal::blocker)
  794.             {
  795.                rawChildren.removeChild(mx_internal::blocker);
  796.                mx_internal::blocker = null;
  797.             }
  798.          }
  799.          else if(!mx_internal::blocker)
  800.          {
  801.             mx_internal::blocker = new FlexSprite();
  802.             mx_internal::blocker.name = "blocker";
  803.             mx_internal::blocker.mouseEnabled = true;
  804.             rawChildren.addChild(mx_internal::blocker);
  805.             mx_internal::blocker.addEventListener(MouseEvent.CLICK,blocker_clickHandler);
  806.             _loc1_ = !!focusManager ? DisplayObject(focusManager.getFocus()) : null;
  807.             while(_loc1_)
  808.             {
  809.                if(_loc1_ == this)
  810.                {
  811.                   _loc2_ = systemManager;
  812.                   if(Boolean(_loc2_) && Boolean(_loc2_.stage))
  813.                   {
  814.                      _loc2_.stage.focus = null;
  815.                   }
  816.                   break;
  817.                }
  818.                _loc1_ = _loc1_.parent;
  819.             }
  820.          }
  821.       }
  822.       
  823.       private function horizontalScrollBar_scrollHandler(param1:Event) : void
  824.       {
  825.          var _loc2_:Number = NaN;
  826.          if(param1 is ScrollEvent)
  827.          {
  828.             _loc2_ = horizontalScrollPosition;
  829.             horizontalScrollPosition = horizontalScrollBar.scrollPosition;
  830.             dispatchScrollEvent(ScrollEventDirection.HORIZONTAL,_loc2_,horizontalScrollPosition,ScrollEvent(param1).detail);
  831.          }
  832.       }
  833.       
  834.       public function createComponentFromDescriptor(param1:ComponentDescriptor, param2:Boolean) : IFlexDisplayObject
  835.       {
  836.          var _loc7_:String = null;
  837.          var _loc10_:IRepeaterClient = null;
  838.          var _loc11_:IStyleClient = null;
  839.          var _loc12_:String = null;
  840.          var _loc13_:String = null;
  841.          var _loc3_:UIComponentDescriptor = UIComponentDescriptor(param1);
  842.          var _loc4_:Object = _loc3_.properties;
  843.          if((numChildrenBefore != 0 || mx_internal::numChildrenCreated != -1) && _loc3_.mx_internal::instanceIndices == null && hasChildMatchingDescriptor(_loc3_))
  844.          {
  845.             return null;
  846.          }
  847.          UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = true;
  848.          var _loc5_:Class = _loc3_.type;
  849.          var _loc6_:IDeferredInstantiationUIComponent = new _loc5_();
  850.          _loc6_.id = _loc3_.id;
  851.          if(Boolean(_loc6_.id) && _loc6_.id != "")
  852.          {
  853.             _loc6_.name = _loc6_.id;
  854.          }
  855.          _loc6_.descriptor = _loc3_;
  856.          if(Boolean(_loc4_.childDescriptors) && _loc6_ is Container)
  857.          {
  858.             Container(_loc6_)._childDescriptors = _loc4_.childDescriptors;
  859.             delete _loc4_.childDescriptors;
  860.          }
  861.          for(_loc7_ in _loc4_)
  862.          {
  863.             _loc6_[_loc7_] = _loc4_[_loc7_];
  864.          }
  865.          if(_loc6_ is Container)
  866.          {
  867.             Container(_loc6_).recursionFlag = param2;
  868.          }
  869.          if(_loc3_.mx_internal::instanceIndices)
  870.          {
  871.             if(_loc6_ is IRepeaterClient)
  872.             {
  873.                _loc10_ = IRepeaterClient(_loc6_);
  874.                _loc10_.instanceIndices = _loc3_.mx_internal::instanceIndices;
  875.                _loc10_.repeaters = _loc3_.mx_internal::repeaters;
  876.                _loc10_.repeaterIndices = _loc3_.mx_internal::repeaterIndices;
  877.             }
  878.          }
  879.          if(_loc6_ is IStyleClient)
  880.          {
  881.             _loc11_ = IStyleClient(_loc6_);
  882.             if(_loc3_.stylesFactory != null)
  883.             {
  884.                if(!_loc11_.styleDeclaration)
  885.                {
  886.                   _loc11_.styleDeclaration = new CSSStyleDeclaration();
  887.                }
  888.                _loc11_.styleDeclaration.factory = _loc3_.stylesFactory;
  889.             }
  890.          }
  891.          var _loc8_:Object = _loc3_.events;
  892.          if(_loc8_)
  893.          {
  894.             for(_loc12_ in _loc8_)
  895.             {
  896.                _loc13_ = _loc8_[_loc12_];
  897.                _loc6_.addEventListener(_loc12_,_loc3_.document[_loc13_]);
  898.             }
  899.          }
  900.          var _loc9_:Array = _loc3_.effects;
  901.          if(_loc9_)
  902.          {
  903.             _loc6_.registerEffects(_loc9_);
  904.          }
  905.          if(_loc6_ is IRepeaterClient)
  906.          {
  907.             IRepeaterClient(_loc6_).initializeRepeaterArrays(this);
  908.          }
  909.          _loc6_.createReferenceOnParentDocument(IFlexDisplayObject(_loc3_.document));
  910.          if(!_loc6_.document)
  911.          {
  912.             _loc6_.document = _loc3_.document;
  913.          }
  914.          if(_loc6_ is IRepeater)
  915.          {
  916.             if(!mx_internal::childRepeaters)
  917.             {
  918.                mx_internal::childRepeaters = [];
  919.             }
  920.             mx_internal::childRepeaters.push(_loc6_);
  921.             _loc6_.executeBindings();
  922.             IRepeater(_loc6_).initializeRepeater(this,param2);
  923.          }
  924.          else
  925.          {
  926.             addChild(DisplayObject(_loc6_));
  927.             _loc6_.executeBindings();
  928.             if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  929.             {
  930.                _loc6_.addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  931.             }
  932.          }
  933.          return _loc6_;
  934.       }
  935.       
  936.       override public function set enabled(param1:Boolean) : void
  937.       {
  938.          super.enabled = param1;
  939.          if(horizontalScrollBar)
  940.          {
  941.             horizontalScrollBar.enabled = param1;
  942.          }
  943.          if(verticalScrollBar)
  944.          {
  945.             verticalScrollBar.enabled = param1;
  946.          }
  947.          invalidateProperties();
  948.       }
  949.       
  950.       public function set horizontalScrollBar(param1:ScrollBar) : void
  951.       {
  952.          _horizontalScrollBar = param1;
  953.       }
  954.       
  955.       mx_internal function get usePadding() : Boolean
  956.       {
  957.          return true;
  958.       }
  959.       
  960.       override public function get baselinePosition() : Number
  961.       {
  962.          var _loc2_:IUIComponent = null;
  963.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  964.          {
  965.             if(getStyle("verticalAlign") == "top" && numChildren > 0)
  966.             {
  967.                _loc2_ = getChildAt(0) as IUIComponent;
  968.                if(_loc2_)
  969.                {
  970.                   return _loc2_.y + _loc2_.baselinePosition;
  971.                }
  972.             }
  973.             return super.baselinePosition;
  974.          }
  975.          if(!mx_internal::validateBaselinePosition())
  976.          {
  977.             return NaN;
  978.          }
  979.          var _loc1_:TextLineMetrics = measureText("Wj");
  980.          if(height < 2 * viewMetrics.top + 4 + _loc1_.ascent)
  981.          {
  982.             return int(height + (_loc1_.ascent - height) / 2);
  983.          }
  984.          return viewMetrics.top + 2 + _loc1_.ascent;
  985.       }
  986.       
  987.       override public function getChildByName(param1:String) : DisplayObject
  988.       {
  989.          var _loc2_:DisplayObject = null;
  990.          var _loc3_:int = 0;
  991.          if(mx_internal::contentPane)
  992.          {
  993.             return mx_internal::contentPane.getChildByName(param1);
  994.          }
  995.          _loc2_ = super.getChildByName(param1);
  996.          if(!_loc2_)
  997.          {
  998.             return null;
  999.          }
  1000.          _loc3_ = super.getChildIndex(_loc2_) - _firstChildIndex;
  1001.          if(_loc3_ < 0 || _loc3_ >= mx_internal::_numChildren)
  1002.          {
  1003.             return null;
  1004.          }
  1005.          return _loc2_;
  1006.       }
  1007.       
  1008.       [Bindable("verticalLineScrollSizeChanged")]
  1009.       public function get verticalLineScrollSize() : Number
  1010.       {
  1011.          return _verticalLineScrollSize;
  1012.       }
  1013.       
  1014.       [Bindable("horizontalScrollPolicyChanged")]
  1015.       public function get horizontalScrollPolicy() : String
  1016.       {
  1017.          return mx_internal::_horizontalScrollPolicy;
  1018.       }
  1019.       
  1020.       mx_internal function $removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  1021.       {
  1022.          super.removeEventListener(param1,param2,param3);
  1023.       }
  1024.       
  1025.       public function get maxVerticalScrollPosition() : Number
  1026.       {
  1027.          return !!verticalScrollBar ? verticalScrollBar.maxScrollPosition : Math.max(scrollableHeight - viewableHeight,0);
  1028.       }
  1029.       
  1030.       public function set horizontalScrollPosition(param1:Number) : void
  1031.       {
  1032.          if(_horizontalScrollPosition == param1)
  1033.          {
  1034.             return;
  1035.          }
  1036.          _horizontalScrollPosition = param1;
  1037.          scrollPositionChanged = true;
  1038.          if(!initialized)
  1039.          {
  1040.             horizontalScrollPositionPending = param1;
  1041.          }
  1042.          invalidateDisplayList();
  1043.          dispatchEvent(new Event("viewChanged"));
  1044.       }
  1045.       
  1046.       mx_internal function invalidateViewMetricsAndPadding() : void
  1047.       {
  1048.          _viewMetricsAndPadding = null;
  1049.       }
  1050.       
  1051.       [Bindable("horizontalLineScrollSizeChanged")]
  1052.       public function get horizontalLineScrollSize() : Number
  1053.       {
  1054.          return _horizontalLineScrollSize;
  1055.       }
  1056.       
  1057.       override public function set focusPane(param1:Sprite) : void
  1058.       {
  1059.          var _loc2_:Boolean = Boolean(mx_internal::invalidateSizeFlag);
  1060.          var _loc3_:Boolean = Boolean(mx_internal::invalidateDisplayListFlag);
  1061.          mx_internal::invalidateSizeFlag = true;
  1062.          mx_internal::invalidateDisplayListFlag = true;
  1063.          if(param1)
  1064.          {
  1065.             rawChildren.addChild(param1);
  1066.             param1.x = 0;
  1067.             param1.y = 0;
  1068.             param1.scrollRect = null;
  1069.             _focusPane = param1;
  1070.          }
  1071.          else
  1072.          {
  1073.             rawChildren.removeChild(_focusPane);
  1074.             _focusPane = null;
  1075.          }
  1076.          if(Boolean(param1) && Boolean(mx_internal::contentPane))
  1077.          {
  1078.             param1.x = mx_internal::contentPane.x;
  1079.             param1.y = mx_internal::contentPane.y;
  1080.             param1.scrollRect = mx_internal::contentPane.scrollRect;
  1081.          }
  1082.          mx_internal::invalidateSizeFlag = _loc2_;
  1083.          mx_internal::invalidateDisplayListFlag = _loc3_;
  1084.       }
  1085.       
  1086.       private function updateBackgroundImageRect() : void
  1087.       {
  1088.          var _loc1_:IRectangularBorder = mx_internal::border as IRectangularBorder;
  1089.          if(!_loc1_)
  1090.          {
  1091.             return;
  1092.          }
  1093.          if(viewableWidth == 0 && viewableHeight == 0)
  1094.          {
  1095.             _loc1_.backgroundImageBounds = null;
  1096.             return;
  1097.          }
  1098.          var _loc2_:EdgeMetrics = viewMetrics;
  1099.          var _loc3_:Number = !!viewableWidth ? viewableWidth : unscaledWidth - _loc2_.left - _loc2_.right;
  1100.          var _loc4_:Number = !!viewableHeight ? viewableHeight : unscaledHeight - _loc2_.top - _loc2_.bottom;
  1101.          if(getStyle("backgroundAttachment") == "fixed")
  1102.          {
  1103.             _loc1_.backgroundImageBounds = new Rectangle(_loc2_.left,_loc2_.top,_loc3_,_loc4_);
  1104.          }
  1105.          else
  1106.          {
  1107.             _loc1_.backgroundImageBounds = new Rectangle(_loc2_.left,_loc2_.top,Math.max(scrollableWidth,_loc3_),Math.max(scrollableHeight,_loc4_));
  1108.          }
  1109.       }
  1110.       
  1111.       private function blocker_clickHandler(param1:Event) : void
  1112.       {
  1113.          param1.stopPropagation();
  1114.       }
  1115.       
  1116.       private function mouseWheelHandler(param1:MouseEvent) : void
  1117.       {
  1118.          var _loc2_:int = 0;
  1119.          var _loc3_:int = 0;
  1120.          var _loc4_:Number = NaN;
  1121.          var _loc5_:Number = NaN;
  1122.          if(verticalScrollBar)
  1123.          {
  1124.             param1.stopPropagation();
  1125.             _loc2_ = param1.delta <= 0 ? 1 : -1;
  1126.             _loc3_ = !!verticalScrollBar ? int(verticalScrollBar.lineScrollSize) : 1;
  1127.             _loc4_ = Math.max(Math.abs(param1.delta),_loc3_);
  1128.             _loc5_ = verticalScrollPosition;
  1129.             verticalScrollPosition += 3 * _loc4_ * _loc2_;
  1130.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc5_,verticalScrollPosition,param1.delta <= 0 ? ScrollEventDetail.LINE_UP : ScrollEventDetail.LINE_DOWN);
  1131.          }
  1132.       }
  1133.       
  1134.       public function get defaultButton() : IFlexDisplayObject
  1135.       {
  1136.          return _defaultButton;
  1137.       }
  1138.       
  1139.       mx_internal function createContentPane() : void
  1140.       {
  1141.          var _loc3_:int = 0;
  1142.          var _loc5_:IUIComponent = null;
  1143.          if(mx_internal::contentPane)
  1144.          {
  1145.             return;
  1146.          }
  1147.          creatingContentPane = true;
  1148.          var _loc1_:int = numChildren;
  1149.          var _loc2_:Sprite = new FlexSprite();
  1150.          _loc2_.name = "contentPane";
  1151.          _loc2_.tabChildren = true;
  1152.          if(mx_internal::border)
  1153.          {
  1154.             _loc3_ = rawChildren.getChildIndex(DisplayObject(mx_internal::border)) + 1;
  1155.             if(mx_internal::border is IRectangularBorder && IRectangularBorder(mx_internal::border).hasBackgroundImage)
  1156.             {
  1157.                _loc3_++;
  1158.             }
  1159.          }
  1160.          else
  1161.          {
  1162.             _loc3_ = 0;
  1163.          }
  1164.          rawChildren.addChildAt(_loc2_,_loc3_);
  1165.          var _loc4_:int = 0;
  1166.          while(_loc4_ < _loc1_)
  1167.          {
  1168.             _loc5_ = IUIComponent(super.getChildAt(_firstChildIndex));
  1169.             _loc2_.addChild(DisplayObject(_loc5_));
  1170.             _loc5_.parentChanged(_loc2_);
  1171.             --mx_internal::_numChildren;
  1172.             _loc4_++;
  1173.          }
  1174.          mx_internal::contentPane = _loc2_;
  1175.          creatingContentPane = false;
  1176.          mx_internal::contentPane.visible = true;
  1177.       }
  1178.       
  1179.       public function set verticalPageScrollSize(param1:Number) : void
  1180.       {
  1181.          scrollPropertiesChanged = true;
  1182.          _verticalPageScrollSize = param1;
  1183.          invalidateDisplayList();
  1184.          dispatchEvent(new Event("verticalPageScrollSizeChanged"));
  1185.       }
  1186.       
  1187.       mx_internal function setDocumentDescriptor(param1:UIComponentDescriptor) : void
  1188.       {
  1189.          var _loc2_:String = null;
  1190.          if(processedDescriptors)
  1191.          {
  1192.             return;
  1193.          }
  1194.          if(Boolean(mx_internal::_documentDescriptor) && Boolean(mx_internal::_documentDescriptor.properties.childDescriptors))
  1195.          {
  1196.             if(param1.properties.childDescriptors)
  1197.             {
  1198.                _loc2_ = resourceManager.getString("core","multipleChildSets_ClassAndSubclass");
  1199.                throw new Error(_loc2_);
  1200.             }
  1201.          }
  1202.          else
  1203.          {
  1204.             mx_internal::_documentDescriptor = param1;
  1205.             mx_internal::_documentDescriptor.document = this;
  1206.          }
  1207.       }
  1208.       
  1209.       private function verticalScrollBar_scrollHandler(param1:Event) : void
  1210.       {
  1211.          var _loc2_:Number = NaN;
  1212.          if(param1 is ScrollEvent)
  1213.          {
  1214.             _loc2_ = verticalScrollPosition;
  1215.             verticalScrollPosition = verticalScrollBar.scrollPosition;
  1216.             dispatchScrollEvent(ScrollEventDirection.VERTICAL,_loc2_,verticalScrollPosition,ScrollEvent(param1).detail);
  1217.          }
  1218.       }
  1219.       
  1220.       public function get creationPolicy() : String
  1221.       {
  1222.          return _creationPolicy;
  1223.       }
  1224.       
  1225.       public function set icon(param1:Class) : void
  1226.       {
  1227.          _icon = param1;
  1228.          dispatchEvent(new Event("iconChanged"));
  1229.       }
  1230.       
  1231.       private function dispatchScrollEvent(param1:String, param2:Number, param3:Number, param4:String) : void
  1232.       {
  1233.          var _loc5_:ScrollEvent = new ScrollEvent(ScrollEvent.SCROLL);
  1234.          _loc5_.direction = param1;
  1235.          _loc5_.position = param3;
  1236.          _loc5_.delta = param3 - param2;
  1237.          _loc5_.detail = param4;
  1238.          dispatchEvent(_loc5_);
  1239.       }
  1240.       
  1241.       [Bindable("labelChanged")]
  1242.       public function get label() : String
  1243.       {
  1244.          return _label;
  1245.       }
  1246.       
  1247.       [Bindable("verticalScrollPolicyChanged")]
  1248.       public function get verticalScrollPolicy() : String
  1249.       {
  1250.          return mx_internal::_verticalScrollPolicy;
  1251.       }
  1252.       
  1253.       public function get borderMetrics() : EdgeMetrics
  1254.       {
  1255.          return Boolean(mx_internal::border) && mx_internal::border is IRectangularBorder ? IRectangularBorder(mx_internal::border).borderMetrics : EdgeMetrics.EMPTY;
  1256.       }
  1257.       
  1258.       private function creationCompleteHandler(param1:FlexEvent) : void
  1259.       {
  1260.          --mx_internal::numChildrenCreated;
  1261.          if(mx_internal::numChildrenCreated <= 0)
  1262.          {
  1263.             dispatchEvent(new FlexEvent("childrenCreationComplete"));
  1264.          }
  1265.       }
  1266.       
  1267.       override public function contentToLocal(param1:Point) : Point
  1268.       {
  1269.          if(!mx_internal::contentPane)
  1270.          {
  1271.             return param1;
  1272.          }
  1273.          param1 = contentToGlobal(param1);
  1274.          return globalToLocal(param1);
  1275.       }
  1276.       
  1277.       override public function removeChild(param1:DisplayObject) : DisplayObject
  1278.       {
  1279.          var _loc2_:int = 0;
  1280.          var _loc3_:int = 0;
  1281.          if(param1 is IDeferredInstantiationUIComponent && Boolean(IDeferredInstantiationUIComponent(param1).descriptor))
  1282.          {
  1283.             if(mx_internal::createdComponents)
  1284.             {
  1285.                _loc2_ = int(mx_internal::createdComponents.length);
  1286.                _loc3_ = 0;
  1287.                while(_loc3_ < _loc2_)
  1288.                {
  1289.                   if(mx_internal::createdComponents[_loc3_] === param1)
  1290.                   {
  1291.                      mx_internal::createdComponents.splice(_loc3_,1);
  1292.                   }
  1293.                   _loc3_++;
  1294.                }
  1295.             }
  1296.          }
  1297.          mx_internal::removingChild(param1);
  1298.          if(param1 is UIComponent && UIComponent(param1).isDocument)
  1299.          {
  1300.             BindingManager.setEnabled(param1,false);
  1301.          }
  1302.          if(mx_internal::contentPane)
  1303.          {
  1304.             mx_internal::contentPane.removeChild(param1);
  1305.          }
  1306.          else
  1307.          {
  1308.             mx_internal::$removeChild(param1);
  1309.          }
  1310.          mx_internal::childRemoved(param1);
  1311.          return param1;
  1312.       }
  1313.       
  1314.       final mx_internal function get $numChildren() : int
  1315.       {
  1316.          return super.numChildren;
  1317.       }
  1318.       
  1319.       mx_internal function get numRepeaters() : int
  1320.       {
  1321.          return !!mx_internal::childRepeaters ? int(mx_internal::childRepeaters.length) : 0;
  1322.       }
  1323.       
  1324.       mx_internal function set numChildrenCreated(param1:int) : void
  1325.       {
  1326.          _numChildrenCreated = param1;
  1327.       }
  1328.       
  1329.       public function get creatingContentPane() : Boolean
  1330.       {
  1331.          return _creatingContentPane;
  1332.       }
  1333.       
  1334.       public function get clipContent() : Boolean
  1335.       {
  1336.          return _clipContent;
  1337.       }
  1338.       
  1339.       mx_internal function rawChildren_getChildIndex(param1:DisplayObject) : int
  1340.       {
  1341.          return super.getChildIndex(param1);
  1342.       }
  1343.       
  1344.       override public function regenerateStyleCache(param1:Boolean) : void
  1345.       {
  1346.          var _loc2_:int = 0;
  1347.          var _loc3_:int = 0;
  1348.          var _loc4_:DisplayObject = null;
  1349.          super.regenerateStyleCache(param1);
  1350.          if(mx_internal::contentPane)
  1351.          {
  1352.             _loc2_ = mx_internal::contentPane.numChildren;
  1353.             _loc3_ = 0;
  1354.             while(_loc3_ < _loc2_)
  1355.             {
  1356.                _loc4_ = getChildAt(_loc3_);
  1357.                if(param1 && _loc4_ is UIComponent)
  1358.                {
  1359.                   if(UIComponent(_loc4_).inheritingStyles != UIComponent.mx_internal::STYLE_UNINITIALIZED)
  1360.                   {
  1361.                      UIComponent(_loc4_).regenerateStyleCache(param1);
  1362.                   }
  1363.                }
  1364.                else if(_loc4_ is IUITextField && Boolean(IUITextField(_loc4_).inheritingStyles))
  1365.                {
  1366.                   StyleProtoChain.initTextField(IUITextField(_loc4_));
  1367.                }
  1368.                _loc3_++;
  1369.             }
  1370.          }
  1371.       }
  1372.       
  1373.       override public function getChildIndex(param1:DisplayObject) : int
  1374.       {
  1375.          var _loc2_:int = 0;
  1376.          if(mx_internal::contentPane)
  1377.          {
  1378.             return mx_internal::contentPane.getChildIndex(param1);
  1379.          }
  1380.          return int(super.getChildIndex(param1) - _firstChildIndex);
  1381.       }
  1382.       
  1383.       mx_internal function rawChildren_contains(param1:DisplayObject) : Boolean
  1384.       {
  1385.          return super.contains(param1);
  1386.       }
  1387.       
  1388.       mx_internal function getScrollableRect() : Rectangle
  1389.       {
  1390.          var _loc9_:DisplayObject = null;
  1391.          var _loc1_:Number = 0;
  1392.          var _loc2_:Number = 0;
  1393.          var _loc3_:Number = 0;
  1394.          var _loc4_:Number = 0;
  1395.          var _loc5_:int = numChildren;
  1396.          var _loc6_:int = 0;
  1397.          while(_loc6_ < _loc5_)
  1398.          {
  1399.             _loc9_ = getChildAt(_loc6_);
  1400.             if(!(_loc9_ is IUIComponent && !IUIComponent(_loc9_).includeInLayout))
  1401.             {
  1402.                _loc1_ = Math.min(_loc1_,_loc9_.x);
  1403.                _loc2_ = Math.min(_loc2_,_loc9_.y);
  1404.                if(!isNaN(_loc9_.width))
  1405.                {
  1406.                   _loc3_ = Math.max(_loc3_,_loc9_.x + _loc9_.width);
  1407.                }
  1408.                if(!isNaN(_loc9_.height))
  1409.                {
  1410.                   _loc4_ = Math.max(_loc4_,_loc9_.y + _loc9_.height);
  1411.                }
  1412.             }
  1413.             _loc6_++;
  1414.          }
  1415.          var _loc7_:EdgeMetrics = viewMetrics;
  1416.          var _loc8_:Rectangle = new Rectangle();
  1417.          _loc8_.left = _loc1_;
  1418.          _loc8_.top = _loc2_;
  1419.          _loc8_.right = _loc3_;
  1420.          _loc8_.bottom = _loc4_;
  1421.          if(mx_internal::usePadding)
  1422.          {
  1423.             _loc8_.right += getStyle("paddingRight");
  1424.             _loc8_.bottom += getStyle("paddingBottom");
  1425.          }
  1426.          return _loc8_;
  1427.       }
  1428.       
  1429.       override protected function createChildren() : void
  1430.       {
  1431.          var _loc1_:Application = null;
  1432.          super.createChildren();
  1433.          createBorder();
  1434.          createOrDestroyScrollbars(horizontalScrollPolicy == ScrollPolicy.ON,verticalScrollPolicy == ScrollPolicy.ON,horizontalScrollPolicy == ScrollPolicy.ON || verticalScrollPolicy == ScrollPolicy.ON);
  1435.          if(creationPolicy != null)
  1436.          {
  1437.             actualCreationPolicy = creationPolicy;
  1438.          }
  1439.          else if(parent is Container)
  1440.          {
  1441.             if(Container(parent).actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  1442.             {
  1443.                actualCreationPolicy = ContainerCreationPolicy.AUTO;
  1444.             }
  1445.             else
  1446.             {
  1447.                actualCreationPolicy = Container(parent).actualCreationPolicy;
  1448.             }
  1449.          }
  1450.          if(actualCreationPolicy == ContainerCreationPolicy.NONE)
  1451.          {
  1452.             actualCreationPolicy = ContainerCreationPolicy.AUTO;
  1453.          }
  1454.          else if(actualCreationPolicy == ContainerCreationPolicy.QUEUED)
  1455.          {
  1456.             _loc1_ = !!parentApplication ? Application(parentApplication) : Application(Application.application);
  1457.             _loc1_.addToCreationQueue(this,creationIndex,null,this);
  1458.          }
  1459.          else if(recursionFlag)
  1460.          {
  1461.             createComponentsFromDescriptors();
  1462.          }
  1463.          if(autoLayout == false)
  1464.          {
  1465.             forceLayout = true;
  1466.          }
  1467.          UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  1468.       }
  1469.       
  1470.       override public function executeBindings(param1:Boolean = false) : void
  1471.       {
  1472.          var _loc2_:Object = Boolean(descriptor) && Boolean(descriptor.document) ? descriptor.document : parentDocument;
  1473.          BindingManager.executeBindings(_loc2_,id,this);
  1474.          if(param1)
  1475.          {
  1476.             executeChildBindings(param1);
  1477.          }
  1478.       }
  1479.       
  1480.       override public function setChildIndex(param1:DisplayObject, param2:int) : void
  1481.       {
  1482.          var _loc3_:int = 0;
  1483.          var _loc4_:int = _loc3_;
  1484.          var _loc5_:int = param2;
  1485.          if(mx_internal::contentPane)
  1486.          {
  1487.             mx_internal::contentPane.setChildIndex(param1,param2);
  1488.             if(_autoLayout || forceLayout)
  1489.             {
  1490.                invalidateDisplayList();
  1491.             }
  1492.          }
  1493.          else
  1494.          {
  1495.             _loc3_ = super.getChildIndex(param1);
  1496.             param2 += _firstChildIndex;
  1497.             if(param2 == _loc3_)
  1498.             {
  1499.                return;
  1500.             }
  1501.             super.setChildIndex(param1,param2);
  1502.             invalidateDisplayList();
  1503.             _loc4_ = _loc3_ - _firstChildIndex;
  1504.             _loc5_ = param2 - _firstChildIndex;
  1505.          }
  1506.          var _loc6_:IndexChangedEvent = new IndexChangedEvent(IndexChangedEvent.CHILD_INDEX_CHANGE);
  1507.          _loc6_.relatedObject = param1;
  1508.          _loc6_.oldIndex = _loc4_;
  1509.          _loc6_.newIndex = _loc5_;
  1510.          dispatchEvent(_loc6_);
  1511.          dispatchEvent(new Event("childrenChanged"));
  1512.       }
  1513.       
  1514.       override public function globalToContent(param1:Point) : Point
  1515.       {
  1516.          if(mx_internal::contentPane)
  1517.          {
  1518.             return mx_internal::contentPane.globalToLocal(param1);
  1519.          }
  1520.          return globalToLocal(param1);
  1521.       }
  1522.       
  1523.       mx_internal function rawChildren_removeChild(param1:DisplayObject) : DisplayObject
  1524.       {
  1525.          var _loc2_:int = mx_internal::rawChildren_getChildIndex(param1);
  1526.          return mx_internal::rawChildren_removeChildAt(_loc2_);
  1527.       }
  1528.       
  1529.       mx_internal function rawChildren_setChildIndex(param1:DisplayObject, param2:int) : void
  1530.       {
  1531.          var _loc3_:int = super.getChildIndex(param1);
  1532.          super.setChildIndex(param1,param2);
  1533.          if(_loc3_ < _firstChildIndex && param2 >= _firstChildIndex)
  1534.          {
  1535.             --_firstChildIndex;
  1536.          }
  1537.          else if(_loc3_ >= _firstChildIndex && param2 <= _firstChildIndex)
  1538.          {
  1539.             ++_firstChildIndex;
  1540.          }
  1541.          dispatchEvent(new Event("childrenChanged"));
  1542.       }
  1543.       
  1544.       public function set verticalLineScrollSize(param1:Number) : void
  1545.       {
  1546.          scrollPropertiesChanged = true;
  1547.          _verticalLineScrollSize = param1;
  1548.          invalidateDisplayList();
  1549.          dispatchEvent(new Event("verticalLineScrollSizeChanged"));
  1550.       }
  1551.       
  1552.       mx_internal function rawChildren_getChildAt(param1:int) : DisplayObject
  1553.       {
  1554.          return super.getChildAt(param1);
  1555.       }
  1556.       
  1557.       public function get creationIndex() : int
  1558.       {
  1559.          return _creationIndex;
  1560.       }
  1561.       
  1562.       public function get verticalScrollBar() : ScrollBar
  1563.       {
  1564.          return _verticalScrollBar;
  1565.       }
  1566.       
  1567.       public function get viewMetricsAndPadding() : EdgeMetrics
  1568.       {
  1569.          if(_viewMetricsAndPadding && (!horizontalScrollBar || horizontalScrollPolicy == ScrollPolicy.ON) && (!verticalScrollBar || verticalScrollPolicy == ScrollPolicy.ON))
  1570.          {
  1571.             return _viewMetricsAndPadding;
  1572.          }
  1573.          if(!_viewMetricsAndPadding)
  1574.          {
  1575.             _viewMetricsAndPadding = new EdgeMetrics();
  1576.          }
  1577.          var _loc1_:EdgeMetrics = _viewMetricsAndPadding;
  1578.          var _loc2_:EdgeMetrics = viewMetrics;
  1579.          _loc1_.left = _loc2_.left + getStyle("paddingLeft");
  1580.          _loc1_.right = _loc2_.right + getStyle("paddingRight");
  1581.          _loc1_.top = _loc2_.top + getStyle("paddingTop");
  1582.          _loc1_.bottom = _loc2_.bottom + getStyle("paddingBottom");
  1583.          return _loc1_;
  1584.       }
  1585.       
  1586.       override public function addChild(param1:DisplayObject) : DisplayObject
  1587.       {
  1588.          return addChildAt(param1,numChildren);
  1589.       }
  1590.       
  1591.       public function set horizontalPageScrollSize(param1:Number) : void
  1592.       {
  1593.          scrollPropertiesChanged = true;
  1594.          _horizontalPageScrollSize = param1;
  1595.          invalidateDisplayList();
  1596.          dispatchEvent(new Event("horizontalPageScrollSizeChanged"));
  1597.       }
  1598.       
  1599.       override mx_internal function childAdded(param1:DisplayObject) : void
  1600.       {
  1601.          dispatchEvent(new Event("childrenChanged"));
  1602.          var _loc2_:ChildExistenceChangedEvent = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_ADD);
  1603.          _loc2_.relatedObject = param1;
  1604.          dispatchEvent(_loc2_);
  1605.          param1.dispatchEvent(new FlexEvent(FlexEvent.ADD));
  1606.          super.mx_internal::childAdded(param1);
  1607.       }
  1608.       
  1609.       public function set horizontalScrollPolicy(param1:String) : void
  1610.       {
  1611.          if(mx_internal::_horizontalScrollPolicy != param1)
  1612.          {
  1613.             mx_internal::_horizontalScrollPolicy = param1;
  1614.             invalidateDisplayList();
  1615.             dispatchEvent(new Event("horizontalScrollPolicyChanged"));
  1616.          }
  1617.       }
  1618.       
  1619.       private function layoutCompleteHandler(param1:FlexEvent) : void
  1620.       {
  1621.          UIComponentGlobals.mx_internal::layoutManager.removeEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler);
  1622.          forceLayout = false;
  1623.          var _loc2_:Boolean = false;
  1624.          if(!isNaN(horizontalScrollPositionPending))
  1625.          {
  1626.             if(horizontalScrollPositionPending < 0)
  1627.             {
  1628.                horizontalScrollPositionPending = 0;
  1629.             }
  1630.             else if(horizontalScrollPositionPending > maxHorizontalScrollPosition)
  1631.             {
  1632.                horizontalScrollPositionPending = maxHorizontalScrollPosition;
  1633.             }
  1634.             if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != horizontalScrollPositionPending)
  1635.             {
  1636.                _horizontalScrollPosition = horizontalScrollPositionPending;
  1637.                horizontalScrollBar.scrollPosition = horizontalScrollPositionPending;
  1638.                _loc2_ = true;
  1639.             }
  1640.             horizontalScrollPositionPending = NaN;
  1641.          }
  1642.          if(!isNaN(verticalScrollPositionPending))
  1643.          {
  1644.             if(verticalScrollPositionPending < 0)
  1645.             {
  1646.                verticalScrollPositionPending = 0;
  1647.             }
  1648.             else if(verticalScrollPositionPending > maxVerticalScrollPosition)
  1649.             {
  1650.                verticalScrollPositionPending = maxVerticalScrollPosition;
  1651.             }
  1652.             if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != verticalScrollPositionPending)
  1653.             {
  1654.                _verticalScrollPosition = verticalScrollPositionPending;
  1655.                verticalScrollBar.scrollPosition = verticalScrollPositionPending;
  1656.                _loc2_ = true;
  1657.             }
  1658.             verticalScrollPositionPending = NaN;
  1659.          }
  1660.          if(_loc2_)
  1661.          {
  1662.             scrollChildren();
  1663.          }
  1664.       }
  1665.       
  1666.       public function createComponentsFromDescriptors(param1:Boolean = true) : void
  1667.       {
  1668.          var _loc4_:IFlexDisplayObject = null;
  1669.          numChildrenBefore = numChildren;
  1670.          mx_internal::createdComponents = [];
  1671.          var _loc2_:int = !!childDescriptors ? int(childDescriptors.length) : 0;
  1672.          var _loc3_:int = 0;
  1673.          while(_loc3_ < _loc2_)
  1674.          {
  1675.             _loc4_ = createComponentFromDescriptor(childDescriptors[_loc3_],param1);
  1676.             mx_internal::createdComponents.push(_loc4_);
  1677.             _loc3_++;
  1678.          }
  1679.          if(creationPolicy == ContainerCreationPolicy.QUEUED || creationPolicy == ContainerCreationPolicy.NONE)
  1680.          {
  1681.             UIComponentGlobals.mx_internal::layoutManager.usePhasedInstantiation = false;
  1682.          }
  1683.          mx_internal::numChildrenCreated = numChildren - numChildrenBefore;
  1684.          processedDescriptors = true;
  1685.       }
  1686.       
  1687.       override mx_internal function fillOverlay(param1:UIComponent, param2:uint, param3:RoundedRectangle = null) : void
  1688.       {
  1689.          var _loc4_:EdgeMetrics = viewMetrics;
  1690.          var _loc5_:Number = 0;
  1691.          if(!param3)
  1692.          {
  1693.             param3 = new RoundedRectangle(_loc4_.left,_loc4_.top,unscaledWidth - _loc4_.right - _loc4_.left,unscaledHeight - _loc4_.bottom - _loc4_.top,_loc5_);
  1694.          }
  1695.          if(isNaN(param3.x) || isNaN(param3.y) || isNaN(param3.width) || isNaN(param3.height) || isNaN(param3.cornerRadius))
  1696.          {
  1697.             return;
  1698.          }
  1699.          var _loc6_:Graphics = param1.graphics;
  1700.          _loc6_.clear();
  1701.          _loc6_.beginFill(param2);
  1702.          _loc6_.drawRoundRect(param3.x,param3.y,param3.width,param3.height,param3.cornerRadius * 2,param3.cornerRadius * 2);
  1703.          _loc6_.endFill();
  1704.       }
  1705.       
  1706.       override public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  1707.       {
  1708.          super.removeEventListener(param1,param2,param3);
  1709.          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)
  1710.          {
  1711.             if(mouseEventReferenceCount > 0 && --mouseEventReferenceCount == 0)
  1712.             {
  1713.                setStyle("mouseShield",false);
  1714.                setStyle("mouseShieldChildren",false);
  1715.             }
  1716.          }
  1717.       }
  1718.       
  1719.       mx_internal function rawChildren_removeChildAt(param1:int) : DisplayObject
  1720.       {
  1721.          var _loc2_:DisplayObject = super.getChildAt(param1);
  1722.          super.mx_internal::removingChild(_loc2_);
  1723.          mx_internal::$removeChildAt(param1);
  1724.          super.mx_internal::childRemoved(_loc2_);
  1725.          if(_firstChildIndex < param1 && param1 < _firstChildIndex + mx_internal::_numChildren)
  1726.          {
  1727.             --mx_internal::_numChildren;
  1728.          }
  1729.          else if(mx_internal::_numChildren == 0 || param1 < _firstChildIndex)
  1730.          {
  1731.             --_firstChildIndex;
  1732.          }
  1733.          invalidateSize();
  1734.          invalidateDisplayList();
  1735.          dispatchEvent(new Event("childrenChanged"));
  1736.          return _loc2_;
  1737.       }
  1738.       
  1739.       public function set data(param1:Object) : void
  1740.       {
  1741.          _data = param1;
  1742.          dispatchEvent(new FlexEvent(FlexEvent.DATA_CHANGE));
  1743.          invalidateDisplayList();
  1744.       }
  1745.       
  1746.       override public function removeChildAt(param1:int) : DisplayObject
  1747.       {
  1748.          return removeChild(getChildAt(param1));
  1749.       }
  1750.       
  1751.       private function isBorderNeeded() : Boolean
  1752.       {
  1753.          var v:Object;
  1754.          var c:Class = getStyle("borderSkin");
  1755.          try
  1756.          {
  1757.             if(c != getDefinitionByName("mx.skins.halo::HaloBorder"))
  1758.             {
  1759.                return true;
  1760.             }
  1761.          }
  1762.          catch(e:Error)
  1763.          {
  1764.             return true;
  1765.          }
  1766.          v = getStyle("borderStyle");
  1767.          if(v)
  1768.          {
  1769.             if(v != "none" || v == "none" && getStyle("mouseShield"))
  1770.             {
  1771.                return true;
  1772.             }
  1773.          }
  1774.          v = getStyle("backgroundColor");
  1775.          if(v !== null && v !== "")
  1776.          {
  1777.             return true;
  1778.          }
  1779.          v = getStyle("backgroundImage");
  1780.          return v != null && v != "";
  1781.       }
  1782.       
  1783.       public function set autoLayout(param1:Boolean) : void
  1784.       {
  1785.          var _loc2_:IInvalidating = null;
  1786.          _autoLayout = param1;
  1787.          if(param1)
  1788.          {
  1789.             invalidateSize();
  1790.             invalidateDisplayList();
  1791.             _loc2_ = parent as IInvalidating;
  1792.             if(_loc2_)
  1793.             {
  1794.                _loc2_.invalidateSize();
  1795.                _loc2_.invalidateDisplayList();
  1796.             }
  1797.          }
  1798.       }
  1799.       
  1800.       [Bindable("verticalPageScrollSizeChanged")]
  1801.       public function get verticalPageScrollSize() : Number
  1802.       {
  1803.          return _verticalPageScrollSize;
  1804.       }
  1805.       
  1806.       [Bindable("childrenChanged")]
  1807.       public function getChildren() : Array
  1808.       {
  1809.          var _loc1_:Array = [];
  1810.          var _loc2_:int = numChildren;
  1811.          var _loc3_:int = 0;
  1812.          while(_loc3_ < _loc2_)
  1813.          {
  1814.             _loc1_.push(getChildAt(_loc3_));
  1815.             _loc3_++;
  1816.          }
  1817.          return _loc1_;
  1818.       }
  1819.       
  1820.       override public function addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  1821.       {
  1822.          var _loc3_:DisplayObjectContainer = param1.parent;
  1823.          if(Boolean(_loc3_) && !(_loc3_ is Loader))
  1824.          {
  1825.             if(_loc3_ == this)
  1826.             {
  1827.                param2 = param2 == numChildren ? param2 - 1 : param2;
  1828.             }
  1829.             _loc3_.removeChild(param1);
  1830.          }
  1831.          mx_internal::addingChild(param1);
  1832.          if(mx_internal::contentPane)
  1833.          {
  1834.             mx_internal::contentPane.addChildAt(param1,param2);
  1835.          }
  1836.          else
  1837.          {
  1838.             mx_internal::$addChildAt(param1,_firstChildIndex + param2);
  1839.          }
  1840.          mx_internal::childAdded(param1);
  1841.          if(param1 is UIComponent && UIComponent(param1).isDocument)
  1842.          {
  1843.             BindingManager.setEnabled(param1,true);
  1844.          }
  1845.          return param1;
  1846.       }
  1847.       
  1848.       private function createScrollbarsIfNeeded(param1:Rectangle) : Boolean
  1849.       {
  1850.          var _loc2_:Number = param1.right;
  1851.          var _loc3_:Number = param1.bottom;
  1852.          var _loc4_:Number = unscaledWidth;
  1853.          var _loc5_:Number = unscaledHeight;
  1854.          var _loc6_:Boolean = param1.left < 0 || param1.top < 0;
  1855.          var _loc7_:EdgeMetrics = viewMetrics;
  1856.          if(scaleX != 1)
  1857.          {
  1858.             _loc4_ += 1 / Math.abs(scaleX);
  1859.          }
  1860.          if(scaleY != 1)
  1861.          {
  1862.             _loc5_ += 1 / Math.abs(scaleY);
  1863.          }
  1864.          _loc4_ = Math.floor(_loc4_);
  1865.          _loc5_ = Math.floor(_loc5_);
  1866.          _loc2_ = Math.floor(_loc2_);
  1867.          _loc3_ = Math.floor(_loc3_);
  1868.          if(Boolean(horizontalScrollBar) && horizontalScrollPolicy != ScrollPolicy.ON)
  1869.          {
  1870.             _loc5_ -= horizontalScrollBar.minHeight;
  1871.          }
  1872.          if(Boolean(verticalScrollBar) && verticalScrollPolicy != ScrollPolicy.ON)
  1873.          {
  1874.             _loc4_ -= verticalScrollBar.minWidth;
  1875.          }
  1876.          _loc4_ -= _loc7_.left + _loc7_.right;
  1877.          _loc5_ -= _loc7_.top + _loc7_.bottom;
  1878.          var _loc8_:* = horizontalScrollPolicy == ScrollPolicy.ON;
  1879.          var _loc9_:* = verticalScrollPolicy == ScrollPolicy.ON;
  1880.          var _loc10_:Boolean = _loc8_ || _loc9_ || _loc6_ || mx_internal::overlay != null || _loc7_.left > 0 || _loc7_.top > 0;
  1881.          if(_loc4_ < _loc2_)
  1882.          {
  1883.             _loc10_ = true;
  1884.             if(horizontalScrollPolicy == ScrollPolicy.AUTO && unscaledHeight - _loc7_.top - _loc7_.bottom >= 18 && unscaledWidth - _loc7_.left - _loc7_.right >= 32)
  1885.             {
  1886.                _loc8_ = true;
  1887.             }
  1888.          }
  1889.          if(_loc5_ < _loc3_)
  1890.          {
  1891.             _loc10_ = true;
  1892.             if(verticalScrollPolicy == ScrollPolicy.AUTO && unscaledWidth - _loc7_.left - _loc7_.right >= 18 && unscaledHeight - _loc7_.top - _loc7_.bottom >= 32)
  1893.             {
  1894.                _loc9_ = true;
  1895.             }
  1896.          }
  1897.          if(_loc8_ && _loc9_ && horizontalScrollPolicy == ScrollPolicy.AUTO && verticalScrollPolicy == ScrollPolicy.AUTO && horizontalScrollBar && verticalScrollBar && _loc4_ + verticalScrollBar.minWidth >= _loc2_ && _loc5_ + horizontalScrollBar.minHeight >= _loc3_)
  1898.          {
  1899.             _loc8_ = _loc9_ = false;
  1900.          }
  1901.          else if(_loc8_ && !_loc9_ && verticalScrollBar && horizontalScrollPolicy == ScrollPolicy.AUTO && _loc4_ + verticalScrollBar.minWidth >= _loc2_)
  1902.          {
  1903.             _loc8_ = false;
  1904.          }
  1905.          var _loc11_:Boolean = createOrDestroyScrollbars(_loc8_,_loc9_,_loc10_);
  1906.          if(scrollableWidth != _loc2_ || viewableWidth != _loc4_ || _loc11_)
  1907.          {
  1908.             if(horizontalScrollBar)
  1909.             {
  1910.                horizontalScrollBar.setScrollProperties(_loc4_,0,_loc2_ - _loc4_,horizontalPageScrollSize);
  1911.                scrollPositionChanged = true;
  1912.             }
  1913.             viewableWidth = _loc4_;
  1914.             scrollableWidth = _loc2_;
  1915.          }
  1916.          if(scrollableHeight != _loc3_ || viewableHeight != _loc5_ || _loc11_)
  1917.          {
  1918.             if(verticalScrollBar)
  1919.             {
  1920.                verticalScrollBar.setScrollProperties(_loc5_,0,_loc3_ - _loc5_,verticalPageScrollSize);
  1921.                scrollPositionChanged = true;
  1922.             }
  1923.             viewableHeight = _loc5_;
  1924.             scrollableHeight = _loc3_;
  1925.          }
  1926.          return _loc11_;
  1927.       }
  1928.       
  1929.       override mx_internal function removingChild(param1:DisplayObject) : void
  1930.       {
  1931.          super.mx_internal::removingChild(param1);
  1932.          param1.dispatchEvent(new FlexEvent(FlexEvent.REMOVE));
  1933.          var _loc2_:ChildExistenceChangedEvent = new ChildExistenceChangedEvent(ChildExistenceChangedEvent.CHILD_REMOVE);
  1934.          _loc2_.relatedObject = param1;
  1935.          dispatchEvent(_loc2_);
  1936.       }
  1937.       
  1938.       mx_internal function get numChildrenCreated() : int
  1939.       {
  1940.          return _numChildrenCreated;
  1941.       }
  1942.       
  1943.       private function hasChildMatchingDescriptor(param1:UIComponentDescriptor) : Boolean
  1944.       {
  1945.          var _loc4_:int = 0;
  1946.          var _loc5_:IUIComponent = null;
  1947.          var _loc2_:String = param1.id;
  1948.          if(_loc2_ != null && _loc2_ in document && document[_loc2_] == null)
  1949.          {
  1950.             return false;
  1951.          }
  1952.          var _loc3_:int = numChildren;
  1953.          _loc4_ = 0;
  1954.          while(_loc4_ < _loc3_)
  1955.          {
  1956.             _loc5_ = IUIComponent(getChildAt(_loc4_));
  1957.             if(_loc5_ is IDeferredInstantiationUIComponent && IDeferredInstantiationUIComponent(_loc5_).descriptor == param1)
  1958.             {
  1959.                return true;
  1960.             }
  1961.             _loc4_++;
  1962.          }
  1963.          if(mx_internal::childRepeaters)
  1964.          {
  1965.             _loc3_ = int(mx_internal::childRepeaters.length);
  1966.             _loc4_ = 0;
  1967.             while(_loc4_ < _loc3_)
  1968.             {
  1969.                if(IDeferredInstantiationUIComponent(mx_internal::childRepeaters[_loc4_]).descriptor == param1)
  1970.                {
  1971.                   return true;
  1972.                }
  1973.                _loc4_++;
  1974.             }
  1975.          }
  1976.          return false;
  1977.       }
  1978.       
  1979.       mx_internal function rawChildren_getChildByName(param1:String) : DisplayObject
  1980.       {
  1981.          return super.getChildByName(param1);
  1982.       }
  1983.       
  1984.       override public function validateDisplayList() : void
  1985.       {
  1986.          var _loc1_:EdgeMetrics = null;
  1987.          var _loc2_:Number = NaN;
  1988.          var _loc3_:Number = NaN;
  1989.          var _loc4_:Object = null;
  1990.          var _loc5_:Number = NaN;
  1991.          var _loc6_:Number = NaN;
  1992.          var _loc7_:Number = NaN;
  1993.          if(_autoLayout || forceLayout)
  1994.          {
  1995.             mx_internal::doingLayout = true;
  1996.             super.validateDisplayList();
  1997.             mx_internal::doingLayout = false;
  1998.          }
  1999.          else
  2000.          {
  2001.             layoutChrome(unscaledWidth,unscaledHeight);
  2002.          }
  2003.          mx_internal::invalidateDisplayListFlag = true;
  2004.          if(createContentPaneAndScrollbarsIfNeeded())
  2005.          {
  2006.             if(_autoLayout || forceLayout)
  2007.             {
  2008.                mx_internal::doingLayout = true;
  2009.                super.validateDisplayList();
  2010.                mx_internal::doingLayout = false;
  2011.             }
  2012.             createContentPaneAndScrollbarsIfNeeded();
  2013.          }
  2014.          if(clampScrollPositions())
  2015.          {
  2016.             scrollChildren();
  2017.          }
  2018.          if(mx_internal::contentPane)
  2019.          {
  2020.             _loc1_ = viewMetrics;
  2021.             if(mx_internal::overlay)
  2022.             {
  2023.                mx_internal::overlay.x = 0;
  2024.                mx_internal::overlay.y = 0;
  2025.                mx_internal::overlay.width = unscaledWidth;
  2026.                mx_internal::overlay.height = unscaledHeight;
  2027.             }
  2028.             if(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar))
  2029.             {
  2030.                if(Boolean(verticalScrollBar) && verticalScrollPolicy == ScrollPolicy.ON)
  2031.                {
  2032.                   _loc1_.right -= verticalScrollBar.minWidth;
  2033.                }
  2034.                if(Boolean(horizontalScrollBar) && horizontalScrollPolicy == ScrollPolicy.ON)
  2035.                {
  2036.                   _loc1_.bottom -= horizontalScrollBar.minHeight;
  2037.                }
  2038.                if(horizontalScrollBar)
  2039.                {
  2040.                   _loc2_ = unscaledWidth - _loc1_.left - _loc1_.right;
  2041.                   if(verticalScrollBar)
  2042.                   {
  2043.                      _loc2_ -= verticalScrollBar.minWidth;
  2044.                   }
  2045.                   horizontalScrollBar.setActualSize(_loc2_,horizontalScrollBar.minHeight);
  2046.                   horizontalScrollBar.move(_loc1_.left,unscaledHeight - _loc1_.bottom - horizontalScrollBar.minHeight);
  2047.                }
  2048.                if(verticalScrollBar)
  2049.                {
  2050.                   _loc3_ = unscaledHeight - _loc1_.top - _loc1_.bottom;
  2051.                   if(horizontalScrollBar)
  2052.                   {
  2053.                      _loc3_ -= horizontalScrollBar.minHeight;
  2054.                   }
  2055.                   verticalScrollBar.setActualSize(verticalScrollBar.minWidth,_loc3_);
  2056.                   verticalScrollBar.move(unscaledWidth - _loc1_.right - verticalScrollBar.minWidth,_loc1_.top);
  2057.                }
  2058.                if(whiteBox)
  2059.                {
  2060.                   whiteBox.x = verticalScrollBar.x;
  2061.                   whiteBox.y = horizontalScrollBar.y;
  2062.                }
  2063.             }
  2064.             mx_internal::contentPane.x = _loc1_.left;
  2065.             mx_internal::contentPane.y = _loc1_.top;
  2066.             if(focusPane)
  2067.             {
  2068.                focusPane.x = _loc1_.left;
  2069.                focusPane.y = _loc1_.top;
  2070.             }
  2071.             scrollChildren();
  2072.          }
  2073.          mx_internal::invalidateDisplayListFlag = false;
  2074.          if(mx_internal::blocker)
  2075.          {
  2076.             _loc1_ = viewMetrics;
  2077.             _loc4_ = enabled ? null : getStyle("backgroundDisabledColor");
  2078.             if(_loc4_ === null || isNaN(Number(_loc4_)))
  2079.             {
  2080.                _loc4_ = getStyle("backgroundColor");
  2081.             }
  2082.             if(_loc4_ === null || isNaN(Number(_loc4_)))
  2083.             {
  2084.                _loc4_ = 16777215;
  2085.             }
  2086.             _loc5_ = getStyle("disabledOverlayAlpha");
  2087.             if(isNaN(_loc5_))
  2088.             {
  2089.                _loc5_ = 0.6;
  2090.             }
  2091.             mx_internal::blocker.x = _loc1_.left;
  2092.             mx_internal::blocker.y = _loc1_.top;
  2093.             _loc6_ = unscaledWidth - (_loc1_.left + _loc1_.right);
  2094.             _loc7_ = unscaledHeight - (_loc1_.top + _loc1_.bottom);
  2095.             mx_internal::blocker.graphics.clear();
  2096.             mx_internal::blocker.graphics.beginFill(uint(_loc4_),_loc5_);
  2097.             mx_internal::blocker.graphics.drawRect(0,0,_loc6_,_loc7_);
  2098.             mx_internal::blocker.graphics.endFill();
  2099.             rawChildren.setChildIndex(mx_internal::blocker,rawChildren.numChildren - 1);
  2100.          }
  2101.       }
  2102.       
  2103.       public function set horizontalLineScrollSize(param1:Number) : void
  2104.       {
  2105.          scrollPropertiesChanged = true;
  2106.          _horizontalLineScrollSize = param1;
  2107.          invalidateDisplayList();
  2108.          dispatchEvent(new Event("horizontalLineScrollSizeChanged"));
  2109.       }
  2110.       
  2111.       mx_internal function rawChildren_addChildAt(param1:DisplayObject, param2:int) : DisplayObject
  2112.       {
  2113.          if(_firstChildIndex < param2 && param2 < _firstChildIndex + mx_internal::_numChildren + 1)
  2114.          {
  2115.             ++mx_internal::_numChildren;
  2116.          }
  2117.          else if(param2 <= _firstChildIndex)
  2118.          {
  2119.             ++_firstChildIndex;
  2120.          }
  2121.          super.mx_internal::addingChild(param1);
  2122.          mx_internal::$addChildAt(param1,param2);
  2123.          super.mx_internal::childAdded(param1);
  2124.          dispatchEvent(new Event("childrenChanged"));
  2125.          return param1;
  2126.       }
  2127.       
  2128.       override public function initialize() : void
  2129.       {
  2130.          var _loc1_:* = undefined;
  2131.          var _loc2_:String = null;
  2132.          if(isDocument && mx_internal::documentDescriptor && !processedDescriptors)
  2133.          {
  2134.             _loc1_ = mx_internal::documentDescriptor.properties;
  2135.             if(_loc1_ && Boolean(_loc1_.childDescriptors))
  2136.             {
  2137.                if(_childDescriptors)
  2138.                {
  2139.                   _loc2_ = resourceManager.getString("core","multipleChildSets_ClassAndInstance");
  2140.                   throw new Error(_loc2_);
  2141.                }
  2142.                _childDescriptors = _loc1_.childDescriptors;
  2143.             }
  2144.          }
  2145.          super.initialize();
  2146.       }
  2147.       
  2148.       mx_internal function set forceClipping(param1:Boolean) : void
  2149.       {
  2150.          if(_clipContent)
  2151.          {
  2152.             if(param1)
  2153.             {
  2154.                ++_forceClippingCount;
  2155.             }
  2156.             else
  2157.             {
  2158.                --_forceClippingCount;
  2159.             }
  2160.             mx_internal::createContentPane();
  2161.             scrollChildren();
  2162.          }
  2163.       }
  2164.       
  2165.       public function removeAllChildren() : void
  2166.       {
  2167.          while(numChildren > 0)
  2168.          {
  2169.             removeChildAt(0);
  2170.          }
  2171.       }
  2172.       
  2173.       override public function contentToGlobal(param1:Point) : Point
  2174.       {
  2175.          if(mx_internal::contentPane)
  2176.          {
  2177.             return mx_internal::contentPane.localToGlobal(param1);
  2178.          }
  2179.          return localToGlobal(param1);
  2180.       }
  2181.       
  2182.       [Bindable("horizontalPageScrollSizeChanged")]
  2183.       public function get horizontalPageScrollSize() : Number
  2184.       {
  2185.          return _horizontalPageScrollSize;
  2186.       }
  2187.       
  2188.       override mx_internal function childRemoved(param1:DisplayObject) : void
  2189.       {
  2190.          super.mx_internal::childRemoved(param1);
  2191.          invalidateSize();
  2192.          invalidateDisplayList();
  2193.          if(!mx_internal::contentPane)
  2194.          {
  2195.             --mx_internal::_numChildren;
  2196.             if(mx_internal::_numChildren == 0)
  2197.             {
  2198.                _firstChildIndex = super.numChildren;
  2199.             }
  2200.          }
  2201.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  2202.          {
  2203.             forceLayout = true;
  2204.             UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  2205.          }
  2206.          dispatchEvent(new Event("childrenChanged"));
  2207.       }
  2208.       
  2209.       public function set defaultButton(param1:IFlexDisplayObject) : void
  2210.       {
  2211.          _defaultButton = param1;
  2212.          ContainerGlobals.focusedContainer = null;
  2213.       }
  2214.       
  2215.       [Bindable("dataChange")]
  2216.       public function get data() : Object
  2217.       {
  2218.          return _data;
  2219.       }
  2220.       
  2221.       override public function get numChildren() : int
  2222.       {
  2223.          return !!mx_internal::contentPane ? mx_internal::contentPane.numChildren : mx_internal::_numChildren;
  2224.       }
  2225.       
  2226.       public function get autoLayout() : Boolean
  2227.       {
  2228.          return _autoLayout;
  2229.       }
  2230.       
  2231.       override public function styleChanged(param1:String) : void
  2232.       {
  2233.          var _loc3_:String = null;
  2234.          var _loc4_:String = null;
  2235.          var _loc2_:Boolean = param1 == null || param1 == "styleName";
  2236.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2237.          {
  2238.             invalidateDisplayList();
  2239.          }
  2240.          if(_loc2_ || param1 == "borderSkin")
  2241.          {
  2242.             if(mx_internal::border)
  2243.             {
  2244.                rawChildren.removeChild(DisplayObject(mx_internal::border));
  2245.                mx_internal::border = null;
  2246.                createBorder();
  2247.             }
  2248.          }
  2249.          if(_loc2_ || param1 == "borderStyle" || param1 == "backgroundColor" || param1 == "backgroundImage" || param1 == "mouseShield" || param1 == "mouseShieldChildren")
  2250.          {
  2251.             createBorder();
  2252.          }
  2253.          super.styleChanged(param1);
  2254.          if(_loc2_ || StyleManager.isSizeInvalidatingStyle(param1))
  2255.          {
  2256.             mx_internal::invalidateViewMetricsAndPadding();
  2257.          }
  2258.          if(_loc2_ || param1 == "horizontalScrollBarStyleName")
  2259.          {
  2260.             if(Boolean(horizontalScrollBar) && horizontalScrollBar is ISimpleStyleClient)
  2261.             {
  2262.                _loc3_ = getStyle("horizontalScrollBarStyleName");
  2263.                ISimpleStyleClient(horizontalScrollBar).styleName = _loc3_;
  2264.             }
  2265.          }
  2266.          if(_loc2_ || param1 == "verticalScrollBarStyleName")
  2267.          {
  2268.             if(Boolean(verticalScrollBar) && verticalScrollBar is ISimpleStyleClient)
  2269.             {
  2270.                _loc4_ = getStyle("verticalScrollBarStyleName");
  2271.                ISimpleStyleClient(verticalScrollBar).styleName = _loc4_;
  2272.             }
  2273.          }
  2274.       }
  2275.       
  2276.       override protected function commitProperties() : void
  2277.       {
  2278.          var _loc1_:String = null;
  2279.          super.commitProperties();
  2280.          if(changedStyles)
  2281.          {
  2282.             _loc1_ = changedStyles == MULTIPLE_PROPERTIES ? null : changedStyles;
  2283.             super.notifyStyleChangeInChildren(_loc1_,true);
  2284.             changedStyles = null;
  2285.          }
  2286.          createOrDestroyBlocker();
  2287.       }
  2288.       
  2289.       override public function finishPrint(param1:Object, param2:IFlexDisplayObject) : void
  2290.       {
  2291.          if(param1)
  2292.          {
  2293.             mx_internal::contentPane.scrollRect = Rectangle(param1);
  2294.          }
  2295.          super.finishPrint(param1,param2);
  2296.       }
  2297.       
  2298.       public function get maxHorizontalScrollPosition() : Number
  2299.       {
  2300.          return !!horizontalScrollBar ? horizontalScrollBar.maxScrollPosition : Math.max(scrollableWidth - viewableWidth,0);
  2301.       }
  2302.       
  2303.       public function set creationPolicy(param1:String) : void
  2304.       {
  2305.          _creationPolicy = param1;
  2306.          mx_internal::setActualCreationPolicies(param1);
  2307.       }
  2308.       
  2309.       public function set label(param1:String) : void
  2310.       {
  2311.          _label = param1;
  2312.          dispatchEvent(new Event("labelChanged"));
  2313.       }
  2314.       
  2315.       private function clampScrollPositions() : Boolean
  2316.       {
  2317.          var _loc1_:Boolean = false;
  2318.          if(_horizontalScrollPosition < 0)
  2319.          {
  2320.             _horizontalScrollPosition = 0;
  2321.             _loc1_ = true;
  2322.          }
  2323.          else if(_horizontalScrollPosition > maxHorizontalScrollPosition)
  2324.          {
  2325.             _horizontalScrollPosition = maxHorizontalScrollPosition;
  2326.             _loc1_ = true;
  2327.          }
  2328.          if(Boolean(horizontalScrollBar) && horizontalScrollBar.scrollPosition != _horizontalScrollPosition)
  2329.          {
  2330.             horizontalScrollBar.scrollPosition = _horizontalScrollPosition;
  2331.          }
  2332.          if(_verticalScrollPosition < 0)
  2333.          {
  2334.             _verticalScrollPosition = 0;
  2335.             _loc1_ = true;
  2336.          }
  2337.          else if(_verticalScrollPosition > maxVerticalScrollPosition)
  2338.          {
  2339.             _verticalScrollPosition = maxVerticalScrollPosition;
  2340.             _loc1_ = true;
  2341.          }
  2342.          if(Boolean(verticalScrollBar) && verticalScrollBar.scrollPosition != _verticalScrollPosition)
  2343.          {
  2344.             verticalScrollBar.scrollPosition = _verticalScrollPosition;
  2345.          }
  2346.          return _loc1_;
  2347.       }
  2348.       
  2349.       override public function prepareToPrint(param1:IFlexDisplayObject) : Object
  2350.       {
  2351.          var _loc2_:Rectangle = Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect) ? mx_internal::contentPane.scrollRect : null;
  2352.          if(_loc2_)
  2353.          {
  2354.             mx_internal::contentPane.scrollRect = null;
  2355.          }
  2356.          super.prepareToPrint(param1);
  2357.          return _loc2_;
  2358.       }
  2359.       
  2360.       mx_internal function get firstChildIndex() : int
  2361.       {
  2362.          return _firstChildIndex;
  2363.       }
  2364.       
  2365.       mx_internal function rawChildren_addChild(param1:DisplayObject) : DisplayObject
  2366.       {
  2367.          if(mx_internal::_numChildren == 0)
  2368.          {
  2369.             ++_firstChildIndex;
  2370.          }
  2371.          super.mx_internal::addingChild(param1);
  2372.          mx_internal::$addChild(param1);
  2373.          super.mx_internal::childAdded(param1);
  2374.          dispatchEvent(new Event("childrenChanged"));
  2375.          return param1;
  2376.       }
  2377.       
  2378.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  2379.       {
  2380.          var _loc3_:Object = null;
  2381.          var _loc4_:Number = NaN;
  2382.          super.updateDisplayList(param1,param2);
  2383.          layoutChrome(param1,param2);
  2384.          if(scrollPositionChanged)
  2385.          {
  2386.             clampScrollPositions();
  2387.             scrollChildren();
  2388.             scrollPositionChanged = false;
  2389.          }
  2390.          if(scrollPropertiesChanged)
  2391.          {
  2392.             if(horizontalScrollBar)
  2393.             {
  2394.                horizontalScrollBar.lineScrollSize = horizontalLineScrollSize;
  2395.                horizontalScrollBar.pageScrollSize = horizontalPageScrollSize;
  2396.             }
  2397.             if(verticalScrollBar)
  2398.             {
  2399.                verticalScrollBar.lineScrollSize = verticalLineScrollSize;
  2400.                verticalScrollBar.pageScrollSize = verticalPageScrollSize;
  2401.             }
  2402.             scrollPropertiesChanged = false;
  2403.          }
  2404.          if(Boolean(mx_internal::contentPane) && Boolean(mx_internal::contentPane.scrollRect))
  2405.          {
  2406.             _loc3_ = enabled ? null : getStyle("backgroundDisabledColor");
  2407.             if(_loc3_ === null || isNaN(Number(_loc3_)))
  2408.             {
  2409.                _loc3_ = getStyle("backgroundColor");
  2410.             }
  2411.             _loc4_ = getStyle("backgroundAlpha");
  2412.             if(!_clipContent || isNaN(Number(_loc3_)) || _loc3_ === "" || !(Boolean(horizontalScrollBar) || Boolean(verticalScrollBar)) && !cacheAsBitmap)
  2413.             {
  2414.                _loc3_ = null;
  2415.             }
  2416.             else if(getStyle("backgroundImage") || getStyle("background"))
  2417.             {
  2418.                _loc3_ = null;
  2419.             }
  2420.             else if(_loc4_ != 1)
  2421.             {
  2422.                _loc3_ = null;
  2423.             }
  2424.             mx_internal::contentPane.opaqueBackground = _loc3_;
  2425.             mx_internal::contentPane.cacheAsBitmap = _loc3_ != null;
  2426.          }
  2427.       }
  2428.       
  2429.       override mx_internal function addingChild(param1:DisplayObject) : void
  2430.       {
  2431.          var _loc2_:IUIComponent = IUIComponent(param1);
  2432.          super.mx_internal::addingChild(param1);
  2433.          invalidateSize();
  2434.          invalidateDisplayList();
  2435.          if(!mx_internal::contentPane)
  2436.          {
  2437.             if(mx_internal::_numChildren == 0)
  2438.             {
  2439.                _firstChildIndex = super.numChildren;
  2440.             }
  2441.             ++mx_internal::_numChildren;
  2442.          }
  2443.          if(Boolean(mx_internal::contentPane) && !autoLayout)
  2444.          {
  2445.             forceLayout = true;
  2446.             UIComponentGlobals.mx_internal::layoutManager.addEventListener(FlexEvent.UPDATE_COMPLETE,layoutCompleteHandler,false,0,true);
  2447.          }
  2448.       }
  2449.       
  2450.       mx_internal function setActualCreationPolicies(param1:String) : void
  2451.       {
  2452.          var _loc5_:IFlexDisplayObject = null;
  2453.          var _loc6_:Container = null;
  2454.          actualCreationPolicy = param1;
  2455.          var _loc2_:String = param1;
  2456.          if(param1 == ContainerCreationPolicy.QUEUED)
  2457.          {
  2458.             _loc2_ = ContainerCreationPolicy.AUTO;
  2459.          }
  2460.          var _loc3_:int = numChildren;
  2461.          var _loc4_:int = 0;
  2462.          while(_loc4_ < _loc3_)
  2463.          {
  2464.             _loc5_ = IFlexDisplayObject(getChildAt(_loc4_));
  2465.             if(_loc5_ is Container)
  2466.             {
  2467.                _loc6_ = Container(_loc5_);
  2468.                if(_loc6_.creationPolicy == null)
  2469.                {
  2470.                   _loc6_.mx_internal::setActualCreationPolicies(_loc2_);
  2471.                }
  2472.             }
  2473.             _loc4_++;
  2474.          }
  2475.       }
  2476.    }
  2477. }
  2478.  
  2479.