Rename RenderNode to RenderObject.

sky/sdk/lib/framework/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 'dart:typed_data';
-import 'node.dart';
+import 'object.dart';
 import 'package:vector_math/vector_math.dart';
 import 'package:sky/framework/net/image_cache.dart' as image_cache;
 
 // GENERIC BOX RENDERING
 // Anything that has a concept of x, y, width, height is going to derive from this
 
 class EdgeDims {
   // used for e.g. padding
   const EdgeDims(this.top, this.right, this.bottom, this.left);
   const EdgeDims.all(double value)
@@ skipping 87 matching lines @@
     value = 37 * value + maxHeight.hashCode;
     return value;
   }
   String toString() => "BoxConstraints($minWidth<=w<$maxWidth, $minHeight<=h<$maxHeight)";
 }
 
 class BoxParentData extends ParentData {
   sky.Point position = new sky.Point(0.0, 0.0);
 }
 
-abstract class RenderBox extends RenderNode {
+abstract class RenderBox extends RenderObject {
 
-  void setParentData(RenderNode child) {
+  void setParentData(RenderObject child) {
     if (child.parentData is! BoxParentData)
       child.parentData = new BoxParentData();
   }
 
   // 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)
   sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
@@ skipping 17 matching lines @@
   bool hitTest(HitTestResult result, { sky.Point position }) {
     hitTestChildren(result, position: position);
     result.add(this);
     return true;
   }
   void hitTestChildren(HitTestResult result, { sky.Point position }) { }
 
   sky.Size size = new sky.Size(0.0, 0.0);
 }
 
-abstract class RenderProxyBox extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
+abstract class RenderProxyBox extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
   RenderProxyBox(RenderBox child) {
     this.child = child;
   }
 
   sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
     if (child != null)
       return child.getIntrinsicDimensions(constraints);
     return super.getIntrinsicDimensions(constraints);
   }
 
   void performLayout() {
     if (child != null) {
       child.layout(constraints, parentUsesSize: true);
       size = child.size;
     } else {
       performResize();
     }
   }
 
   void hitTestChildren(HitTestResult result, { sky.Point position }) {
     if (child != null)
       child.hitTest(result, position: position);
     else
       super.hitTestChildren(result, position: position);
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList canvas) {
     if (child != null)
       child.paint(canvas);
   }
 }
 
 class RenderSizedBox extends RenderProxyBox {
 
   RenderSizedBox({
     RenderBox child,
     sky.Size desiredSize: const sky.Size.infinite()
@@ skipping 16 matching lines @@
     return constraints.constrain(_desiredSize);
   }
 
   void performLayout() {
     size = constraints.constrain(_desiredSize);
     if (child != null)
       child.layout(new BoxConstraints.tight(size));
   }
 }
 
-class RenderPadding extends RenderBox with RenderNodeWithChildMixin<RenderBox> {
+class RenderPadding extends RenderBox with RenderObjectWithChildMixin<RenderBox> {
 
   RenderPadding({ EdgeDims padding, RenderBox child }) {
     assert(padding != null);
     this.padding = padding;
     this.child = child;
   }
 
   EdgeDims _padding;
   EdgeDims get padding => _padding;
   void set padding (EdgeDims value) {
@@ skipping 20 matching lines @@
           new sky.Size(padding.left + padding.right, padding.top + padding.bottom));
       return;
     }
     child.layout(innerConstraints, parentUsesSize: true);
     assert(child.parentData is BoxParentData);
     child.parentData.position = new sky.Point(padding.left, padding.top);
     size = constraints.constrain(new sky.Size(padding.left + child.size.width + padding.right,
                                               padding.top + child.size.height + padding.bottom));
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList canvas) {
     if (child != null)
       canvas.paintChild(child, child.parentData.position);
   }
 
   void hitTestChildren(HitTestResult result, { sky.Point position }) {
     if (child != null) {
       assert(child.parentData is BoxParentData);
       sky.Rect childBounds = new sky.Rect.fromPointAndSize(child.parentData.position, child.size);
       if (childBounds.contains(position)) {
         child.hitTest(result, position: new sky.Point(position.x - child.parentData.position.x,
@@ skipping 55 matching lines @@
         size = constraints.constrain(new sky.Size(width, requestedSize.height));
       }
     } else if (requestedSize.height == null) {
       double height = requestedSize.width * _image.height / _image.width;
       size = constraints.constrain(new sky.Size(requestedSize.width, height));
     } else {
       size = constraints.constrain(requestedSize);
     }
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList 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);
     }
     sky.Paint paint = new sky.Paint();
     canvas.drawImage(_image, 0.0, 0.0, paint);
@@ skipping 18 matching lines @@
 
   BoxDecoration _decoration;
   BoxDecoration get decoration => _decoration;
   void set decoration (BoxDecoration value) {
     if (value == _decoration)
       return;
     _decoration = value;
     markNeedsPaint();
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList 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);
     }
@@ skipping 49 matching lines @@
     Matrix4 inverse = new Matrix4.zero();
     double det = inverse.copyInverse(_transform);
     // TODO(abarth): Check the determinant for degeneracy.
 
     Vector3 position3 = new Vector3(position.x, position.y, 0.0);
     Vector3 transformed3 = inverse.transform3(position3);
     sky.Point transformed = new sky.Point(transformed3.x, transformed3.y);
     super.hitTestChildren(result, position: transformed);
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList canvas) {
     Float32List storage = _transform.storage;
 
     canvas.save();
     canvas.concat([
       storage[ 0], storage[ 4], storage[12],
       storage[ 1], storage[ 5], storage[13],
       storage[ 3], storage[ 7], storage[15],
     ]);
     super.paint(canvas);
     canvas.restore();
   }
 }
 
 
 // RENDER VIEW LAYOUT MANAGER
 
 class ViewConstraints {
 
   const ViewConstraints({
     this.width: 0.0, this.height: 0.0, this.orientation: null
   });
 
   final double width;
   final double height;
   final int orientation;
 
 }
 
