Refactor padding out of RenderBlock.

sky/sdk/lib/framework/layout2.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 import 'node.dart';
 import 'dart:sky' as sky;
 
 // ABSTRACT LAYOUT
 
 class ParentData {
@@ skipping 222 matching lines @@
 
   void handlePointer(sky.PointerEvent event) {
     // override this if you have a client, to hand it to the client
     // override this if you want to do anything with the pointer event
   }
 
   // RenderNode subclasses are expected to have a method like the
   // following (with the signature being whatever passes for coordinates
   // for this particular class):
   // bool hitTest(HitTestResult result, { double x, double y }) {
-  //   // If (x,y) is not inside this node, then return false.
+  //   // If (x,y) is not inside this node, then return false. (You
+  //   // can assume that the given coordinate is inside your
+  //   // dimensions. You only need to check this if you're an
+  //   // irregular shape, e.g. if you have a hole.)
   //   // Otherwise:
   //   // For each child that intersects x,y, in z-order starting from the top,
   //   // call hitTest() for that child, passing it /result/, and the coordinates
   //   // converted to the child's coordinate origin, and stop at the first child
   //   // that returns true.
   //   // Then, add yourself to /result/, and return true.
   // }
   // You must not add yourself to /result/ if you return false.
 
 }
 
 class HitTestResult {
   final List<RenderNode> path = new List<RenderNode>();
 
   RenderNode get result => path.first;
 
   void add(RenderNode node) {
     path.add(node);
   }
 }
 
+
+// GENERIC MIXIN FOR RENDER NODES WITH ONE CHILD
+
 abstract class RenderNodeWithChildMixin<ChildType extends RenderNode> {
   ChildType _child;
   ChildType get child => _child;
   void set child (ChildType value) {
     if (_child != null)
       dropChild(_child);
     _child = value;
     if (_child != null)
       adoptChild(_child);
     markNeedsLayout();
   }
 }
 
-// GENERIC MIXIN FOR RENDER NODES THAT TAKE A LIST OF CHILDREN
+
+// GENERIC MIXIN FOR RENDER NODES WITH A LIST OF CHILDREN
 
 abstract class ContainerParentDataMixin<ChildType extends RenderNode> {
   ChildType previousSibling;
   ChildType nextSibling;
   void detachSiblings() {
     if (previousSibling != null) {
       assert(previousSibling.parentData is ContainerParentDataMixin<ChildType>);
       assert(previousSibling != this);
       assert(previousSibling.parentData.nextSibling == this);
       previousSibling.parentData.nextSibling = nextSibling;
@@ skipping 134 matching lines @@
     assert(child.parentData is ParentDataType);
     return child.parentData.nextSibling;
   }
 
 }
 
 
 // GENERIC BOX RENDERING
 // Anything that has a concept of x, y, width, height is going to derive from this
 
+class EdgeDims {
+  // used for e.g. padding
+  const EdgeDims(this.top, this.right, this.bottom, this.left);
+  final double top;
+  final double right;
+  final double bottom;
+  final double left;
+  operator ==(EdgeDims other) => (top == other.top) ||
+                                 (right == other.right) ||
+                                 (bottom == other.bottom) ||
+                                 (left == other.left);
+}
+
 class BoxConstraints {
   const BoxConstraints({
     this.minWidth: 0.0,
     this.maxWidth: double.INFINITY,
     this.minHeight: 0.0,
     this.maxHeight: double.INFINITY});
 
   const BoxConstraints.tight({ double width: 0.0, double height: 0.0 })
     : minWidth = width,
       maxWidth = width,
       minHeight = height,
       maxHeight = height;
 
+  BoxConstraints deflate(EdgeDims edges) {
+    assert(edges != null);
+    return new BoxConstraints(
+      minWidth: minWidth,
+      maxWidth: maxWidth - (edges.left + edges.right),
+      minHeight: minHeight,
+      maxHeight: maxHeight - (edges.top + edges.bottom)
+    );
+  }
+
   final double minWidth;
   final double maxWidth;
   final double minHeight;
   final double maxHeight;
 
   double constrainWidth(double width) {
     return clamp(min: minWidth, max: maxWidth, value: width);
   }
 
   double constrainHeight(double height) {
@@ skipping 37 matching lines @@
     return new BoxDimensions.withConstraints(constraints);
   }
 
   void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
     width = constraints.constrainWidth(0.0);
     height = constraints.constrainHeight(0.0);
     layoutDone();
   }
 
   bool hitTest(HitTestResult result, { double x, double y }) {
-    if (x < 0.0 || x >= width || y < 0.0 || y >= height)
-      return false;
     hitTestChildren(result, x: x, y: y);
     result.add(this);
     return true;
   }
   void hitTestChildren(HitTestResult result, { double x, double y }) { }
 
   double width;
   double height;
 }
 
