Refactor layout/relayout into a single method.

sky/examples/raw/sector-layout.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:sky/framework/app.dart';
 import 'package:sky/framework/layout2.dart';
 
 const double kTwoPi = 2 * math.PI;
@@ skipping 54 matching lines @@
 
   void setParentData(RenderNode child) {
     if (child.parentData is! SectorParentData)
       child.parentData = new SectorParentData();
   }
 
   SectorDimensions getIntrinsicDimensions(SectorConstraints constraints, double radius) {
     return new SectorDimensions.withConstraints(constraints);
   }
 
-  void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+  SectorConstraints get constraints => super.constraints as SectorConstraints;
+  void performResize() {
+    // default behaviour for subclasses that have sizedByParent = true
     deltaRadius = constraints.constrainDeltaRadius(0.0);
     deltaTheta = constraints.constrainDeltaTheta(0.0);
-    layoutDone();
+  }
+  void performLayout() {
+    // descendants have to either override performLayout() to set both
+    // the dimensions 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 radius, double theta }) {
     assert(parentData is SectorParentData);
     if (radius < parentData.radius || radius >= parentData.radius + deltaRadius ||
         theta < parentData.theta || theta >= parentData.theta + deltaTheta)
       return false;
     hitTestChildren(result, radius: radius, theta: theta);
     result.add(this);
     return true;
@@ skipping 114 matching lines @@
       if (child != null) {
         innerTheta += paddingTheta;
         remainingDeltaTheta -= paddingTheta;
       }
     }
     return new SectorDimensions.withConstraints(constraints,
                                                 deltaRadius: outerDeltaRadius,
                                                 deltaTheta: innerTheta);
   }
 
-  SectorConstraints _constraints;
-  void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
+  void performLayout() {
+    assert(this.parentData is SectorParentData);
     deltaRadius = constraints.constrainDeltaRadius(desiredDeltaRadius);
     assert(deltaRadius < double.INFINITY);
-    _constraints = constraints;
-    internalLayout(relayoutSubtreeRoot);
-  }
-
-  void relayout() {
-    // TODO(ianh): avoid code duplication
-    assert(parentData is SectorParentData);
-    internalLayout(this);
-  }
-
-  void internalLayout(RenderNode relayoutSubtreeRoot) {
-    assert(this.parentData is SectorParentData);
     double innerDeltaRadius = deltaRadius - padding * 2.0;
     double childRadius = this.parentData.radius + padding;
     double paddingTheta = math.atan(padding / (this.parentData.radius + deltaRadius));
     double innerTheta = paddingTheta; // increments with each child
-    double remainingDeltaTheta = _constraints.maxDeltaTheta - (innerTheta + paddingTheta);
+    double remainingDeltaTheta = constraints.maxDeltaTheta - (innerTheta + paddingTheta);
     RenderSector child = firstChild;
     while (child != null) {
       SectorConstraints innerConstraints = new SectorConstraints(
         maxDeltaRadius: innerDeltaRadius,
         maxDeltaTheta: remainingDeltaTheta
       );
       assert(child.parentData is SectorParentData);
       child.parentData.theta = innerTheta;
       child.parentData.radius = childRadius;
-      child.layout(innerConstraints, relayoutSubtreeRoot: relayoutSubtreeRoot);
+      child.layout(innerConstraints, parentUsesSize: true);
       innerTheta += child.deltaTheta;
       remainingDeltaTheta -= child.deltaTheta;
       assert(child.parentData is SectorChildListParentData);
       child = child.parentData.nextSibling;
       if (child != null) {
         innerTheta += paddingTheta;
         remainingDeltaTheta -= paddingTheta;
       }
     }
     deltaTheta = innerTheta;
@@ skipping 69 matching lines @@
       assert(child.parentData is SectorChildListParentData);
       child = child.parentData.nextSibling;
       childRadius += padding;
       remainingDeltaRadius -= padding;
     }
     return new SectorDimensions.withConstraints(constraints,
                                                 deltaRadius: childRadius - this.parentData.radius,
                                                 deltaTheta: outerDeltaTheta);
   }
 
