anchor.diff:        ourDimensions = new BoxDimensions.withConstraints(constraints, width: 0.0, height: 0.0);
       } else {
         assert(child is RenderSector);
  -      assert(child.parentData is SectorParentData);
         assert(!constraints.isInfinite);
         double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
  -      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), innerRadius, relayoutSubtreeRoot: relayoutSubtreeRoot);
  +      assert(child.parentData is SectorParentData);
  +      child.parentData.radius = innerRadius;
  +      child.parentData.theta = 0.0;
  +      child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), relayoutSubtreeRoot: relayoutSubtreeRoot);
         double dimension = (innerRadius + child.deltaRadius) * 2.0;
         ourDimensions = new BoxDimensions.withConstraints(constraints, width: dimension, height: dimension);
       }
       width = ourDimensions.width;
       height = ourDimensions.height;
  -    print("adapter is: ${width}x${height}");
       layoutDone();
     }
   
  
positive.code:     double childRadius = radius + padding;
      double paddingTheta = math.atan(padding / (radius + outerDeltaRadius));
      double innerTheta = paddingTheta; // increments with each child
      double remainingTheta = constraints.maxDeltaTheta - (innerTheta + paddingTheta);
      RenderSector child = firstChild;
      while (child != null) {
        SectorConstraints innerConstraints = new SectorConstraints(
          maxDeltaRadius: innerDeltaRadius,
          maxDeltaTheta: remainingTheta
        );
        SectorDimensions childDimensions = child.getIntrinsicDimensions(innerConstraints, childRadius);
        innerTheta += childDimensions.deltaTheta;
        remainingTheta -= childDimensions.deltaTheta;
        assert(child.parentData is SectorChildListParentData);
        child = child.parentData.nextSibling;
        if (child != null) {
          innerTheta += paddingTheta;
          remainingTheta -= paddingTheta;
        }
      }
      return new SectorDimensions.withConstraints(constraints,
  
negative.code:   // 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);
    }
    
  }
  
  class RenderSolidColor extends RenderDecoratedSector {
    RenderSolidColor(int backgroundColor, {
      this.desiredDeltaRadius: double.INFINITY,
      this.desiredDeltaTheta: kTwoPi
    }) : super(new BoxDecoration(backgroundColor: backgroundColor));
  
    double desiredDeltaRadius;
    double desiredDeltaTheta;
  
    SectorDimensions getIntrinsicDimensions(SectorConstraints constraints, double radius) {
      return new SectorDimensions.withConstraints(constraints, deltaTheta: 1.0); // 1.0 radians
    }
  
    void layout(SectorConstraints constraints, { RenderNode relayoutSubtreeRoot }) {
      deltaRadius = constraints.constrainDeltaRadius(desiredDeltaRadius);
      deltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
      layoutDone();
    }
  }
  