Material and RaisedButton.

sky/sdk/lib/framework/rendering/box.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 'dart:math' as math;
 import 'dart:sky' as sky;
 import 'object.dart';
 import '../painting/box_painter.dart';
 import 'package:vector_math/vector_math.dart';
 import 'package:sky/framework/net/image_cache.dart' as image_cache;
@@ skipping 35 matching lines @@
     return value;
   }
   String toString() => "EdgeDims($top, $right, $bottom, $left)";
 }
 
 class BoxConstraints {
   const BoxConstraints({
     this.minWidth: 0.0,
     this.maxWidth: double.INFINITY,
     this.minHeight: 0.0,
-    this.maxHeight: double.INFINITY});
+    this.maxHeight: double.INFINITY
+  });
 
   BoxConstraints.tight(Size size)
     : minWidth = size.width,
       maxWidth = size.width,
       minHeight = size.height,
       maxHeight = size.height;
 
   BoxConstraints.loose(Size size)
     : minWidth = 0.0,
       maxWidth = size.width,
       minHeight = 0.0,
       maxHeight = size.height;
 
   BoxConstraints deflate(EdgeDims edges) {
     assert(edges != null);
     double horizontal = edges.left + edges.right;
     double vertical = edges.top + edges.bottom;
     return new BoxConstraints(
       minWidth: math.max(0.0, minWidth - horizontal),
       maxWidth: maxWidth - horizontal,
       minHeight: math.max(0.0, minHeight - vertical),
       maxHeight: maxHeight - vertical
     );
   }
 
+  BoxConstraints loosen() {
+    return new BoxConstraints(
+      minWidth: 0.0,
+      maxWidth: maxWidth,
+      minHeight: 0.0,
+      maxHeight: maxHeight
+    );
+  }
+
   BoxConstraints apply(BoxConstraints constraints) {
     return new BoxConstraints(
       minWidth: math.max(minWidth, constraints.minWidth),
       maxWidth: math.min(maxWidth, constraints.maxWidth),
       minHeight: math.max(minHeight, constraints.minHeight),
       maxHeight: math.min(maxHeight, constraints.maxHeight));
   }
 
   BoxConstraints applyWidth(double width) {
     return new BoxConstraints(minWidth: math.max(minWidth, width),
@@ skipping 144 matching lines @@
   void set size(Size value) {
     assert(RenderObject.debugDoingLayout);
     _size = value;
   }
 
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}size: ${size}\n';
 }
 
 class RenderProxyBox extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
 
+  // ProxyBox assumes the child will be at 0,0 and will have the same size
+
   RenderProxyBox([RenderBox child = null]) {
     this.child = child;
   }
 
   double getMinIntrinsicWidth(BoxConstraints constraints) {
     if (child != null)
       return child.getMinIntrinsicWidth(constraints);
     return super.getMinIntrinsicWidth(constraints);
   }
 
@@ skipping 240 matching lines @@
       canvas.saveLayer(rect, new Paint());
       Path path = new Path();
       path.addOval(rect);
       canvas.clipPath(path);
       child.paint(canvas);
       canvas.restore();
     }
   }
 }
 
-class RenderPadding extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
+abstract class RenderShiftedBox extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
 
-  RenderPadding({ EdgeDims padding, RenderBox child }) {
-    assert(padding != null);
-    this.padding = padding;
+  // Abstract class for one-child-layout render boxes
+
+  RenderShiftedBox(RenderBox child) {
     this.child = child;
   }
 
+  void paint(RenderObjectDisplayList canvas) {
+    if (child != null)
+      canvas.paintChild(child, child.parentData.position);
+  }
+
+  void hitTestChildren(HitTestResult result, { Point position }) {
+    if (child != null) {
+      assert(child.parentData is BoxParentData);
+      Rect childBounds = new Rect.fromPointAndSize(child.parentData.position, child.size);
+      if (childBounds.contains(position)) {
+        child.hitTest(result, position: new Point(position.x - child.parentData.position.x,
+                                                      position.y - child.parentData.position.y));
+      }
+    }
+  }
+
+}
+
+class RenderPadding extends RenderShiftedBox {
+
+  RenderPadding({ EdgeDims padding, RenderBox child }) : super(child) {
+    assert(padding != null);
+    this.padding = padding;
+  }
+
   EdgeDims _padding;
   EdgeDims get padding => _padding;
   void set padding (EdgeDims value) {
     assert(value != null);
     if (_padding == value)
       return;
     _padding = value;
     markNeedsLayout();
   }
 
@@ skipping 33 matching lines @@
           new Size(padding.left + padding.right, padding.top + padding.bottom));
       return;
     }
     child.layout(innerConstraints, parentUsesSize: true);
     assert(child.parentData is BoxParentData);
     child.parentData.position = new Point(padding.left, padding.top);
     size = constraints.constrain(new Size(padding.left + child.size.width + padding.right,
                                               padding.top + child.size.height + padding.bottom));
   }
 
