Adding Point & Rect primitives

tools/dom/src/Rectangle.dart

Index: tools/dom/src/Rectangle.dart
diff --git a/tools/dom/src/Rectangle.dart b/tools/dom/src/Rectangle.dart
new file mode 100644
index 0000000000000000000000000000000000000000..857a1992ebe2fc215a6c21df44dc59fcca154365
--- /dev/null
+++ b/tools/dom/src/Rectangle.dart
@@ -0,0 +1,142 @@
+// Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of html;
+
+/**
+ * A class for representing two-dimensional rectangles.
+ */
+class Rect {
+  final num left;
+  final num top;
+  final num width;
+  final num height;
+
+  Rect(this.left, this.top, this.width, this.height) {
+    if (width < 0) {
+      throw new ArgumentError(width);
+    }
+    if (height < 0) {
+      throw new ArgumentError(height);
+    }
+  }
+
+  factory Rect.fromPoints(Point a, Point b) {
+    var left;
+    var width;
+    if (a.x < b.x) {
+      left = a.x;
+      width = b.x - left;
+    } else {
+      left = b.x;
+      width = a.x - left;
+    }
+    var top;
+    var height;
+    if (a.y < b.y) {
+      top = a.y;
+      height = b.y - top;
+    } else {
+      top = b.y;
+      height = a.y - top;
+    }
+
+    return new Rect(left, top, width, height);
+  }
+
+  num get right => left + width;
+  num get bottom => top + height;
+
+  // NOTE! All code below should be common with Rect.
+  // TODO: implement with mixins when available.
+
+  String toString() {
+    return '($left, $top, $width, $height)';
+  }
+
+  bool operator ==(other) {
+    if (other is !Rect) return false;
+    return left == other.left && top == other.top && width == other.width &&
+        height == other.height;
+  }
+
+  /**
+   * Computes the intersection of this rectangle and the rectangle parameter.
+   * Returns null if there is no intersection.
+   */
+  Rect intersection(Rect rect) {
+    var x0 = max(left, rect.left);
+    var x1 = min(left + width, rect.left + rect.width);
+
+    if (x0 <= x1) {
+      var y0 = max(top, rect.top);
+      var y1 = min(top + height, rect.top + rect.height);
+
+      if (y0 <= y1) {
+        return new Rect(x0, y0, x1 - x0, y1 - y0);
+      }
+    }
+    return null;
+  }
+
+
+  /**
+   * Returns whether a rectangle intersects this rectangle.
+   */
+  bool intersects(Rect other) {
+    return (left <= other.left + other.width && other.left <= left + width &&
+        top <= other.top + other.height && other.top <= top + height);
+  }
+
+  /**
+   * Returns a new rectangle which completely contains this rectangle and the
+   * input rectangle.
+   */
+  Rect union(Rect rect) {
+    var right = max(this.left + this.width, rect.left + rect.width);
+    var bottom = max(this.top + this.height, rect.top + rect.height);
+
+    var left = min(this.left, rect.left);
+    var top = min(this.top, rect.top);
+
+    return new Rect(left, top, right - left, bottom - top);
+  }
+
+  /**
+   * Tests whether this rectangle entirely contains another rectangle.
+   */
+  bool containsRect(Rect another) {
+    return left <= another.left &&
+           left + width >= another.left + another.width &&
+           top <= another.top &&
+           top + height >= another.top + another.height;
+  }
+
+  /**
+   * Tests whether this rectangle entirely contains a point.
+   */
+  bool containsPoint(Point another) {
+    return another.x >= left &&
+           another.x <= left + width &&
+           another.y >= top &&
+           another.y <= top + height;
+  }
+
+  Rect ceil() => new Rect(left.ceil(), top.ceil(), width.ceil(), height.ceil());
+  Rect floor() => new Rect(left.floor(), top.floor(), width.floor(),
+      height.floor());
+  Rect round() => new Rect(left.round(), top.round(), width.round(),
+      height.round());
+
+  /**
+   * Truncates coordinates to integers and returns the result as a new
+   * rectangle.
+   */
+  Rect toInt() => new Rect(left.toInt(), top.toInt(), width.toInt(),
+      height.toInt());
+
+  Point get topLeft => new Point(this.left, this.top);
+  Point get bottomRight => new Point(this.left + this.width,
+      this.top + this.height);
+}