home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / containers / utilityClasses / CanvasLayout.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  53.5 KB  |  1,656 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.geom.Rectangle;
  5.    import flash.utils.Dictionary;
  6.    import mx.containers.errors.ConstraintError;
  7.    import mx.core.Container;
  8.    import mx.core.EdgeMetrics;
  9.    import mx.core.FlexVersion;
  10.    import mx.core.IConstraintClient;
  11.    import mx.core.IUIComponent;
  12.    import mx.core.mx_internal;
  13.    import mx.events.ChildExistenceChangedEvent;
  14.    import mx.events.MoveEvent;
  15.    
  16.    use namespace mx_internal;
  17.    
  18.    public class CanvasLayout extends Layout
  19.    {
  20.       mx_internal static const VERSION:String = "3.5.0.12683";
  21.       
  22.       private static var r:Rectangle = new Rectangle();
  23.       
  24.       private var colSpanChildren:Array = [];
  25.       
  26.       private var constraintRegionsInUse:Boolean = false;
  27.       
  28.       private var rowSpanChildren:Array = [];
  29.       
  30.       private var constraintCache:Dictionary = new Dictionary(true);
  31.       
  32.       private var _contentArea:Rectangle;
  33.       
  34.       public function CanvasLayout()
  35.       {
  36.          super();
  37.       }
  38.       
  39.       private function parseConstraints(param1:IUIComponent = null) : ChildConstraintInfo
  40.       {
  41.          var _loc3_:Number = NaN;
  42.          var _loc4_:Number = NaN;
  43.          var _loc5_:Number = NaN;
  44.          var _loc6_:Number = NaN;
  45.          var _loc7_:Number = NaN;
  46.          var _loc8_:Number = NaN;
  47.          var _loc9_:Number = NaN;
  48.          var _loc10_:String = null;
  49.          var _loc11_:String = null;
  50.          var _loc12_:String = null;
  51.          var _loc13_:String = null;
  52.          var _loc14_:String = null;
  53.          var _loc15_:String = null;
  54.          var _loc16_:String = null;
  55.          var _loc17_:Array = null;
  56.          var _loc18_:int = 0;
  57.          var _loc30_:ConstraintColumn = null;
  58.          var _loc31_:Boolean = false;
  59.          var _loc32_:ConstraintRow = null;
  60.          var _loc2_:LayoutConstraints = getLayoutConstraints(param1);
  61.          if(!_loc2_)
  62.          {
  63.             return null;
  64.          }
  65.          _loc17_ = parseConstraintExp(_loc2_.left);
  66.          if(!_loc17_)
  67.          {
  68.             _loc3_ = NaN;
  69.          }
  70.          else if(_loc17_.length == 1)
  71.          {
  72.             _loc3_ = Number(_loc17_[0]);
  73.          }
  74.          else
  75.          {
  76.             _loc10_ = _loc17_[0];
  77.             _loc3_ = Number(_loc17_[1]);
  78.          }
  79.          _loc17_ = parseConstraintExp(_loc2_.right);
  80.          if(!_loc17_)
  81.          {
  82.             _loc4_ = NaN;
  83.          }
  84.          else if(_loc17_.length == 1)
  85.          {
  86.             _loc4_ = Number(_loc17_[0]);
  87.          }
  88.          else
  89.          {
  90.             _loc11_ = _loc17_[0];
  91.             _loc4_ = Number(_loc17_[1]);
  92.          }
  93.          _loc17_ = parseConstraintExp(_loc2_.horizontalCenter);
  94.          if(!_loc17_)
  95.          {
  96.             _loc5_ = NaN;
  97.          }
  98.          else if(_loc17_.length == 1)
  99.          {
  100.             _loc5_ = Number(_loc17_[0]);
  101.          }
  102.          else
  103.          {
  104.             _loc12_ = _loc17_[0];
  105.             _loc5_ = Number(_loc17_[1]);
  106.          }
  107.          _loc17_ = parseConstraintExp(_loc2_.top);
  108.          if(!_loc17_)
  109.          {
  110.             _loc6_ = NaN;
  111.          }
  112.          else if(_loc17_.length == 1)
  113.          {
  114.             _loc6_ = Number(_loc17_[0]);
  115.          }
  116.          else
  117.          {
  118.             _loc13_ = _loc17_[0];
  119.             _loc6_ = Number(_loc17_[1]);
  120.          }
  121.          _loc17_ = parseConstraintExp(_loc2_.bottom);
  122.          if(!_loc17_)
  123.          {
  124.             _loc7_ = NaN;
  125.          }
  126.          else if(_loc17_.length == 1)
  127.          {
  128.             _loc7_ = Number(_loc17_[0]);
  129.          }
  130.          else
  131.          {
  132.             _loc14_ = _loc17_[0];
  133.             _loc7_ = Number(_loc17_[1]);
  134.          }
  135.          _loc17_ = parseConstraintExp(_loc2_.verticalCenter);
  136.          if(!_loc17_)
  137.          {
  138.             _loc8_ = NaN;
  139.          }
  140.          else if(_loc17_.length == 1)
  141.          {
  142.             _loc8_ = Number(_loc17_[0]);
  143.          }
  144.          else
  145.          {
  146.             _loc15_ = _loc17_[0];
  147.             _loc8_ = Number(_loc17_[1]);
  148.          }
  149.          _loc17_ = parseConstraintExp(_loc2_.baseline);
  150.          if(!_loc17_)
  151.          {
  152.             _loc9_ = NaN;
  153.          }
  154.          else if(_loc17_.length == 1)
  155.          {
  156.             _loc9_ = Number(_loc17_[0]);
  157.          }
  158.          else
  159.          {
  160.             _loc16_ = _loc17_[0];
  161.             _loc9_ = Number(_loc17_[1]);
  162.          }
  163.          var _loc19_:ContentColumnChild = new ContentColumnChild();
  164.          var _loc20_:Boolean = false;
  165.          var _loc21_:Number = 0;
  166.          var _loc22_:Number = 0;
  167.          var _loc23_:Number = 0;
  168.          _loc18_ = 0;
  169.          while(_loc18_ < IConstraintLayout(target).constraintColumns.length)
  170.          {
  171.             _loc30_ = IConstraintLayout(target).constraintColumns[_loc18_];
  172.             if(_loc30_.mx_internal::contentSize)
  173.             {
  174.                if(_loc30_.id == _loc10_)
  175.                {
  176.                   _loc19_.leftCol = _loc30_;
  177.                   _loc19_.leftOffset = _loc3_;
  178.                   _loc19_.left = _loc21_ = _loc18_;
  179.                   _loc20_ = true;
  180.                }
  181.                if(_loc30_.id == _loc11_)
  182.                {
  183.                   _loc19_.rightCol = _loc30_;
  184.                   _loc19_.rightOffset = _loc4_;
  185.                   _loc19_.right = _loc22_ = _loc18_ + 1;
  186.                   _loc20_ = true;
  187.                }
  188.                if(_loc30_.id == _loc12_)
  189.                {
  190.                   _loc19_.hcCol = _loc30_;
  191.                   _loc19_.hcOffset = _loc5_;
  192.                   _loc19_.hc = _loc23_ = _loc18_ + 1;
  193.                   _loc20_ = true;
  194.                }
  195.             }
  196.             _loc18_++;
  197.          }
  198.          if(_loc20_)
  199.          {
  200.             _loc19_.child = param1;
  201.             if(_loc19_.leftCol && !_loc19_.rightCol || _loc19_.rightCol && !_loc19_.leftCol || Boolean(_loc19_.hcCol))
  202.             {
  203.                _loc19_.span = 1;
  204.             }
  205.             else
  206.             {
  207.                _loc19_.span = _loc22_ - _loc21_;
  208.             }
  209.             _loc31_ = false;
  210.             _loc18_ = 0;
  211.             while(_loc18_ < colSpanChildren.length)
  212.             {
  213.                if(_loc19_.child == colSpanChildren[_loc18_].child)
  214.                {
  215.                   _loc31_ = true;
  216.                   break;
  217.                }
  218.                _loc18_++;
  219.             }
  220.             if(!_loc31_)
  221.             {
  222.                colSpanChildren.push(_loc19_);
  223.             }
  224.          }
  225.          _loc20_ = false;
  226.          var _loc24_:ContentRowChild = new ContentRowChild();
  227.          var _loc25_:Number = 0;
  228.          var _loc26_:Number = 0;
  229.          var _loc27_:Number = 0;
  230.          var _loc28_:Number = 0;
  231.          _loc18_ = 0;
  232.          while(_loc18_ < IConstraintLayout(target).constraintRows.length)
  233.          {
  234.             _loc32_ = IConstraintLayout(target).constraintRows[_loc18_];
  235.             if(_loc32_.mx_internal::contentSize)
  236.             {
  237.                if(_loc32_.id == _loc13_)
  238.                {
  239.                   _loc24_.topRow = _loc32_;
  240.                   _loc24_.topOffset = _loc6_;
  241.                   _loc24_.top = _loc25_ = _loc18_;
  242.                   _loc20_ = true;
  243.                }
  244.                if(_loc32_.id == _loc14_)
  245.                {
  246.                   _loc24_.bottomRow = _loc32_;
  247.                   _loc24_.bottomOffset = _loc7_;
  248.                   _loc24_.bottom = _loc26_ = _loc18_ + 1;
  249.                   _loc20_ = true;
  250.                }
  251.                if(_loc32_.id == _loc15_)
  252.                {
  253.                   _loc24_.vcRow = _loc32_;
  254.                   _loc24_.vcOffset = _loc8_;
  255.                   _loc24_.vc = _loc27_ = _loc18_ + 1;
  256.                   _loc20_ = true;
  257.                }
  258.                if(_loc32_.id == _loc16_)
  259.                {
  260.                   _loc24_.baselineRow = _loc32_;
  261.                   _loc24_.baselineOffset = _loc9_;
  262.                   _loc24_.baseline = _loc28_ = _loc18_ + 1;
  263.                   _loc20_ = true;
  264.                }
  265.             }
  266.             _loc18_++;
  267.          }
  268.          if(_loc20_)
  269.          {
  270.             _loc24_.child = param1;
  271.             if(_loc24_.topRow && !_loc24_.bottomRow || _loc24_.bottomRow && !_loc24_.topRow || _loc24_.vcRow || Boolean(_loc24_.baselineRow))
  272.             {
  273.                _loc24_.span = 1;
  274.             }
  275.             else
  276.             {
  277.                _loc24_.span = _loc26_ - _loc25_;
  278.             }
  279.             _loc31_ = false;
  280.             _loc18_ = 0;
  281.             while(_loc18_ < rowSpanChildren.length)
  282.             {
  283.                if(_loc24_.child == rowSpanChildren[_loc18_].child)
  284.                {
  285.                   _loc31_ = true;
  286.                   break;
  287.                }
  288.                _loc18_++;
  289.             }
  290.             if(!_loc31_)
  291.             {
  292.                rowSpanChildren.push(_loc24_);
  293.             }
  294.          }
  295.          var _loc29_:ChildConstraintInfo = new ChildConstraintInfo(_loc3_,_loc4_,_loc5_,_loc6_,_loc7_,_loc8_,_loc9_,_loc10_,_loc11_,_loc12_,_loc13_,_loc14_,_loc15_,_loc16_);
  296.          constraintCache[param1] = _loc29_;
  297.          return _loc29_;
  298.       }
  299.       
  300.       private function bound(param1:Number, param2:Number, param3:Number) : Number
  301.       {
  302.          if(param1 < param2)
  303.          {
  304.             param1 = param2;
  305.          }
  306.          else if(param1 > param3)
  307.          {
  308.             param1 = param3;
  309.          }
  310.          else
  311.          {
  312.             param1 = Math.floor(param1);
  313.          }
  314.          return param1;
  315.       }
  316.       
  317.       private function shareRowSpace(param1:ContentRowChild, param2:Number) : Number
  318.       {
  319.          var _loc11_:Number = NaN;
  320.          var _loc12_:Number = NaN;
  321.          var _loc13_:Number = NaN;
  322.          var _loc3_:ConstraintRow = param1.topRow;
  323.          var _loc4_:ConstraintRow = param1.bottomRow;
  324.          var _loc5_:IUIComponent = param1.child;
  325.          var _loc6_:Number = 0;
  326.          var _loc7_:Number = 0;
  327.          var _loc8_:Number = !!param1.topOffset ? param1.topOffset : 0;
  328.          var _loc9_:Number = !!param1.bottomOffset ? param1.bottomOffset : 0;
  329.          if(Boolean(_loc3_) && Boolean(_loc3_.height))
  330.          {
  331.             _loc6_ += _loc3_.height;
  332.          }
  333.          else if(Boolean(_loc4_) && !_loc3_)
  334.          {
  335.             _loc3_ = IConstraintLayout(target).constraintRows[param1.bottom - 2];
  336.             if(Boolean(_loc3_) && Boolean(_loc3_.height))
  337.             {
  338.                _loc6_ += _loc3_.height;
  339.             }
  340.          }
  341.          if(Boolean(_loc4_) && Boolean(_loc4_.height))
  342.          {
  343.             _loc7_ += _loc4_.height;
  344.          }
  345.          else if(Boolean(_loc3_) && !_loc4_)
  346.          {
  347.             _loc4_ = IConstraintLayout(target).constraintRows[param1.top + 1];
  348.             if((Boolean(_loc4_)) && Boolean(_loc4_.height))
  349.             {
  350.                _loc7_ += _loc4_.height;
  351.             }
  352.          }
  353.          if(Boolean(_loc3_) && isNaN(_loc3_.height))
  354.          {
  355.             _loc3_.setActualHeight(Math.max(0,_loc3_.maxHeight));
  356.          }
  357.          if(Boolean(_loc4_) && isNaN(_loc4_.height))
  358.          {
  359.             _loc4_.setActualHeight(Math.max(0,_loc4_.height));
  360.          }
  361.          var _loc10_:Number = Number(_loc5_.getExplicitOrMeasuredHeight());
  362.          if(_loc10_)
  363.          {
  364.             if(!param1.topRow)
  365.             {
  366.                if(_loc10_ > _loc6_)
  367.                {
  368.                   _loc12_ = _loc10_ - _loc6_ + _loc9_;
  369.                }
  370.                else
  371.                {
  372.                   _loc12_ = _loc10_ + _loc9_;
  373.                }
  374.             }
  375.             if(!param1.bottomRow)
  376.             {
  377.                if(_loc10_ > _loc7_)
  378.                {
  379.                   _loc11_ = _loc10_ - _loc7_ + _loc8_;
  380.                }
  381.                else
  382.                {
  383.                   _loc11_ = _loc10_ + _loc8_;
  384.                }
  385.             }
  386.             if(Boolean(param1.topRow) && Boolean(param1.bottomRow))
  387.             {
  388.                _loc13_ = _loc10_ / Number(param1.span);
  389.                if(_loc13_ + _loc8_ < _loc6_)
  390.                {
  391.                   _loc11_ = _loc6_;
  392.                   _loc12_ = _loc10_ - (_loc6_ - _loc8_) + _loc9_;
  393.                }
  394.                else
  395.                {
  396.                   _loc11_ = _loc13_ + _loc8_;
  397.                }
  398.                if(_loc13_ + _loc9_ < _loc7_)
  399.                {
  400.                   _loc12_ = _loc7_;
  401.                   _loc11_ = _loc10_ - (_loc7_ - _loc9_) + _loc8_;
  402.                }
  403.                else
  404.                {
  405.                   _loc12_ = _loc13_ + _loc9_;
  406.                }
  407.             }
  408.             _loc12_ = bound(_loc12_,_loc4_.minHeight,_loc4_.maxHeight);
  409.             _loc4_.setActualHeight(_loc12_);
  410.             param2 -= _loc12_;
  411.             _loc11_ = bound(_loc11_,_loc3_.minHeight,_loc3_.maxHeight);
  412.             _loc3_.setActualHeight(_loc11_);
  413.             param2 -= _loc11_;
  414.          }
  415.          return param2;
  416.       }
  417.       
  418.       private function parseConstraintExp(param1:String) : Array
  419.       {
  420.          if(!param1)
  421.          {
  422.             return null;
  423.          }
  424.          var _loc2_:String = param1.replace(/:/g," ");
  425.          return _loc2_.split(/\s+/);
  426.       }
  427.       
  428.       private function measureColumnsAndRows() : void
  429.       {
  430.          var _loc3_:int = 0;
  431.          var _loc4_:int = 0;
  432.          var _loc13_:ConstraintColumn = null;
  433.          var _loc14_:ConstraintRow = null;
  434.          var _loc15_:Number = NaN;
  435.          var _loc16_:Number = NaN;
  436.          var _loc17_:Number = NaN;
  437.          var _loc18_:Number = NaN;
  438.          var _loc19_:ContentColumnChild = null;
  439.          var _loc20_:ContentRowChild = null;
  440.          var _loc1_:Array = IConstraintLayout(target).constraintColumns;
  441.          var _loc2_:Array = IConstraintLayout(target).constraintRows;
  442.          if(!_loc2_.length > 0 && !_loc1_.length > 0)
  443.          {
  444.             constraintRegionsInUse = false;
  445.             return;
  446.          }
  447.          constraintRegionsInUse = true;
  448.          var _loc5_:Number = 0;
  449.          var _loc6_:Number = 0;
  450.          var _loc7_:EdgeMetrics = Container(target).viewMetrics;
  451.          var _loc8_:Number = Container(target).width - _loc7_.left - _loc7_.right;
  452.          var _loc9_:Number = Container(target).height - _loc7_.top - _loc7_.bottom;
  453.          var _loc10_:Array = [];
  454.          var _loc11_:Array = [];
  455.          var _loc12_:Array = [];
  456.          if(_loc1_.length > 0)
  457.          {
  458.             _loc3_ = 0;
  459.             while(_loc3_ < _loc1_.length)
  460.             {
  461.                _loc13_ = _loc1_[_loc3_];
  462.                if(!isNaN(_loc13_.percentWidth))
  463.                {
  464.                   _loc11_.push(_loc13_);
  465.                }
  466.                else if(!isNaN(_loc13_.width) && !_loc13_.mx_internal::contentSize)
  467.                {
  468.                   _loc10_.push(_loc13_);
  469.                }
  470.                else
  471.                {
  472.                   _loc12_.push(_loc13_);
  473.                   _loc13_.mx_internal::contentSize = true;
  474.                }
  475.                _loc3_++;
  476.             }
  477.             _loc3_ = 0;
  478.             while(_loc3_ < _loc10_.length)
  479.             {
  480.                _loc13_ = ConstraintColumn(_loc10_[_loc3_]);
  481.                _loc8_ -= _loc13_.width;
  482.                _loc3_++;
  483.             }
  484.             if(_loc12_.length > 0)
  485.             {
  486.                if(colSpanChildren.length > 0)
  487.                {
  488.                   colSpanChildren.sortOn("span");
  489.                   _loc4_ = 0;
  490.                   while(_loc4_ < colSpanChildren.length)
  491.                   {
  492.                      _loc19_ = colSpanChildren[_loc4_];
  493.                      if(_loc19_.span == 1)
  494.                      {
  495.                         if(_loc19_.hcCol)
  496.                         {
  497.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.hcCol)]);
  498.                         }
  499.                         else if(_loc19_.leftCol)
  500.                         {
  501.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.leftCol)]);
  502.                         }
  503.                         else if(_loc19_.rightCol)
  504.                         {
  505.                            _loc13_ = ConstraintColumn(_loc1_[_loc1_.indexOf(_loc19_.rightCol)]);
  506.                         }
  507.                         _loc16_ = Number(_loc19_.child.getExplicitOrMeasuredWidth());
  508.                         if(_loc19_.hcOffset)
  509.                         {
  510.                            _loc16_ += _loc19_.hcOffset;
  511.                         }
  512.                         else
  513.                         {
  514.                            if(_loc19_.leftOffset)
  515.                            {
  516.                               _loc16_ += _loc19_.leftOffset;
  517.                            }
  518.                            if(_loc19_.rightOffset)
  519.                            {
  520.                               _loc16_ += _loc19_.rightOffset;
  521.                            }
  522.                         }
  523.                         if(!isNaN(_loc13_.width))
  524.                         {
  525.                            _loc16_ = Math.max(_loc13_.width,_loc16_);
  526.                         }
  527.                         _loc16_ = bound(_loc16_,_loc13_.minWidth,_loc13_.maxWidth);
  528.                         _loc13_.setActualWidth(_loc16_);
  529.                         _loc8_ -= _loc13_.width;
  530.                      }
  531.                      else
  532.                      {
  533.                         _loc8_ = shareColumnSpace(_loc19_,_loc8_);
  534.                      }
  535.                      _loc4_++;
  536.                   }
  537.                   colSpanChildren = [];
  538.                }
  539.                _loc3_ = 0;
  540.                while(_loc3_ < _loc12_.length)
  541.                {
  542.                   _loc13_ = _loc12_[_loc3_];
  543.                   if(!_loc13_.width)
  544.                   {
  545.                      _loc16_ = bound(0,_loc13_.minWidth,0);
  546.                      _loc13_.setActualWidth(_loc16_);
  547.                   }
  548.                   _loc3_++;
  549.                }
  550.             }
  551.             _loc18_ = _loc8_;
  552.             _loc3_ = 0;
  553.             while(_loc3_ < _loc11_.length)
  554.             {
  555.                _loc13_ = ConstraintColumn(_loc11_[_loc3_]);
  556.                if(_loc18_ <= 0)
  557.                {
  558.                   _loc16_ = 0;
  559.                }
  560.                else
  561.                {
  562.                   _loc16_ = Math.round(_loc18_ * _loc13_.percentWidth / 100);
  563.                }
  564.                _loc16_ = bound(_loc16_,_loc13_.minWidth,_loc13_.maxWidth);
  565.                _loc13_.setActualWidth(_loc16_);
  566.                _loc8_ -= _loc16_;
  567.                _loc3_++;
  568.             }
  569.             _loc3_ = 0;
  570.             while(_loc3_ < _loc1_.length)
  571.             {
  572.                _loc13_ = ConstraintColumn(_loc1_[_loc3_]);
  573.                _loc13_.x = _loc5_;
  574.                _loc5_ += _loc13_.width;
  575.                _loc3_++;
  576.             }
  577.          }
  578.          _loc10_ = [];
  579.          _loc11_ = [];
  580.          _loc12_ = [];
  581.          if(_loc2_.length > 0)
  582.          {
  583.             _loc3_ = 0;
  584.             while(_loc3_ < _loc2_.length)
  585.             {
  586.                _loc14_ = _loc2_[_loc3_];
  587.                if(!isNaN(_loc14_.percentHeight))
  588.                {
  589.                   _loc11_.push(_loc14_);
  590.                }
  591.                else if(!isNaN(_loc14_.height) && !_loc14_.mx_internal::contentSize)
  592.                {
  593.                   _loc10_.push(_loc14_);
  594.                }
  595.                else
  596.                {
  597.                   _loc12_.push(_loc14_);
  598.                   _loc14_.mx_internal::contentSize = true;
  599.                }
  600.                _loc3_++;
  601.             }
  602.             _loc3_ = 0;
  603.             while(_loc3_ < _loc10_.length)
  604.             {
  605.                _loc14_ = ConstraintRow(_loc10_[_loc3_]);
  606.                _loc9_ -= _loc14_.height;
  607.                _loc3_++;
  608.             }
  609.             if(_loc12_.length > 0)
  610.             {
  611.                if(rowSpanChildren.length > 0)
  612.                {
  613.                   rowSpanChildren.sortOn("span");
  614.                   _loc4_ = 0;
  615.                   while(_loc4_ < rowSpanChildren.length)
  616.                   {
  617.                      _loc20_ = rowSpanChildren[_loc4_];
  618.                      if(_loc20_.span == 1)
  619.                      {
  620.                         if(_loc20_.vcRow)
  621.                         {
  622.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.vcRow)]);
  623.                         }
  624.                         else if(_loc20_.baselineRow)
  625.                         {
  626.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.baselineRow)]);
  627.                         }
  628.                         else if(_loc20_.topRow)
  629.                         {
  630.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.topRow)]);
  631.                         }
  632.                         else if(_loc20_.bottomRow)
  633.                         {
  634.                            _loc14_ = ConstraintRow(_loc2_[_loc2_.indexOf(_loc20_.bottomRow)]);
  635.                         }
  636.                         _loc17_ = Number(_loc20_.child.getExplicitOrMeasuredHeight());
  637.                         if(_loc20_.baselineOffset)
  638.                         {
  639.                            _loc17_ += _loc20_.baselineOffset;
  640.                         }
  641.                         else if(_loc20_.vcOffset)
  642.                         {
  643.                            _loc17_ += _loc20_.vcOffset;
  644.                         }
  645.                         else
  646.                         {
  647.                            if(_loc20_.topOffset)
  648.                            {
  649.                               _loc17_ += _loc20_.topOffset;
  650.                            }
  651.                            if(_loc20_.bottomOffset)
  652.                            {
  653.                               _loc17_ += _loc20_.bottomOffset;
  654.                            }
  655.                         }
  656.                         if(!isNaN(_loc14_.height))
  657.                         {
  658.                            _loc17_ = Math.max(_loc14_.height,_loc17_);
  659.                         }
  660.                         _loc17_ = bound(_loc17_,_loc14_.minHeight,_loc14_.maxHeight);
  661.                         _loc14_.setActualHeight(_loc17_);
  662.                         _loc9_ -= _loc14_.height;
  663.                      }
  664.                      else
  665.                      {
  666.                         _loc9_ = shareRowSpace(_loc20_,_loc9_);
  667.                      }
  668.                      _loc4_++;
  669.                   }
  670.                   rowSpanChildren = [];
  671.                }
  672.                _loc3_ = 0;
  673.                while(_loc3_ < _loc12_.length)
  674.                {
  675.                   _loc14_ = ConstraintRow(_loc12_[_loc3_]);
  676.                   if(!_loc14_.height)
  677.                   {
  678.                      _loc17_ = bound(0,_loc14_.minHeight,0);
  679.                      _loc14_.setActualHeight(_loc17_);
  680.                   }
  681.                   _loc3_++;
  682.                }
  683.             }
  684.             _loc18_ = _loc9_;
  685.             _loc3_ = 0;
  686.             while(_loc3_ < _loc11_.length)
  687.             {
  688.                _loc14_ = ConstraintRow(_loc11_[_loc3_]);
  689.                if(_loc18_ <= 0)
  690.                {
  691.                   _loc17_ = 0;
  692.                }
  693.                else
  694.                {
  695.                   _loc17_ = Math.round(_loc18_ * _loc14_.percentHeight / 100);
  696.                }
  697.                _loc17_ = bound(_loc17_,_loc14_.minHeight,_loc14_.maxHeight);
  698.                _loc14_.setActualHeight(_loc17_);
  699.                _loc9_ -= _loc17_;
  700.                _loc3_++;
  701.             }
  702.             _loc3_ = 0;
  703.             while(_loc3_ < _loc2_.length)
  704.             {
  705.                _loc14_ = _loc2_[_loc3_];
  706.                _loc14_.y = _loc6_;
  707.                _loc6_ += _loc14_.height;
  708.                _loc3_++;
  709.             }
  710.          }
  711.       }
  712.       
  713.       private function child_moveHandler(param1:MoveEvent) : void
  714.       {
  715.          if(param1.target is IUIComponent)
  716.          {
  717.             if(!IUIComponent(param1.target).includeInLayout)
  718.             {
  719.                return;
  720.             }
  721.          }
  722.          var _loc2_:Container = super.target;
  723.          if(_loc2_)
  724.          {
  725.             _loc2_.invalidateSize();
  726.             _loc2_.invalidateDisplayList();
  727.             _contentArea = null;
  728.          }
  729.       }
  730.       
  731.       private function applyAnchorStylesDuringMeasure(param1:IUIComponent, param2:Rectangle) : void
  732.       {
  733.          var _loc13_:int = 0;
  734.          var _loc3_:IConstraintClient = param1 as IConstraintClient;
  735.          if(!_loc3_)
  736.          {
  737.             return;
  738.          }
  739.          var _loc4_:ChildConstraintInfo = constraintCache[_loc3_];
  740.          if(!_loc4_)
  741.          {
  742.             _loc4_ = parseConstraints(param1);
  743.          }
  744.          var _loc5_:Number = _loc4_.left;
  745.          var _loc6_:Number = _loc4_.right;
  746.          var _loc7_:Number = _loc4_.hc;
  747.          var _loc8_:Number = _loc4_.top;
  748.          var _loc9_:Number = _loc4_.bottom;
  749.          var _loc10_:Number = _loc4_.vc;
  750.          var _loc11_:Array = IConstraintLayout(target).constraintColumns;
  751.          var _loc12_:Array = IConstraintLayout(target).constraintRows;
  752.          var _loc14_:Number = 0;
  753.          if(!_loc11_.length > 0)
  754.          {
  755.             if(!isNaN(_loc7_))
  756.             {
  757.                param2.x = Math.round((target.width - param1.width) / 2 + _loc7_);
  758.             }
  759.             else if(!isNaN(_loc5_) && !isNaN(_loc6_))
  760.             {
  761.                param2.x = _loc5_;
  762.                param2.width += _loc6_;
  763.             }
  764.             else if(!isNaN(_loc5_))
  765.             {
  766.                param2.x = _loc5_;
  767.             }
  768.             else if(!isNaN(_loc6_))
  769.             {
  770.                param2.x = 0;
  771.                param2.width += _loc6_;
  772.             }
  773.          }
  774.          else
  775.          {
  776.             param2.x = 0;
  777.             _loc13_ = 0;
  778.             while(_loc13_ < _loc11_.length)
  779.             {
  780.                _loc14_ += ConstraintColumn(_loc11_[_loc13_]).width;
  781.                _loc13_++;
  782.             }
  783.             param2.width = _loc14_;
  784.          }
  785.          if(!_loc12_.length > 0)
  786.          {
  787.             if(!isNaN(_loc10_))
  788.             {
  789.                param2.y = Math.round((target.height - param1.height) / 2 + _loc10_);
  790.             }
  791.             else if(!isNaN(_loc8_) && !isNaN(_loc9_))
  792.             {
  793.                param2.y = _loc8_;
  794.                param2.height += _loc9_;
  795.             }
  796.             else if(!isNaN(_loc8_))
  797.             {
  798.                param2.y = _loc8_;
  799.             }
  800.             else if(!isNaN(_loc9_))
  801.             {
  802.                param2.y = 0;
  803.                param2.height += _loc9_;
  804.             }
  805.          }
  806.          else
  807.          {
  808.             _loc14_ = 0;
  809.             param2.y = 0;
  810.             _loc13_ = 0;
  811.             while(_loc13_ < _loc12_.length)
  812.             {
  813.                _loc14_ += ConstraintRow(_loc12_[_loc13_]).height;
  814.                _loc13_++;
  815.             }
  816.             param2.height = _loc14_;
  817.          }
  818.       }
  819.       
  820.       override public function measure() : void
  821.       {
  822.          var _loc1_:Container = null;
  823.          var _loc5_:EdgeMetrics = null;
  824.          var _loc6_:Rectangle = null;
  825.          var _loc7_:IUIComponent = null;
  826.          var _loc8_:ConstraintColumn = null;
  827.          var _loc9_:ConstraintRow = null;
  828.          _loc1_ = super.target;
  829.          var _loc2_:Number = 0;
  830.          var _loc3_:Number = 0;
  831.          var _loc4_:Number = 0;
  832.          _loc5_ = _loc1_.viewMetrics;
  833.          _loc4_ = 0;
  834.          while(_loc4_ < _loc1_.numChildren)
  835.          {
  836.             _loc7_ = _loc1_.getChildAt(_loc4_) as IUIComponent;
  837.             parseConstraints(_loc7_);
  838.             _loc4_++;
  839.          }
  840.          _loc4_ = 0;
  841.          while(_loc4_ < IConstraintLayout(_loc1_).constraintColumns.length)
  842.          {
  843.             _loc8_ = IConstraintLayout(_loc1_).constraintColumns[_loc4_];
  844.             if(_loc8_.mx_internal::contentSize)
  845.             {
  846.                _loc8_.mx_internal::_width = NaN;
  847.             }
  848.             _loc4_++;
  849.          }
  850.          _loc4_ = 0;
  851.          while(_loc4_ < IConstraintLayout(_loc1_).constraintRows.length)
  852.          {
  853.             _loc9_ = IConstraintLayout(_loc1_).constraintRows[_loc4_];
  854.             if(_loc9_.mx_internal::contentSize)
  855.             {
  856.                _loc9_.mx_internal::_height = NaN;
  857.             }
  858.             _loc4_++;
  859.          }
  860.          measureColumnsAndRows();
  861.          _contentArea = null;
  862.          _loc6_ = measureContentArea();
  863.          _loc1_.measuredWidth = _loc6_.width + _loc5_.left + _loc5_.right;
  864.          _loc1_.measuredHeight = _loc6_.height + _loc5_.top + _loc5_.bottom;
  865.       }
  866.       
  867.       private function target_childRemoveHandler(param1:ChildExistenceChangedEvent) : void
  868.       {
  869.          DisplayObject(param1.relatedObject).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  870.          delete constraintCache[param1.relatedObject];
  871.       }
  872.       
  873.       override public function set target(param1:Container) : void
  874.       {
  875.          var _loc3_:int = 0;
  876.          var _loc4_:int = 0;
  877.          var _loc2_:Container = super.target;
  878.          if(param1 != _loc2_)
  879.          {
  880.             if(_loc2_)
  881.             {
  882.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  883.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  884.                _loc4_ = _loc2_.numChildren;
  885.                _loc3_ = 0;
  886.                while(_loc3_ < _loc4_)
  887.                {
  888.                   DisplayObject(_loc2_.getChildAt(_loc3_)).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  889.                   _loc3_++;
  890.                }
  891.             }
  892.             if(param1)
  893.             {
  894.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  895.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  896.                _loc4_ = param1.numChildren;
  897.                _loc3_ = 0;
  898.                while(_loc3_ < _loc4_)
  899.                {
  900.                   DisplayObject(param1.getChildAt(_loc3_)).addEventListener(MoveEvent.MOVE,child_moveHandler);
  901.                   _loc3_++;
  902.                }
  903.             }
  904.             super.target = param1;
  905.          }
  906.       }
  907.       
  908.       private function measureContentArea() : Rectangle
  909.       {
  910.          var _loc1_:int = 0;
  911.          var _loc3_:Array = null;
  912.          var _loc4_:Array = null;
  913.          var _loc5_:IUIComponent = null;
  914.          var _loc6_:LayoutConstraints = null;
  915.          var _loc7_:Number = NaN;
  916.          var _loc8_:Number = NaN;
  917.          var _loc9_:Number = NaN;
  918.          var _loc10_:Number = NaN;
  919.          var _loc11_:Number = NaN;
  920.          var _loc12_:Number = NaN;
  921.          if(_contentArea)
  922.          {
  923.             return _contentArea;
  924.          }
  925.          _contentArea = new Rectangle();
  926.          var _loc2_:int = target.numChildren;
  927.          if(_loc2_ == 0 && constraintRegionsInUse)
  928.          {
  929.             _loc3_ = IConstraintLayout(target).constraintColumns;
  930.             _loc4_ = IConstraintLayout(target).constraintRows;
  931.             if(_loc3_.length > 0)
  932.             {
  933.                _contentArea.right = _loc3_[_loc3_.length - 1].x + _loc3_[_loc3_.length - 1].width;
  934.             }
  935.             else
  936.             {
  937.                _contentArea.right = 0;
  938.             }
  939.             if(_loc4_.length > 0)
  940.             {
  941.                _contentArea.bottom = _loc4_[_loc4_.length - 1].y + _loc4_[_loc4_.length - 1].height;
  942.             }
  943.             else
  944.             {
  945.                _contentArea.bottom = 0;
  946.             }
  947.          }
  948.          _loc1_ = 0;
  949.          while(_loc1_ < _loc2_)
  950.          {
  951.             _loc5_ = target.getChildAt(_loc1_) as IUIComponent;
  952.             _loc6_ = getLayoutConstraints(_loc5_);
  953.             if(_loc5_.includeInLayout)
  954.             {
  955.                _loc7_ = Number(_loc5_.x);
  956.                _loc8_ = Number(_loc5_.y);
  957.                _loc9_ = Number(_loc5_.getExplicitOrMeasuredWidth());
  958.                _loc10_ = Number(_loc5_.getExplicitOrMeasuredHeight());
  959.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  960.                {
  961.                   if(!isNaN(_loc5_.percentWidth) || _loc6_ && !isNaN(_loc6_.left) && !isNaN(_loc6_.right))
  962.                   {
  963.                      _loc9_ = Number(_loc5_.minWidth);
  964.                   }
  965.                }
  966.                else if(!isNaN(_loc5_.percentWidth) || _loc6_ && !isNaN(_loc6_.left) && !isNaN(_loc6_.right) && isNaN(_loc5_.explicitWidth))
  967.                {
  968.                   _loc9_ = Number(_loc5_.minWidth);
  969.                }
  970.                if(FlexVersion.compatibilityVersion < FlexVersion.VERSION_3_0)
  971.                {
  972.                   if(!isNaN(_loc5_.percentHeight) || _loc6_ && !isNaN(_loc6_.top) && !isNaN(_loc6_.bottom))
  973.                   {
  974.                      _loc10_ = Number(_loc5_.minHeight);
  975.                   }
  976.                }
  977.                else if(!isNaN(_loc5_.percentHeight) || _loc6_ && !isNaN(_loc6_.top) && !isNaN(_loc6_.bottom) && isNaN(_loc5_.explicitHeight))
  978.                {
  979.                   _loc10_ = Number(_loc5_.minHeight);
  980.                }
  981.                r.x = _loc7_;
  982.                r.y = _loc8_;
  983.                r.width = _loc9_;
  984.                r.height = _loc10_;
  985.                applyAnchorStylesDuringMeasure(_loc5_,r);
  986.                _loc7_ = r.x;
  987.                _loc8_ = r.y;
  988.                _loc9_ = r.width;
  989.                _loc10_ = r.height;
  990.                if(isNaN(_loc7_))
  991.                {
  992.                   _loc7_ = Number(_loc5_.x);
  993.                }
  994.                if(isNaN(_loc8_))
  995.                {
  996.                   _loc8_ = Number(_loc5_.y);
  997.                }
  998.                _loc11_ = _loc7_;
  999.                _loc12_ = _loc8_;
  1000.                if(isNaN(_loc9_))
  1001.                {
  1002.                   _loc9_ = Number(_loc5_.width);
  1003.                }
  1004.                if(isNaN(_loc10_))
  1005.                {
  1006.                   _loc10_ = Number(_loc5_.height);
  1007.                }
  1008.                _loc11_ += _loc9_;
  1009.                _loc12_ += _loc10_;
  1010.                _contentArea.right = Math.max(_contentArea.right,_loc11_);
  1011.                _contentArea.bottom = Math.max(_contentArea.bottom,_loc12_);
  1012.             }
  1013.             _loc1_++;
  1014.          }
  1015.          return _contentArea;
  1016.       }
  1017.       
  1018.       private function shareColumnSpace(param1:ContentColumnChild, param2:Number) : Number
  1019.       {
  1020.          var _loc11_:Number = NaN;
  1021.          var _loc12_:Number = NaN;
  1022.          var _loc13_:Number = NaN;
  1023.          var _loc3_:ConstraintColumn = param1.leftCol;
  1024.          var _loc4_:ConstraintColumn = param1.rightCol;
  1025.          var _loc5_:IUIComponent = param1.child;
  1026.          var _loc6_:Number = 0;
  1027.          var _loc7_:Number = 0;
  1028.          var _loc8_:Number = !!param1.rightOffset ? param1.rightOffset : 0;
  1029.          var _loc9_:Number = !!param1.leftOffset ? param1.leftOffset : 0;
  1030.          if(Boolean(_loc3_) && Boolean(_loc3_.width))
  1031.          {
  1032.             _loc6_ += _loc3_.width;
  1033.          }
  1034.          else if(Boolean(_loc4_) && !_loc3_)
  1035.          {
  1036.             _loc3_ = IConstraintLayout(target).constraintColumns[param1.right - 2];
  1037.             if(Boolean(_loc3_) && Boolean(_loc3_.width))
  1038.             {
  1039.                _loc6_ += _loc3_.width;
  1040.             }
  1041.          }
  1042.          if(Boolean(_loc4_) && Boolean(_loc4_.width))
  1043.          {
  1044.             _loc7_ += _loc4_.width;
  1045.          }
  1046.          else if(Boolean(_loc3_) && !_loc4_)
  1047.          {
  1048.             _loc4_ = IConstraintLayout(target).constraintColumns[param1.left + 1];
  1049.             if((Boolean(_loc4_)) && Boolean(_loc4_.width))
  1050.             {
  1051.                _loc7_ += _loc4_.width;
  1052.             }
  1053.          }
  1054.          if(Boolean(_loc3_) && isNaN(_loc3_.width))
  1055.          {
  1056.             _loc3_.setActualWidth(Math.max(0,_loc3_.maxWidth));
  1057.          }
  1058.          if(Boolean(_loc4_) && isNaN(_loc4_.width))
  1059.          {
  1060.             _loc4_.setActualWidth(Math.max(0,_loc4_.maxWidth));
  1061.          }
  1062.          var _loc10_:Number = Number(_loc5_.getExplicitOrMeasuredWidth());
  1063.          if(_loc10_)
  1064.          {
  1065.             if(!param1.leftCol)
  1066.             {
  1067.                if(_loc10_ > _loc6_)
  1068.                {
  1069.                   _loc12_ = _loc10_ - _loc6_ + _loc8_;
  1070.                }
  1071.                else
  1072.                {
  1073.                   _loc12_ = _loc10_ + _loc8_;
  1074.                }
  1075.             }
  1076.             if(!param1.rightCol)
  1077.             {
  1078.                if(_loc10_ > _loc7_)
  1079.                {
  1080.                   _loc11_ = _loc10_ - _loc7_ + _loc9_;
  1081.                }
  1082.                else
  1083.                {
  1084.                   _loc11_ = _loc10_ + _loc9_;
  1085.                }
  1086.             }
  1087.             if(Boolean(param1.leftCol) && Boolean(param1.rightCol))
  1088.             {
  1089.                _loc13_ = _loc10_ / Number(param1.span);
  1090.                if(_loc13_ + _loc9_ < _loc6_)
  1091.                {
  1092.                   _loc11_ = _loc6_;
  1093.                   _loc12_ = _loc10_ - (_loc6_ - _loc9_) + _loc8_;
  1094.                }
  1095.                else
  1096.                {
  1097.                   _loc11_ = _loc13_ + _loc9_;
  1098.                }
  1099.                if(_loc13_ + _loc8_ < _loc7_)
  1100.                {
  1101.                   _loc12_ = _loc7_;
  1102.                   _loc11_ = _loc10_ - (_loc7_ - _loc8_) + _loc9_;
  1103.                }
  1104.                else
  1105.                {
  1106.                   _loc12_ = _loc13_ + _loc8_;
  1107.                }
  1108.             }
  1109.             _loc11_ = bound(_loc11_,_loc3_.minWidth,_loc3_.maxWidth);
  1110.             _loc3_.setActualWidth(_loc11_);
  1111.             param2 -= _loc11_;
  1112.             _loc12_ = bound(_loc12_,_loc4_.minWidth,_loc4_.maxWidth);
  1113.             _loc4_.setActualWidth(_loc12_);
  1114.             param2 -= _loc12_;
  1115.          }
  1116.          return param2;
  1117.       }
  1118.       
  1119.       private function getLayoutConstraints(param1:IUIComponent) : LayoutConstraints
  1120.       {
  1121.          var _loc2_:IConstraintClient = param1 as IConstraintClient;
  1122.          if(!_loc2_)
  1123.          {
  1124.             return null;
  1125.          }
  1126.          var _loc3_:LayoutConstraints = new LayoutConstraints();
  1127.          _loc3_.baseline = _loc2_.getConstraintValue("baseline");
  1128.          _loc3_.bottom = _loc2_.getConstraintValue("bottom");
  1129.          _loc3_.horizontalCenter = _loc2_.getConstraintValue("horizontalCenter");
  1130.          _loc3_.left = _loc2_.getConstraintValue("left");
  1131.          _loc3_.right = _loc2_.getConstraintValue("right");
  1132.          _loc3_.top = _loc2_.getConstraintValue("top");
  1133.          _loc3_.verticalCenter = _loc2_.getConstraintValue("verticalCenter");
  1134.          return _loc3_;
  1135.       }
  1136.       
  1137.       override public function updateDisplayList(param1:Number, param2:Number) : void
  1138.       {
  1139.          var _loc3_:int = 0;
  1140.          var _loc4_:IUIComponent = null;
  1141.          var _loc10_:ConstraintColumn = null;
  1142.          var _loc11_:ConstraintRow = null;
  1143.          var _loc5_:Container = super.target;
  1144.          var _loc6_:int = _loc5_.numChildren;
  1145.          _loc5_.mx_internal::doingLayout = false;
  1146.          var _loc7_:EdgeMetrics = _loc5_.viewMetrics;
  1147.          _loc5_.mx_internal::doingLayout = true;
  1148.          var _loc8_:Number = param1 - _loc7_.left - _loc7_.right;
  1149.          var _loc9_:Number = param2 - _loc7_.top - _loc7_.bottom;
  1150.          if(IConstraintLayout(_loc5_).constraintColumns.length > 0 || IConstraintLayout(_loc5_).constraintRows.length > 0)
  1151.          {
  1152.             constraintRegionsInUse = true;
  1153.          }
  1154.          if(constraintRegionsInUse)
  1155.          {
  1156.             _loc3_ = 0;
  1157.             while(_loc3_ < _loc6_)
  1158.             {
  1159.                _loc4_ = _loc5_.getChildAt(_loc3_) as IUIComponent;
  1160.                parseConstraints(_loc4_);
  1161.                _loc3_++;
  1162.             }
  1163.             _loc3_ = 0;
  1164.             while(_loc3_ < IConstraintLayout(_loc5_).constraintColumns.length)
  1165.             {
  1166.                _loc10_ = IConstraintLayout(_loc5_).constraintColumns[_loc3_];
  1167.                if(_loc10_.mx_internal::contentSize)
  1168.                {
  1169.                   _loc10_.mx_internal::_width = NaN;
  1170.                }
  1171.                _loc3_++;
  1172.             }
  1173.             _loc3_ = 0;
  1174.             while(_loc3_ < IConstraintLayout(_loc5_).constraintRows.length)
  1175.             {
  1176.                _loc11_ = IConstraintLayout(_loc5_).constraintRows[_loc3_];
  1177.                if(_loc11_.mx_internal::contentSize)
  1178.                {
  1179.                   _loc11_.mx_internal::_height = NaN;
  1180.                }
  1181.                _loc3_++;
  1182.             }
  1183.             measureColumnsAndRows();
  1184.          }
  1185.          _loc3_ = 0;
  1186.          while(_loc3_ < _loc6_)
  1187.          {
  1188.             _loc4_ = _loc5_.getChildAt(_loc3_) as IUIComponent;
  1189.             applyAnchorStylesDuringUpdateDisplayList(_loc8_,_loc9_,_loc4_);
  1190.             _loc3_++;
  1191.          }
  1192.       }
  1193.       
  1194.       private function applyAnchorStylesDuringUpdateDisplayList(param1:Number, param2:Number, param3:IUIComponent = null) : void
  1195.       {
  1196.          var _loc20_:int = 0;
  1197.          var _loc21_:Number = NaN;
  1198.          var _loc22_:Number = NaN;
  1199.          var _loc23_:Number = NaN;
  1200.          var _loc24_:Number = NaN;
  1201.          var _loc25_:String = null;
  1202.          var _loc34_:Number = NaN;
  1203.          var _loc35_:Number = NaN;
  1204.          var _loc36_:Number = NaN;
  1205.          var _loc37_:Number = NaN;
  1206.          var _loc38_:Number = NaN;
  1207.          var _loc39_:Boolean = false;
  1208.          var _loc40_:Boolean = false;
  1209.          var _loc41_:Boolean = false;
  1210.          var _loc42_:ConstraintColumn = null;
  1211.          var _loc43_:Boolean = false;
  1212.          var _loc44_:Boolean = false;
  1213.          var _loc45_:Boolean = false;
  1214.          var _loc46_:Boolean = false;
  1215.          var _loc47_:ConstraintRow = null;
  1216.          var _loc4_:IConstraintClient = param3 as IConstraintClient;
  1217.          if(!_loc4_)
  1218.          {
  1219.             return;
  1220.          }
  1221.          var _loc5_:ChildConstraintInfo = parseConstraints(param3);
  1222.          var _loc6_:Number = _loc5_.left;
  1223.          var _loc7_:Number = _loc5_.right;
  1224.          var _loc8_:Number = _loc5_.hc;
  1225.          var _loc9_:Number = _loc5_.top;
  1226.          var _loc10_:Number = _loc5_.bottom;
  1227.          var _loc11_:Number = _loc5_.vc;
  1228.          var _loc12_:Number = _loc5_.baseline;
  1229.          var _loc13_:String = _loc5_.leftBoundary;
  1230.          var _loc14_:String = _loc5_.rightBoundary;
  1231.          var _loc15_:String = _loc5_.hcBoundary;
  1232.          var _loc16_:String = _loc5_.topBoundary;
  1233.          var _loc17_:String = _loc5_.bottomBoundary;
  1234.          var _loc18_:String = _loc5_.vcBoundary;
  1235.          var _loc19_:String = _loc5_.baselineBoundary;
  1236.          var _loc26_:Boolean = false;
  1237.          var _loc27_:Boolean = false;
  1238.          var _loc28_:Boolean = !_loc15_ && !_loc13_ && !_loc14_;
  1239.          var _loc29_:Boolean = !_loc18_ && !_loc16_ && !_loc17_ && !_loc19_;
  1240.          var _loc30_:Number = 0;
  1241.          var _loc31_:Number = param1;
  1242.          var _loc32_:Number = 0;
  1243.          var _loc33_:Number = param2;
  1244.          if(!_loc28_)
  1245.          {
  1246.             _loc39_ = !!_loc13_ ? true : false;
  1247.             _loc40_ = !!_loc14_ ? true : false;
  1248.             _loc41_ = !!_loc15_ ? true : false;
  1249.             _loc20_ = 0;
  1250.             while(_loc20_ < IConstraintLayout(target).constraintColumns.length)
  1251.             {
  1252.                _loc42_ = ConstraintColumn(IConstraintLayout(target).constraintColumns[_loc20_]);
  1253.                if(_loc39_)
  1254.                {
  1255.                   if(_loc13_ == _loc42_.id)
  1256.                   {
  1257.                      _loc30_ = _loc42_.x;
  1258.                      _loc39_ = false;
  1259.                   }
  1260.                }
  1261.                if(_loc40_)
  1262.                {
  1263.                   if(_loc14_ == _loc42_.id)
  1264.                   {
  1265.                      _loc31_ = _loc42_.x + _loc42_.width;
  1266.                      _loc40_ = false;
  1267.                   }
  1268.                }
  1269.                if(_loc41_)
  1270.                {
  1271.                   if(_loc15_ == _loc42_.id)
  1272.                   {
  1273.                      _loc35_ = _loc42_.width;
  1274.                      _loc37_ = _loc42_.x;
  1275.                      _loc41_ = false;
  1276.                   }
  1277.                }
  1278.                _loc20_++;
  1279.             }
  1280.             if(_loc39_)
  1281.             {
  1282.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc13_]);
  1283.                throw new ConstraintError(_loc25_);
  1284.             }
  1285.             if(_loc40_)
  1286.             {
  1287.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc14_]);
  1288.                throw new ConstraintError(_loc25_);
  1289.             }
  1290.             if(_loc41_)
  1291.             {
  1292.                _loc25_ = resourceManager.getString("containers","columnNotFound",[_loc15_]);
  1293.                throw new ConstraintError(_loc25_);
  1294.             }
  1295.          }
  1296.          else if(!_loc28_)
  1297.          {
  1298.             _loc25_ = resourceManager.getString("containers","noColumnsFound");
  1299.             throw new ConstraintError(_loc25_);
  1300.          }
  1301.          param1 = Math.round(_loc31_ - _loc30_);
  1302.          if(!isNaN(_loc6_) && !isNaN(_loc7_))
  1303.          {
  1304.             _loc21_ = param1 - _loc6_ - _loc7_;
  1305.             if(_loc21_ < param3.minWidth)
  1306.             {
  1307.                _loc21_ = Number(param3.minWidth);
  1308.             }
  1309.          }
  1310.          else if(!isNaN(param3.percentWidth))
  1311.          {
  1312.             _loc21_ = param3.percentWidth / 100 * param1;
  1313.             _loc21_ = bound(_loc21_,param3.minWidth,param3.maxWidth);
  1314.             _loc26_ = true;
  1315.          }
  1316.          else
  1317.          {
  1318.             _loc21_ = Number(param3.getExplicitOrMeasuredWidth());
  1319.          }
  1320.          if(!_loc29_ && IConstraintLayout(target).constraintRows.length > 0)
  1321.          {
  1322.             _loc43_ = !!_loc16_ ? true : false;
  1323.             _loc44_ = !!_loc17_ ? true : false;
  1324.             _loc45_ = !!_loc18_ ? true : false;
  1325.             _loc46_ = !!_loc19_ ? true : false;
  1326.             _loc20_ = 0;
  1327.             while(_loc20_ < IConstraintLayout(target).constraintRows.length)
  1328.             {
  1329.                _loc47_ = ConstraintRow(IConstraintLayout(target).constraintRows[_loc20_]);
  1330.                if(_loc43_)
  1331.                {
  1332.                   if(_loc16_ == _loc47_.id)
  1333.                   {
  1334.                      _loc32_ = _loc47_.y;
  1335.                      _loc43_ = false;
  1336.                   }
  1337.                }
  1338.                if(_loc44_)
  1339.                {
  1340.                   if(_loc17_ == _loc47_.id)
  1341.                   {
  1342.                      _loc33_ = _loc47_.y + _loc47_.height;
  1343.                      _loc44_ = false;
  1344.                   }
  1345.                }
  1346.                if(_loc45_)
  1347.                {
  1348.                   if(_loc18_ == _loc47_.id)
  1349.                   {
  1350.                      _loc34_ = _loc47_.height;
  1351.                      _loc36_ = _loc47_.y;
  1352.                      _loc45_ = false;
  1353.                   }
  1354.                }
  1355.                if(_loc46_)
  1356.                {
  1357.                   if(_loc19_ == _loc47_.id)
  1358.                   {
  1359.                      _loc38_ = _loc47_.y;
  1360.                      _loc46_ = false;
  1361.                   }
  1362.                }
  1363.                _loc20_++;
  1364.             }
  1365.             if(_loc43_)
  1366.             {
  1367.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc16_]);
  1368.                throw new ConstraintError(_loc25_);
  1369.             }
  1370.             if(_loc44_)
  1371.             {
  1372.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc17_]);
  1373.                throw new ConstraintError(_loc25_);
  1374.             }
  1375.             if(_loc45_)
  1376.             {
  1377.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc18_]);
  1378.                throw new ConstraintError(_loc25_);
  1379.             }
  1380.             if(_loc46_)
  1381.             {
  1382.                _loc25_ = resourceManager.getString("containers","rowNotFound",[_loc19_]);
  1383.                throw new ConstraintError(_loc25_);
  1384.             }
  1385.          }
  1386.          else if(!_loc29_ && IConstraintLayout(target).constraintRows.length <= 0)
  1387.          {
  1388.             _loc25_ = resourceManager.getString("containers","noRowsFound");
  1389.             throw new ConstraintError(_loc25_);
  1390.          }
  1391.          param2 = Math.round(_loc33_ - _loc32_);
  1392.          if(!isNaN(_loc9_) && !isNaN(_loc10_))
  1393.          {
  1394.             _loc22_ = param2 - _loc9_ - _loc10_;
  1395.             if(_loc22_ < param3.minHeight)
  1396.             {
  1397.                _loc22_ = Number(param3.minHeight);
  1398.             }
  1399.          }
  1400.          else if(!isNaN(param3.percentHeight))
  1401.          {
  1402.             _loc22_ = param3.percentHeight / 100 * param2;
  1403.             _loc22_ = bound(_loc22_,param3.minHeight,param3.maxHeight);
  1404.             _loc27_ = true;
  1405.          }
  1406.          else
  1407.          {
  1408.             _loc22_ = Number(param3.getExplicitOrMeasuredHeight());
  1409.          }
  1410.          if(!isNaN(_loc8_))
  1411.          {
  1412.             if(_loc15_)
  1413.             {
  1414.                _loc23_ = Math.round((_loc35_ - _loc21_) / 2 + _loc8_ + _loc37_);
  1415.             }
  1416.             else
  1417.             {
  1418.                _loc23_ = Math.round((param1 - _loc21_) / 2 + _loc8_);
  1419.             }
  1420.          }
  1421.          else if(!isNaN(_loc6_))
  1422.          {
  1423.             if(_loc13_)
  1424.             {
  1425.                _loc23_ = _loc30_ + _loc6_;
  1426.             }
  1427.             else
  1428.             {
  1429.                _loc23_ = _loc6_;
  1430.             }
  1431.          }
  1432.          else if(!isNaN(_loc7_))
  1433.          {
  1434.             if(_loc14_)
  1435.             {
  1436.                _loc23_ = _loc31_ - _loc7_ - _loc21_;
  1437.             }
  1438.             else
  1439.             {
  1440.                _loc23_ = param1 - _loc7_ - _loc21_;
  1441.             }
  1442.          }
  1443.          if(!isNaN(_loc12_))
  1444.          {
  1445.             if(_loc19_)
  1446.             {
  1447.                _loc24_ = _loc38_ - param3.baselinePosition + _loc12_;
  1448.             }
  1449.             else
  1450.             {
  1451.                _loc24_ = _loc12_;
  1452.             }
  1453.          }
  1454.          if(!isNaN(_loc11_))
  1455.          {
  1456.             if(_loc18_)
  1457.             {
  1458.                _loc24_ = Math.round((_loc34_ - _loc22_) / 2 + _loc11_ + _loc36_);
  1459.             }
  1460.             else
  1461.             {
  1462.                _loc24_ = Math.round((param2 - _loc22_) / 2 + _loc11_);
  1463.             }
  1464.          }
  1465.          else if(!isNaN(_loc9_))
  1466.          {
  1467.             if(_loc16_)
  1468.             {
  1469.                _loc24_ = _loc32_ + _loc9_;
  1470.             }
  1471.             else
  1472.             {
  1473.                _loc24_ = _loc9_;
  1474.             }
  1475.          }
  1476.          else if(!isNaN(_loc10_))
  1477.          {
  1478.             if(_loc17_)
  1479.             {
  1480.                _loc24_ = _loc33_ - _loc10_ - _loc22_;
  1481.             }
  1482.             else
  1483.             {
  1484.                _loc24_ = param2 - _loc10_ - _loc22_;
  1485.             }
  1486.          }
  1487.          _loc23_ = isNaN(_loc23_) ? Number(param3.x) : _loc23_;
  1488.          _loc24_ = isNaN(_loc24_) ? Number(param3.y) : _loc24_;
  1489.          param3.move(_loc23_,_loc24_);
  1490.          if(_loc26_)
  1491.          {
  1492.             if(_loc23_ + _loc21_ > param1)
  1493.             {
  1494.                _loc21_ = Math.max(param1 - _loc23_,param3.minWidth);
  1495.             }
  1496.          }
  1497.          if(_loc27_)
  1498.          {
  1499.             if(_loc24_ + _loc22_ > param2)
  1500.             {
  1501.                _loc22_ = Math.max(param2 - _loc24_,param3.minHeight);
  1502.             }
  1503.          }
  1504.          if(!isNaN(_loc21_) && !isNaN(_loc22_))
  1505.          {
  1506.             param3.setActualSize(_loc21_,_loc22_);
  1507.          }
  1508.       }
  1509.       
  1510.       private function target_childAddHandler(param1:ChildExistenceChangedEvent) : void
  1511.       {
  1512.          DisplayObject(param1.relatedObject).addEventListener(MoveEvent.MOVE,child_moveHandler);
  1513.       }
  1514.    }
  1515. }
  1516.  
  1517. import mx.core.IUIComponent;
  1518.  
  1519. class LayoutConstraints
  1520. {
  1521.    public var baseline:*;
  1522.    
  1523.    public var left:*;
  1524.    
  1525.    public var bottom:*;
  1526.    
  1527.    public var top:*;
  1528.    
  1529.    public var horizontalCenter:*;
  1530.    
  1531.    public var verticalCenter:*;
  1532.    
  1533.    public var right:*;
  1534.    
  1535.    public function LayoutConstraints()
  1536.    {
  1537.       super();
  1538.    }
  1539. }
  1540.  
  1541. class ChildConstraintInfo
  1542. {
  1543.    public var baseline:Number;
  1544.    
  1545.    public var left:Number;
  1546.    
  1547.    public var baselineBoundary:String;
  1548.    
  1549.    public var leftBoundary:String;
  1550.    
  1551.    public var hcBoundary:String;
  1552.    
  1553.    public var top:Number;
  1554.    
  1555.    public var right:Number;
  1556.    
  1557.    public var topBoundary:String;
  1558.    
  1559.    public var rightBoundary:String;
  1560.    
  1561.    public var bottom:Number;
  1562.    
  1563.    public var vc:Number;
  1564.    
  1565.    public var bottomBoundary:String;
  1566.    
  1567.    public var vcBoundary:String;
  1568.    
  1569.    public var hc:Number;
  1570.    
  1571.    public function ChildConstraintInfo(param1:Number, param2:Number, param3:Number, param4:Number, param5:Number, param6:Number, param7:Number, param8:String = null, param9:String = null, param10:String = null, param11:String = null, param12:String = null, param13:String = null, param14:String = null)
  1572.    {
  1573.       super();
  1574.       this.left = param1;
  1575.       this.right = param2;
  1576.       this.hc = param3;
  1577.       this.top = param4;
  1578.       this.bottom = param5;
  1579.       this.vc = param6;
  1580.       this.baseline = param7;
  1581.       this.leftBoundary = param8;
  1582.       this.rightBoundary = param9;
  1583.       this.hcBoundary = param10;
  1584.       this.topBoundary = param11;
  1585.       this.bottomBoundary = param12;
  1586.       this.vcBoundary = param13;
  1587.       this.baselineBoundary = param14;
  1588.    }
  1589. }
  1590.  
  1591. class ContentColumnChild
  1592. {
  1593.    public var rightCol:ConstraintColumn;
  1594.    
  1595.    public var hcCol:ConstraintColumn;
  1596.    
  1597.    public var left:Number;
  1598.    
  1599.    public var child:IUIComponent;
  1600.    
  1601.    public var rightOffset:Number;
  1602.    
  1603.    public var span:Number;
  1604.    
  1605.    public var hcOffset:Number;
  1606.    
  1607.    public var leftCol:ConstraintColumn;
  1608.    
  1609.    public var leftOffset:Number;
  1610.    
  1611.    public var hc:Number;
  1612.    
  1613.    public var right:Number;
  1614.    
  1615.    public function ContentColumnChild()
  1616.    {
  1617.       super();
  1618.    }
  1619. }
  1620.  
  1621. class ContentRowChild
  1622. {
  1623.    public var topRow:ConstraintRow;
  1624.    
  1625.    public var topOffset:Number;
  1626.    
  1627.    public var baseline:Number;
  1628.    
  1629.    public var baselineRow:ConstraintRow;
  1630.    
  1631.    public var span:Number;
  1632.    
  1633.    public var top:Number;
  1634.    
  1635.    public var vcOffset:Number;
  1636.    
  1637.    public var child:IUIComponent;
  1638.    
  1639.    public var bottomOffset:Number;
  1640.    
  1641.    public var bottom:Number;
  1642.    
  1643.    public var vc:Number;
  1644.    
  1645.    public var bottomRow:ConstraintRow;
  1646.    
  1647.    public var vcRow:ConstraintRow;
  1648.    
  1649.    public var baselineOffset:Number;
  1650.    
  1651.    public function ContentRowChild()
  1652.    {
  1653.       super();
  1654.    }
  1655. }
  1656.