Struct druid::Rect

pub struct Rect {
    pub x0: f64,
    pub y0: f64,
    pub x1: f64,
    pub y1: f64,
}

A rectangle.

Fields

x0: f64

The minimum x coordinate (left edge).

y0: f64

The minimum y coordinate (top edge in y-down spaces).

x1: f64

The maximum x coordinate (right edge).

y1: f64

The maximum y coordinate (bottom edge in y-down spaces).

Implementations

impl Rect

pub const ZERO: Rect

The empty rectangle at the origin.

pub const fn new(x0: f64, y0: f64, x1: f64, y1: f64) -> Rect

A new rectangle from minimum and maximum coordinates.

pub fn from_points(p0: impl Into<Point>, p1: impl Into<Point>) -> Rect

A new rectangle from two points.

The result will have non-negative width and height.

pub fn from_origin_size(origin: impl Into<Point>, size: impl Into<Size>) -> Rect

A new rectangle from origin and size.

The result will have non-negative width and height.

pub fn from_center_size(center: impl Into<Point>, size: impl Into<Size>) -> Rect

A new rectangle from center and size.

pub fn with_origin(self, origin: impl Into<Point>) -> Rect

Create a new Rect with the same size as self and a new origin.

pub fn with_size(self, size: impl Into<Size>) -> Rect

Create a new Rect with the same origin as self and a new size.

pub fn inset(self, insets: impl Into<Insets>) -> Rect

Create a new Rect by applying the Insets.

This will not preserve negative width and height.

Examples

use kurbo::Rect;
let inset_rect = Rect::new(0., 0., 10., 10.,).inset(2.);
assert_eq!(inset_rect.width(), 14.0);
assert_eq!(inset_rect.x0, -2.0);
assert_eq!(inset_rect.x1, 12.0);

pub fn width(&self) -> f64

The width of the rectangle.

Note: nothing forbids negative width.

pub fn height(&self) -> f64

The height of the rectangle.

Note: nothing forbids negative height.

pub fn min_x(&self) -> f64

Returns the minimum value for the x-coordinate of the rectangle.

pub fn max_x(&self) -> f64

Returns the maximum value for the x-coordinate of the rectangle.

pub fn min_y(&self) -> f64

Returns the minimum value for the y-coordinate of the rectangle.

pub fn max_y(&self) -> f64

Returns the maximum value for the y-coordinate of the rectangle.

pub fn origin(&self) -> Point

The origin of the rectangle.

This is the top left corner in a y-down space and with non-negative width and height.

pub fn size(&self) -> Size

The size of the rectangle.

pub fn area(&self) -> f64

The area of the rectangle.

pub fn center(&self) -> Point

The center point of the rectangle.

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

Returns true if point lies within self.

pub fn abs(&self) -> Rect

Take absolute value of width and height.

The resulting rect has the same extents as the original, but is guaranteed to have non-negative width and height.

pub fn union(&self, other: Rect) -> Rect

The smallest rectangle enclosing two rectangles.

Results are valid only if width and height are non-negative.

pub fn union_pt(&self, pt: Point) -> Rect

Compute the union with one point.

This method includes the perimeter of zero-area rectangles. Thus, a succession of union_pt operations on a series of points yields their enclosing rectangle.

Results are valid only if width and height are non-negative.

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

The intersection of two rectangles.

The result is zero-area if either input has negative width or height. The result always has non-negative width and height.

pub fn inflate(&self, width: f64, height: f64) -> Rect

Expand a rectangle by a constant amount in both directions.

The logic simply applies the amount in each direction. If rectangle area or added dimensions are negative, this could give odd results.

pub fn round(self) -> Rect

Returns a new Rect, with each coordinate value rounded to the nearest integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).round();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -3.0);

pub fn ceil(self) -> Rect

Returns a new Rect, with each coordinate value rounded up to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).ceil();
assert_eq!(rect.x0, 4.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -3.0);

pub fn floor(self) -> Rect

Returns a new Rect, with each coordinate value rounded down to the nearest integer, unless they are already an integer.

Examples

use kurbo::Rect;
let rect = Rect::new(3.3, 3.6, 3.0, -3.1).floor();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 3.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -4.0);

pub fn expand(self) -> Rect

Returns a new Rect, with each coordinate value rounded away from the center of the Rect to the nearest integer, unless they are already an integer. That is to say this function will return the smallest possible Rect with integer coordinates that is a superset of self.

Examples

use kurbo::Rect;

// In positive space
let rect = Rect::new(3.3, 3.6, 5.6, 4.1).expand();
assert_eq!(rect.x0, 3.0);
assert_eq!(rect.y0, 3.0);
assert_eq!(rect.x1, 6.0);
assert_eq!(rect.y1, 5.0);

// In both positive and negative space
let rect = Rect::new(-3.3, -3.6, 5.6, 4.1).expand();
assert_eq!(rect.x0, -4.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, 6.0);
assert_eq!(rect.y1, 5.0);

// In negative space
let rect = Rect::new(-5.6, -4.1, -3.3, -3.6).expand();
assert_eq!(rect.x0, -6.0);
assert_eq!(rect.y0, -5.0);
assert_eq!(rect.x1, -3.0);
assert_eq!(rect.y1, -3.0);

// Inverse orientation
let rect = Rect::new(5.6, -3.6, 3.3, -4.1).expand();
assert_eq!(rect.x0, 6.0);
assert_eq!(rect.y0, -3.0);
assert_eq!(rect.x1, 3.0);
assert_eq!(rect.y1, -5.0);

pub fn trunc(self) -> Rect

Returns a new Rect, with each coordinate value rounded towards the center of the Rect to the nearest integer, unless they are already an integer. That is to say this function will return the biggest possible Rect with integer coordinates that is a subset of self.

