Make RenderParagraph mutable, and make it fit the new RenderNode protocols

sky/sdk/lib/framework/layout2.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 'node.dart';
 import 'dart:sky' as sky;
 
 // ABSTRACT LAYOUT
 
 class ParentData {
@@ skipping 484 matching lines @@
 
   sky.Size size = new sky.Size(0.0, 0.0);
 }
 
 abstract class RenderProxyBox extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
   RenderProxyBox(RenderBox child) {
     this.child = child;
   }
 
   sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
-    return child.getIntrinsicDimensions(constraints);
+    if (child != null)
+      return child.getIntrinsicDimensions(constraints);
+    return super.getIntrinsicDimensions(constraints);
   }
 
   void performLayout() {
-    child.layout(constraints, parentUsesSize: true);
-    size = child.size;
+    if (child != null) {
+      child.layout(constraints, parentUsesSize: true);
+      size = child.size;
+    } else {
+      performResize();
+    }
   }
 
   void hitTestChildren(HitTestResult result, { sky.Point position }) {
-    child.hitTest(result, position: position);
+    if (child != null)
+      child.hitTest(result, position: position);
+    else
+      super.hitTestChildren(result, position: position);
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    child.paint(canvas);
+    if (child != null)
+      child.paint(canvas);
   }
 }
 
 class RenderSizedBox extends RenderProxyBox {
   final sky.Size desiredSize;
 
-  RenderSizedBox(RenderBox child, [this.desiredSize = const sky.Size.infinite()])
-      : super(child);
+  RenderSizedBox({
+    RenderBox child, 
+    this.desiredSize: const sky.Size.infinite()
+  }) : super(child);
 
   sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
     return constraints.constrain(desiredSize);
   }
 
   void performLayout() {
     size = constraints.constrain(desiredSize);
     child.layout(new BoxConstraints.tight(size));
   }
 }
@@ skipping 59 matching lines @@
 
 // This must be immutable, because we won't notice when it changes
 class BoxDecoration {
   const BoxDecoration({
     this.backgroundColor
   });
 
   final int backgroundColor;
 }
 
-class RenderDecoratedBox extends RenderBox {
+class RenderDecoratedBox extends RenderProxyBox {
 
-  RenderDecoratedBox(BoxDecoration decoration) : _decoration = decoration;
+  RenderDecoratedBox({
+    BoxDecoration decoration,
+    RenderBox child
+  }) : _decoration = decoration, super(child);
 
   BoxDecoration _decoration;
   BoxDecoration get decoration => _decoration;
   void set decoration (BoxDecoration value) {
     if (value == _decoration)
       return;
     _decoration = value;
     markNeedsPaint();
   }
 
-  void performLayout() {
-    size = constraints.constrain(new sky.Size.infinite());
-  }
-
   void paint(RenderNodeDisplayList canvas) {
     assert(size.width != null);
     assert(size.height != null);
 
     if (_decoration == null)
       return;
 
     if (_decoration.backgroundColor != null) {
       sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
       canvas.drawRect(new sky.Rect.fromLTRB(0.0, 0.0, size.width, size.height), paint);
     }
-  }
-}
-
-class RenderDecoratedCircle extends RenderDecoratedBox with RenderNodeWithChildMixin<RenderBox> {
-  RenderDecoratedCircle({
-    BoxDecoration decoration,
-    RenderBox child
-  }) : super(decoration) {
-    this.child = child;
+    super.paint(canvas);
   }
 
-  void paint(RenderNodeDisplayList canvas) {
-    assert(size.width != null);
-    assert(size.height != null);
-
-    if (_decoration == null)
-      return;
-
-    if (_decoration.backgroundColor != null) {
-      sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
-      canvas.drawCircle(0.0, 0.0, (size.width + size.height) / 2, paint);
-    }
-  }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
 class ViewConstraints {
 
   const ViewConstraints({
     this.width: 0.0, this.height: 0.0, this.orientation: null
   });
@@ skipping 95 matching lines @@
       canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }
 
 // BLOCK LAYOUT MANAGER
 
 class BlockParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> { }
 
-class RenderBlock extends RenderDecoratedBox with ContainerRenderNodeMixin<RenderBox, BlockParentData>,
-                                                  RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
+class RenderBlock extends RenderBox with ContainerRenderNodeMixin<RenderBox, BlockParentData>,
+                                         RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
   // lays out RenderBox children in a vertical stack
   // uses the maximum width provided by the parent
   // sizes itself to the height of its child stack
 
-  RenderBlock({
-    BoxDecoration decoration
-  }) : super(decoration);
-
   void setParentData(RenderBox child) {
     if (child.parentData is! BlockParentData)
       child.parentData = new BlockParentData();
   }
 
   // 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)
@@ skipping 28 matching lines @@
     size = new sky.Size(width, constraints.constrainHeight(y));
     assert(size.width < double.INFINITY);
     assert(size.height < double.INFINITY);
   }
 
   void hitTestChildren(HitTestResult result, { sky.Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    super.paint(canvas);
     defaultPaint(canvas);
   }
 
 }
 
 // FLEXBOX LAYOUT MANAGER
 
 class FlexBoxParentData extends BoxParentData with ContainerParentDataMixin<RenderBox> {
   int flex;
   void merge(FlexBoxParentData other) {
     if (other.flex != null)
       flex = other.flex;
     super.merge(other);
   }
 }
 
 enum FlexDirection { Horizontal, Vertical }
 
-class RenderFlex extends RenderDecoratedBox with ContainerRenderNodeMixin<RenderBox, FlexBoxParentData>,
-                                                 RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
+class RenderFlex extends RenderBox with ContainerRenderNodeMixin<RenderBox, FlexBoxParentData>,
+                                        RenderBoxContainerDefaultsMixin<RenderBox, BlockParentData> {
   // lays out RenderBox children using flexible layout
 
   RenderFlex({
-    BoxDecoration decoration,
     FlexDirection direction: FlexDirection.Horizontal
-  }) : super(decoration), _direction = direction;
+  }) : _direction = direction;
 
   FlexDirection _direction;
   FlexDirection get direction => _direction;
   void set direction (FlexDirection value) {
     if (_direction != value) {
       _direction = value;
       markNeedsLayout();
     }
   }
 