+class RenderPadding extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
+
+  RenderPadding(EdgeDims padding, RenderBox child) {
+    assert(padding != null);
+    this.padding = padding;
+    this.child = child;
+  }
+
+  EdgeDims _padding;
+  EdgeDims get padding => _padding;
+  void set padding (EdgeDims value) {
+    assert(value != null);
+    if (_padding != value) {
+      _padding = value;
+      markNeedsLayout();
+    }
+  }
+
+  BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
+    assert(padding != null);
+    constraints = constraints.deflate(padding);
+    if (child == null)
+      return super.getIntrinsicDimensions(constraints);
+    return child.getIntrinsicDimensions(constraints);
+  }
+
+  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+    assert(padding != null);
+    constraints = constraints.deflate(padding);
+    if (child == null) {
+      width = constraints.constrainWidth(padding.left + padding.right);
+      height = constraints.constrainHeight(padding.top + padding.bottom);
+      return;
+    }
+    if (relayoutSubtreeRoot != null)
+      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
+    else
+      relayoutSubtreeRoot = this;
+    child.layout(constraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
+    assert(child.parentData is BoxParentData);
+    child.parentData.x = padding.left;
+    child.parentData.y = padding.top;
+    width = constraints.constrainWidth(padding.left + child.width + padding.right);
+    height = constraints.constrainHeight(padding.top + child.height + padding.bottom);
+  }
+
+  void paint(RenderNodeDisplayList canvas) {
+    if (child != null)
+      canvas.paintChild(child, child.parentData.x, child.parentData.y);
+  }
+
+  void hitTestChildren(HitTestResult result, { double x, double y }) {
+    if (child != null) {
+      assert(child.parentData is BoxParentData);
+      if ((x >= child.parentData.x) && (x < child.parentData.x + child.width) &&
+          (y >= child.parentData.y) && (y < child.parentData.y + child.height))
+        child.hitTest(result, x: x+child.parentData.x, y: y+child.parentData.y);
+    }
+  }
+
+}
+
 // This must be immutable, because we won't notice when it changes
 class BoxDecoration {
   const BoxDecoration({
     this.backgroundColor
   });
 
   final int backgroundColor;
 }
 
 class RenderDecoratedBox extends RenderBox {
@@ skipping 81 matching lines @@
       _width = newWidth;
       _height = newHeight;
       relayout();
     } else {
       layoutDone();
     }
   }
 
   void relayout() {
     if (child != null) {
-      child.layout(new BoxConstraints(
-        minWidth: width,
-        maxWidth: width,
-        minHeight: height,
-        maxHeight: height
-      ));
+      child.layout(new BoxConstraints.tight(width: width, height: height));
       assert(child.width == width);
       assert(child.height == height);
     }
     layoutDone();
   }
 
   void rotate({ int oldAngle, int newAngle, Duration time }) {
     assert(false); // nobody tells the screen to rotate, the whole rotate() dance is started from our layout()
   }
 
   bool hitTest(HitTestResult result, { double x, double y }) {
-    if (x < 0.0 || x >= width || y < 0.0 || y >= height)
-      return false;
-    if (child != null) {
-      if (x >= 0.0 && x < child.width && y >= 0.0 && y < child.height)
-        child.hitTest(result, x: x, y: y);
-    }
+    if (child != null && x >= 0.0 && x < child.width && y >= 0.0 && y < child.height)
+      child.hitTest(result, x: x, y: y);
     result.add(this);
     return true;
   }
 
   void paint(RenderNodeDisplayList canvas) {
     if (child != null)
       canvas.paintChild(child, 0.0, 0.0);
   }
 
   void paintFrame() {
@@ skipping 28 matching lines @@
     while (child != null) {
       assert(child.parentData is BoxParentData);
       canvas.paintChild(child, child.parentData.x, child.parentData.y);
       child = child.parentData.nextSibling;
     }
   }
 }
 
 // BLOCK LAYOUT MANAGER
 
