## Rect class

A class for representing two-dimensional rectangles.

```class Rect {
final num left;
final num top;
final num width;
final num height;

const Rect(this.left, this.top, this.width, this.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);
}
```

### Constructors

#### const Rect(num left, num top, num width, num height) #

```const Rect(this.left, this.top, this.width, this.height);
```

#### factory Rect.fromPoints(Point a, Point b) #

```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);
}
```

### Properties

#### final numbottom#

```num get bottom => top + height;
```

#### final PointbottomRight#

```Point get bottomRight => new Point(this.left + this.width,
this.top + this.height);
```

#### final numheight#

```final num height
```

#### final numleft#

```final num left
```
```num get right => left + width;
```

#### final numtop#

```final num top
```

#### final PointtopLeft#

```Point get topLeft => new Point(this.left, this.top);
```

#### final numwidth#

```final num width
```

### Operators

#### booloperator ==(other) #

The equality operator.

The default behavior for all `Object`s is to return true if and only if `this` and other are the same object.

If a subclass overrides the equality operator it should override the `hashCode` method as well to maintain consistency.

docs inherited from Object
```bool operator ==(other) {
if (other is !Rect) return false;
return left == other.left && top == other.top && width == other.width &&
height == other.height;
}
```

### Methods

#### Rectceil() #

```Rect ceil() => new Rect(left.ceil(), top.ceil(), width.ceil(), height.ceil());
```

#### boolcontainsPoint(Point another) #

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;
}
```

#### boolcontainsRect(Rect another) #

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;
}
```

#### Rectfloor() #

```Rect floor() => new Rect(left.floor(), top.floor(), width.floor(),
height.floor());
```

#### Rectintersection(Rect rect) #

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;
}
```

#### boolintersects(Rect other) #

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);
}
```

#### Rectround() #

```Rect round() => new Rect(left.round(), top.round(), width.round(),
height.round());
```

#### RecttoInt() #

Truncates coordinates to integers and returns the result as a new rectangle.

```Rect toInt() => new Rect(left.toInt(), top.toInt(), width.toInt(),
height.toInt());
```

#### StringtoString() #

Returns a string representation of this object.

docs inherited from Object
```String toString() {
return '(\$left, \$top, \$width, \$height)';
}
```

#### Rectunion(Rect rect) #

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);
}
```