Use Point, Size, and Rect in layout2.dart

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 16 matching lines @@
 
   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) {
+  void paintChild(RenderNode child, sky.Point position) {
     save();
-    translate(x, y);
+    translate(position.x, position.y);
     child.paint(this);
     restore();
   }
 }
 
 abstract class RenderNode extends AbstractNode {
 
   // LAYOUT
 
   // parentData is only for use by the RenderNode that actually lays this
@@ skipping 141 matching lines @@
   // HIT TESTING  
 
   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 }) {
+  // bool hitTest(HitTestResult result, { sky.Point position }) {
   //   // 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.
@@ skipping 226 matching lines @@
   final double maxHeight;
 
   double constrainWidth(double width) {
     return clamp(min: minWidth, max: maxWidth, value: width);
   }
 
   double constrainHeight(double height) {
     return clamp(min: minHeight, max: maxHeight, value: height);
   }
 
+  sky.Size constrain(sky.Size size) {
+    return new sky.Size(constrainWidth(size.width), constrainHeight(size.height));
+  }
+
   bool get isInfinite => maxWidth >= double.INFINITY || maxHeight >= double.INFINITY;
 }
 
+// TODO(abarth): Replace with sky.Size.
 class BoxDimensions {
   const BoxDimensions({ this.width: 0.0, this.height: 0.0 });
 
   BoxDimensions.withConstraints(
     BoxConstraints constraints,
     { double width: 0.0, double height: 0.0 }
   ) : width = constraints.constrainWidth(width),
       height = constraints.constrainHeight(height);
 
   final double width;
   final double height;
 }
 
 class BoxParentData extends ParentData {
-  double x = 0.0;
-  double y = 0.0;
+  sky.Point position = new sky.Point(0.0, 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(BoxConstraints constraints) {
     return new BoxDimensions.withConstraints(constraints);
   }
 
   BoxConstraints get constraints => super.constraints as BoxConstraints;
   void performResize() {
     // default behaviour for subclasses that have sizedByParent = true
-    width = constraints.constrainWidth(0.0);
-    height = constraints.constrainHeight(0.0);
-    assert(height < double.INFINITY);
-    assert(width < double.INFINITY);
+    size = constraints.constrain(new sky.Size(0.0, 0.0));
+    assert(size.height < double.INFINITY);
+    assert(size.width < double.INFINITY);
   }
   void performLayout() {
     // descendants have to either override performLayout() to set both
     // width and height and lay out children, or, set sizedByParent to
     // true so that performResize()'s logic above does its thing.
     assert(sizedByParent);
   }
 
-  bool hitTest(HitTestResult result, { double x, double y }) {
-    hitTestChildren(result, x: x, y: y);
+  bool hitTest(HitTestResult result, { sky.Point position }) {
+    hitTestChildren(result, position: position);
     result.add(this);
     return true;
   }
-  void hitTestChildren(HitTestResult result, { double x, double y }) { }
+  void hitTestChildren(HitTestResult result, { sky.Point position }) { }
 
-  double width;
-  double height;
+  sky.Size size = new sky.Size(0.0, 0.0);
 }
 
 class RenderPadding extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
 
   RenderPadding(EdgeDims padding, RenderBox child) {
     assert(padding != null);
     this.padding = padding;
     this.child = child;
   }
 
@@ skipping 12 matching lines @@
     constraints = constraints.deflate(padding);
     if (child == null)
       return super.getIntrinsicDimensions(constraints);
     return child.getIntrinsicDimensions(constraints);
   }
 
   void performLayout() {
     assert(padding != null);
     BoxConstraints innerConstraints = constraints.deflate(padding);
     if (child == null) {
-      width = innerConstraints.constrainWidth(padding.left + padding.right);
-      height = innerConstraints.constrainHeight(padding.top + padding.bottom);
+      size = innerConstraints.constrain(
+          new sky.Size(padding.left + padding.right, padding.top + padding.bottom));
       return;
     }
     child.layout(innerConstraints, parentUsesSize: true);
     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);
+    child.parentData.position = new sky.Point(padding.left, padding.top);
+    size = constraints.constrain(new sky.Size(padding.left + child.size.width + padding.right,
+                                              padding.top + child.size.height + padding.bottom));
   }
 
   void paint(RenderNodeDisplayList canvas) {
     if (child != null)
-      canvas.paintChild(child, child.parentData.x, child.parentData.y);
+      canvas.paintChild(child, child.parentData.position);
   }
 
