Struct Rect 

pub struct Rect {
    pub x: f32,
    pub y: f32,
    pub w: f32,
    pub h: f32,
}

A rectangle in space, represented with f32 coordinates.

Fields

x: f32

y: f32

w: f32

h: f32

Implementations

impl Rect

pub fn new(x: f32, y: f32, w: f32, h: f32) -> Self

Create a new rectangle with the given dimensions and position.

pub fn new_checked(x: f32, y: f32, w: f32, h: f32) -> Option<Self>

Identical to new, but returns None if either the width or height is negative.

pub fn is_valid(&self) -> bool

Returns false if either the width or height is negative. Otherwise, returns true.

pub fn is_empty(&self) -> bool

Returns true if the rectangle has no width or no height.

pub fn is_zero(&self) -> bool

Returns true if the rectangle has no width and no height.

pub fn shrink_begin_x(self, amount: f32) -> Self

Shrink the width of the rectangle by the given amount toward the left.

pub fn shrink_end_x(self, amount: f32) -> Self

Shrink the width of the rectangle by the given amount toward the right.

pub fn shrink_center_x(self, amount: f32) -> Self

Shrink the width of the rectangle by the given amount toward the center.

pub fn shrink_begin_y(self, amount: f32) -> Self

Shrink the height of the rectangle by the given amount toward the top.

pub fn shrink_end_y(self, amount: f32) -> Self

Shrink the height of the rectangle by the given amount toward the bottom.

pub fn shrink_center_y(self, amount: f32) -> Self

Shrink the height of the rectangle by the given amount toward the middle.

pub fn align(self, align: (Alignment, Alignment), min: (f32, f32)) -> Self

Create a contained rectangle aligned within self.

Example:

use layuit::{Rect, Alignment};

let rect = Rect::new(0.0, 0.0, 100.0, 100.0);

let contained_center = rect.align((Alignment::Center, Alignment::Center), (50.0, 50.0));
assert_eq!(contained_center, Rect::new(25.0, 25.0, 50.0, 50.0));

let contained_top_right = rect.align((Alignment::End, Alignment::Begin), (50.0, 50.0));
assert_eq!(contained_top_right, Rect::new(50.0, 0.0, 50.0, 50.0));

let contained_equal = rect.align((Alignment::Full, Alignment::Full), (50.0, 50.0));
assert_eq!(contained_equal, Rect::new(0.0, 0.0, 100.0, 100.0));

pub fn anchor(self, anchor: (Anchor, Anchor), size: (f32, f32)) -> Self

Similar to align, but based on Anchor instead of Alignment.

pub fn intersect(self, other: Self) -> Self

Returns the area included by both self and other.

Trait Implementations

impl Clone for Rect

fn clone(&self) -> Rect

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Rect

Returns the “default value” for a type.

impl PartialEq for Rect

fn eq(&self, other: &Rect) -> 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 Copy for Rect

impl StructuralPartialEq for Rect