@@ skipping 71 matching lines @@
       }
       child = child.parentData.nextSibling;
     }
   }
 
   void hitTestChildren(HitTestResult result, { sky.Point position }) {
     defaultHitTestChildren(result, position: position);
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    super.paint(canvas);
     defaultPaint(canvas);
   }
 }
 
 class RenderInline extends RenderNode {
   String data;
 
   RenderInline(this.data);
 }
 
-class RenderParagraph extends RenderDecoratedBox {
-  String text;
-  sky.LayoutRoot _layoutRoot = new sky.LayoutRoot();
-  sky.Document _document;
+class RenderParagraph extends RenderBox {
 
-  RenderParagraph(String this.text) :
-   super(new BoxDecoration(backgroundColor: 0xFFFFFFFF)) {
-    _document = new sky.Document();
+  RenderParagraph({
+    String text,
+    int color
+  }) : _color = color {
     _layoutRoot.rootElement = _document.createElement('p');
-    _layoutRoot.rootElement.appendChild(_document.createText(this.text));
+    this.text = text;
+  }
+
+  final sky.Document _document = new sky.Document();
+  final sky.LayoutRoot _layoutRoot = new sky.LayoutRoot();
+
+  String get text => (_layoutRoot.rootElement.firstChild as sky.Text).data;
+  void set text (String value) {
+    _layoutRoot.rootElement.setChild(_document.createText(value));
+    markNeedsLayout();
+  }
+
+  int _color = 0xFF000000;
+  int get color => _color;
+  void set color (int value) {
+    if (_color != value) {
+      _color = value;
+      markNeedsPaint();
+    }
+  }
+
+  sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
+    assert(false);
+    return null;
+    // we don't currently support this for RenderParagraph
   }
 
   void performLayout() {
     _layoutRoot.maxWidth = constraints.maxWidth;
     _layoutRoot.minWidth = constraints.minWidth;
     _layoutRoot.minHeight = constraints.minHeight;
     _layoutRoot.maxHeight = constraints.maxHeight;
     _layoutRoot.layout();
-    width = _layoutRoot.rootElement.width;
-    // TODO(eseidel): LayoutRoot will not expand to fill height. :(
-    height = _constraints.constrainHeight(_layoutRoot.rootElement.height);
-  }
-
-  void hitTestChildren(HitTestResult result, { double x, double y }) {
-    // defaultHitTestChildren(result, x: x, y: y);
+    size = constraints.constrain(new sky.Size(_layoutRoot.rootElement.width, _layoutRoot.rootElement.height));
   }
 
   void paint(RenderNodeDisplayList canvas) {
-    super.paint(canvas);
+    // _layoutRoot.rootElement.style['color'] = 'rgba(' + ...color... + ')';
     _layoutRoot.paint(canvas);
   }
+
+  // we should probably expose a way to do precise (inter-glpyh) hit testing
+
 }