Split Size into Size and Offset.

sky/sdk/lib/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 'package:vector_math/vector_math.dart';
 
 import '../base/debug.dart';
@@ skipping 187 matching lines @@
   double constrainHeight([double height = double.INFINITY]) {
     return clamp(min: minHeight, max: maxHeight, value: height);
   }
 
   Size constrain(Size size) {
     Size result = new Size(constrainWidth(size.width), constrainHeight(size.height));
     if (size is _DebugSize)
       result = new _DebugSize(result, size._owner, size._canBeUsedByParent);
     return result;
   }
+  Size get biggest => new Size(constrainWidth(), constrainHeight());
+  Size get smallest => new Size(constrainWidth(0.0), constrainHeight(0.0));
 
   bool get isInfinite => maxWidth >= double.INFINITY && maxHeight >= double.INFINITY;
 
   bool get hasTightWidth => minWidth >= maxWidth;
   bool get hasTightHeight => minHeight >= maxHeight;
   bool get isTight => hasTightWidth && hasTightHeight;
 
   bool contains(Size size) {
     return (minWidth <= size.width) && (size.width <= math.max(minWidth, maxWidth)) &&
            (minHeight <= size.height) && (size.height <= math.max(minHeight, maxHeight));
@@ skipping 614 matching lines @@
     if (child != null)
       return child.getMaxIntrinsicHeight(constraints);
     return super.getMaxIntrinsicHeight(constraints);
   }
 
   void performLayout() {
     if (child != null) {
       child.layout(constraints.loosen(), parentUsesSize: true);
       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);
+      Offset delta = size - child.size;
+      child.parentData.position = (delta.scale(horizontal, vertical)).toPoint();
     } else {
       performResize();
     }
   }
 
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}horizontal: ${horizontal}\n${prefix}vertical: ${vertical}\n';
 }
 
 class RenderImage extends RenderBox {
 
@@ skipping 81 matching lines @@
   void paint(RenderCanvas canvas) {
     if (_image == null) return;
     bool needsScale = size.width != _image.width || size.height != _image.height;
     if (needsScale) {
       double widthScale = size.width / _image.width;
       double heightScale = size.height / _image.height;
       canvas.save();
       canvas.scale(widthScale, heightScale);
     }
     Paint paint = new Paint();
-    canvas.drawImage(_image, 0.0, 0.0, paint);
+    canvas.drawImage(_image, Point.origin, paint);
     if (needsScale)
       canvas.restore();
   }
 
   String debugDescribeSettings(String prefix) => '${super.debugDescribeSettings(prefix)}${prefix}url: ${src}\n${prefix}dimensions: ${requestedSize}\n';
 }
 
 class RenderDecoratedBox extends RenderProxyBox {
 
   RenderDecoratedBox({
@@ skipping 146 matching lines @@
   void paint(RenderCanvas canvas) {
     assert(_callback != null);
     _callback(canvas, size);
     super.paint(canvas);
   }
 }
 
 // RENDER VIEW LAYOUT MANAGER
 
 class ViewConstraints {
-
   const ViewConstraints({
-    this.width: 0.0, this.height: 0.0, this.orientation: null
+    this.size: Size.zero,
+    this.orientation
   });
-
-  final double width;
-  final double height;
+  final Size size;
   final int orientation;
-
 }
 
 class RenderView extends RenderObject with RenderObjectWithChildMixin<RenderBox> {
 
   RenderView({
     RenderBox child,
     this.timeForRotation: const Duration(microseconds: 83333)
   }) {
     this.child = child;
   }
 
   Size _size = Size.zero;
-  double get width => _size.width;
-  double get height => _size.height;
+  Size get size => _size;
 
   int _orientation; // 0..3
   int get orientation => _orientation;
   Duration timeForRotation;
 
   ViewConstraints _rootConstraints;
   ViewConstraints get rootConstraints => _rootConstraints;
   void set rootConstraints(ViewConstraints value) {
     if (_rootConstraints == value)
       return;
     _rootConstraints = value;
     markNeedsLayout();
   }
 
   void performResize() {
     assert(false);
   }
 
   void performLayout() {
     if (_rootConstraints.orientation != _orientation) {
       if (_orientation != null && child != null)
         child.rotate(oldAngle: _orientation, newAngle: _rootConstraints.orientation, time: timeForRotation);
       _orientation = _rootConstraints.orientation;
     }
-    _size = new Size(_rootConstraints.width, _rootConstraints.height);
+    _size = _rootConstraints.size;
     assert(!_size.isInfinite);
 
     if (child != null)
       child.layout(new BoxConstraints.tight(_size));
   }
 
   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()
   }
 
@@ skipping 10 matching lines @@
   void paint(RenderCanvas canvas) {
     if (child != null)
       canvas.paintChild(child, Point.origin);
   }
 
   void paintFrame() {
     sky.tracing.begin('RenderView.paintFrame');
     RenderObject.debugDoingPaint = true;
     try {
       sky.PictureRecorder recorder = new sky.PictureRecorder();
-      RenderCanvas canvas = new RenderCanvas(recorder, width, height);
+      RenderCanvas canvas = new RenderCanvas(recorder, _size);
       paint(canvas);
       sky.view.picture = recorder.endRecording();
     } finally {
       RenderObject.debugDoingPaint = false;
       sky.tracing.end('RenderView.paintFrame');
     }
   }
 
 }
 
@@ skipping 52 matching lines @@
 
   void defaultPaint(RenderCanvas canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }