home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / containers / Tile.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  11.5 KB  |  347 lines
  1. package mx.containers
  2. {
  3.    import flash.events.Event;
  4.    import mx.core.Container;
  5.    import mx.core.EdgeMetrics;
  6.    import mx.core.IUIComponent;
  7.    import mx.core.mx_internal;
  8.    
  9.    use namespace mx_internal;
  10.    
  11.    public class Tile extends Container
  12.    {
  13.       mx_internal static const VERSION:String = "3.5.0.12683";
  14.       
  15.       private var _direction:String = "horizontal";
  16.       
  17.       mx_internal var cellWidth:Number;
  18.       
  19.       mx_internal var cellHeight:Number;
  20.       
  21.       private var _tileHeight:Number;
  22.       
  23.       private var _tileWidth:Number;
  24.       
  25.       public function Tile()
  26.       {
  27.          super();
  28.       }
  29.       
  30.       override protected function measure() : void
  31.       {
  32.          var _loc1_:Number = NaN;
  33.          var _loc2_:Number = NaN;
  34.          var _loc3_:Number = NaN;
  35.          var _loc4_:Number = NaN;
  36.          var _loc11_:Number = NaN;
  37.          var _loc12_:Number = NaN;
  38.          var _loc13_:Number = NaN;
  39.          var _loc14_:Number = NaN;
  40.          var _loc15_:Number = NaN;
  41.          var _loc16_:Number = NaN;
  42.          super.measure();
  43.          mx_internal::findCellSize();
  44.          _loc3_ = mx_internal::cellWidth;
  45.          _loc4_ = mx_internal::cellHeight;
  46.          var _loc5_:int;
  47.          var _loc6_:int = _loc5_ = numChildren;
  48.          var _loc7_:int = 0;
  49.          while(_loc7_ < _loc5_)
  50.          {
  51.             if(!IUIComponent(getChildAt(_loc7_)).includeInLayout)
  52.             {
  53.                _loc6_--;
  54.             }
  55.             _loc7_++;
  56.          }
  57.          _loc5_ = _loc6_;
  58.          if(_loc5_ > 0)
  59.          {
  60.             _loc11_ = getStyle("horizontalGap");
  61.             _loc12_ = getStyle("verticalGap");
  62.             if(direction == TileDirection.HORIZONTAL)
  63.             {
  64.                _loc15_ = explicitWidth / Math.abs(scaleX);
  65.                if(!isNaN(_loc15_))
  66.                {
  67.                   _loc13_ = Math.floor((_loc15_ + _loc11_) / (mx_internal::cellWidth + _loc11_));
  68.                }
  69.             }
  70.             else
  71.             {
  72.                _loc16_ = explicitHeight / Math.abs(scaleY);
  73.                if(!isNaN(_loc16_))
  74.                {
  75.                   _loc13_ = Math.floor((_loc16_ + _loc12_) / (mx_internal::cellHeight + _loc12_));
  76.                }
  77.             }
  78.             if(isNaN(_loc13_))
  79.             {
  80.                _loc13_ = Math.ceil(Math.sqrt(_loc5_));
  81.             }
  82.             if(_loc13_ < 1)
  83.             {
  84.                _loc13_ = 1;
  85.             }
  86.             _loc14_ = Math.ceil(_loc5_ / _loc13_);
  87.             if(direction == TileDirection.HORIZONTAL)
  88.             {
  89.                _loc1_ = _loc13_ * mx_internal::cellWidth + (_loc13_ - 1) * _loc11_;
  90.                _loc2_ = _loc14_ * mx_internal::cellHeight + (_loc14_ - 1) * _loc12_;
  91.             }
  92.             else
  93.             {
  94.                _loc1_ = _loc14_ * mx_internal::cellWidth + (_loc14_ - 1) * _loc11_;
  95.                _loc2_ = _loc13_ * mx_internal::cellHeight + (_loc13_ - 1) * _loc12_;
  96.             }
  97.          }
  98.          else
  99.          {
  100.             _loc1_ = _loc3_;
  101.             _loc2_ = _loc4_;
  102.          }
  103.          var _loc8_:EdgeMetrics = viewMetricsAndPadding;
  104.          var _loc9_:Number = _loc8_.left + _loc8_.right;
  105.          var _loc10_:Number = _loc8_.top + _loc8_.bottom;
  106.          _loc3_ += _loc9_;
  107.          _loc1_ += _loc9_;
  108.          _loc4_ += _loc10_;
  109.          _loc2_ += _loc10_;
  110.          measuredMinWidth = Math.ceil(_loc3_);
  111.          measuredMinHeight = Math.ceil(_loc4_);
  112.          measuredWidth = Math.ceil(_loc1_);
  113.          measuredHeight = Math.ceil(_loc2_);
  114.       }
  115.       
  116.       public function set tileHeight(param1:Number) : void
  117.       {
  118.          _tileHeight = param1;
  119.          invalidateSize();
  120.       }
  121.       
  122.       mx_internal function calcHorizontalOffset(param1:Number, param2:String) : Number
  123.       {
  124.          var _loc3_:Number = NaN;
  125.          if(param2 == "left")
  126.          {
  127.             _loc3_ = 0;
  128.          }
  129.          else if(param2 == "center")
  130.          {
  131.             _loc3_ = (mx_internal::cellWidth - param1) / 2;
  132.          }
  133.          else if(param2 == "right")
  134.          {
  135.             _loc3_ = mx_internal::cellWidth - param1;
  136.          }
  137.          return _loc3_;
  138.       }
  139.       
  140.       mx_internal function calcVerticalOffset(param1:Number, param2:String) : Number
  141.       {
  142.          var _loc3_:Number = NaN;
  143.          if(param2 == "top")
  144.          {
  145.             _loc3_ = 0;
  146.          }
  147.          else if(param2 == "middle")
  148.          {
  149.             _loc3_ = (mx_internal::cellHeight - param1) / 2;
  150.          }
  151.          else if(param2 == "bottom")
  152.          {
  153.             _loc3_ = mx_internal::cellHeight - param1;
  154.          }
  155.          return _loc3_;
  156.       }
  157.       
  158.       public function set tileWidth(param1:Number) : void
  159.       {
  160.          _tileWidth = param1;
  161.          invalidateSize();
  162.       }
  163.       
  164.       [Bindable("resize")]
  165.       public function get tileHeight() : Number
  166.       {
  167.          return _tileHeight;
  168.       }
  169.       
  170.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  171.       {
  172.          var _loc12_:Number = NaN;
  173.          var _loc13_:Number = NaN;
  174.          var _loc15_:int = 0;
  175.          var _loc16_:IUIComponent = null;
  176.          var _loc17_:Number = NaN;
  177.          var _loc18_:Number = NaN;
  178.          super.updateDisplayList(param1,param2);
  179.          if(isNaN(mx_internal::cellWidth) || isNaN(mx_internal::cellHeight))
  180.          {
  181.             mx_internal::findCellSize();
  182.          }
  183.          var _loc3_:EdgeMetrics = viewMetricsAndPadding;
  184.          var _loc4_:Number = getStyle("paddingLeft");
  185.          var _loc5_:Number = getStyle("paddingTop");
  186.          var _loc6_:Number = getStyle("horizontalGap");
  187.          var _loc7_:Number = getStyle("verticalGap");
  188.          var _loc8_:String = getStyle("horizontalAlign");
  189.          var _loc9_:String = getStyle("verticalAlign");
  190.          var _loc10_:Number = _loc4_;
  191.          var _loc11_:Number = _loc5_;
  192.          var _loc14_:int = numChildren;
  193.          if(direction == TileDirection.HORIZONTAL)
  194.          {
  195.             _loc17_ = Math.ceil(param1) - _loc3_.right;
  196.             _loc15_ = 0;
  197.             while(_loc15_ < _loc14_)
  198.             {
  199.                _loc16_ = IUIComponent(getChildAt(_loc15_));
  200.                if(_loc16_.includeInLayout)
  201.                {
  202.                   if(_loc10_ + mx_internal::cellWidth > _loc17_)
  203.                   {
  204.                      if(_loc10_ != _loc4_)
  205.                      {
  206.                         _loc11_ += mx_internal::cellHeight + _loc7_;
  207.                         _loc10_ = _loc4_;
  208.                      }
  209.                   }
  210.                   setChildSize(_loc16_);
  211.                   _loc12_ = Math.floor(mx_internal::calcHorizontalOffset(_loc16_.width,_loc8_));
  212.                   _loc13_ = Math.floor(mx_internal::calcVerticalOffset(_loc16_.height,_loc9_));
  213.                   _loc16_.move(_loc10_ + _loc12_,_loc11_ + _loc13_);
  214.                   _loc10_ += mx_internal::cellWidth + _loc6_;
  215.                }
  216.                _loc15_++;
  217.             }
  218.          }
  219.          else
  220.          {
  221.             _loc18_ = Math.ceil(param2) - _loc3_.bottom;
  222.             _loc15_ = 0;
  223.             while(_loc15_ < _loc14_)
  224.             {
  225.                _loc16_ = IUIComponent(getChildAt(_loc15_));
  226.                if(_loc16_.includeInLayout)
  227.                {
  228.                   if(_loc11_ + mx_internal::cellHeight > _loc18_)
  229.                   {
  230.                      if(_loc11_ != _loc5_)
  231.                      {
  232.                         _loc10_ += mx_internal::cellWidth + _loc6_;
  233.                         _loc11_ = _loc5_;
  234.                      }
  235.                   }
  236.                   setChildSize(_loc16_);
  237.                   _loc12_ = Math.floor(mx_internal::calcHorizontalOffset(_loc16_.width,_loc8_));
  238.                   _loc13_ = Math.floor(mx_internal::calcVerticalOffset(_loc16_.height,_loc9_));
  239.                   _loc16_.move(_loc10_ + _loc12_,_loc11_ + _loc13_);
  240.                   _loc11_ += mx_internal::cellHeight + _loc7_;
  241.                }
  242.                _loc15_++;
  243.             }
  244.          }
  245.          mx_internal::cellWidth = NaN;
  246.          mx_internal::cellHeight = NaN;
  247.       }
  248.       
  249.       [Bindable("resize")]
  250.       public function get tileWidth() : Number
  251.       {
  252.          return _tileWidth;
  253.       }
  254.       
  255.       private function setChildSize(param1:IUIComponent) : void
  256.       {
  257.          var _loc2_:Number = NaN;
  258.          var _loc3_:Number = NaN;
  259.          var _loc4_:Number = NaN;
  260.          var _loc5_:Number = NaN;
  261.          if(param1.percentWidth > 0)
  262.          {
  263.             _loc2_ = Math.min(mx_internal::cellWidth,mx_internal::cellWidth * param1.percentWidth / 100);
  264.          }
  265.          else
  266.          {
  267.             _loc2_ = Number(param1.getExplicitOrMeasuredWidth());
  268.             if(_loc2_ > mx_internal::cellWidth)
  269.             {
  270.                _loc4_ = isNaN(param1.explicitWidth) ? 0 : Number(param1.explicitWidth);
  271.                _loc5_ = isNaN(param1.explicitMinWidth) ? 0 : Number(param1.explicitMinWidth);
  272.                _loc2_ = _loc4_ > mx_internal::cellWidth || _loc5_ > mx_internal::cellWidth ? Math.max(_loc5_,_loc4_) : mx_internal::cellWidth;
  273.             }
  274.          }
  275.          if(param1.percentHeight > 0)
  276.          {
  277.             _loc3_ = Math.min(mx_internal::cellHeight,mx_internal::cellHeight * param1.percentHeight / 100);
  278.          }
  279.          else
  280.          {
  281.             _loc3_ = Number(param1.getExplicitOrMeasuredHeight());
  282.             if(_loc3_ > mx_internal::cellHeight)
  283.             {
  284.                _loc4_ = isNaN(param1.explicitHeight) ? 0 : Number(param1.explicitHeight);
  285.                _loc5_ = isNaN(param1.explicitMinHeight) ? 0 : Number(param1.explicitMinHeight);
  286.                _loc3_ = _loc4_ > mx_internal::cellHeight || _loc5_ > mx_internal::cellHeight ? Math.max(_loc5_,_loc4_) : mx_internal::cellHeight;
  287.             }
  288.          }
  289.          param1.setActualSize(_loc2_,_loc3_);
  290.       }
  291.       
  292.       mx_internal function findCellSize() : void
  293.       {
  294.          var _loc7_:IUIComponent = null;
  295.          var _loc8_:Number = NaN;
  296.          var _loc9_:Number = NaN;
  297.          var _loc1_:* = !isNaN(tileWidth);
  298.          var _loc2_:* = !isNaN(tileHeight);
  299.          if(_loc1_ && _loc2_)
  300.          {
  301.             mx_internal::cellWidth = tileWidth;
  302.             mx_internal::cellHeight = tileHeight;
  303.             return;
  304.          }
  305.          var _loc3_:Number = 0;
  306.          var _loc4_:Number = 0;
  307.          var _loc5_:int = numChildren;
  308.          var _loc6_:int = 0;
  309.          while(_loc6_ < _loc5_)
  310.          {
  311.             _loc7_ = IUIComponent(getChildAt(_loc6_));
  312.             if(_loc7_.includeInLayout)
  313.             {
  314.                _loc8_ = Number(_loc7_.getExplicitOrMeasuredWidth());
  315.                if(_loc8_ > _loc3_)
  316.                {
  317.                   _loc3_ = _loc8_;
  318.                }
  319.                _loc9_ = Number(_loc7_.getExplicitOrMeasuredHeight());
  320.                if(_loc9_ > _loc4_)
  321.                {
  322.                   _loc4_ = _loc9_;
  323.                }
  324.             }
  325.             _loc6_++;
  326.          }
  327.          mx_internal::cellWidth = _loc1_ ? tileWidth : _loc3_;
  328.          mx_internal::cellHeight = _loc2_ ? tileHeight : _loc4_;
  329.       }
  330.       
  331.       public function set direction(param1:String) : void
  332.       {
  333.          _direction = param1;
  334.          invalidateSize();
  335.          invalidateDisplayList();
  336.          dispatchEvent(new Event("directionChanged"));
  337.       }
  338.       
  339.       [Bindable("directionChanged")]
  340.       public function get direction() : String
  341.       {
  342.          return _direction;
  343.       }
  344.    }
  345. }
  346.  
  347.