-class RenderView extends RenderNode with RenderNodeWithChildMixin<RenderBox> {
+class RenderView extends RenderObject with RenderObjectWithChildMixin<RenderBox> {
 
   RenderView({
     RenderBox child,
     this.timeForRotation: const Duration(microseconds: 83333)
   }) {
     this.child = child;
   }
 
   sky.Size _size = new sky.Size(0.0, 0.0);
   double get width => _size.width;
@@ skipping 30 matching lines @@
   bool hitTest(HitTestResult result, { sky.Point position }) {
     if (child != null) {
       sky.Rect childBounds = new sky.Rect.fromSize(child.size);
       if (childBounds.contains(position))
         child.hitTest(result, position: position);
     }
     result.add(this);
     return true;
   }
 
-  void paint(RenderNodeDisplayList canvas) {
+  void paint(RenderObjectDisplayList canvas) {
     if (child != null)
       canvas.paintChild(child, new sky.Point(0.0, 0.0));
   }
 
   void paintFrame() {
-    RenderNode.debugDoingPaint = true;
-    RenderNodeDisplayList canvas = new RenderNodeDisplayList(sky.view.width, sky.view.height);
+    RenderObject.debugDoingPaint = true;
+    RenderObjectDisplayList canvas = new RenderObjectDisplayList(sky.view.width, sky.view.height);
     paint(canvas);
     sky.view.picture = canvas.endRecording();
-    RenderNode.debugDoingPaint = false;
+    RenderObject.debugDoingPaint = false;
   }
 
 }
 
 // DEFAULT BEHAVIORS FOR RENDERBOX CONTAINERS
-abstract class RenderBoxContainerDefaultsMixin<ChildType extends RenderBox, ParentDataType extends ContainerParentDataMixin<ChildType>> implements ContainerRenderNodeMixin<ChildType, ParentDataType> {
+abstract class RenderBoxContainerDefaultsMixin<ChildType extends RenderBox, ParentDataType extends ContainerParentDataMixin<ChildType>> implements ContainerRenderObjectMixin<ChildType, ParentDataType> {
 
   void defaultHitTestChildren(HitTestResult result, { sky.Point position }) {
     // the x, y parameters have the top left of the node's box as the origin
     ChildType child = lastChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       sky.Rect childBounds = new sky.Rect.fromPointAndSize(child.parentData.position, child.size);
       if (childBounds.contains(position)) {
         if (child.hitTest(result, position: new sky.Point(position.x - child.parentData.position.x,
                                                           position.y - child.parentData.position.y)))
           break;
       }
       child = child.parentData.previousSibling;
     }
   }
 
-  void defaultPaint(RenderNodeDisplayList canvas) {
+  void defaultPaint(RenderObjectDisplayList canvas) {
     RenderBox child = firstChild;
     while (child != null) {
       assert(child.parentData is ParentDataType);
       canvas.paintChild(child, child.parentData.position);
       child = child.parentData.nextSibling;
     }
   }
 }