-  void paint(RenderObjectDisplayList canvas) {
-    if (child != null)
-      canvas.paintChild(child, child.parentData.position);
-  }
-
-  void hitTestChildren(HitTestResult result, { Point position }) {
-    if (child != null) {
-      assert(child.parentData is BoxParentData);
-      Rect childBounds = new Rect.fromPointAndSize(child.parentData.position, child.size);
-      if (childBounds.contains(position)) {
-        child.hitTest(result, position: new Point(position.x - child.parentData.position.x,
-                                                      position.y - child.parentData.position.y));
-      }
-    }
-  }
-
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}padding: ${padding}\n';
 }
 
+class RenderPositionedBox extends RenderShiftedBox {
+
+  RenderPositionedBox({
+    RenderBox child,
+    double horizontal: 0.5,
+    double vertical: 0.5
+  }) : _horizontal = horizontal,
+       _vertical = vertical,
+       super(child) {
+    assert(horizontal != null);
+    assert(vertical != null);
+  }
+
+  double _horizontal;
+  double get horizontal => _horizontal;
+  void set horizontal (double value) {
+    assert(value != null);
+    if (_horizontal == value)
+      return;
+    _horizontal = value;
+    markNeedsLayout();
+  }
+
+  double _vertical;
+  double get vertical => _vertical;
+  void set vertical (double value) {
+    assert(value != null);
+    if (_vertical == value)
+      return;
+    _vertical = value;
+    markNeedsLayout();
+  }
+
+  double getMinIntrinsicWidth(BoxConstraints constraints) {
+    if (child != null)
+      return child.getMinIntrinsicWidth(constraints);
+    return super.getMinIntrinsicWidth(constraints);
+  }
+
+  double getMaxIntrinsicWidth(BoxConstraints constraints) {
+    if (child != null)
+      return child.getMaxIntrinsicWidth(constraints);
+    return super.getMaxIntrinsicWidth(constraints);
+  }
+
+  double getMinIntrinsicHeight(BoxConstraints constraints) {
+    if (child != null)
+      return child.getMinIntrinsicHeight(constraints);
+    return super.getMinIntrinsicHeight(constraints);
+  }
+
+  double getMaxIntrinsicHeight(BoxConstraints constraints) {
+    if (child != null)
+      return child.getMaxIntrinsicHeight(constraints);
+    return super.getMaxIntrinsicHeight(constraints);
+  }
+
+  void performLayout() {
+    if (child != null) {
+      child.layout(constraints.loosen());
+      size = constraints.constrain(child.size);
+      assert(child.parentData is BoxParentData);
+      Size delta = size - child.size;
+      child.parentData.position = new Point(delta.width * horizontal, delta.height * vertical);
+    } else {
+      performResize();
+    }
+  }
+
+  String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}horizontal: ${horizontal}\n${prefix}vertical: ${vertical}\n';
+}
+
 class RenderImage extends RenderBox {
 
   RenderImage(String url, Size dimensions) {
     requestedSize = dimensions;
     src = url;
   }
 
   sky.Image _image;
   String _src;
   String get src => _src;
   void set src (String value) {
     if (value == _src)
       return;
     _src = value;
     image_cache.load(_src, (result) {
       _image = result;
       if (requestedSize.width == null || requestedSize.height == null)
         markNeedsLayout();
       markNeedsPaint();
     });
   }
 
   Size _requestedSize;
   Size get requestedSize => _requestedSize;
   void set requestedSize (Size value) {
+    if (value == null)
+      value = const Size(null, null);
     if (value == _requestedSize)
       return;
     _requestedSize = value;
     markNeedsLayout();
   }
 
   Size _sizeForConstraints(BoxConstraints innerConstraints) {
     // If there's no image, we can't size ourselves automatically
     if (_image == null) {
       double width = requestedSize.width == null ? 0.0 : requestedSize.width;
@@ skipping 323 matching lines @@
 
   void defaultPaint(RenderObjectDisplayList canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }