Struct Rect

pub struct Rect<T> { /* private fields */ }

A generic rectangle structure.

Implementations

impl<T> Rect<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Ord + One + Default + Copy + Clone,

pub fn new(left: T, top: T, width: T, height: T) -> Rect<T>

Returns a new rectangle with the supplied position and dimensions.

pub fn from_points(top_left: Point<T>, bottom_right: Point<T>) -> Rect<T>

Returns a new rectangle with the given top-left and bottom-right points.

pub fn width(&self) -> T

Returns the width of the rectangle.

pub fn height(&self) -> T

Returns the height of the rectangle.

pub fn top_left(&self) -> Point<T>

Returns a copy of the top-left point of the rectangle.

pub fn top(&self) -> T

Returns the y coordinate of the top side of the rectangle.

pub fn left(&self) -> T

Returns the x coordinate of the left side of the rectangle.

pub fn bottom_right(&self) -> Point<T>

Returns a copy of the bottom-right point of the rectangle.

pub fn bottom(&self) -> T

Returns the y coordinate of the bottom side of the rectangle.

pub fn right(&self) -> T

Returns the x coordinate of the right side of the rectangle.

pub fn area(&self) -> T

Returns the area of the rectangle.

pub fn contains(&self, point: Point<T>) -> bool

Returns true if the given point lies within the bounds of the rectangle, and false otherwise.

pub fn intersect(&self, other: &Rect<T>) -> Option<Rect<T>>

If self and other intersect, then the intersection of the two rectangles is returned as a new rectangle, otherwise None is returned.

pub fn split_column_mut(&mut self, col: T) -> Rect<T>

Splits the rectangle at the given column col. The right side of the left part of the resulting split will be at col - 1, and the left side of the right part will be at col. The current rectangle will be modified in-place to be the left part, and the right part will be returned as a new rectangle.

Examples

use geom::Rect;

let mut r = Rect::new(0, 0, 10, 10);
let s = r.split_column_mut(5);

assert_eq!(r.top(), 0);
assert_eq!(r.left(), 0);
assert_eq!(r.bottom(), 9);
assert_eq!(r.right(), 4);

assert_eq!(s.top(), 0);
assert_eq!(s.left(), 5);
assert_eq!(s.bottom(), 9);
assert_eq!(s.right(), 9);

pub fn split_row_mut(&mut self, row: T) -> Rect<T>

Splits the rectangle at the given row row. The bottom side of the top part of the resulting split will be at row - 1, and the top side of the bottom part will be at row. The current rectangle will be modified in-place to be the top part, and the bottom part will be returned as a new rectangle.

Examples

use geom::Rect;

let mut r = Rect::new(0, 0, 10, 10);
let s = r.split_row_mut(5);

assert_eq!(r.top(), 0);
assert_eq!(r.left(), 0);
assert_eq!(r.bottom(), 4);
assert_eq!(r.right(), 9);

assert_eq!(s.top(), 5);
assert_eq!(s.left(), 0);
assert_eq!(s.bottom(), 9);
assert_eq!(s.right(), 9);

pub fn columns(&self) -> Vec<Rect<T>>

Returns a Vec containing a one-width rectangle for each column of the rectangle.

pub fn rows(&self) -> Vec<Rect<T>>

Returns a Vec containing a one-height rectangle for each row of the rectangle.

impl<T> Rect<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Ord + One + Default + Copy + Clone,

pub fn iter(&self) -> Iter<T>

Returns an iterator over each point in the rectangle, going from left-to-right and top-to-bottom.

Trait Implementations

impl<T: Clone> Clone for Rect<T>

fn clone(&self) -> Rect<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Rect<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Hash> Hash for Rect<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> IntoIterator for Rect<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Mul<T, Output = T> + Ord + One + Default + Copy + Clone,

type Item = Point<T>

The type of the elements being iterated over.

type IntoIter = Iter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<T>

Creates an iterator from a value.

impl<T: PartialEq> PartialEq for Rect<T>

fn eq(&self, other: &Rect<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Copy> Copy for Rect<T>

impl<T: Eq> Eq for Rect<T>

impl<T> StructuralPartialEq for Rect<T>