home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / containers / FormItem.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  34.1 KB  |  1,004 lines
  1. package mx.containers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import mx.containers.utilityClasses.BoxLayout;
  6.    import mx.containers.utilityClasses.Flex;
  7.    import mx.controls.FormItemLabel;
  8.    import mx.controls.Label;
  9.    import mx.core.Container;
  10.    import mx.core.EdgeMetrics;
  11.    import mx.core.FlexVersion;
  12.    import mx.core.IFlexDisplayObject;
  13.    import mx.core.IUIComponent;
  14.    import mx.core.ScrollPolicy;
  15.    import mx.core.mx_internal;
  16.    import mx.styles.CSSStyleDeclaration;
  17.    import mx.styles.StyleManager;
  18.    
  19.    use namespace mx_internal;
  20.    
  21.    public class FormItem extends Container
  22.    {
  23.       mx_internal static const VERSION:String = "3.5.0.12683";
  24.       
  25.       private var _direction:String = "vertical";
  26.       
  27.       private var guessedNumColumns:int;
  28.       
  29.       private var _required:Boolean = false;
  30.       
  31.       mx_internal var verticalLayoutObject:BoxLayout = new BoxLayout();
  32.       
  33.       private var labelChanged:Boolean = false;
  34.       
  35.       private var guessedRowWidth:Number;
  36.       
  37.       private var labelObj:Label;
  38.       
  39.       private var numberOfGuesses:int = 0;
  40.       
  41.       private var indicatorObj:IFlexDisplayObject;
  42.       
  43.       private var _label:String = "";
  44.       
  45.       public function FormItem()
  46.       {
  47.          super();
  48.          mx_internal::_horizontalScrollPolicy = ScrollPolicy.OFF;
  49.          mx_internal::_verticalScrollPolicy = ScrollPolicy.OFF;
  50.          mx_internal::verticalLayoutObject.target = this;
  51.          mx_internal::verticalLayoutObject.direction = BoxDirection.VERTICAL;
  52.       }
  53.       
  54.       override public function styleChanged(param1:String) : void
  55.       {
  56.          var _loc3_:String = null;
  57.          var _loc4_:CSSStyleDeclaration = null;
  58.          super.styleChanged(param1);
  59.          var _loc2_:Boolean = param1 == null || param1 == "styleName";
  60.          if(_loc2_ || param1 == "labelStyleName")
  61.          {
  62.             if(labelObj)
  63.             {
  64.                _loc3_ = getStyle("labelStyleName");
  65.                if(_loc3_)
  66.                {
  67.                   _loc4_ = StyleManager.getStyleDeclaration("." + _loc3_);
  68.                   if(_loc4_)
  69.                   {
  70.                      labelObj.styleDeclaration = _loc4_;
  71.                      labelObj.regenerateStyleCache(true);
  72.                   }
  73.                }
  74.             }
  75.          }
  76.       }
  77.       
  78.       mx_internal function getHorizontalAlignValue() : Number
  79.       {
  80.          var _loc1_:String = getStyle("horizontalAlign");
  81.          if(_loc1_ == "center")
  82.          {
  83.             return 0.5;
  84.          }
  85.          if(_loc1_ == "right")
  86.          {
  87.             return 1;
  88.          }
  89.          return 0;
  90.       }
  91.       
  92.       private function calcNumColumns(param1:Number) : int
  93.       {
  94.          var _loc7_:IUIComponent = null;
  95.          var _loc8_:Number = NaN;
  96.          var _loc2_:Number = 0;
  97.          var _loc3_:Number = 0;
  98.          var _loc4_:Number = getStyle("horizontalGap");
  99.          if(direction != FormItemDirection.HORIZONTAL)
  100.          {
  101.             return 1;
  102.          }
  103.          var _loc5_:Number = numChildren;
  104.          var _loc6_:int = 0;
  105.          while(_loc6_ < numChildren)
  106.          {
  107.             _loc7_ = IUIComponent(getChildAt(_loc6_));
  108.             if(!_loc7_.includeInLayout)
  109.             {
  110.                _loc5_--;
  111.             }
  112.             else
  113.             {
  114.                _loc8_ = Number(_loc7_.getExplicitOrMeasuredWidth());
  115.                _loc3_ = Math.max(_loc3_,_loc8_);
  116.                _loc2_ += _loc8_;
  117.                if(_loc6_ > 0)
  118.                {
  119.                   _loc2_ += _loc4_;
  120.                }
  121.             }
  122.             _loc6_++;
  123.          }
  124.          if(isNaN(param1) || _loc2_ <= param1)
  125.          {
  126.             return _loc5_;
  127.          }
  128.          if(_loc3_ * 2 <= param1)
  129.          {
  130.             return 2;
  131.          }
  132.          return 1;
  133.       }
  134.       
  135.       override protected function commitProperties() : void
  136.       {
  137.          super.commitProperties();
  138.          if(labelChanged)
  139.          {
  140.             labelObj.text = label;
  141.             labelObj.validateSize();
  142.             labelChanged = false;
  143.          }
  144.       }
  145.       
  146.       mx_internal function get labelObject() : Object
  147.       {
  148.          return labelObj;
  149.       }
  150.       
  151.       private function previousUpdateDisplayList(param1:Number, param2:Number) : void
  152.       {
  153.          var _loc10_:int = 0;
  154.          var _loc11_:IUIComponent = null;
  155.          var _loc12_:Number = NaN;
  156.          var _loc13_:Number = NaN;
  157.          var _loc14_:Number = NaN;
  158.          var _loc15_:Number = NaN;
  159.          var _loc16_:Number = NaN;
  160.          var _loc19_:Number = NaN;
  161.          var _loc20_:int = 0;
  162.          var _loc21_:Number = NaN;
  163.          var _loc22_:int = 0;
  164.          var _loc23_:Number = NaN;
  165.          var _loc24_:Number = NaN;
  166.          var _loc25_:Number = NaN;
  167.          var _loc26_:Number = NaN;
  168.          super.updateDisplayList(param1,param2);
  169.          var _loc3_:EdgeMetrics = viewMetricsAndPadding;
  170.          var _loc4_:Number = _loc3_.left;
  171.          var _loc5_:Number;
  172.          var _loc6_:Number = _loc5_ = _loc3_.top;
  173.          var _loc7_:Number = calculateLabelWidth();
  174.          var _loc8_:Number = getStyle("indicatorGap");
  175.          var _loc9_:String = getStyle("horizontalAlign");
  176.          if(_loc9_ == "right")
  177.          {
  178.             _loc16_ = 1;
  179.          }
  180.          else if(_loc9_ == "center")
  181.          {
  182.             _loc16_ = 0.5;
  183.          }
  184.          else
  185.          {
  186.             _loc16_ = 0;
  187.          }
  188.          var _loc17_:int = numChildren;
  189.          if(_loc17_ > 0)
  190.          {
  191.             _loc11_ = IUIComponent(getChildAt(0));
  192.             _loc12_ = Number(_loc11_.baselinePosition);
  193.             if(!isNaN(_loc12_))
  194.             {
  195.                _loc6_ += _loc12_ - labelObj.baselinePosition;
  196.             }
  197.          }
  198.          labelObj.setActualSize(_loc7_,labelObj.getExplicitOrMeasuredHeight());
  199.          labelObj.move(_loc4_,_loc6_);
  200.          _loc4_ += _loc7_;
  201.          displayIndicator(_loc4_,_loc6_);
  202.          _loc4_ += _loc8_;
  203.          var _loc18_:Number = param1 - _loc3_.right - _loc4_;
  204.          if(_loc18_ < 0)
  205.          {
  206.             _loc18_ = 0;
  207.          }
  208.          if(direction == FormItemDirection.HORIZONTAL)
  209.          {
  210.             _loc19_ = 0;
  211.             _loc20_ = calcNumColumns(_loc18_);
  212.             _loc22_ = 0;
  213.             _loc14_ = getStyle("horizontalGap");
  214.             _loc15_ = getStyle("verticalGap");
  215.             if(_loc20_ != guessedNumColumns && numberOfGuesses == 0)
  216.             {
  217.                guessedRowWidth = _loc18_;
  218.                numberOfGuesses = 1;
  219.                invalidateSize();
  220.             }
  221.             else
  222.             {
  223.                numberOfGuesses = 0;
  224.             }
  225.             if(_loc20_ == _loc17_)
  226.             {
  227.                _loc23_ = height - (_loc5_ + _loc3_.bottom);
  228.                _loc24_ = Flex.flexChildWidthsProportionally(this,_loc18_ - (_loc17_ - 1) * _loc14_,_loc23_);
  229.                _loc4_ += _loc24_ * _loc16_;
  230.                _loc10_ = 0;
  231.                while(_loc10_ < _loc17_)
  232.                {
  233.                   _loc11_ = IUIComponent(getChildAt(_loc10_));
  234.                   _loc11_.move(Math.floor(_loc4_),_loc5_);
  235.                   _loc4_ += _loc11_.width + _loc14_;
  236.                   _loc10_++;
  237.                }
  238.             }
  239.             else
  240.             {
  241.                _loc10_ = 0;
  242.                while(_loc10_ < _loc17_)
  243.                {
  244.                   _loc11_ = IUIComponent(getChildAt(_loc10_));
  245.                   _loc19_ = Math.max(_loc19_,_loc11_.getExplicitOrMeasuredWidth());
  246.                   _loc10_++;
  247.                }
  248.                _loc25_ = _loc18_ - (_loc20_ * _loc19_ + (_loc20_ - 1) * _loc14_);
  249.                if(_loc25_ < 0)
  250.                {
  251.                   _loc25_ = 0;
  252.                }
  253.                _loc21_ = _loc4_ += _loc25_ * _loc16_;
  254.                _loc10_ = 0;
  255.                while(_loc10_ < _loc17_)
  256.                {
  257.                   _loc11_ = IUIComponent(getChildAt(_loc10_));
  258.                   _loc13_ = Math.min(_loc19_,_loc11_.getExplicitOrMeasuredWidth());
  259.                   _loc11_.setActualSize(_loc13_,_loc11_.getExplicitOrMeasuredHeight());
  260.                   _loc11_.move(_loc21_,_loc5_);
  261.                   if(++_loc22_ >= _loc20_)
  262.                   {
  263.                      _loc21_ = _loc4_;
  264.                      _loc22_ = 0;
  265.                      _loc5_ += _loc11_.height + _loc15_;
  266.                   }
  267.                   else
  268.                   {
  269.                      _loc21_ += _loc19_ + _loc14_;
  270.                   }
  271.                   _loc10_++;
  272.                }
  273.             }
  274.          }
  275.          else
  276.          {
  277.             _loc15_ = getStyle("verticalGap");
  278.             _loc10_ = 0;
  279.             while(_loc10_ < _loc17_)
  280.             {
  281.                _loc11_ = IUIComponent(getChildAt(_loc10_));
  282.                if(!isNaN(_loc11_.percentWidth))
  283.                {
  284.                   _loc13_ = Math.floor(_loc18_ * Math.min(_loc11_.percentWidth,100) / 100);
  285.                }
  286.                else
  287.                {
  288.                   _loc13_ = Number(_loc11_.getExplicitOrMeasuredWidth());
  289.                   if(isNaN(_loc11_.explicitWidth))
  290.                   {
  291.                      if(_loc13_ < Math.floor(_loc18_ * 0.25))
  292.                      {
  293.                         _loc13_ = Math.floor(_loc18_ * 0.25);
  294.                      }
  295.                      else if(_loc13_ < Math.floor(_loc18_ * 0.5))
  296.                      {
  297.                         _loc13_ = Math.floor(_loc18_ * 0.5);
  298.                      }
  299.                      else if(_loc13_ < Math.floor(_loc18_ * 0.75))
  300.                      {
  301.                         _loc13_ = Math.floor(_loc18_ * 0.75);
  302.                      }
  303.                      else if(_loc13_ < Math.floor(_loc18_))
  304.                      {
  305.                         _loc13_ = Math.floor(_loc18_);
  306.                      }
  307.                   }
  308.                }
  309.                _loc11_.setActualSize(_loc13_,_loc11_.getExplicitOrMeasuredHeight());
  310.                _loc26_ = (_loc18_ - _loc13_) * _loc16_;
  311.                _loc11_.move(_loc4_ + _loc26_,_loc5_);
  312.                _loc5_ += _loc11_.height;
  313.                _loc5_ = _loc5_ + _loc15_;
  314.                _loc10_++;
  315.             }
  316.          }
  317.          _loc6_ = _loc3_.top;
  318.          if(_loc17_ > 0)
  319.          {
  320.             _loc11_ = IUIComponent(getChildAt(0));
  321.             _loc12_ = Number(_loc11_.baselinePosition);
  322.             if(!isNaN(_loc12_))
  323.             {
  324.                _loc6_ += _loc12_ - labelObj.baselinePosition;
  325.             }
  326.          }
  327.          labelObj.move(labelObj.x,_loc6_);
  328.       }
  329.       
  330.       override protected function createChildren() : void
  331.       {
  332.          var _loc1_:String = null;
  333.          var _loc2_:CSSStyleDeclaration = null;
  334.          super.createChildren();
  335.          if(!labelObj)
  336.          {
  337.             labelObj = new FormItemLabel();
  338.             _loc1_ = getStyle("labelStyleName");
  339.             if(_loc1_)
  340.             {
  341.                _loc2_ = StyleManager.getStyleDeclaration("." + _loc1_);
  342.                if(_loc2_)
  343.                {
  344.                   labelObj.styleDeclaration = _loc2_;
  345.                }
  346.             }
  347.             rawChildren.addChild(labelObj);
  348.             dispatchEvent(new Event("itemLabelChanged"));
  349.          }
  350.       }
  351.       
  352.       internal function getPreferredLabelWidth() : Number
  353.       {
  354.          if(!label || label == "")
  355.          {
  356.             return 0;
  357.          }
  358.          if(isNaN(labelObj.measuredWidth))
  359.          {
  360.             labelObj.validateSize();
  361.          }
  362.          var _loc1_:Number = labelObj.measuredWidth;
  363.          if(isNaN(_loc1_))
  364.          {
  365.             return 0;
  366.          }
  367.          return _loc1_;
  368.       }
  369.       
  370.       override protected function measure() : void
  371.       {
  372.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  373.          {
  374.             previousMeasure();
  375.             return;
  376.          }
  377.          super.measure();
  378.          if(direction == FormItemDirection.VERTICAL)
  379.          {
  380.             measureVertical();
  381.          }
  382.          else
  383.          {
  384.             measureHorizontal();
  385.          }
  386.       }
  387.       
  388.       [Bindable("itemLabelChanged")]
  389.       public function get itemLabel() : Label
  390.       {
  391.          return labelObj;
  392.       }
  393.       
  394.       [Bindable("requiredChanged")]
  395.       public function get required() : Boolean
  396.       {
  397.          return _required;
  398.       }
  399.       
  400.       private function previousMeasure() : void
  401.       {
  402.          var _loc12_:Number = NaN;
  403.          var _loc13_:Number = NaN;
  404.          var _loc16_:int = 0;
  405.          var _loc17_:IUIComponent = null;
  406.          super.measure();
  407.          var _loc1_:int = guessedNumColumns = calcNumColumns(guessedRowWidth);
  408.          var _loc2_:Number = getStyle("horizontalGap");
  409.          var _loc3_:Number = getStyle("verticalGap");
  410.          var _loc4_:Number = getStyle("indicatorGap");
  411.          var _loc5_:int = 0;
  412.          var _loc6_:Number = 0;
  413.          var _loc7_:Number = 0;
  414.          var _loc8_:Number = 0;
  415.          var _loc9_:Number = 0;
  416.          var _loc10_:Number = 0;
  417.          var _loc11_:Number = 0;
  418.          _loc12_ = 0;
  419.          _loc13_ = 0;
  420.          var _loc14_:Number = 0;
  421.          var _loc15_:int = numChildren;
  422.          if(direction == FormItemDirection.HORIZONTAL && _loc1_ < _loc15_)
  423.          {
  424.             _loc16_ = 0;
  425.             while(_loc16_ < _loc15_)
  426.             {
  427.                _loc17_ = IUIComponent(getChildAt(_loc16_));
  428.                _loc14_ = Math.max(_loc14_,_loc17_.getExplicitOrMeasuredWidth());
  429.                _loc16_++;
  430.             }
  431.          }
  432.          _loc16_ = 0;
  433.          while(_loc16_ < _loc15_)
  434.          {
  435.             _loc17_ = IUIComponent(getChildAt(_loc16_));
  436.             if(_loc5_ < _loc1_)
  437.             {
  438.                _loc6_ += !isNaN(_loc17_.percentWidth) ? _loc17_.minWidth : _loc17_.getExplicitOrMeasuredWidth();
  439.                _loc7_ += _loc14_ > 0 ? _loc14_ : _loc17_.getExplicitOrMeasuredWidth();
  440.                if(_loc5_ > 0)
  441.                {
  442.                   _loc6_ += _loc2_;
  443.                   _loc7_ += _loc2_;
  444.                }
  445.                _loc8_ = Math.max(_loc8_,!isNaN(_loc17_.percentHeight) ? Number(_loc17_.minHeight) : Number(_loc17_.getExplicitOrMeasuredHeight()));
  446.                _loc9_ = Math.max(_loc9_,_loc17_.getExplicitOrMeasuredHeight());
  447.             }
  448.             _loc5_++;
  449.             if(_loc5_ >= _loc1_ || _loc16_ == _loc15_ - 1)
  450.             {
  451.                _loc10_ = Math.max(_loc10_,_loc6_);
  452.                _loc12_ = Math.max(_loc12_,_loc7_);
  453.                _loc11_ += _loc8_;
  454.                _loc13_ += _loc9_;
  455.                if(_loc16_ > 0)
  456.                {
  457.                   _loc11_ += _loc3_;
  458.                   _loc13_ += _loc3_;
  459.                }
  460.                _loc5_ = 0;
  461.                _loc6_ = 0;
  462.                _loc7_ = 0;
  463.                _loc8_ = 0;
  464.                _loc9_ = 0;
  465.             }
  466.             _loc16_++;
  467.          }
  468.          var _loc18_:Number = calculateLabelWidth() + _loc4_;
  469.          _loc10_ += _loc18_;
  470.          _loc12_ += _loc18_;
  471.          if(label != null && label != "")
  472.          {
  473.             _loc11_ = Math.max(_loc11_,labelObj.getExplicitOrMeasuredHeight());
  474.             _loc13_ = Math.max(_loc13_,labelObj.getExplicitOrMeasuredHeight());
  475.          }
  476.          var _loc19_:EdgeMetrics = viewMetricsAndPadding;
  477.          _loc11_ += _loc19_.top + _loc19_.bottom;
  478.          _loc10_ += _loc19_.left + _loc19_.right;
  479.          _loc13_ += _loc19_.top + _loc19_.bottom;
  480.          _loc12_ += _loc19_.left + _loc19_.right;
  481.          measuredMinWidth = _loc10_;
  482.          measuredMinHeight = _loc11_;
  483.          measuredWidth = _loc12_;
  484.          measuredHeight = _loc13_;
  485.       }
  486.       
  487.       private function measureHorizontal() : void
  488.       {
  489.          var _loc10_:Number = NaN;
  490.          var _loc12_:Number = NaN;
  491.          var _loc14_:int = 0;
  492.          var _loc16_:IUIComponent = null;
  493.          var _loc1_:int = guessedNumColumns = calcNumColumns(guessedRowWidth);
  494.          var _loc2_:Number = getStyle("horizontalGap");
  495.          var _loc3_:Number = getStyle("verticalGap");
  496.          var _loc4_:Number = getStyle("indicatorGap");
  497.          var _loc5_:Number = 0;
  498.          var _loc6_:Number = 0;
  499.          var _loc7_:Number = 0;
  500.          var _loc8_:Number = 0;
  501.          var _loc9_:Number = 0;
  502.          _loc10_ = 0;
  503.          var _loc11_:Number = 0;
  504.          _loc12_ = 0;
  505.          var _loc13_:Number = 0;
  506.          var _loc15_:int = 0;
  507.          if(_loc1_ < numChildren)
  508.          {
  509.             _loc14_ = 0;
  510.             while(_loc14_ < numChildren)
  511.             {
  512.                _loc16_ = IUIComponent(getChildAt(_loc14_));
  513.                if(_loc16_.includeInLayout)
  514.                {
  515.                   _loc13_ = Math.max(_loc13_,_loc16_.getExplicitOrMeasuredWidth());
  516.                }
  517.                _loc14_++;
  518.             }
  519.          }
  520.          var _loc17_:int = 0;
  521.          _loc14_ = 0;
  522.          while(_loc14_ < numChildren)
  523.          {
  524.             _loc16_ = IUIComponent(getChildAt(_loc14_));
  525.             if(_loc16_.includeInLayout)
  526.             {
  527.                _loc5_ += !isNaN(_loc16_.percentWidth) ? _loc16_.minWidth : _loc16_.getExplicitOrMeasuredWidth();
  528.                _loc6_ += _loc13_ > 0 ? _loc13_ : _loc16_.getExplicitOrMeasuredWidth();
  529.                if(_loc15_ > 0)
  530.                {
  531.                   _loc5_ += _loc2_;
  532.                   _loc6_ += _loc2_;
  533.                }
  534.                _loc7_ = Math.max(_loc7_,!isNaN(_loc16_.percentHeight) ? Number(_loc16_.minHeight) : Number(_loc16_.getExplicitOrMeasuredHeight()));
  535.                _loc8_ = Math.max(_loc8_,_loc16_.getExplicitOrMeasuredHeight());
  536.                _loc15_++;
  537.                if(_loc15_ >= _loc1_ || _loc14_ == numChildren - 1)
  538.                {
  539.                   _loc9_ = Math.max(_loc9_,_loc5_);
  540.                   _loc11_ = Math.max(_loc11_,_loc6_);
  541.                   _loc10_ += _loc7_;
  542.                   _loc12_ += _loc8_;
  543.                   if(_loc17_ > 0)
  544.                   {
  545.                      _loc10_ += _loc3_;
  546.                      _loc12_ += _loc3_;
  547.                   }
  548.                   _loc15_ = 0;
  549.                   _loc17_++;
  550.                   _loc5_ = 0;
  551.                   _loc6_ = 0;
  552.                   _loc7_ = 0;
  553.                   _loc8_ = 0;
  554.                }
  555.             }
  556.             _loc14_++;
  557.          }
  558.          var _loc18_:Number = calculateLabelWidth() + _loc4_;
  559.          _loc9_ += _loc18_;
  560.          _loc11_ += _loc18_;
  561.          if(label != null && label != "")
  562.          {
  563.             _loc10_ = Math.max(_loc10_,labelObj.getExplicitOrMeasuredHeight());
  564.             _loc12_ = Math.max(_loc12_,labelObj.getExplicitOrMeasuredHeight());
  565.          }
  566.          var _loc19_:EdgeMetrics = viewMetricsAndPadding;
  567.          _loc10_ += _loc19_.top + _loc19_.bottom;
  568.          _loc9_ += _loc19_.left + _loc19_.right;
  569.          _loc12_ += _loc19_.top + _loc19_.bottom;
  570.          _loc11_ += _loc19_.left + _loc19_.right;
  571.          measuredMinWidth = _loc9_;
  572.          measuredMinHeight = _loc10_;
  573.          measuredWidth = _loc11_;
  574.          measuredHeight = _loc12_;
  575.       }
  576.       
  577.       public function set required(param1:Boolean) : void
  578.       {
  579.          if(param1 != _required)
  580.          {
  581.             _required = param1;
  582.             invalidateDisplayList();
  583.             dispatchEvent(new Event("requiredChanged"));
  584.          }
  585.       }
  586.       
  587.       private function updateDisplayListVerticalChildren(param1:Number, param2:Number) : void
  588.       {
  589.          var _loc5_:IUIComponent = null;
  590.          var _loc3_:Number = calculateLabelWidth() + getStyle("indicatorGap");
  591.          if(!isNaN(explicitMinWidth))
  592.          {
  593.             mx_internal::_explicitMinWidth -= _loc3_;
  594.          }
  595.          else if(!isNaN(measuredMinWidth))
  596.          {
  597.             measuredMinWidth -= _loc3_;
  598.          }
  599.          mx_internal::verticalLayoutObject.updateDisplayList(param1 - _loc3_,param2);
  600.          if(!isNaN(explicitMinWidth))
  601.          {
  602.             mx_internal::_explicitMinWidth += _loc3_;
  603.          }
  604.          else if(!isNaN(measuredMinWidth))
  605.          {
  606.             measuredMinWidth += _loc3_;
  607.          }
  608.          var _loc4_:Number = numChildren;
  609.          var _loc6_:Number = 0;
  610.          while(_loc6_ < _loc4_)
  611.          {
  612.             _loc5_ = IUIComponent(getChildAt(_loc6_));
  613.             _loc5_.move(_loc5_.x + _loc3_,_loc5_.y);
  614.             _loc6_++;
  615.          }
  616.       }
  617.       
  618.       private function displayIndicator(param1:Number, param2:Number) : void
  619.       {
  620.          var _loc3_:Class = null;
  621.          if(required)
  622.          {
  623.             if(!indicatorObj)
  624.             {
  625.                _loc3_ = getStyle("indicatorSkin") as Class;
  626.                indicatorObj = IFlexDisplayObject(new _loc3_());
  627.                rawChildren.addChild(DisplayObject(indicatorObj));
  628.             }
  629.             indicatorObj.x = param1 + (getStyle("indicatorGap") - indicatorObj.width) / 2;
  630.             if(labelObj)
  631.             {
  632.                indicatorObj.y = param2 + (labelObj.getExplicitOrMeasuredHeight() - indicatorObj.measuredHeight) / 2;
  633.             }
  634.          }
  635.          else if(indicatorObj)
  636.          {
  637.             rawChildren.removeChild(DisplayObject(indicatorObj));
  638.             indicatorObj = null;
  639.          }
  640.       }
  641.       
  642.       override public function set label(param1:String) : void
  643.       {
  644.          _label = param1;
  645.          labelChanged = true;
  646.          invalidateProperties();
  647.          invalidateSize();
  648.          invalidateDisplayList();
  649.          if(parent is Form)
  650.          {
  651.             Form(parent).invalidateLabelWidth();
  652.          }
  653.          dispatchEvent(new Event("labelChanged"));
  654.       }
  655.       
  656.       private function updateDisplayListHorizontalChildren(param1:Number, param2:Number) : void
  657.       {
  658.          var _loc17_:int = 0;
  659.          var _loc18_:IUIComponent = null;
  660.          var _loc19_:Number = NaN;
  661.          var _loc20_:Number = NaN;
  662.          var _loc27_:Number = NaN;
  663.          var _loc28_:Number = NaN;
  664.          var _loc29_:Number = NaN;
  665.          var _loc30_:Number = NaN;
  666.          var _loc32_:Number = NaN;
  667.          var _loc33_:Number = NaN;
  668.          var _loc34_:Number = NaN;
  669.          var _loc35_:Number = NaN;
  670.          var _loc36_:Number = NaN;
  671.          var _loc37_:Number = NaN;
  672.          var _loc38_:Number = NaN;
  673.          var _loc39_:Boolean = false;
  674.          var _loc40_:Array = null;
  675.          var _loc41_:Number = NaN;
  676.          var _loc42_:* = undefined;
  677.          var _loc43_:* = undefined;
  678.          var _loc44_:* = undefined;
  679.          var _loc3_:EdgeMetrics = viewMetricsAndPadding;
  680.          var _loc4_:Number = calculateLabelWidth();
  681.          var _loc5_:Number = getStyle("indicatorGap");
  682.          var _loc6_:Number = getStyle("horizontalGap");
  683.          var _loc7_:Number = getStyle("verticalGap");
  684.          var _loc8_:Number = getStyle("paddingLeft");
  685.          var _loc9_:Number = getStyle("paddingTop");
  686.          var _loc10_:Number = mx_internal::getHorizontalAlignValue();
  687.          var _loc11_:Number = scaleX > 0 && scaleX != 1 ? minWidth / Math.abs(scaleX) : minWidth;
  688.          var _loc12_:Number = scaleY > 0 && scaleY != 1 ? minHeight / Math.abs(scaleY) : minHeight;
  689.          var _loc13_:Number = Math.max(param1,_loc11_) - _loc3_.left - _loc3_.right;
  690.          var _loc14_:Number = Math.max(param2,_loc12_) - _loc3_.top - _loc3_.bottom;
  691.          var _loc15_:Number = 0;
  692.          var _loc16_:Number = _loc13_ - _loc4_ - _loc5_;
  693.          if(_loc16_ < 0)
  694.          {
  695.             _loc16_ = 0;
  696.          }
  697.          var _loc21_:int = calcNumColumns(_loc16_);
  698.          var _loc22_:int = 0;
  699.          if(_loc21_ != guessedNumColumns && isNaN(explicitWidth))
  700.          {
  701.             if(numberOfGuesses < 2)
  702.             {
  703.                guessedRowWidth = _loc16_;
  704.                ++numberOfGuesses;
  705.                invalidateSize();
  706.                return;
  707.             }
  708.             _loc21_ = guessedNumColumns;
  709.             numberOfGuesses = 0;
  710.          }
  711.          else
  712.          {
  713.             numberOfGuesses = 0;
  714.          }
  715.          var _loc23_:Number = _loc8_ + _loc4_ + _loc5_;
  716.          var _loc24_:Number = _loc9_;
  717.          var _loc25_:Number = _loc23_;
  718.          var _loc26_:Number = _loc24_;
  719.          var _loc31_:int = numChildren;
  720.          _loc17_ = 0;
  721.          while(_loc17_ < numChildren)
  722.          {
  723.             if(!IUIComponent(getChildAt(_loc17_)).includeInLayout)
  724.             {
  725.                _loc31_--;
  726.             }
  727.             _loc17_++;
  728.          }
  729.          if(_loc21_ == _loc31_)
  730.          {
  731.             _loc32_ = Flex.flexChildWidthsProportionally(this,_loc16_ - (_loc31_ - 1) * _loc6_,_loc14_);
  732.             _loc23_ += _loc32_ * _loc10_;
  733.             _loc17_ = 0;
  734.             while(_loc17_ < numChildren)
  735.             {
  736.                _loc18_ = IUIComponent(getChildAt(_loc17_));
  737.                if(_loc18_.includeInLayout)
  738.                {
  739.                   _loc18_.move(Math.floor(_loc23_),_loc24_);
  740.                   _loc23_ += _loc18_.width + _loc6_;
  741.                }
  742.                _loc17_++;
  743.             }
  744.          }
  745.          else
  746.          {
  747.             _loc17_ = 0;
  748.             while(_loc17_ < numChildren)
  749.             {
  750.                _loc18_ = IUIComponent(getChildAt(_loc17_));
  751.                if(_loc18_.includeInLayout)
  752.                {
  753.                   _loc27_ = Number(_loc18_.getExplicitOrMeasuredWidth());
  754.                   _loc29_ = Number(_loc18_.percentWidth);
  755.                   _loc19_ = !isNaN(_loc29_) ? _loc29_ * _loc16_ / 100 : _loc27_;
  756.                   _loc19_ = Math.max(_loc18_.minWidth,Math.min(_loc18_.maxWidth,_loc19_));
  757.                   _loc15_ = Math.max(_loc15_,_loc19_);
  758.                }
  759.                _loc17_++;
  760.             }
  761.             _loc15_ = Math.min(_loc15_,Math.floor((_loc16_ - (_loc21_ - 1) * _loc6_) / _loc21_));
  762.             _loc33_ = _loc16_ - (_loc21_ * _loc15_ + (_loc21_ - 1) * _loc6_);
  763.             if(_loc33_ < 0)
  764.             {
  765.                _loc33_ = 0;
  766.             }
  767.             _loc23_ += _loc33_ * _loc10_;
  768.             _loc34_ = 0;
  769.             _loc35_ = 0;
  770.             _loc36_ = 0;
  771.             _loc38_ = _loc37_ = _loc14_;
  772.             _loc22_ = 0;
  773.             _loc17_ = 0;
  774.             while(_loc17_ < numChildren)
  775.             {
  776.                _loc18_ = IUIComponent(getChildAt(_loc17_));
  777.                if(!_loc18_.includeInLayout)
  778.                {
  779.                   if(_loc17_ == numChildren - 1)
  780.                   {
  781.                      _loc38_ -= _loc35_;
  782.                      if(_loc17_ != numChildren - 1)
  783.                      {
  784.                         _loc38_ -= _loc7_;
  785.                      }
  786.                      if(_loc35_ > 0 && _loc34_ > 0)
  787.                      {
  788.                         _loc34_ = Math.max(0,_loc34_ - 100 * _loc35_ / _loc37_);
  789.                      }
  790.                      _loc36_ += _loc34_;
  791.                      _loc35_ = 0;
  792.                      _loc34_ = 0;
  793.                      _loc22_ = 0;
  794.                   }
  795.                }
  796.                else
  797.                {
  798.                   if(!isNaN(_loc18_.percentHeight))
  799.                   {
  800.                      _loc34_ = Math.max(_loc34_,_loc18_.percentHeight);
  801.                   }
  802.                   else
  803.                   {
  804.                      _loc35_ = Math.max(_loc35_,_loc18_.getExplicitOrMeasuredHeight());
  805.                   }
  806.                   if(++_loc22_ >= _loc21_ || _loc17_ == numChildren - 1)
  807.                   {
  808.                      _loc38_ -= _loc35_;
  809.                      if(_loc17_ != numChildren - 1)
  810.                      {
  811.                         _loc38_ -= _loc7_;
  812.                      }
  813.                      if(_loc35_ > 0 && _loc34_ > 0)
  814.                      {
  815.                         _loc34_ = Math.max(0,_loc34_ - 100 * _loc35_ / _loc37_);
  816.                      }
  817.                      _loc36_ += _loc34_;
  818.                      _loc35_ = 0;
  819.                      _loc34_ = 0;
  820.                      _loc22_ = 0;
  821.                   }
  822.                }
  823.                _loc17_++;
  824.             }
  825.             _loc39_ = false;
  826.             _loc40_ = new Array(numChildren);
  827.             _loc17_ = 0;
  828.             while(_loc17_ < numChildren)
  829.             {
  830.                _loc40_[_loc17_] = -1;
  831.                _loc17_++;
  832.             }
  833.             _loc41_ = _loc38_ - _loc37_ * _loc36_ / 100;
  834.             if(_loc41_ > 0)
  835.             {
  836.                _loc38_ -= _loc41_;
  837.             }
  838.             do
  839.             {
  840.                _loc39_ = true;
  841.                _loc42_ = _loc38_ / _loc36_;
  842.                _loc22_ = 0;
  843.                _loc25_ = _loc23_;
  844.                _loc26_ = _loc24_;
  845.                _loc43_ = 0;
  846.                _loc17_ = 0;
  847.                while(_loc17_ < numChildren)
  848.                {
  849.                   _loc18_ = IUIComponent(getChildAt(_loc17_));
  850.                   if(_loc18_.includeInLayout)
  851.                   {
  852.                      _loc27_ = Number(_loc18_.getExplicitOrMeasuredWidth());
  853.                      _loc28_ = Number(_loc18_.getExplicitOrMeasuredHeight());
  854.                      _loc29_ = Number(_loc18_.percentWidth);
  855.                      _loc30_ = Number(_loc18_.percentHeight);
  856.                      _loc19_ = Math.min(_loc15_,!isNaN(_loc29_) ? _loc29_ * _loc16_ / 100 : _loc27_);
  857.                      _loc19_ = Math.max(_loc18_.minWidth,Math.min(_loc18_.maxWidth,_loc19_));
  858.                      if(_loc40_[_loc17_] != -1)
  859.                      {
  860.                         _loc20_ = Number(_loc40_[_loc17_]);
  861.                      }
  862.                      else
  863.                      {
  864.                         _loc20_ = !isNaN(_loc30_) ? _loc30_ * _loc42_ : _loc28_;
  865.                         if(_loc20_ < _loc18_.minHeight)
  866.                         {
  867.                            _loc20_ = Number(_loc18_.minHeight);
  868.                            _loc36_ -= _loc18_.percentHeight;
  869.                            _loc38_ -= _loc20_;
  870.                            _loc40_[_loc17_] = _loc20_;
  871.                            _loc39_ = false;
  872.                            break;
  873.                         }
  874.                         if(_loc20_ > _loc18_.maxHeight)
  875.                         {
  876.                            _loc20_ = Number(_loc18_.maxHeight);
  877.                            _loc36_ -= _loc18_.percentHeight;
  878.                            _loc38_ -= _loc20_;
  879.                            _loc40_[_loc17_] = _loc20_;
  880.                            _loc39_ = false;
  881.                            break;
  882.                         }
  883.                      }
  884.                      if(_loc18_.scaleX == 1 && _loc18_.scaleY == 1)
  885.                      {
  886.                         _loc18_.setActualSize(Math.floor(_loc19_),Math.floor(_loc20_));
  887.                      }
  888.                      else
  889.                      {
  890.                         _loc18_.setActualSize(_loc19_,_loc20_);
  891.                      }
  892.                      _loc44_ = (_loc15_ - _loc18_.width) * _loc10_;
  893.                      _loc18_.move(Math.floor(_loc25_ + _loc44_),Math.floor(_loc26_));
  894.                      _loc43_ = Math.max(_loc43_,_loc18_.height);
  895.                      if(++_loc22_ >= _loc21_)
  896.                      {
  897.                         _loc25_ = _loc23_;
  898.                         _loc22_ = 0;
  899.                         _loc26_ += _loc43_ + _loc7_;
  900.                         _loc43_ = 0;
  901.                      }
  902.                      else
  903.                      {
  904.                         _loc25_ += _loc15_ + _loc6_;
  905.                      }
  906.                   }
  907.                   _loc17_++;
  908.                }
  909.             }
  910.             while(!_loc39_);
  911.             
  912.          }
  913.       }
  914.       
  915.       [Bindable("labelChanged")]
  916.       override public function get label() : String
  917.       {
  918.          return _label;
  919.       }
  920.       
  921.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  922.       {
  923.          var _loc7_:IUIComponent = null;
  924.          var _loc8_:Number = NaN;
  925.          if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  926.          {
  927.             previousUpdateDisplayList(param1,param2);
  928.             return;
  929.          }
  930.          super.updateDisplayList(param1,param2);
  931.          if(direction == FormItemDirection.VERTICAL)
  932.          {
  933.             updateDisplayListVerticalChildren(param1,param2);
  934.          }
  935.          else
  936.          {
  937.             updateDisplayListHorizontalChildren(param1,param2);
  938.          }
  939.          var _loc3_:EdgeMetrics = viewMetricsAndPadding;
  940.          var _loc4_:Number = _loc3_.left;
  941.          var _loc5_:Number = _loc3_.top;
  942.          var _loc6_:Number = calculateLabelWidth();
  943.          if(numChildren > 0)
  944.          {
  945.             _loc7_ = IUIComponent(getChildAt(0));
  946.             _loc8_ = Number(_loc7_.baselinePosition);
  947.             if(!isNaN(_loc8_))
  948.             {
  949.                _loc5_ += _loc8_ - labelObj.baselinePosition;
  950.             }
  951.          }
  952.          labelObj.setActualSize(_loc6_,labelObj.getExplicitOrMeasuredHeight());
  953.          labelObj.move(_loc4_,_loc5_);
  954.          _loc4_ += _loc6_;
  955.          displayIndicator(_loc4_,_loc5_);
  956.       }
  957.       
  958.       private function calculateLabelWidth() : Number
  959.       {
  960.          var _loc1_:Number = getStyle("labelWidth");
  961.          if(_loc1_ == 0)
  962.          {
  963.             _loc1_ = NaN;
  964.          }
  965.          if(isNaN(_loc1_) && parent is Form)
  966.          {
  967.             _loc1_ = Form(parent).calculateLabelWidth();
  968.          }
  969.          if(isNaN(_loc1_))
  970.          {
  971.             _loc1_ = getPreferredLabelWidth();
  972.          }
  973.          return _loc1_;
  974.       }
  975.       
  976.       private function measureVertical() : void
  977.       {
  978.          var _loc2_:Number = NaN;
  979.          mx_internal::verticalLayoutObject.measure();
  980.          var _loc1_:Number = calculateLabelWidth() + getStyle("indicatorGap");
  981.          measuredMinWidth += _loc1_;
  982.          measuredWidth += _loc1_;
  983.          _loc2_ = labelObj.getExplicitOrMeasuredHeight();
  984.          measuredMinHeight = Math.max(measuredMinHeight,_loc2_);
  985.          measuredHeight = Math.max(measuredHeight,_loc2_);
  986.       }
  987.       
  988.       public function set direction(param1:String) : void
  989.       {
  990.          _direction = param1;
  991.          invalidateSize();
  992.          invalidateDisplayList();
  993.          dispatchEvent(new Event("directionChanged"));
  994.       }
  995.       
  996.       [Bindable("directionChanged")]
  997.       public function get direction() : String
  998.       {
  999.          return _direction;
  1000.       }
  1001.    }
  1002. }
  1003.  
  1004.