home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Puzzle / filler.swf / scripts / mx / containers / utilityClasses / CanvasLayout.as < prev    next >
Encoding:
Text File  |  2008-09-02  |  12.6 KB  |  395 lines
  1. package mx.containers.utilityClasses
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.geom.Rectangle;
  5.    import mx.core.Container;
  6.    import mx.core.EdgeMetrics;
  7.    import mx.core.IUIComponent;
  8.    import mx.core.mx_internal;
  9.    import mx.events.ChildExistenceChangedEvent;
  10.    import mx.events.MoveEvent;
  11.    import mx.styles.IStyleClient;
  12.    
  13.    use namespace mx_internal;
  14.    
  15.    public class CanvasLayout extends Layout
  16.    {
  17.       
  18.       mx_internal static const VERSION:String = "2.0.1.0";
  19.       
  20.       private static var r:Rectangle = new Rectangle();
  21.        
  22.       
  23.       private var _contentArea:Rectangle;
  24.       
  25.       public function CanvasLayout()
  26.       {
  27.          super();
  28.       }
  29.       
  30.       private function applyAnchorStylesDuringUpdateDisplayList(param1:Number, param2:Number, param3:IUIComponent) : void
  31.       {
  32.          var _loc4_:IStyleClient = null;
  33.          var _loc5_:Number = NaN;
  34.          var _loc6_:Number = NaN;
  35.          var _loc7_:Number = NaN;
  36.          var _loc8_:Number = NaN;
  37.          var _loc9_:Number = NaN;
  38.          var _loc10_:Number = NaN;
  39.          var _loc11_:Number = NaN;
  40.          var _loc12_:Number = NaN;
  41.          var _loc13_:Number = NaN;
  42.          var _loc14_:Number = NaN;
  43.          var _loc15_:Boolean = false;
  44.          var _loc16_:Boolean = false;
  45.          if(!(_loc4_ = param3 as IStyleClient))
  46.          {
  47.             return;
  48.          }
  49.          _loc5_ = _loc4_.getStyle("left");
  50.          _loc6_ = _loc4_.getStyle("right");
  51.          _loc7_ = _loc4_.getStyle("horizontalCenter");
  52.          _loc8_ = _loc4_.getStyle("top");
  53.          _loc9_ = _loc4_.getStyle("bottom");
  54.          _loc10_ = _loc4_.getStyle("verticalCenter");
  55.          _loc15_ = false;
  56.          _loc16_ = false;
  57.          if(!isNaN(_loc5_) && !isNaN(_loc6_))
  58.          {
  59.             if((_loc11_ = param1 - _loc5_ - _loc6_) < param3.minWidth)
  60.             {
  61.                _loc11_ = param3.minWidth;
  62.             }
  63.          }
  64.          else if(!isNaN(param3.percentWidth))
  65.          {
  66.             _loc11_ = param3.percentWidth / 100 * param1;
  67.             _loc11_ = bound(_loc11_,param3.minWidth,param3.maxWidth);
  68.             _loc15_ = true;
  69.          }
  70.          else
  71.          {
  72.             _loc11_ = param3.getExplicitOrMeasuredWidth();
  73.          }
  74.          if(!isNaN(_loc8_) && !isNaN(_loc9_))
  75.          {
  76.             if((_loc12_ = param2 - _loc8_ - _loc9_) < param3.minHeight)
  77.             {
  78.                _loc12_ = param3.minHeight;
  79.             }
  80.          }
  81.          else if(!isNaN(param3.percentHeight))
  82.          {
  83.             _loc12_ = param3.percentHeight / 100 * param2;
  84.             _loc12_ = bound(_loc12_,param3.minHeight,param3.maxHeight);
  85.             _loc16_ = true;
  86.          }
  87.          else
  88.          {
  89.             _loc12_ = param3.getExplicitOrMeasuredHeight();
  90.          }
  91.          if(!isNaN(_loc7_))
  92.          {
  93.             _loc13_ = Math.round((param1 - _loc11_) / 2 + _loc7_);
  94.          }
  95.          else if(!isNaN(_loc5_))
  96.          {
  97.             _loc13_ = _loc5_;
  98.          }
  99.          else if(!isNaN(_loc6_))
  100.          {
  101.             _loc13_ = param1 - _loc6_ - _loc11_;
  102.          }
  103.          if(!isNaN(_loc10_))
  104.          {
  105.             _loc14_ = Math.round((param2 - _loc12_) / 2 + _loc10_);
  106.          }
  107.          else if(!isNaN(_loc8_))
  108.          {
  109.             _loc14_ = _loc8_;
  110.          }
  111.          else if(!isNaN(_loc9_))
  112.          {
  113.             _loc14_ = param2 - _loc9_ - _loc12_;
  114.          }
  115.          _loc13_ = isNaN(_loc13_) ? Number(param3.x) : _loc13_;
  116.          _loc14_ = isNaN(_loc14_) ? Number(param3.y) : _loc14_;
  117.          param3.move(_loc13_,_loc14_);
  118.          if(_loc15_)
  119.          {
  120.             if(_loc13_ + _loc11_ > param1)
  121.             {
  122.                _loc11_ = Math.max(param1 - _loc13_,param3.minWidth);
  123.             }
  124.          }
  125.          if(_loc16_)
  126.          {
  127.             if(_loc14_ + _loc12_ > param2)
  128.             {
  129.                _loc12_ = Math.max(param2 - _loc14_,param3.minHeight);
  130.             }
  131.          }
  132.          if(!isNaN(_loc11_) && !isNaN(_loc12_))
  133.          {
  134.             param3.setActualSize(_loc11_,_loc12_);
  135.          }
  136.       }
  137.       
  138.       override public function set target(param1:Container) : void
  139.       {
  140.          var _loc2_:Container = null;
  141.          var _loc3_:int = 0;
  142.          var _loc4_:int = 0;
  143.          _loc2_ = super.target;
  144.          if(param1 != _loc2_)
  145.          {
  146.             if(_loc2_)
  147.             {
  148.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  149.                _loc2_.removeEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  150.                _loc4_ = _loc2_.numChildren;
  151.                _loc3_ = 0;
  152.                while(_loc3_ < _loc4_)
  153.                {
  154.                   DisplayObject(_loc2_.getChildAt(_loc3_)).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  155.                   _loc3_++;
  156.                }
  157.             }
  158.             if(param1)
  159.             {
  160.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_ADD,target_childAddHandler);
  161.                param1.addEventListener(ChildExistenceChangedEvent.CHILD_REMOVE,target_childRemoveHandler);
  162.                _loc4_ = param1.numChildren;
  163.                _loc3_ = 0;
  164.                while(_loc3_ < _loc4_)
  165.                {
  166.                   DisplayObject(param1.getChildAt(_loc3_)).addEventListener(MoveEvent.MOVE,child_moveHandler);
  167.                   _loc3_++;
  168.                }
  169.             }
  170.             super.target = param1;
  171.          }
  172.       }
  173.       
  174.       override public function measure() : void
  175.       {
  176.          var _loc1_:Container = null;
  177.          var _loc2_:Number = NaN;
  178.          var _loc3_:Number = NaN;
  179.          var _loc4_:EdgeMetrics = null;
  180.          var _loc5_:Rectangle = null;
  181.          _loc1_ = super.target;
  182.          _loc2_ = 0;
  183.          _loc3_ = 0;
  184.          _loc4_ = _loc1_.viewMetrics;
  185.          _contentArea = null;
  186.          _loc5_ = measureContentArea();
  187.          _loc1_.measuredWidth = _loc5_.width + _loc4_.left + _loc4_.right;
  188.          _loc1_.measuredHeight = _loc5_.height + _loc4_.top + _loc4_.bottom;
  189.       }
  190.       
  191.       private function target_childAddHandler(param1:ChildExistenceChangedEvent) : void
  192.       {
  193.          DisplayObject(param1.relatedObject).addEventListener(MoveEvent.MOVE,child_moveHandler);
  194.       }
  195.       
  196.       private function measureContentArea() : Rectangle
  197.       {
  198.          var _loc1_:int = 0;
  199.          var _loc2_:int = 0;
  200.          var _loc3_:IUIComponent = null;
  201.          var _loc4_:IStyleClient = null;
  202.          var _loc5_:Number = NaN;
  203.          var _loc6_:Number = NaN;
  204.          var _loc7_:Number = NaN;
  205.          var _loc8_:Number = NaN;
  206.          var _loc9_:Number = NaN;
  207.          var _loc10_:Number = NaN;
  208.          if(_contentArea)
  209.          {
  210.             return _contentArea;
  211.          }
  212.          _contentArea = new Rectangle();
  213.          _loc1_ = target.numChildren;
  214.          _loc2_ = 0;
  215.          while(_loc2_ < _loc1_)
  216.          {
  217.             _loc3_ = target.getChildAt(_loc2_) as IUIComponent;
  218.             _loc4_ = _loc3_ as IStyleClient;
  219.             if(_loc3_.includeInLayout)
  220.             {
  221.                _loc5_ = Number(_loc3_.x);
  222.                _loc6_ = Number(_loc3_.y);
  223.                _loc7_ = _loc3_.getExplicitOrMeasuredWidth();
  224.                _loc8_ = _loc3_.getExplicitOrMeasuredHeight();
  225.                if(!isNaN(_loc3_.percentWidth) || _loc4_ && !isNaN(_loc4_.getStyle("left")) && !isNaN(_loc4_.getStyle("right")))
  226.                {
  227.                   _loc7_ = _loc3_.minWidth;
  228.                }
  229.                if(!isNaN(_loc3_.percentHeight) || _loc4_ && !isNaN(_loc4_.getStyle("top")) && !isNaN(_loc4_.getStyle("bottom")))
  230.                {
  231.                   _loc8_ = _loc3_.minHeight;
  232.                }
  233.                r.x = _loc5_;
  234.                r.y = _loc6_;
  235.                r.width = _loc7_;
  236.                r.height = _loc8_;
  237.                applyAnchorStylesDuringMeasure(_loc3_,r);
  238.                _loc5_ = r.x;
  239.                _loc6_ = r.y;
  240.                _loc7_ = r.width;
  241.                _loc8_ = r.height;
  242.                if(isNaN(_loc5_))
  243.                {
  244.                   _loc5_ = Number(_loc3_.x);
  245.                }
  246.                if(isNaN(_loc6_))
  247.                {
  248.                   _loc6_ = Number(_loc3_.y);
  249.                }
  250.                _loc9_ = _loc5_;
  251.                _loc10_ = _loc6_;
  252.                if(isNaN(_loc7_))
  253.                {
  254.                   _loc7_ = Number(_loc3_.width);
  255.                }
  256.                if(isNaN(_loc8_))
  257.                {
  258.                   _loc8_ = Number(_loc3_.height);
  259.                }
  260.                _loc9_ += _loc7_;
  261.                _loc10_ += _loc8_;
  262.                _contentArea.right = Math.max(_contentArea.right,_loc9_);
  263.                _contentArea.bottom = Math.max(_contentArea.bottom,_loc10_);
  264.             }
  265.             _loc2_++;
  266.          }
  267.          return _contentArea;
  268.       }
  269.       
  270.       private function child_moveHandler(param1:MoveEvent) : void
  271.       {
  272.          var _loc2_:Container = null;
  273.          if(param1.target is IUIComponent)
  274.          {
  275.             if(!IUIComponent(param1.target).includeInLayout)
  276.             {
  277.                return;
  278.             }
  279.          }
  280.          _loc2_ = super.target;
  281.          if(_loc2_)
  282.          {
  283.             _loc2_.invalidateSize();
  284.             _loc2_.invalidateDisplayList();
  285.             _contentArea = null;
  286.          }
  287.       }
  288.       
  289.       override public function updateDisplayList(param1:Number, param2:Number) : void
  290.       {
  291.          var _loc3_:Container = null;
  292.          var _loc4_:EdgeMetrics = null;
  293.          var _loc5_:Number = NaN;
  294.          var _loc6_:Number = NaN;
  295.          var _loc7_:int = 0;
  296.          var _loc8_:int = 0;
  297.          var _loc9_:IUIComponent = null;
  298.          _loc3_ = super.target;
  299.          _loc3_.mx_internal::doingLayout = false;
  300.          _loc4_ = _loc3_.viewMetrics;
  301.          _loc3_.mx_internal::doingLayout = true;
  302.          _loc5_ = param1 - _loc4_.left - _loc4_.right;
  303.          _loc6_ = param2 - _loc4_.top - _loc4_.bottom;
  304.          _loc7_ = _loc3_.numChildren;
  305.          _loc8_ = 0;
  306.          while(_loc8_ < _loc7_)
  307.          {
  308.             _loc9_ = _loc3_.getChildAt(_loc8_) as IUIComponent;
  309.             applyAnchorStylesDuringUpdateDisplayList(_loc5_,_loc6_,_loc9_);
  310.             _loc8_++;
  311.          }
  312.       }
  313.       
  314.       private function applyAnchorStylesDuringMeasure(param1:IUIComponent, param2:Rectangle) : void
  315.       {
  316.          var _loc3_:IStyleClient = null;
  317.          var _loc4_:Number = NaN;
  318.          var _loc5_:Number = NaN;
  319.          var _loc6_:Number = NaN;
  320.          var _loc7_:Number = NaN;
  321.          var _loc8_:Number = NaN;
  322.          var _loc9_:Number = NaN;
  323.          _loc3_ = param1 as IStyleClient;
  324.          if(!_loc3_)
  325.          {
  326.             return;
  327.          }
  328.          _loc4_ = _loc3_.getStyle("left");
  329.          _loc5_ = _loc3_.getStyle("right");
  330.          _loc6_ = _loc3_.getStyle("horizontalCenter");
  331.          if(!isNaN(_loc6_))
  332.          {
  333.             param2.x = Math.round((target.width - param1.width) / 2 + _loc6_);
  334.          }
  335.          else if(!isNaN(_loc4_) && !isNaN(_loc5_))
  336.          {
  337.             param2.x = _loc4_;
  338.             param2.width += _loc5_;
  339.          }
  340.          else if(!isNaN(_loc4_))
  341.          {
  342.             param2.x = _loc4_;
  343.          }
  344.          else if(!isNaN(_loc5_))
  345.          {
  346.             param2.x = 0;
  347.             param2.width += _loc5_;
  348.          }
  349.          _loc7_ = _loc3_.getStyle("top");
  350.          _loc8_ = _loc3_.getStyle("bottom");
  351.          _loc9_ = _loc3_.getStyle("verticalCenter");
  352.          if(!isNaN(_loc9_))
  353.          {
  354.             param2.y = Math.round((target.height - param1.height) / 2 + _loc9_);
  355.          }
  356.          else if(!isNaN(_loc7_) && !isNaN(_loc8_))
  357.          {
  358.             param2.y = _loc7_;
  359.             param2.height += _loc8_;
  360.          }
  361.          else if(!isNaN(_loc7_))
  362.          {
  363.             param2.y = _loc7_;
  364.          }
  365.          else if(!isNaN(_loc8_))
  366.          {
  367.             param2.y = 0;
  368.             param2.height += _loc8_;
  369.          }
  370.       }
  371.       
  372.       private function bound(param1:Number, param2:Number, param3:Number) : Number
  373.       {
  374.          if(param1 < param2)
  375.          {
  376.             param1 = param2;
  377.          }
  378.          else if(param1 > param3)
  379.          {
  380.             param1 = param3;
  381.          }
  382.          else
  383.          {
  384.             param1 = Math.floor(param1);
  385.          }
  386.          return param1;
  387.       }
  388.       
  389.       private function target_childRemoveHandler(param1:ChildExistenceChangedEvent) : void
  390.       {
  391.          DisplayObject(param1.relatedObject).removeEventListener(MoveEvent.MOVE,child_moveHandler);
  392.       }
  393.    }
  394. }
  395.