Introduce sky.Sky.zero

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/rendering/box.dart';
 import 'package:sky/framework/rendering/object.dart';
 
@@ skipping 106 matching lines @@
   // origin must be set to the center of the circle
   void paint(RenderObjectDisplayList canvas) {
     assert(deltaRadius != null);
     assert(deltaTheta != null);
     assert(parentData is SectorParentData);
 
     if (_decoration == null)
       return;
 
     if (_decoration.backgroundColor != null) {
-      sky.Paint paint = new sky.Paint()..color = _decoration.backgroundColor;
-      sky.Path path = new sky.Path();
+      Paint paint = new Paint()..color = _decoration.backgroundColor;
+      Path path = new Path();
       double outerRadius = (parentData.radius + deltaRadius);
-      sky.Rect outerBounds = new sky.Rect.fromLTRB(-outerRadius, -outerRadius, outerRadius, outerRadius);
+      Rect outerBounds = new Rect.fromLTRB(-outerRadius, -outerRadius, outerRadius, outerRadius);
       path.arcTo(outerBounds, deg(parentData.theta), deg(deltaTheta), true);
       double innerRadius = parentData.radius;
-      sky.Rect innerBounds = new sky.Rect.fromLTRB(-innerRadius, -innerRadius, innerRadius, innerRadius);
+      Rect innerBounds = new Rect.fromLTRB(-innerRadius, -innerRadius, innerRadius, innerRadius);
       path.arcTo(innerBounds, deg(parentData.theta + deltaTheta), deg(-deltaTheta), false);
       path.close();
       canvas.drawPath(path, paint);
     }
   }
 }
 
 class SectorChildListParentData extends SectorParentData with ContainerParentDataMixin<RenderSector> { }
 
 class RenderSectorWithChildren extends RenderDecoratedSector with ContainerRenderObjectMixin<RenderSector, SectorChildListParentData> {
@@ skipping 106 matching lines @@
   }
 
   // paint origin is 0,0 of our circle
   // each sector then knows how to paint itself at its location
   void paint(RenderObjectDisplayList canvas) {
     // TODO(ianh): avoid code duplication
     super.paint(canvas);
     RenderSector child = firstChild;
     while (child != null) {
       assert(child.parentData is SectorChildListParentData);
-      canvas.paintChild(child, new sky.Point(0.0, 0.0));
+      canvas.paintChild(child, new Point(0.0, 0.0));
       child = child.parentData.nextSibling;
     }
   }
 
 }
 
 class RenderSectorSlice extends RenderSectorWithChildren {
   // lays out RenderSector children in a stack
 
   RenderSectorSlice({
@@ skipping 84 matching lines @@
   }
 
   // paint origin is 0,0 of our circle
   // each sector then knows how to paint itself at its location
   void paint(RenderObjectDisplayList canvas) {
     // TODO(ianh): avoid code duplication
     super.paint(canvas);
     RenderSector child = firstChild;
     while (child != null) {
       assert(child.parentData is SectorChildListParentData);
-      canvas.paintChild(child, new sky.Point(0.0, 0.0));
+      canvas.paintChild(child, new Point(0.0, 0.0));
       child = child.parentData.nextSibling;
     }
   }
 
 }
 
 class RenderBoxToRenderSectorAdapter extends RenderBox {
 
   RenderBoxToRenderSectorAdapter({ double innerRadius: 0.0, RenderSector child }) :
     _innerRadius = innerRadius {
@@ skipping 16 matching lines @@
     _child = value;
     adoptChild(_child);
     markNeedsLayout();
   }
 
   void setParentData(RenderObject child) {
     if (child.parentData is! SectorParentData)
       child.parentData = new SectorParentData();
   }
 
-  sky.Size getIntrinsicDimensions(BoxConstraints constraints) {
+  Size getIntrinsicDimensions(BoxConstraints constraints) {
     if (child == null)
-      return constraints.constrain(new sky.Size(0.0, 0.0));
+      return constraints.constrain(Size.zero);
     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 constraints.constrain(new sky.Size(dimension, dimension));
+    return constraints.constrain(new Size(dimension, dimension));
   }
 
   void performLayout() {
     if (child == null) {
-      size = constraints.constrain(new sky.Size(0.0, 0.0));
+      size = constraints.constrain(Size.zero);
     } else {
       assert(child is RenderSector);
       assert(!constraints.isInfinite);
       print("constraint maxes: ${constraints.maxWidth} and ${constraints.maxHeight}");
       double maxChildDeltaRadius = math.min(constraints.maxWidth, constraints.maxHeight) / 2.0 - innerRadius;
       print("maxChildDeltaRadius = $maxChildDeltaRadius");
       assert(child.parentData is SectorParentData);
       child.parentData.radius = innerRadius;
       child.parentData.theta = 0.0;
       child.layout(new SectorConstraints(maxDeltaRadius: maxChildDeltaRadius), parentUsesSize: true);
       double dimension = (innerRadius + child.deltaRadius) * 2.0;
-      size = constraints.constrain(new sky.Size(dimension, dimension));
+      size = constraints.constrain(new Size(dimension, dimension));
     }
   }
 
   // paint origin is 0,0 of our circle
   void paint(RenderObjectDisplayList canvas) {
     super.paint(canvas);
     if (child != null) {
-      sky.Rect bounds = new sky.Rect.fromSize(size);
+      Rect bounds = new Rect.fromSize(size);
       canvas.paintChild(child, bounds.center);
     }
   }
 
-  bool hitTest(HitTestResult result, { sky.Point position }) {
+  bool hitTest(HitTestResult result, { Point position }) {
     double x = position.x;
     double y = position.y;
     if (child == null)
       return false;
     // translate to our origin
     x -= size.width/2.0;
     y -= size.height/2.0;
     // convert to radius/theta
     double radius = math.sqrt(x*x+y*y);
     double theta = (math.atan2(x, -y) - math.PI/2.0) % kTwoPi;
     if (radius < innerRadius)
       return false;
     if (radius >= innerRadius + child.deltaRadius)
       return false;
     if (theta > child.deltaTheta)
       return false;
     child.hitTest(result, radius: radius, theta: theta);
     result.add(this);
     return true;
   }
   
 }
 
 class RenderSolidColor extends RenderDecoratedSector {
-  RenderSolidColor(sky.Color backgroundColor, {
+  RenderSolidColor(Color backgroundColor, {
     this.desiredDeltaRadius: double.INFINITY,
     this.desiredDeltaTheta: kTwoPi
   }) : this.backgroundColor = backgroundColor,
        super(new BoxDecoration(backgroundColor: backgroundColor));
 
   double desiredDeltaRadius;
   double desiredDeltaTheta;
-  final sky.Color backgroundColor;
+  final Color backgroundColor;
 
   SectorDimensions getIntrinsicDimensions(SectorConstraints constraints, double radius) {
     return new SectorDimensions.withConstraints(constraints, deltaTheta: 1.0); // 1.0 radians
   }
 
   void performLayout() {
     deltaRadius = constraints.constrainDeltaRadius(desiredDeltaRadius);
     deltaTheta = constraints.constrainDeltaTheta(desiredDeltaTheta);
   }
 
   void handleEvent(sky.Event event) {
     if (event.type == 'pointerdown')
-      decoration = new BoxDecoration(backgroundColor: const sky.Color(0xFFFF0000));
+      decoration = new BoxDecoration(backgroundColor: const Color(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(const sky.Color(0xFF00FFFF), desiredDeltaTheta: kTwoPi * 0.15));
-  rootCircle.add(new RenderSolidColor(const sky.Color(0xFF0000FF), desiredDeltaTheta: kTwoPi * 0.4));
+  rootCircle.add(new RenderSolidColor(const Color(0xFF00FFFF), desiredDeltaTheta: kTwoPi * 0.15));
+  rootCircle.add(new RenderSolidColor(const Color(0xFF0000FF), desiredDeltaTheta: kTwoPi * 0.4));
   var stack = new RenderSectorSlice(padding: 2.0);
-  stack.add(new RenderSolidColor(const sky.Color(0xFFFFFF00), desiredDeltaRadius: 20.0));
-  stack.add(new RenderSolidColor(const sky.Color(0xFFFF9000), desiredDeltaRadius: 20.0));
-  stack.add(new RenderSolidColor(const sky.Color(0xFF00FF00)));
+  stack.add(new RenderSolidColor(const Color(0xFFFFFF00), desiredDeltaRadius: 20.0));
+  stack.add(new RenderSolidColor(const Color(0xFFFF9000), desiredDeltaRadius: 20.0));
+  stack.add(new RenderSolidColor(const Color(0xFF00FF00)));
   rootCircle.add(stack);
 
   var root = new RenderBoxToRenderSectorAdapter(innerRadius: 50.0, child: rootCircle);
   app = new AppView(root);
 }