home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / containers / utilityClasses / Flex.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  7.7 KB  |  236 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import mx.core.Container;
  4.    import mx.core.IUIComponent;
  5.    import mx.core.mx_internal;
  6.    
  7.    use namespace mx_internal;
  8.    
  9.    public class Flex
  10.    {
  11.       
  12.       mx_internal static const VERSION:String = "2.0.1.0";
  13.        
  14.       
  15.       public function Flex()
  16.       {
  17.          super();
  18.       }
  19.       
  20.       public static function flexChildWidthsProportionally(param1:Container, param2:Number, param3:Number) : Number
  21.       {
  22.          var _loc4_:Number = NaN;
  23.          var _loc5_:Number = NaN;
  24.          var _loc6_:Array = null;
  25.          var _loc7_:FlexChildInfo = null;
  26.          var _loc8_:IUIComponent = null;
  27.          var _loc9_:int = 0;
  28.          var _loc10_:int = 0;
  29.          var _loc11_:Number = NaN;
  30.          var _loc12_:Number = NaN;
  31.          var _loc13_:Number = NaN;
  32.          var _loc14_:Number = NaN;
  33.          _loc4_ = param2;
  34.          _loc5_ = 0;
  35.          _loc6_ = [];
  36.          _loc10_ = param1.numChildren;
  37.          _loc9_ = 0;
  38.          while(_loc9_ < _loc10_)
  39.          {
  40.             _loc11_ = (_loc8_ = IUIComponent(param1.getChildAt(_loc9_))).percentWidth;
  41.             _loc12_ = _loc8_.percentHeight;
  42.             if(!isNaN(_loc12_) && _loc8_.includeInLayout)
  43.             {
  44.                _loc13_ = Math.max(_loc8_.minHeight,Math.min(_loc8_.maxHeight,_loc12_ >= 100 ? param3 : param3 * _loc12_ / 100));
  45.             }
  46.             else
  47.             {
  48.                _loc13_ = _loc8_.getExplicitOrMeasuredHeight();
  49.             }
  50.             if(!isNaN(_loc11_) && _loc8_.includeInLayout)
  51.             {
  52.                _loc5_ += _loc11_;
  53.                (_loc7_ = new FlexChildInfo()).percent = _loc11_;
  54.                _loc7_.min = _loc8_.minWidth;
  55.                _loc7_.max = _loc8_.maxWidth;
  56.                _loc7_.height = _loc13_;
  57.                _loc7_.child = _loc8_;
  58.                _loc6_.push(_loc7_);
  59.             }
  60.             else
  61.             {
  62.                _loc14_ = _loc8_.getExplicitOrMeasuredWidth();
  63.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  64.                {
  65.                   _loc8_.setActualSize(Math.floor(_loc14_),Math.floor(_loc13_));
  66.                }
  67.                else
  68.                {
  69.                   _loc8_.setActualSize(_loc14_,_loc13_);
  70.                }
  71.                if(_loc8_.includeInLayout)
  72.                {
  73.                   _loc4_ -= _loc8_.width;
  74.                }
  75.             }
  76.             _loc9_++;
  77.          }
  78.          if(_loc5_)
  79.          {
  80.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  81.             _loc10_ = int(_loc6_.length);
  82.             _loc9_ = 0;
  83.             while(_loc9_ < _loc10_)
  84.             {
  85.                if((_loc8_ = (_loc7_ = _loc6_[_loc9_]).child).scaleX == 1 && _loc8_.scaleY == 1)
  86.                {
  87.                   _loc8_.setActualSize(Math.floor(_loc7_.size),Math.floor(_loc7_.height));
  88.                }
  89.                else
  90.                {
  91.                   _loc8_.setActualSize(_loc7_.size,_loc7_.height);
  92.                }
  93.                _loc9_++;
  94.             }
  95.          }
  96.          return _loc4_;
  97.       }
  98.       
  99.       public static function flexChildHeightsProportionally(param1:Container, param2:Number, param3:Number) : Number
  100.       {
  101.          var _loc4_:Number = NaN;
  102.          var _loc5_:Number = NaN;
  103.          var _loc6_:Array = null;
  104.          var _loc7_:FlexChildInfo = null;
  105.          var _loc8_:IUIComponent = null;
  106.          var _loc9_:int = 0;
  107.          var _loc10_:int = 0;
  108.          var _loc11_:Number = NaN;
  109.          var _loc12_:Number = NaN;
  110.          var _loc13_:Number = NaN;
  111.          var _loc14_:Number = NaN;
  112.          _loc4_ = param2;
  113.          _loc5_ = 0;
  114.          _loc6_ = [];
  115.          _loc10_ = param1.numChildren;
  116.          _loc9_ = 0;
  117.          while(_loc9_ < _loc10_)
  118.          {
  119.             _loc11_ = (_loc8_ = IUIComponent(param1.getChildAt(_loc9_))).percentWidth;
  120.             _loc12_ = _loc8_.percentHeight;
  121.             if(!isNaN(_loc11_) && _loc8_.includeInLayout)
  122.             {
  123.                _loc13_ = Math.max(_loc8_.minWidth,Math.min(_loc8_.maxWidth,_loc11_ >= 100 ? param3 : param3 * _loc11_ / 100));
  124.             }
  125.             else
  126.             {
  127.                _loc13_ = _loc8_.getExplicitOrMeasuredWidth();
  128.             }
  129.             if(!isNaN(_loc12_) && _loc8_.includeInLayout)
  130.             {
  131.                _loc5_ += _loc12_;
  132.                (_loc7_ = new FlexChildInfo()).percent = _loc12_;
  133.                _loc7_.min = _loc8_.minHeight;
  134.                _loc7_.max = _loc8_.maxHeight;
  135.                _loc7_.width = _loc13_;
  136.                _loc7_.child = _loc8_;
  137.                _loc6_.push(_loc7_);
  138.             }
  139.             else
  140.             {
  141.                _loc14_ = _loc8_.getExplicitOrMeasuredHeight();
  142.                if(_loc8_.scaleX == 1 && _loc8_.scaleY == 1)
  143.                {
  144.                   _loc8_.setActualSize(Math.floor(_loc13_),Math.floor(_loc14_));
  145.                }
  146.                else
  147.                {
  148.                   _loc8_.setActualSize(_loc13_,_loc14_);
  149.                }
  150.                if(_loc8_.includeInLayout)
  151.                {
  152.                   _loc4_ -= _loc8_.height;
  153.                }
  154.             }
  155.             _loc9_++;
  156.          }
  157.          if(_loc5_)
  158.          {
  159.             _loc4_ = flexChildrenProportionally(param2,_loc4_,_loc5_,_loc6_);
  160.             _loc10_ = int(_loc6_.length);
  161.             _loc9_ = 0;
  162.             while(_loc9_ < _loc10_)
  163.             {
  164.                if((_loc8_ = (_loc7_ = _loc6_[_loc9_]).child).scaleX == 1 && _loc8_.scaleY == 1)
  165.                {
  166.                   _loc8_.setActualSize(Math.floor(_loc7_.width),Math.floor(_loc7_.size));
  167.                }
  168.                else
  169.                {
  170.                   _loc8_.setActualSize(_loc7_.width,_loc7_.size);
  171.                }
  172.                _loc9_++;
  173.             }
  174.          }
  175.          return _loc4_;
  176.       }
  177.       
  178.       public static function flexChildrenProportionally(param1:Number, param2:Number, param3:Number, param4:Array) : Number
  179.       {
  180.          var _loc5_:int = 0;
  181.          var _loc6_:Number = NaN;
  182.          var _loc7_:Boolean = false;
  183.          var _loc8_:Number = NaN;
  184.          var _loc9_:* = undefined;
  185.          var _loc10_:* = undefined;
  186.          var _loc11_:* = undefined;
  187.          var _loc12_:* = undefined;
  188.          var _loc13_:* = undefined;
  189.          var _loc14_:* = undefined;
  190.          _loc5_ = int(param4.length);
  191.          if((_loc8_ = param2 - param1 * param3 / 100) > 0)
  192.          {
  193.             param2 -= _loc8_;
  194.          }
  195.          do
  196.          {
  197.             _loc6_ = 0;
  198.             _loc7_ = true;
  199.             _loc9_ = param2 / param3;
  200.             _loc10_ = 0;
  201.             while(_loc10_ < _loc5_)
  202.             {
  203.                if((_loc12_ = (_loc11_ = param4[_loc10_]).percent * _loc9_) < _loc11_.min)
  204.                {
  205.                   _loc13_ = _loc11_.min;
  206.                   _loc11_.size = _loc13_;
  207.                   param4[_loc10_] = param4[--_loc5_];
  208.                   param4[_loc5_] = _loc11_;
  209.                   param3 -= _loc11_.percent;
  210.                   param2 -= _loc13_;
  211.                   _loc7_ = false;
  212.                   break;
  213.                }
  214.                if(_loc12_ > _loc11_.max)
  215.                {
  216.                   _loc14_ = _loc11_.max;
  217.                   _loc11_.size = _loc14_;
  218.                   param4[_loc10_] = param4[--_loc5_];
  219.                   param4[_loc5_] = _loc11_;
  220.                   param3 -= _loc11_.percent;
  221.                   param2 -= _loc14_;
  222.                   _loc7_ = false;
  223.                   break;
  224.                }
  225.                _loc11_.size = _loc12_;
  226.                _loc6_ += _loc12_;
  227.                _loc10_++;
  228.             }
  229.          }
  230.          while(!_loc7_);
  231.          
  232.          return Math.max(0,Math.floor(param2 - _loc6_));
  233.       }
  234.    }
  235. }
  236.