Actually perform a block layout

sky/sdk/lib/framework/layout2.dart

 library layout;
 
 // This version of layout.dart is an update to the other one, this one using new APIs.
 // It will not work in a stock Sky setup currently.
 
 import 'node.dart';
 
 import 'dart:sky' as sky;
 
 // ABSTRACT LAYOUT
 
 class ParentData {
   void detach() {
     detachSiblings();
   }
   void detachSiblings() { } // workaround for lack of inter-class mixins in Dart
   void merge(ParentData other) {
     // override this in subclasses to merge in data from other into this
     assert(other.runtimeType == this.runtimeType);
   }
 }
 
 const kLayoutDirections = 4;
 
 double clamp({double min: 0.0, double value: 0.0, double max: double.INFINITY}) {
+  assert(min != null);
+  assert(value != null);
+  assert(max != null);
+
   if (value > max)
     value = max;
   if (value < min)
     value = min;
   return value;
 }
 
 class RenderNodeDisplayList extends sky.PictureRecorder {
   RenderNodeDisplayList(double width, double height) : super(width, height);
   void paintChild(RenderNode child, double x, double y) {
@@ skipping 182 matching lines @@
     // override this if you have children, to hand it to the appropriate child
     // override this if you want to do anything with the pointer event
   }
 
 
   // PAINTING
 
   static bool _debugDoingPaint = false;
   void markNeedsPaint() {
     assert(!_debugDoingPaint);
-    var ancestor = this;
-    while (ancestor.parent != null)
-      ancestor = ancestor.parent;
-    assert(ancestor is RenderView);
-    ancestor.paintFrame();

[Hixie, 2015/05/21 19:45:03]

This is the code I was talking about earlier.

   }
   void paint(RenderNodeDisplayList canvas) { }
 
 }
 
 
 // GENERIC MIXIN FOR RENDER NODES THAT TAKE A LIST OF CHILDREN
 
 abstract class ContainerParentDataMixin<ChildType extends RenderNode> {
   ChildType previousSibling;
@@ skipping 141 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 BoxConstraints {
+  const BoxConstraints({
+    this.minWidth: 0.0,
+    this.maxWidth: double.INFINITY,
+    this.minHeight: 0.0,
+    this.maxHeight: double.INFINITY});
+
+  final double minWidth;
+  final double maxWidth;
+  final double minHeight;
+  final double maxHeight;
+}
+
 class BoxDimensions {
   const BoxDimensions({this.width, this.height});
+
+  BoxDimensions.withConstraints(
+      BoxConstraints constraints, {double width: 0.0, double height: 0.0}) {
+    this.width = clamp(min: minWidth, max: maxWidth, value: width);
+    this.height = clamp(min: minHeight, max: maxHeight, value: height);
+  }
+
   final double width;
   final double height;
 }
 
 class BoxParentData extends ParentData {
   double x = 0.0;
   double y = 0.0;
 }
 
 abstract class RenderBox extends RenderNode {
 
   void setParentData(RenderNode child) {
     if (child.parentData is! BoxParentData)
       child.parentData = new BoxParentData();
   }
 
   // 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({
-    double minWidth: 0.0,
-    double maxWidth: double.INFINITY,
-    double minHeight: 0.0,
-    double maxHeight: double.INFINITY
-  }) {
-    return new BoxDimensions(
-      width: clamp(min: minWidth, max: maxWidth),
-      height: clamp(min: minHeight, max: maxHeight)
-    );
+  BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
+    return new BoxDimensions.withConstraints(constraints);
   }
 
-  void layout({
-    double minWidth: 0.0,
-    double maxWidth: double.INFINITY,
-    double minHeight: 0.0,
-    double maxHeight: double.INFINITY,
-    RenderNode relayoutSubtreeRoot
-  }) {
-    width = clamp(min: minWidth, max: maxWidth);
-    height = clamp(min: minHeight, max: maxHeight);
+  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+    setWidth(constraints, 0.0);

[Hixie, 2015/05/21 19:45:03]

how about:

   width = constraints.constrainWidth(0.0);

...? (and ditto height)

(and remove setWidth/setHeight, since people will think those are an API they
can use from outside)

+    setHeight(constraints, 0.0);
     layoutDone();
   }
 
   double width;
   double height;

