Struct Rect

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

Expand description

Tracks scroll events on Scroll views for testing.

This helper records viewport changes from scroll events, making it easy to verify scroll behavior in tests.

§Example

let scroll_tracker = ScrollTracker::new();

let content = Empty::new().style(|s| s.size(200.0, 400.0));
let scroll_view = scroll_tracker.track(Scroll::new(content));

let mut harness = HeadlessHarness::new_with_size(scroll_view, 100.0, 100.0);
harness.scroll_vertical(50.0, 50.0, 50.0);

let viewport = scroll_tracker.last_viewport().unwrap();
assert!(viewport.y0 > 0.0, "Should have scrolled down");

Kurbo types re-exported for convenience. 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 const fn width(&self) -> f64

The width of the rectangle.

Note: nothing forbids negative width.

pub const 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 const 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 const fn size(&self) -> Size

The size of the rectangle.

pub const fn area(&self) -> f64

The area of the rectangle.

pub const fn is_zero_area(&self) -> bool

Whether this rectangle has zero area.

pub const fn center(&self) -> Point

The center point of the rectangle.

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

Returns true if point lies within self.

pub const 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 const 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: impl Into<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 const 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.

If you want to determine whether two rectangles intersect, use the overlaps method instead.

pub const fn overlaps(&self, other: Rect) -> bool

Determines whether this rectangle overlaps with another in any way.

Note that the edge of the rectangle is considered to be part of itself, meaning that two rectangles that share an edge are considered to overlap.

Returns true if the rectangles overlap, false otherwise.

If you want to compute the intersection of two rectangles, use the intersect method instead.

§Examples

use kurbo::Rect;

let rect1 = Rect::new(0.0, 0.0, 10.0, 10.0);
let rect2 = Rect::new(5.0, 5.0, 15.0, 15.0);
assert!(rect1.overlaps(rect2));

let rect1 = Rect::new(0.0, 0.0, 10.0, 10.0);
let rect2 = Rect::new(10.0, 0.0, 20.0, 10.0);
assert!(rect1.overlaps(rect2));

pub const fn contains_rect(&self, other: Rect) -> bool

Returns whether this rectangle contains another rectangle.

A rectangle is considered to contain another rectangle if the other rectangle is fully enclosed within the bounds of this rectangle.

§Examples

use kurbo::Rect;

let rect1 = Rect::new(0.0, 0.0, 10.0, 10.0);
let rect2 = Rect::new(2.0, 2.0, 4.0, 4.0);
assert!(rect1.contains_rect(rect2));

Two equal rectangles are considered to contain each other.

use kurbo::Rect;

let rect = Rect::new(0.0, 0.0, 10.0, 10.0);
assert!(rect.contains_rect(rect));

pub const 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 const fn scale_from_origin(self, factor: f64) -> Rect

Scales the Rect by factor with respect to the origin (the point (0, 0)).

§Examples

use kurbo::Rect;

let rect = Rect::new(2., 2., 4., 6.).scale_from_origin(2.);
assert_eq!(rect.x0, 4.);
assert_eq!(rect.x1, 8.);

pub fn to_rounded_rect(self, radii: impl Into<RoundedRectRadii>) -> RoundedRect

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

pub fn to_ellipse(self) -> Ellipse

Returns the [Ellipse] that is bounded by this Rect.

pub const fn aspect_ratio_width(self) -> f64

The aspect ratio of this Rect.

This is defined as the width divided by the height. It measures the “squareness” of the rectangle (a value of 1 is square).

If the height is 0, the output will be sign(self.width) * infinity. If the width and height are both 0, then the output will be NaN.

pub fn aspect_ratio(&self) -> f64

👎Deprecated since 0.12.0:

You should use aspect_ratio_width instead, as this method returns a potentially unexpected value.

The inverse of the aspect ratio of this Rect.

Aspect ratios are usually defined as the ratio of the width to the height, but this method incorrectly returns the ratio of height to width. You should generally prefer aspect_ratio_width.

If the width is 0 the output will be sign(y1 - y0) * infinity.

If the width and height are both 0, the result will be NaN.

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

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

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

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

§Examples

let outer = Rect::new(0.0, 0.0, 10.0, 20.0);
let inner = outer.inscribed_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));

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

👎Deprecated since 0.12.0:

You should use inscribed_rect_with_aspect_ratio instead, as this method expects an unusually defined parameter.

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

Aspect ratios are usually defined as the ratio of the width to the height, but this method accepts an aspect ratio specified fractionally as height / width. You should generally prefer inscribed_rect_with_aspect_ratio, which takes a “normal” aspect ratio.

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