A proof of concept for annular sector 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
@@ skipping 61 matching lines @@
   }
 
   static List<RenderNode> _nodesNeedingLayout = new List<RenderNode>();
   static bool _debugDoingLayout = false;
   bool _needsLayout = true;
   bool get needsLayout => _needsLayout;
   RenderNode _relayoutSubtreeRoot;
   void saveRelayoutSubtreeRoot(RenderNode relayoutSubtreeRoot) {
     _relayoutSubtreeRoot = relayoutSubtreeRoot;
     assert(_relayoutSubtreeRoot == null || _relayoutSubtreeRoot._relayoutSubtreeRoot == null);
-    assert(_relayoutSubtreeRoot == null || _relayoutSubtreeRoot == parent || _relayoutSubtreeRoot == parent._relayoutSubtreeRoot);
+    assert(_relayoutSubtreeRoot == null || _relayoutSubtreeRoot == parent || (parent is RenderNode && _relayoutSubtreeRoot == parent._relayoutSubtreeRoot));
   }
   bool debugAncestorsAlreadyMarkedNeedsLayout() {
     if (_relayoutSubtreeRoot == null)
       return true;
     RenderNode node = this;
     while (node != _relayoutSubtreeRoot) {
       assert(node._relayoutSubtreeRoot == _relayoutSubtreeRoot);
       assert(node.parent != null);
       node = node.parent as RenderNode;
       if (!node._needsLayout)
         return false;
     }
     assert(node._relayoutSubtreeRoot == null);
     return true;
   }
   void markNeedsLayout() {
     assert(!_debugDoingLayout);
     assert(!_debugDoingPaint);
     if (_needsLayout) {
       assert(debugAncestorsAlreadyMarkedNeedsLayout());
       return;
     }
     _needsLayout = true;
+    assert(parent is RenderNode);
     if (_relayoutSubtreeRoot != null)
       parent.markNeedsLayout();
     else
       _nodesNeedingLayout.add(this);
   }
   static void flushLayout() {
     _debugDoingLayout = true;
     List<RenderNode> dirtyNodes = _nodesNeedingLayout;
     _nodesNeedingLayout = new List<RenderNode>();
     dirtyNodes..sort((a, b) => a.depth - b.depth)..forEach((node) {
@@ skipping 279 matching lines @@
 // 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});
 
-  const BoxConstraints.tight({ width: width, height: height })
+  const BoxConstraints.tight({ double width: 0.0, double height: 0.0 })
     : minWidth = width,
       maxWidth = width,
       minHeight = height,
       maxHeight = height;
 
   final double minWidth;
   final double maxWidth;
   final double minHeight;
   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);
   }
+
+  bool get isInfinite => maxWidth >= double.INFINITY || maxHeight >= double.INFINITY;
 }
 
 class BoxDimensions {
-  const BoxDimensions({this.width, this.height});
+  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),
+    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;
 }
@@ skipping 213 matching lines @@
   // 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) {
     double outerHeight = _padding.top + _padding.bottom;
     double outerWidth = constraints.constrainWidth(constraints.maxWidth);
     assert(outerWidth < double.INFINITY);
     double innerWidth = outerWidth - (_padding.left + _padding.right);
-    RenderBox child = _firstChild;
+    RenderBox child = firstChild;
     BoxConstraints innerConstraints = new BoxConstraints(minWidth: innerWidth,
                                                          maxWidth: innerWidth);
     while (child != null) {
       outerHeight += child.getIntrinsicDimensions(innerConstraints).height;
       assert(child.parentData is BlockParentData);
       child = child.parentData.nextSibling;
     }
 
     return new BoxDimensions(width: outerWidth,
                              height: constraints.constrainHeight(outerHeight));
@@ skipping 14 matching lines @@
 
   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;
+    RenderBox child = firstChild;
     while (child != null) {
       child.layout(new BoxConstraints(minWidth: innerWidth, maxWidth: innerWidth),
                    relayoutSubtreeRoot: relayoutSubtreeRoot);
       assert(child.parentData is BlockParentData);
       child.parentData.x = _padding.left;
       child.parentData.y = y;
       y += child.height;
       child = child.parentData.nextSibling;
     }
     height = clamp(min: _minHeight, value: y + _padding.bottom, max: _maxHeight);
@@ skipping 59 matching lines @@
     assert(width < double.INFINITY);
     internalLayout(relayoutSubtreeRoot);
   }
 
   void relayout() {
     internalLayout(this);
   }
 
   int _getFlex(RenderBox child) {
     assert(child.parentData is FlexBoxParentData);
-    return (child.parentData.flex != null ? child.parentData.flex : 0);
+    return child.parentData.flex != null ? child.parentData.flex : 0;
   }
 
   void internalLayout(RenderNode relayoutSubtreeRoot) {
     // 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 numFlexibleChildren = 0;
     int totalFlex = 0;
     assert(_constraints != null);
     double freeSpace = (_direction == FlexDirection.Horizontal) ? _constraints.maxWidth : _constraints.maxHeight;
-    RenderBox child = _firstChild;
+    RenderBox child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
       if (flex > 0) {
-        numFlexibleChildren++;
         totalFlex += child.parentData.flex;
       } else {
         BoxConstraints constraints = new BoxConstraints(maxHeight: _constraints.maxHeight,
                                                         maxWidth: _constraints.maxWidth);
         child.layout(constraints,
                      relayoutSubtreeRoot: relayoutSubtreeRoot);
         freeSpace -= (_direction == FlexDirection.Horizontal) ? child.width : child.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;
+    child = firstChild;
     while (child != null) {
       int flex = _getFlex(child);
       if (flex > 0) {
         double spaceForChild = spacePerFlex * flex;
         BoxConstraints constraints;
         switch (_direction) {
           case FlexDirection.Horizontal:
             constraints = new BoxConstraints(maxHeight: _constraints.maxHeight,
                                              minWidth: spaceForChild,
                                              maxWidth: spaceForChild);
@@ skipping 102 matching lines @@
     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);
   }
 
 }