[Hixie, 2015/05/21 19:45:03]

I wish we could make these protected and only public expose the getters, but
Dart doesn't have protected.

 
-  void rotate({
-    int oldAngle, // 0..3
-    int newAngle, // 0..3
-    Duration time
-  }) { }
+  void setWidth(BoxConstraints constraints, double newWidth) {
+    width = clamp(min: constraints.minWidth,
+                  max: constraints.maxWidth,
+                  value: newWidth);
+  }
 
+  void setHeight(BoxConstraints constraints, double newHeight) {
+    height = clamp(min: constraints.minHeight,
+                   max: constraints.maxHeight,
+                   value: newHeight);
+  }
+}
+
+class BoxDecoration {
+  BoxDecoration({

[Hixie, 2015/05/21 19:45:04]

make this a const constructor.

+    this.backgroundColor
+  });
+
+  final int backgroundColor;
+}
+
+class RenderDecoratedBox extends RenderBox {
+  BoxDecoration decoration;
+
+  RenderDecoratedBox(this.decoration);
+
+  void paint(RenderNodeDisplayList canvas) {
+    assert(width != null);
+    assert(height != null);
+
+    if (decoration == null)
+      return;
+
+    if (decoration.backgroundColor != null) {
+      sky.Paint paint = new sky.Paint()..color = decoration.backgroundColor;
+      canvas.drawRect(new sky.Rect()..setLTRB(0.0, 0.0, width, height), paint);
+    }
+  }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
 class RenderView extends RenderNode {
 
   RenderView({
     RenderBox root,
     this.timeForRotation: const Duration(microseconds: 83333)
@@ skipping 33 matching lines @@
     }
     if ((newWidth != width) || (newHeight != height)) {
       _width = newWidth;
       _height = newHeight;
       relayout();
     }
   }
 
   void relayout() {
     assert(root != null);
-    root.layout(
-      minWidth: width,
-      maxWidth: width,
-      minHeight: height,
-      maxHeight: height
-    );
+    root.layout(new BoxConstraints(
+        minWidth: width, maxWidth: width, minHeight: height, maxHeight: height));
     assert(root.width == width);
     assert(root.height == height);
   }
 
   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()
   }
 
   void paint(RenderNodeDisplayList canvas) {
     canvas.paintChild(root, 0.0, 0.0);
@@ skipping 21 matching lines @@
   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 RenderBox with ContainerRenderNodeMixin<RenderBox, BlockParentData> {
+class RenderBlock extends RenderDecoratedBox with ContainerRenderNodeMixin<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)
-  }) {
-    _padding = padding;
-  }
+  }) : super(decoration), _padding = padding;
 
   EdgeDims _padding;
   EdgeDims get padding => _padding;
   void set padding(EdgeDims value) {
     assert(value != null);
     if (_padding != value) {
       _padding = value;
       markNeedsLayout();
     }
   }
 
   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({
-    double minWidth: 0.0,
-    double maxWidth: double.INFINITY,
-    double minHeight: 0.0,
-    double maxHeight: double.INFINITY
-  }) {
+  BoxDimensions getIntrinsicDimensions(BoxConstraints constraints) {
     double outerHeight = _padding.top + _padding.bottom;
-    double outerWidth = clamp(min: minWidth, max: maxWidth);
+    // TODO(abarth): Shouldn't this have a value: maxWidth?

[Hixie, 2015/05/21 19:45:04]

good question.

if it does, we should assert that the maxWidth isn't double.INFINITY,
probably...

+    double outerWidth = clamp(min: constraints.minWidth,
+                              max: constraints.maxWidth);
     double innerWidth = outerWidth - (_padding.left + _padding.right);
     RenderBox child = _firstChild;
+    BoxConstraints constraints = new BoxConstraints(minWidth: innerWidth,
+                                                    maxWidth: innerWidth);
     while (child != null) {
-      outerHeight += child.getIntrinsicDimensions(minWidth: innerWidth, maxWidth: innerWidth).height;
+      outerHeight += child.getIntrinsicDimensions(constraints).height;
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
+

[Hixie, 2015/05/21 19:45:04]

Why the blank line?

     return new BoxDimensions(
       width: outerWidth,
-      height: clamp(min: minHeight, max: maxHeight, value: outerHeight)
+      height: clamp(min: constraints.minHeight,
+                    max: constraints.maxHeight,
+                    value: outerHeight)
     );
   }
 
   double _minHeight; // value cached from parent for relayout call
   double _maxHeight; // value cached from parent for relayout call
-  void layout({
-    double minWidth: 0.0,
-    double maxWidth: double.INFINITY,
-    double minHeight: 0.0,
-    double maxHeight: double.INFINITY,
-    RenderNode relayoutSubtreeRoot
-  }) {
+  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
     if (relayoutSubtreeRoot != null)
       saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
     relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
-    width = clamp(min: minWidth, max: maxWidth);
-    _minHeight = minHeight;
-    _maxHeight = maxHeight;
+    // TODO(abarth): Shouldn't this be setWidth(constaints, constraints.maxWidth)?
+    width = clamp(min: constraints.minWidth, max: constraints.maxWidth);

[Hixie, 2015/05/21 19:45:03]

should be consistent with the intrinsic dimensions logic, whatever that is.

+    _minHeight = constraints.minHeight;
+    _maxHeight = constraints.maxHeight;
     internalLayout(relayoutSubtreeRoot);
   }
 
   void relayout() {
     internalLayout(this);
   }
 
   void internalLayout(RenderNode relayoutSubtreeRoot) {
     assert(_minHeight != null);
     assert(_maxHeight != null);
     double y = _padding.top;
     double innerWidth = width - (_padding.left + _padding.right);
     RenderBox child = _firstChild;
     while (child != null) {
-      child.layout(minWidth: innerWidth, maxWidth: innerWidth, relayoutSubtreeRoot: relayoutSubtreeRoot);
+      child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth),
+                   relayoutSubtreeRoot: relayoutSubtreeRoot);
       assert(child.parentData is BlockParentData);
-      child.parentData.x = 0.0;
+      child.parentData.x = 0.0; // TODO(abarth): Shouldn't this be _padding.left?

[Hixie, 2015/05/21 19:45:03]

Yes.

       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
     height = clamp(min: _minHeight, value: y + _padding.bottom, max: _maxHeight);
     layoutDone();
   }
 
   void handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
     // the x, y parameters have the top left of the node's box as the origin
     RenderBox child = _lastChild;
     while (child != null) {
       assert(child.parentData is BlockParentData);
       if ((x >= child.parentData.x) && (x < child.parentData.x + child.width) &&
           (y >= child.parentData.y) && (y < child.parentData.y + child.height)) {
         child.handlePointer(event, x: x-child.parentData.x, y: y-child.parentData.y);
         break;
       }
       child = child.parentData.previousSibling;
     }
     super.handlePointer(event);
   }
 
   void paint(RenderNodeDisplayList canvas) {
+    super.paint(canvas);
     RenderBox child = _firstChild;
     while (child != null) {
       assert(child.parentData is BlockParentData);
       canvas.paintChild(child, child.parentData.x, child.parentData.y);
       child = child.parentData.nextSibling;
     }
   }
 
 }
 