-  SectorConstraints _constraints;
-  void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
+  void performLayout() {
+    assert(this.parentData is SectorParentData);
     deltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
     assert(deltaTheta <= kTwoPi);
-    _constraints = constraints;
-    internalLayout(relayoutSubtreeRoot);
-  }
-
-  void relayout() {
-    // TODO(ianh): avoid code duplication
-    assert(parentData is SectorParentData);
-    internalLayout(this);
-  }
-
-  void internalLayout(RenderNode relayoutSubtreeRoot) {
-    assert(this.parentData is SectorParentData);
     double paddingTheta = math.atan(padding / this.parentData.radius);
     double innerTheta = this.parentData.theta + paddingTheta;
     double innerDeltaTheta = deltaTheta - paddingTheta * 2.0;
     double childRadius = this.parentData.radius + padding;
-    double remainingDeltaRadius = _constraints.maxDeltaRadius - (padding * 2.0);
+    double remainingDeltaRadius = constraints.maxDeltaRadius - (padding * 2.0);
     RenderSector child = firstChild;
     while (child != null) {
       SectorConstraints innerConstraints = new SectorConstraints(
         maxDeltaRadius: remainingDeltaRadius,
         maxDeltaTheta: innerDeltaTheta
       );
       child.parentData.theta = innerTheta;
       child.parentData.radius = childRadius;
-      child.layout(innerConstraints);
+      child.layout(innerConstraints, parentUsesSize: true);
       childRadius += child.deltaRadius;
       remainingDeltaRadius -= child.deltaRadius;
       assert(child.parentData is SectorChildListParentData);
       child = child.parentData.nextSibling;
       childRadius += padding;
       remainingDeltaRadius -= padding;
     }
     deltaRadius = childRadius - this.parentData.radius;
   }
 
@@ skipping 47 matching lines @@
       return new BoxDimensions.withConstraints(constraints, width: 0.0, height: 0.0);
     assert(child is RenderSector);
     assert(child.parentData is SectorParentData);
     assert(!constraints.isInfinite);
     double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
     SectorDimensions childDimensions = child.getIntrinsicDimensions(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), innerRadius);
     double dimension = (innerRadius + childDimensions.deltaRadius) * 2.0;
     return new BoxDimensions.withConstraints(constraints, width: dimension, height: dimension);
   }
 
-  void layout(BoxConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
-    if (relayoutSubtreeRoot != null)
-      saveRelayoutSubtreeRoot(relayoutSubtreeRoot);
-    relayoutSubtreeRoot = relayoutSubtreeRoot == null ? this : relayoutSubtreeRoot;
+  void performLayout() {
     BoxDimensions ourDimensions;
     if (child == null) {
       ourDimensions = new BoxDimensions.withConstraints(constraints, width: 0.0, height: 0.0);
     } else {
       assert(child is RenderSector);
       assert(!constraints.isInfinite);
       double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
       assert(child.parentData is SectorParentData);
       child.parentData.radius = innerRadius;
       child.parentData.theta = 0.0;
-      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), relayoutSubtreeRoot: relayoutSubtreeRoot);
+      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), parentUsesSize: true);
       double dimension = (innerRadius + child.deltaRadius) * 2.0;
       ourDimensions = new BoxDimensions.withConstraints(constraints, width: dimension, height: dimension);
     }
     width = ourDimensions.width;
     height = ourDimensions.height;
-    layoutDone();
   }
 
   double width;
   double height;
 
   // paint origin is 0,0 of our circle
   void paint(RenderNodeDisplayList canvas) {
     super.paint(canvas);
     if (child != null)
       canvas.paintChild(child, width/2.0, height/2.0);
@@ skipping 29 matching lines @@
        super(new BoxDecoration(backgroundColor: backgroundColor));
 
   double desiredDeltaRadius;
   double desiredDeltaTheta;
   final int backgroundColor;
 
   SectorDimensions getIntrinsicDimensions(SectorConstraints constraints, double radius) {
     return new SectorDimensions.withConstraints(constraints, deltaTheta: 1.0); // 1.0 radians
   }
 
-  void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
+  void performLayout() {
     deltaRadius = constraints.constrainDeltaRadius(desiredDeltaRadius);
     deltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
-    layoutDone();
   }
 
   void handlePointer(sky.PointerEvent event) {
     if (event.type == 'pointerdown')
       decoration = new BoxDecoration(backgroundColor: 0xFFFF0000);
     else if (event.type == 'pointerup')
       decoration = new BoxDecoration(backgroundColor: backgroundColor);
   }
 }
 
 AppView app;
 
 void main() {
 
   var rootCircle = new RenderSectorRing(padding: 20.0);
   rootCircle.add(new RenderSolidColor(0xFF00FFFF, desiredDeltaTheta: kTwoPi * 0.15));
   rootCircle.add(new RenderSolidColor(0xFF0000FF, desiredDeltaTheta: kTwoPi * 0.4));
   var stack = new RenderSectorSlice(padding: 2.0);
   stack.add(new RenderSolidColor(0xFFFFFF00, desiredDeltaRadius: 20.0));
   stack.add(new RenderSolidColor(0xFFFF9000, desiredDeltaRadius: 20.0));
   stack.add(new RenderSolidColor(0xFF00FF00));
   rootCircle.add(stack);
 
   var root = new RenderBoxToRenderSectorAdapter(innerRadius: 50.0, child: rootCircle);
   app = new AppView(root);
 }