-  void hitTestChildren(HitTestResult result, { double x, double y }) {
+  void hitTestChildren(HitTestResult result, { sky.Point position }) {
     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);
+      sky.Rect childRect = new sky.Rect.fromPointAndSize(child.parentData.position, child.size);
+      if (childRect.contains(position)) {
+        child.hitTest(result, position: new sky.Point(position.x - child.parentData.position.x,
+                                                      position.y - child.parentData.position.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 {
 
   RenderDecoratedBox(BoxDecoration decoration) : _decoration = decoration;
 
   BoxDecoration _decoration;
   BoxDecoration get decoration => _decoration;
   void set decoration (BoxDecoration value) {
     if (value == _decoration)
       return;
     _decoration = value;
     markNeedsPaint();
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    assert(width != null);
-    assert(height != null);
+    assert(size.width != null);
+    assert(size.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);
+      canvas.drawRect(new sky.Rect.fromLTRB(0.0, 0.0, size.width, size.height), paint);
     }
   }
 
 }
 
 class RenderDecoratedCircle extends RenderDecoratedBox with RenderNodeWithChildMixin<RenderBox> {
   RenderDecoratedCircle({
     BoxDecoration decoration,
     RenderBox child
   }) : super(decoration) {
     this.child = child;
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    assert(width != null);
-    assert(height != null);
+    assert(size.width != null);
+    assert(size.height != null);
 
     if (_decoration == null)
       return;
 
     if (_decoration.backgroundColor != null) {
       sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
-      canvas.drawCircle(new sky.Rect()..setLTRB(0.0, 0.0, width, height), paint);
+      canvas.drawCircle(0.0, 0.0, (size.width + size.height) / 2, paint);
     }
   }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
 class ViewConstraints {
 
   const ViewConstraints({
     this.width: 0.0, this.height: 0.0, this.orientation: null
   });
 
   final double width;
   final double height;
   final int orientation;
 
 }
 
 class RenderView extends RenderNode with RenderNodeWithChildMixin<RenderBox> {
 
   RenderView({
     RenderBox child,
     this.timeForRotation: const Duration(microseconds: 83333)
   }) {
     this.child = child;
   }
 
-  double _width;
-  double get width => _width;
-  double _height;
-  double get height => _height;
+  sky.Size _size = new sky.Size(0.0, 0.0);
+  double get width => _size.width;
+  double get height => _size.height;
 
   int _orientation; // 0..3
   int get orientation => _orientation;
   Duration timeForRotation;
 
   ViewConstraints get constraints => super.constraints as ViewConstraints;
   bool get sizedByParent => true;
   void performResize() {
     if (constraints.orientation != _orientation) {
       if (_orientation != null && child != null)
         child.rotate(oldAngle: _orientation, newAngle: constraints.orientation, time: timeForRotation);
       _orientation = constraints.orientation;
     }
-    _width = constraints.width;
-    _height = constraints.height;
-    assert(height < double.INFINITY);
-    assert(width < double.INFINITY);
+    _size = new sky.Size(constraints.width, constraints.height);
+    assert(_size.height < double.INFINITY);
+    assert(_size.width < double.INFINITY);
   }
   void performLayout() {
     if (child != null) {
       child.layout(new BoxConstraints.tight(width: width, height: height));
-      assert(child.width == width);
-      assert(child.height == height);
+      assert(child.size.width == width);
+      assert(child.size.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 performResize()
   }
 
-  bool hitTest(HitTestResult result, { double x, double y }) {
-    if (child != null && x >= 0.0 && x < child.width && y >= 0.0 && y < child.height)
-      child.hitTest(result, x: x, y: y);
+  bool hitTest(HitTestResult result, { sky.Point position }) {
+    if (child != null) {
+      sky.Rect childRect = new sky.Rect.fromPointAndSize(new sky.Point(0.0, 0.0), child.size);
+      if (childRect.contains(position))
+        child.hitTest(result, position: position);
+    }
     result.add(this);
     return true;
   }
 
   void paint(RenderNodeDisplayList canvas) {
     if (child != null)
-      canvas.paintChild(child, 0.0, 0.0);
+      canvas.paintChild(child, new sky.Point(0.0, 0.0));
   }
 
   void paintFrame() {
     RenderNode._debugDoingPaint = true;
     var canvas = new RenderNodeDisplayList(sky.view.width, sky.view.height);
     paint(canvas);
     sky.view.picture = canvas.endRecording();
     RenderNode._debugDoingPaint = false;
   }
 
 }
 
 // DEFAULT BEHAVIORS FOR RENDERBOX CONTAINERS
 abstract class RenderBoxContainerDefaultsMixin<ChildType extends RenderBox, ParentDataType extends ContainerParentDataMixin<ChildType>> implements ContainerRenderNodeMixin<ChildType, ParentDataType> {
 
-  void defaultHitTestChildren(HitTestResult result, { double x, double y }) {
+  void defaultHitTestChildren(HitTestResult result, { sky.Point position }) {
     // the x, y parameters have the top left of the node's box as the origin
     ChildType child = lastChild;
     while (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)) {
-        if (child.hitTest(result, x: x-child.parentData.x, y: y-child.parentData.y))
+      sky.Rect childRect = new sky.Rect.fromPointAndSize(child.parentData.position, child.size);
+      if (childRect.contains(position)) {
+        if (child.hitTest(result, position: new sky.Point(position.x - child.parentData.position.x,
+                                                          position.y - child.parentData.position.y)))
           break;
       }
       child = child.parentData.previousSibling;
     }
   }
 
   void defaultPaint(RenderNodeDisplayList canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is BoxParentData);
-      canvas.paintChild(child, child.parentData.x, child.parentData.y);
+      canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }
 
 // BLOCK LAYOUT MANAGER
 
 class BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
 
 class RenderBlock extends RenderDecoratedBox with ContainerRenderNodeMixin<RenderBox, BlockParentData>,
@@ skipping 29 matching lines @@
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
 
     return new BoxDimensions(width: outerWidth,
                              height: constraints.constrainHeight(outerHeight));
   }
 
   void performLayout() {
     assert(constraints is BoxConstraints);
-    width = constraints.constrainWidth(constraints.maxWidth);
-    assert(width < double.INFINITY);
+    size.width = constraints.constrainWidth(constraints.maxWidth);
+    assert(size.width < double.INFINITY);
     double y = 0.0;
-    double innerWidth = width;
+    double innerWidth = size.width;
     RenderBox child = firstChild;
     while (child != null) {
       child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth), parentUsesSize: true);
       assert(child.parentData is BlockParentData);
-      child.parentData.x = 0.0;
-      child.parentData.y = y;
-      y += child.height;
+      child.parentData.position = new sky.Point(0.0, y);
+      y += child.size.height;
       child = child.parentData.nextSibling;
     }
-    height = constraints.constrainHeight(y);
+    size.height = constraints.constrainHeight(y);
   }
 
-  void hitTestChildren(HitTestResult result, { double x, double y }) {
-    defaultHitTestChildren(result, x: x, y: y);
+  void hitTestChildren(HitTestResult result, { sky.Point position }) {
+    defaultHitTestChildren(result, position: position);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 
 }
 
 // FLEXBOX LAYOUT MANAGER
@@ skipping 27 matching lines @@
     }
   }
 
   void setParentData(RenderBox child) {
     if (child.parentData is! FlexBoxParentData)
       child.parentData = new FlexBoxParentData();
   }
 
   bool get sizedByParent => true;
   void performResize() {
-    width = _constraints.constrainWidth(_constraints.maxWidth);
-    height = _constraints.constrainHeight(_constraints.maxHeight);
-    assert(height < double.INFINITY);
-    assert(width < double.INFINITY);
+    size = _constraints.constrain(new sky.Size(_constraints.maxWidth, _constraints.maxHeight));
+    assert(size.height < double.INFINITY);
+    assert(size.width < double.INFINITY);
   }
 
   int _getFlex(RenderBox child) {
     assert(child.parentData is FlexBoxParentData);
     return child.parentData.flex != null ? child.parentData.flex : 0;
   }
 
   void performLayout() {
     // Based on http://www.w3.org/TR/css-flexbox-1/ Section 9.7 Resolving Flexible Lengths
     // Steps 1-3. Determine used flex factor, size inflexible items, calculate free space
     int totalFlex = 0;
     assert(constraints != null);
     double freeSpace = (_direction == FlexDirection.Horizontal) ? constraints.maxWidth : constraints.maxHeight;
     RenderBox child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
       if (flex > 0) {
         totalFlex += child.parentData.flex;
       } else {
         BoxConstraints innerConstraints = new BoxConstraints(maxHeight: constraints.maxHeight,
                                                              maxWidth: constraints.maxWidth);
         child.layout(innerConstraints, parentUsesSize: true);
-        freeSpace -= (_direction == FlexDirection.Horizontal) ? child.width : child.height;
+        freeSpace -= (_direction == FlexDirection.Horizontal) ? child.size.width : child.size.height;
       }
       child = child.parentData.nextSibling;
     }
 
     // Steps 4-5. Distribute remaining space to flexible children.
     double spacePerFlex = totalFlex > 0 ? (freeSpace / totalFlex) : 0.0;
     double usedSpace = 0.0;
     child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
@@ skipping 11 matching lines @@
                                                   maxHeight: spaceForChild,
                                                   maxWidth: constraints.maxWidth);
             break;
         }
         child.layout(innerConstraints, parentUsesSize: true);
       }
 
       // For now, center the flex items in the cross direction
       switch (_direction) {
         case FlexDirection.Horizontal:
-          child.parentData.x = usedSpace;
-          usedSpace += child.width;
-          child.parentData.y = height / 2.0 - child.height / 2.0;
+          child.parentData.position = new sky.Point(usedSpace, size.height / 2.0 - child.size.height / 2.0);
+          usedSpace += child.size.width;
           break;
         case FlexDirection.Vertical:
-          child.parentData.y = usedSpace;
-          usedSpace += child.height;
-          child.parentData.x = width / 2.0 - child.width / 2.0;
+          child.parentData.position = new sky.Point(size.width / 2.0 - child.size.width / 2.0, usedSpace);
+          usedSpace += child.size.height;
           break;
       }
       child = child.parentData.nextSibling;
     }
   }
 
-  void hitTestChildren(HitTestResult result, { double x, double y }) {
-    defaultHitTestChildren(result, x: x, y: y);
+  void hitTestChildren(HitTestResult result, { sky.Point position }) {
+    defaultHitTestChildren(result, position: position);
   }
 
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     defaultPaint(canvas);
   }
 }