Struct figures::Rect

pub struct Rect<Unit> {
    pub origin: Point<Unit>,
    pub size: Size<Unit>,
}

A 2d area expressed as an origin (Point) and a Size.

Fields

origin: Point<Unit>

The origin of the rectangle

size: Size<Unit>

The size of the rectangle.

Implementations

impl<Unit> Rect<Unit>

pub const fn new(origin: Point<Unit>, size: Size<Unit>) -> Self

Returns a new rectangle.

pub fn from_extents(p1: Point<Unit>, p2: Point<Unit>) -> Self

where Unit: Unit,

Returns a new rectangle using the given points to form the top-left and bottom-right of the rectangle.

The order of the parameters does not matter. The minimum values will form the top-left and the maximum values will form the bottom-right.

pub fn expand_rounded(self) -> Self

where Unit: Round + Unit,

Expands this rect to the nearest whole number.

This function will never return a smaller rectangle.

pub fn map<NewUnit>(self, map: impl FnMut(Unit) -> NewUnit) -> Rect<NewUnit>

Maps each component to map and returns a new value with the mapped components.

pub fn inset(self, amount: impl Into<Unit>) -> Self

where Unit: Add<Unit, Output = Unit> + AddAssign<Unit> + SubAssign<Unit> + Copy,

Returns a rectangle that has been inset by amount on all sides.

pub fn cast<NewUnit>(self) -> Rect<NewUnit>

where NewUnit: From<Unit>,

Converts the contents of this point to NewUnit using From.

pub fn try_cast<NewUnit>(self) -> Result<Rect<NewUnit>, NewUnit::Error>

where NewUnit: TryFrom<Unit>,

Converts the contents of this rect to NewUnit using TryFrom.

Errors

Returns <NewUnit as TryFrom>::Error when the inner type cannot be converted. For this crate’s types, this genenerally will be

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

where Unit: Unit,

Returns true if this rect contains point.

pub fn intersects(&self, other: &Self) -> bool

where Unit: Add<Output = Unit> + Ord + Copy,

Returns true if the areas of self and other overlap.

This function does not return true if the edges touch but do not overlap.

use figures::{Point, Rect, Size};

let a: Rect<i32> = Rect::new(Point::new(1, 1), Size::new(2, 2));
let b = Rect::new(Point::new(2, 2), Size::new(1, 1));
assert!(a.intersects(&b));
let c = Rect::new(Point::new(3, 1), Size::new(1, 1));
assert!(!a.intersects(&c));

pub fn intersection(&self, other: &Self) -> Option<Rect<Unit>>

where Unit: Unit,

Returns the overlapping rectangle of self and other. If the rectangles do not overlap, None will be returned.

use figures::{Point, Rect, Size};

let a: Rect<i32> = Rect::new(Point::new(1, 1), Size::new(3, 3));
let b = Rect::new(Point::new(2, 2), Size::new(3, 3));
assert_eq!(
    a.intersection(&b),
    Some(Rect::new(Point::new(2, 2), Size::new(2, 2)))
);
let c = Rect::new(Point::new(4, 1), Size::new(1, 1));
assert_eq!(a.intersection(&c), None);

pub fn extent(&self) -> Point<Unit>

where Unit: Unit,

Returns the non-origin point.

impl<Unit> Rect<Unit>

where Unit: Add<Output = Unit> + Ord + Copy,

pub fn extents(&self) -> (Point<Unit>, Point<Unit>)

Returns the top-left and bottom-right points of this rectangle.

The first point returned will always be the top-right point, even if the size of the rectangle is negative.

Trait Implementations

impl<Unit> Add<Point<Unit>> for Rect<Unit>

where Unit: Add<Output = Unit>,

type Output = Rect<Unit>

The resulting type after applying the + operator.

fn add(self, rhs: Point<Unit>) -> Self::Output

Performs the + operation.

impl<Unit: Clone> Clone for Rect<Unit>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Unit: Debug> Debug for Rect<Unit>

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

Formats the value using the given formatter.

impl<Unit> Default for Rect<Unit>

where Unit: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Unit> From<Size<Unit>> for Rect<Unit>

where Unit: Default,

fn from(size: Size<Unit>) -> Self

Converts to this type from the input type.

impl<Unit: Hash> Hash for Rect<Unit>

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<Unit> IntoSigned for Rect<Unit>

where Unit: IntoSigned,

type Signed = Rect<<Unit as IntoSigned>::Signed>

The signed representation of this type.

fn into_signed(self) -> Self::Signed

Returns this value as an unsigned value. Values that are larger than can fit in an i32 are converted to i32::MAX.

impl<Unit> IntoUnsigned for Rect<Unit>

where Unit: IntoUnsigned,

type Unsigned = Rect<<Unit as IntoUnsigned>::Unsigned>

The unsigned representation of this type.

fn into_unsigned(self) -> Self::Unsigned

Returns this value as an unsigned value. Negative values will be converted to 0.

impl<Unit: PartialEq> PartialEq for Rect<Unit>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<Unit> Ranged for Rect<Unit>

where Unit: Ranged,

const MAX: Self = _

The maximum value for this type.

const MIN: Self = _

The minimum value for this type.

impl<Unit> Sub<Point<Unit>> for Rect<Unit>

where Unit: Sub<Output = Unit>,

type Output = Rect<Unit>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<Unit>) -> Self::Output

Performs the - operation.

impl<Unit> Zero for Rect<Unit>

where Unit: Zero,

const ZERO: Self = _

The zero value for this type.

fn is_zero(&self) -> bool

Returns true if self represents 0.

impl<Unit: Copy> Copy for Rect<Unit>

impl<Unit: Eq> Eq for Rect<Unit>

impl<Unit> StructuralPartialEq for Rect<Unit>