-class EdgeDims {
-  // used for e.g. padding
-  const EdgeDims(this.top, this.right, this.bottom, this.left);
-  final double top;
-  final double right;
-  final double bottom;
-  final double left;
-  operator ==(EdgeDims other) => (top == other.top) ||
-                                 (right == other.right) ||
-                                 (bottom == other.bottom) ||
-                                 (left == other.left);
-}
-
 class BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
 
 class RenderBlock extends RenderDecoratedBox with ContainerRenderNodeMixin<RenderBox, BlockParentData>,
                                                   RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
   // lays out RenderBox children in a vertical stack
   // uses the maximum width provided by the parent
   // sizes itself to the height of its child stack
 
   RenderBlock({
-    BoxDecoration decoration,
-    EdgeDims padding: const EdgeDims(0.0, 0.0, 0.0, 0.0)
-  }) : super(decoration), _padding = padding;
-
-  EdgeDims _padding;
-  EdgeDims get padding => _padding;
-  void set padding (EdgeDims value) {
-    assert(value != null);
-    if (_padding != value) {
-      _padding = value;
-      markNeedsLayout();
-    }
-  }
+    BoxDecoration decoration
+  }) : super(decoration);
 
   void setParentData(RenderBox child) {
     if (child.parentData is! BlockParentData)
       child.parentData = new BlockParentData();
   }
 
   // override this to report what dimensions you would have if you
   // were laid out with the given constraints this can walk the tree
   // if it must, but it should be as cheap as possible; just get the
   // dimensions and nothing else (e.g. don't calculate hypothetical
   // child positions if they're not needed to determine dimensions)
   BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
-    double outerHeight = _padding.top + _padding.bottom;
+    double outerHeight = 0.0;
     double outerWidth = constraints.constrainWidth(constraints.maxWidth);
     assert(outerWidth < double.INFINITY);
-    double innerWidth = outerWidth - (_padding.left + _padding.right);
+    double innerWidth = outerWidth;
     RenderBox child = firstChild;
     BoxConstraints innerConstraints = new BoxConstraints(minWidth: innerWidth,
                                                          maxWidth: innerWidth);
     while (child != null) {
       outerHeight += child.getIntrinsicDimensions(innerConstraints).height;
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
 
     return new BoxDimensions(width: outerWidth,
@@ skipping 11 matching lines @@
     _constraints = constraints;
     internalLayout(relayoutSubtreeRoot);
   }
 
   void relayout() {
     internalLayout(this);
   }
 
   void internalLayout(RenderNode relayoutSubtreeRoot) {
     assert(_constraints != null);
-    double y = _padding.top;
-    double innerWidth = width - (_padding.left + _padding.right);
+    double y = 0.0;
+    double innerWidth = width;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth),
                    relayoutSubtreeRoot: relayoutSubtreeRoot);
       assert(child.parentData is BlockParentData);
-      child.parentData.x = _padding.left;
+      child.parentData.x = 0.0;
       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
-    height = _constraints.constrainHeight(y + _padding.bottom);
+    height = _constraints.constrainHeight(y);
     layoutDone();
   }
 
   void hitTestChildren(HitTestResult result, { double x, double y }) {
     defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
@@ skipping 125 matching lines @@
 
   void hitTestChildren(HitTestResult result, { double x, double y }) {
     defaultHitTestChildren(result, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 }