Examples

use kurbo::Rect;

// In positive space
let rect = Rect::new(3.3, 3.6, 5.6, 4.1).trunc();
assert_eq!(rect.x0, 4.0);
assert_eq!(rect.y0, 4.0);
assert_eq!(rect.x1, 5.0);
assert_eq!(rect.y1, 4.0);

// In both positive and negative space
let rect = Rect::new(-3.3, -3.6, 5.6, 4.1).trunc();
assert_eq!(rect.x0, -3.0);
assert_eq!(rect.y0, -3.0);
assert_eq!(rect.x1, 5.0);
assert_eq!(rect.y1, 4.0);

// In negative space
let rect = Rect::new(-5.6, -4.1, -3.3, -3.6).trunc();
assert_eq!(rect.x0, -5.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, -4.0);
assert_eq!(rect.y1, -4.0);

// Inverse orientation
let rect = Rect::new(5.6, -3.6, 3.3, -4.1).trunc();
assert_eq!(rect.x0, 5.0);
assert_eq!(rect.y0, -4.0);
assert_eq!(rect.x1, 4.0);
assert_eq!(rect.y1, -4.0);

pub fn to_rounded_rect(self, radius: f64) -> RoundedRect

Creates a new RoundedRect from this Rect and the provided corner radius.

pub fn contained_rect_with_aspect_ratio(&self, aspect_ratio: f64) -> Rect

Returns the largest possible Rect that is fully contained in self with the given aspect_ratio.

The aspect ratio is specified fractionally, as height / width.

The resulting rectangle will be centered if it is smaller than the input rectangle.

For the special case where the aspect ratio is 1.0, the resulting Rect will be square.

Examples

let outer = Rect::new(0.0, 0.0, 10.0, 20.0);
let inner = outer.contained_rect_with_aspect_ratio(1.0);
// The new `Rect` is a square centered at the center of `outer`.
assert_eq!(inner, Rect::new(0.0, 5.0, 10.0, 15.0));

Trait Implementations

impl Add<Insets> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, other: Insets) -> Rect

Performs the + operation.

impl Add<Rect> for Insets

type Output = Rect

The resulting type after applying the + operator.

fn add(self, other: Rect) -> Rect

Performs the + operation.

impl Add<Vec2> for Rect

type Output = Rect

The resulting type after applying the + operator.

fn add(self, v: Vec2) -> Rect

Performs the + operation.

impl Clone for Rect

fn clone(&self) -> Rect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Rect

impl Data for Rect

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

Determine whether two values are the same.

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Rect

Returns the "default value" for a type.

impl Display for Rect

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

Formats the value using the given formatter.

impl From<(Point, Point)> for Rect

fn from(points: (Point, Point)) -> Rect

Performs the conversion.

impl From<(Point, Size)> for Rect

fn from(params: (Point, Size)) -> Rect

Performs the conversion.

impl From<Rect> for Region

fn from(src: Rect) -> Region

Performs the conversion.

impl Into<Value> for Rect

fn into(self) -> Value

Performs the conversion.

impl Mul<Rect> for TranslateScale

type Output = Rect

The resulting type after applying the * operator.

fn mul(self, other: Rect) -> Rect

Performs the * operation.

impl PartialEq<Rect> for Rect

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

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

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

This method tests for !=.

impl Scalable for Rect

fn to_px(&self, scale: &Scale) -> Rect

Converts a Rect from display points into pixels, using the x axis scale factor for x0 and x1 and the y axis scale factor for y0 and y1.

fn to_dp(&self, scale: &Scale) -> Rect

Converts a Rect from pixels into display points, using the x axis scale factor for x0 and x1 and the y axis scale factor for y0 and y1.

impl Shape for Rect

type BezPathIter = RectPathIter

The iterator resulting from to_bez_path.

fn to_bez_path(&self, _tolerance: f64) -> RectPathIter

Convert to a Bézier path, as an iterator over path elements.

fn area(&self) -> f64

Signed area.

fn perimeter(&self, _accuracy: f64) -> f64

Total length of perimeter.

fn winding(&self, pt: Point) -> i32

Note: this function is carefully designed so that if the plane is tiled with rectangles, the winding number will be nonzero for exactly one of them.

fn bounding_box(&self) -> Rect

The smallest rectangle that encloses the shape.

fn as_rect(&self) -> Option<Rect>

If the shape is a rectangle, make it available.

fn into_bez_path(self, tolerance: f64) -> BezPath

Convert into a Bézier path.

fn as_line(&self) -> Option<Line>

If the shape is a line, make it available.

fn as_rounded_rect(&self) -> Option<RoundedRect>

If the shape is a rounded rectangle, make it available.

fn as_circle(&self) -> Option<Circle>

If the shape is a circle, make it available.

fn as_path_slice(&self) -> Option<&[PathEl]>

If the shape is stored as a slice of path elements, make that available.

impl StructuralPartialEq for Rect

impl Sub<Insets> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, other: Insets) -> Rect

Performs the - operation.

impl Sub<Rect> for Rect

type Output = Insets

The resulting type after applying the - operator.

fn sub(self, other: Rect) -> Insets

Performs the - operation.

impl Sub<Rect> for Insets

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, other: Rect) -> Rect

Performs the - operation.

impl Sub<Vec2> for Rect

type Output = Rect

The resulting type after applying the - operator.

fn sub(self, v: Vec2) -> Rect

Performs the - operation.

impl<'a> ValueType<'a> for Rect

type Owned = Rect

The corresponding owned type.

fn try_from_value(value: &Value) -> Result<Self, ValueTypeError>

Attempt to convert the generic Value into this type.