@@ skipping 19 matching lines @@
 
   ScaffoldBox(this.toolbar, this.body, this.statusbar, this.drawer) {
     assert(body != null);
   }
 
   final RenderBox toolbar;
   final RenderBox body;
   final RenderBox statusbar;
   final RenderBox drawer;
 
-  void layout({
-    double minWidth: 0.0,
-    double maxWidth: double.INFINITY,
-    double minHeight: 0.0,
-    double maxHeight: double.INFINITY,
-    RenderNode relayoutSubtreeRoot
-  }) {
-    width = clamp(min: minWidth, max: maxWidth);
-    height = clamp(min: minHeight, max: maxHeight);
+  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+    setHeight(constraints, 0.0);
+    setWidth(constraints, 0.0);

[Hixie, 2015/05/21 19:45:03]

change as discussed above.

     relayout();
   }
 
   static const kToolbarHeight = 100.0;
   static const kStatusbarHeight = 50.0;
 
   void relayout() {
     double bodyHeight = height;
     if (toolbar != null) {
-      toolbar.layout(minWidth: width, maxWidth: width, minHeight: kToolbarHeight, maxHeight: kToolbarHeight);
+      toolbar.layout(new BoxConstraints(minWidth: width, maxWidth: width, minHeight: kToolbarHeight, maxHeight: kToolbarHeight));

[Hixie, 2015/05/21 19:45:03]

Make a BoxConstraints constructor that takes just a width/height and sets the
min/max accordingly.

       assert(toolbar.parentData is BoxParentData);
       toolbar.parentData.x = 0.0;
       toolbar.parentData.y = 0.0;
       bodyHeight -= kToolbarHeight;
     }
     if (statusbar != null) {
-      statusbar.layout(minWidth: width, maxWidth: width, minHeight: kStatusbarHeight, maxHeight: kStatusbarHeight);
+      statusbar.layout(new BoxConstraints(minWidth: width, maxWidth: width, minHeight: kStatusbarHeight, maxHeight: kStatusbarHeight));

[Hixie, 2015/05/21 19:45:04]

ditto

       assert(statusbar.parentData is BoxParentData);
       statusbar.parentData.x = 0.0;
       statusbar.parentData.y = height - kStatusbarHeight;
       bodyHeight -= kStatusbarHeight;
     }
-    body.layout(minWidth: width, maxWidth: width, minHeight: bodyHeight, maxHeight: bodyHeight);
+    body.layout(new BoxConstraints(minWidth: width, maxWidth: width, minHeight: bodyHeight, maxHeight: bodyHeight));

[Hixie, 2015/05/21 19:45:03]

ditto

     if (drawer != null)
-      drawer.layout(minWidth: 0.0, maxWidth: width, minHeight: height, maxHeight: height);
+      drawer.layout(new BoxConstraints(minWidth: 0.0, maxWidth: width, minHeight: height, maxHeight: height));
     layoutDone();
   }
 
   void handlePointer(sky.PointerEvent event, { double x: 0.0, double y: 0.0 }) {
     if ((drawer != null) && (x < drawer.width)) {
       drawer.handlePointer(event, x: x, y: y);
     } else if ((toolbar != null) && (y < toolbar.height)) {
       toolbar.handlePointer(event, x: x, y: y);
     } else if ((statusbar != null) && (y > (statusbar.parentData as BoxParentData).y)) {
       statusbar.handlePointer(event, x: x, y: y-(statusbar.parentData as BoxParentData).y);
     } else {
       body.handlePointer(event, x: x, y: y-(body.parentData as BoxParentData).y);
     }
     super.handlePointer(event, x: x, y: y);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     canvas.paintChild(body, (body.parentData as BoxParentData).x, (body.parentData as BoxParentData).y);
     if (statusbar != null)
       canvas.paintChild(statusbar, (statusbar.parentData as BoxParentData).x, (statusbar.parentData as BoxParentData).y);
     if (toolbar != null)
       canvas.paintChild(toolbar, (toolbar.parentData as BoxParentData).x, (toolbar.parentData as BoxParentData).y);
     if (drawer != null)
       canvas.paintChild(drawer, (drawer.parentData as BoxParentData).x, (drawer.parentData as BoxParentData).y);
   }
 
 }