Struct Bounds 

#[repr(C)]
pub struct Bounds<T: Clone + Debug + Default + PartialEq> {
    pub origin: Point<T>,
    pub size: Size<T>,
}

A rectangle, defined by its top left corner and its size.

The rectangle covers the area from origin to the bottom right corner. Bounds::contains treats the left and top edges as inside and the right and bottom edges as outside, so adjacent bounds don’t overlap. Elements receive their bounds in logical pixels when they are laid out and painted. See layout and style.

Examples

use gpui::{Bounds, Point, Size};

let bounds = Bounds::new(Point { x: 10, y: 20 }, Size { width: 30, height: 40 });
assert_eq!(bounds.right(), 40);
assert_eq!(bounds.bottom(), 60);

Fields

origin: Point<T>

The top left corner of the rectangle.

size: Size<T>

The width and height of the rectangle.

Implementations

impl Bounds<Pixels>

pub fn centered( display_id: Option<DisplayId>, size: Size<Pixels>, cx: &App, ) -> Self

Returns bounds of size centered on a display.

Uses the display with display_id, or the primary display if display_id is None or doesn’t match a connected display. If there is no display at all, the bounds start at (0, 0).

Examples

app.read(|cx| {
    // The test platform has one 1920 by 1080 display.
    let window = Bounds::centered(None, size(px(800.), px(600.)), cx);
    assert_eq!(window, bounds(point(px(560.), px(240.)), size(px(800.), px(600.))));
});

pub fn maximized(display_id: Option<DisplayId>, cx: &App) -> Self

Returns bounds that cover a display.

Uses the display with display_id, or the primary display if display_id is None or doesn’t match a connected display. If there is no display at all, returns 1024 by 768 pixels at (0, 0).

Examples

app.read(|cx| {
    // The test platform has one 1920 by 1080 display.
    let screen = Bounds::maximized(None, cx);
    assert_eq!(screen, bounds(point(px(0.), px(0.)), size(px(1920.), px(1080.))));
});

impl<T> Bounds<T>

where T: Clone + Debug + Default + PartialEq,

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

Creates bounds from an origin and a size. Same as bounds.

Examples

let b = Bounds::new(Point { x: 0, y: 0 }, Size { width: 10, height: 20 });
assert_eq!(b.size.height, 20);

impl<T> Bounds<T>

where T: Sub<Output = T> + Clone + Debug + Default + PartialEq,

pub fn from_corners(top_left: Point<T>, bottom_right: Point<T>) -> Self

Creates bounds from its top left and bottom right corners.

The size is bottom_right - top_left and is not clamped. A bottom_right above or to the left of top_left gives a negative width or height, which Bounds::is_empty reports as empty.

Examples

let top_left = Point { x: 0, y: 0 };
let bottom_right = Point { x: 10, y: 10 };
let bounds = Bounds::from_corners(top_left, bottom_right);

assert_eq!(bounds.origin, top_left);
assert_eq!(bounds.size.width, 10);
assert_eq!(bounds.size.height, 10);

impl<T> Bounds<T>

where T: Sub<Output = T> + Half + Clone + Debug + Default + PartialEq,

pub fn from_anchor_and_size( corner: Anchor, origin: Point<T>, size: Size<T>, ) -> Bounds<T>

Creates bounds of size whose corner sits at origin.

Use this to place a box by one of its corners or edge centers: the box’s top left corner is origin minus the offset of corner within the size.

Examples

let b = Bounds::from_anchor_and_size(
    Anchor::BottomRight,
    point(px(10.), px(10.)),
    size(px(4.), px(2.)),
);
assert_eq!(b.origin, point(px(6.), px(8.)));
assert_eq!(b.bottom_right(), point(px(10.), px(10.)));

impl<T> Bounds<T>

where T: Sub<T, Output = T> + Half + Clone + Debug + Default + PartialEq,

pub fn centered_at(center: Point<T>, size: Size<T>) -> Self

Creates bounds of size centered on center.

Examples

let b = Bounds::centered_at(point(px(50.), px(50.)), size(px(20.), px(10.)));
assert_eq!(b.origin, point(px(40.), px(45.)));
assert_eq!(b.center(), point(px(50.), px(50.)));

impl<T> Bounds<T>

where T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,

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

Returns the midpoint of the top edge.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.top_center(), Point { x: 5, y: 0 });

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

Returns the midpoint of the bottom edge.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.bottom_center(), Point { x: 5, y: 20 });

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

Returns the midpoint of the left edge.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.left_center(), Point { x: 0, y: 10 });

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

Returns the midpoint of the right edge.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.right_center(), Point { x: 10, y: 10 });

impl<T> Bounds<T>

where T: PartialOrd + Add<T, Output = T> + Clone + Debug + Default + PartialEq,

pub fn intersects(&self, other: &Bounds<T>) -> bool

Returns true if this rectangle and other share some area.

Bounds that only touch along an edge don’t intersect.

Examples

let bounds1 = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 10 },
};
let bounds2 = Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 10, height: 10 },
};
let bounds3 = Bounds {
    origin: Point { x: 20, y: 20 },
    size: Size { width: 10, height: 10 },
};

assert_eq!(bounds1.intersects(&bounds2), true);
assert_eq!(bounds1.intersects(&bounds3), false);

impl<T> Bounds<T>

where T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,

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

Returns the center point of the bounds.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.center(), Point { x: 5, y: 10 });

impl<T> Bounds<T>

where T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,

pub fn half_perimeter(&self) -> T

Returns the width plus the height.

The perimeter of the bounds is twice this value.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.half_perimeter(), 30);

impl<T> Bounds<T>

where T: Add<T, Output = T> + Sub<Output = T> + Clone + Debug + Default + PartialEq,

pub fn dilate(&self, amount: T) -> Bounds<T>

Returns the bounds grown by amount on every side.

The origin moves by -amount and the width and height grow by twice amount, so the center stays in place. A negative amount shrinks the bounds. Use Bounds::inset to shrink by a positive amount.

Examples

let bounds = Bounds {
    origin: Point { x: 10, y: 10 },
    size: Size { width: 10, height: 10 },
};
assert_eq!(bounds.dilate(5), Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 20, height: 20 },
});

pub fn extend(&self, amount: Edges<T>) -> Bounds<T>

Returns the bounds grown by a different amount on each side.

Each side of amount moves the matching edge outward: top grows upward, right grows to the right, and so on.

Examples

let bounds = Bounds {
    origin: Point { x: 10, y: 10 },
    size: Size { width: 10, height: 10 },
};
let amount = Edges { top: 1, right: 2, bottom: 3, left: 4 };
assert_eq!(bounds.extend(amount), Bounds {
    origin: Point { x: 6, y: 9 },
    size: Size { width: 16, height: 14 },
});

impl<T> Bounds<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Neg<Output = T> + Clone + Debug + Default + PartialEq,

pub fn inset(&self, amount: T) -> Self

Returns the bounds shrunk by amount on every side.

Same as Bounds::dilate with amount negated.

Examples

let bounds = Bounds {
    origin: Point { x: 0.0, y: 0.0 },
    size: Size { width: 10.0, height: 10.0 },
};
assert_eq!(bounds.inset(2.0), Bounds {
    origin: Point { x: 2.0, y: 2.0 },
    size: Size { width: 6.0, height: 6.0 },
});

impl<T: PartialOrd + Add<T, Output = T> + Sub<Output = T> + Clone + Debug + Default + PartialEq> Bounds<T>

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

Returns the area that this rectangle and other share.

If the bounds don’t overlap, the result has zero width or zero height. Its origin is then the larger of the two origins in each coordinate, which may lie outside both bounds.

Examples

let bounds1 = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 10 },
};
let bounds2 = Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 10, height: 10 },
};
assert_eq!(bounds1.intersect(&bounds2), Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 5, height: 5 },
});

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

Returns the smallest bounds that contain both rectangles.

Examples

let bounds1 = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 10 },
};
let bounds2 = Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 15, height: 15 },
};
assert_eq!(bounds1.union(&bounds2), Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 20, height: 20 },
});

impl<T> Bounds<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + Clone + Debug + Default + PartialEq,

pub fn space_within(&self, outer: &Self) -> Edges<T>

Returns the distance from each edge of this rectangle to the matching edge of outer.

A positive value means this rectangle lies inside outer on that side. A negative value means it extends past outer.

Examples

let outer = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 100, height: 100 },
};
let inner = Bounds {
    origin: Point { x: 10, y: 20 },
    size: Size { width: 30, height: 40 },
};
assert_eq!(inner.space_within(&outer), Edges { top: 20, right: 60, bottom: 40, left: 10 });

impl<T> Bounds<T>

where T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,

pub fn top(&self) -> T

Returns the y coordinate of the top edge.

pub fn bottom(&self) -> T

Returns the y coordinate of the bottom edge, which is outside the bounds.

pub fn left(&self) -> T

Returns the x coordinate of the left edge.

pub fn right(&self) -> T

Returns the x coordinate of the right edge, which is outside the bounds.

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

Returns the top right corner point of the bounds.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.top_right(), Point { x: 10, y: 0 });

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

Returns the bottom right corner point of the bounds.

This point is outside the bounds: Bounds::contains returns false for it.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.bottom_right(), Point { x: 10, y: 20 });

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

Returns the bottom left corner point of the bounds.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.bottom_left(), Point { x: 0, y: 20 });

impl<T> Bounds<T>

where T: Add<T, Output = T> + Half + Clone + Debug + Default + PartialEq,

pub fn corner(&self, corner: Anchor) -> Point<T>

Returns the point at corner on this rectangle.

Accepts the four corners and the four edge midpoints.

Examples

use gpui::{Anchor, Bounds, Point, Size};
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
assert_eq!(bounds.corner(Anchor::BottomLeft), Point { x: 0, y: 20 });

impl<T> Bounds<T>

where T: Add<T, Output = T> + PartialOrd + Clone + Debug + Default + PartialEq,

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

Returns true if point lies inside the bounds.

The left and top edges are inside, and the right and bottom edges are outside. A point at (right, y) or (x, bottom) returns false. With integer coordinates, a rectangle of width 10 at x = 0 contains x = 0 through x = 9 only.

Examples

let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 10 },
};
assert!(bounds.contains(&Point { x: 5, y: 5 }));
assert!(bounds.contains(&Point { x: 0, y: 0 }));
assert!(!bounds.contains(&Point { x: 10, y: 5 }));
assert!(!bounds.contains(&Point { x: 15, y: 15 }));

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

Returns true if this rectangle lies entirely inside other.

Checks that the top left and bottom right corners of this rectangle are inside other, using the rules of Bounds::contains.

Examples

let outer = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 20, height: 20 },
};
let inner = Bounds {
    origin: Point { x: 5, y: 5 },
    size: Size { width: 10, height: 10 },
};
let overlapping = Bounds {
    origin: Point { x: 15, y: 15 },
    size: Size { width: 10, height: 10 },
};

assert!(inner.is_contained_within(&outer));
assert!(!overlapping.is_contained_within(&outer));

pub fn map<U>(&self, f: impl Fn(T) -> U) -> Bounds<U>

where U: Clone + Debug + Default + PartialEq,

Returns bounds with f applied to the origin and the size, converting T to U.

Examples

let bounds = Bounds {
    origin: Point { x: 10.0, y: 10.0 },
    size: Size { width: 10.0, height: 20.0 },
};
let new_bounds = bounds.map(|value| value as f64 * 1.5);

assert_eq!(new_bounds, Bounds {
    origin: Point { x: 15.0, y: 15.0 },
    size: Size { width: 15.0, height: 30.0 },
});

pub fn map_origin(self, f: impl Fn(T) -> T) -> Bounds<T>

Returns bounds with f applied to each coordinate of the origin. The size is unchanged.

Examples

let bounds = Bounds {
    origin: Point { x: 10.0, y: 10.0 },
    size: Size { width: 10.0, height: 20.0 },
};
let new_bounds = bounds.map_origin(|value| value * 1.5);

assert_eq!(new_bounds, Bounds {
    origin: Point { x: 15.0, y: 15.0 },
    size: Size { width: 10.0, height: 20.0 },
});

pub fn map_size(self, f: impl Fn(T) -> T) -> Bounds<T>

Returns bounds with f applied to the width and the height. The origin is unchanged.

Examples

let bounds = Bounds {
    origin: Point { x: 10.0, y: 10.0 },
    size: Size { width: 10.0, height: 20.0 },
};
let new_bounds = bounds.map_size(|value| value * 1.5);

assert_eq!(new_bounds, Bounds {
    origin: Point { x: 10.0, y: 10.0 },
    size: Size { width: 15.0, height: 30.0 },
});

impl<T> Bounds<T>

where T: Add<T, Output = T> + Sub<T, Output = T> + PartialOrd + Clone + Debug + Default + PartialEq,

pub fn localize(&self, point: &Point<T>) -> Option<Point<T>>

Returns point relative to the origin of this rectangle, or None if point is outside.

Use it to turn a window position into a position inside an element. The result follows the rules of Bounds::contains.

Examples

let panel = bounds(point(px(100.), px(50.)), size(px(200.), px(100.)));
assert_eq!(panel.localize(&point(px(110.), px(60.))), Some(point(px(10.), px(10.))));
assert_eq!(panel.localize(&point(px(10.), px(10.))), None);

impl<T: PartialOrd + Clone + Debug + Default + PartialEq> Bounds<T>

pub fn is_empty(&self) -> bool

Returns true if the width or the height is zero or less.

Examples

let empty = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 0 },
};
assert!(empty.is_empty());

impl Bounds<Pixels>

pub fn scale(&self, factor: f32) -> Bounds<ScaledPixels>

Multiplies the origin and the size by factor, producing ScaledPixels.

Pass the display’s scale factor to convert logical bounds into the scaled space. The values aren’t rounded: use Bounds::to_device_pixels to get whole device pixels.

Examples

let bounds = Bounds {
    origin: Point { x: Pixels::from(10.0), y: Pixels::from(20.0) },
    size: Size { width: Pixels::from(30.0), height: Pixels::from(40.0) },
};
let scaled_bounds = bounds.scale(2.0);
assert_eq!(scaled_bounds, Bounds {
    origin: Point {
        x: ScaledPixels::from(20.0),
        y: ScaledPixels::from(40.0),
    },
    size: Size {
        width: ScaledPixels::from(60.0),
        height: ScaledPixels::from(80.0)
    },
});

pub fn to_device_pixels(self, factor: f32) -> Bounds<DevicePixels>

Converts these logical bounds to device pixels.

Multiplies each coordinate and size by factor, rounding each to the nearest whole device pixel. The origin and the size are rounded separately, so the bottom right corner can differ by one pixel from rounding the corner directly.

Examples

let logical = bounds(point(px(10.), px(20.)), size(px(30.), px(40.)));
assert_eq!(
    logical.to_device_pixels(1.5),
    bounds(point(DevicePixels(15), DevicePixels(30)), size(DevicePixels(45), DevicePixels(60))),
);

impl Bounds<DevicePixels>

pub fn to_pixels(self, scale_factor: f32) -> Bounds<Pixels>

Converts these device pixel bounds to logical pixels by dividing by scale_factor.

Examples

let device = bounds(point(DevicePixels(200), DevicePixels(100)), size(DevicePixels(400), DevicePixels(300)));
assert_eq!(device.to_pixels(2.), bounds(point(px(100.), px(50.)), size(px(200.), px(150.))));

Trait Implementations

impl<T> Add<Point<T>> for Bounds<T>

where T: Add<T, Output = T> + Clone + Debug + Default + PartialEq,

type Output = Bounds<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Clone + Clone + Debug + Default + PartialEq> Clone for Bounds<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Clone + Debug + Default + PartialEq> Copy for Bounds<T>

impl<T: Debug + Clone + Debug + Default + PartialEq> Debug for Bounds<T>

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

Formats the value using the given formatter.

impl<T: Default + Clone + Debug + Default + PartialEq> Default for Bounds<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Bounds<T>

where T: Deserialize<'de> + Clone + Debug + Default + PartialEq,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone + Debug + Default + PartialEq + Display + Add<T, Output = T>> Display for Bounds<T>

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

Formats the value using the given formatter.

impl<T, S> Div<S> for Bounds<T>

where Size<T>: Div<S, Output = Size<T>>, T: Div<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

type Output = Bounds<T>

The resulting type after applying the / operator.

fn div(self, rhs: S) -> Self

Performs the / operation.

impl<T: Eq + Clone + Debug + Default + PartialEq> Eq for Bounds<T>

impl<T: Clone + Debug + Default + PartialEq> From<BoundsRefinement<T>> for Bounds<T>

where Option<Point<T>>: Clone, Option<Size<T>>: Clone,

fn from(value: BoundsRefinement<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + Clone + Debug + Default + PartialEq> Hash for Bounds<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: IsZero + Clone + Debug + Default + PartialEq> IsZero for Bounds<T>

fn is_zero(&self) -> bool

Returns true if this value is zero.

impl<T: Lerp + Clone + Debug + Default + PartialEq> Lerp for Bounds<T>

fn lerp(&self, to: &Self, delta: f32) -> Self

Returns the value delta of the way from self to to.

impl<T, Rhs> Mul<Rhs> for Bounds<T>

where T: Mul<Rhs, Output = Rhs> + Clone + Debug + Default + PartialEq, Point<T>: Mul<Rhs, Output = Point<Rhs>>, Rhs: Clone + Debug + Default + PartialEq,

type Output = Bounds<Rhs>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<T, S> MulAssign<S> for Bounds<T>

where T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<T: PartialEq + Clone + Debug + Default + PartialEq> PartialEq for Bounds<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: Clone + Debug + Default + PartialEq> Refineable for Bounds<T>

where Option<Point<T>>: Clone, Option<Size<T>>: Clone,

type Refinement = BoundsRefinement<T>

fn refine(&mut self, refinement: &Self::Refinement)

Applies the given refinement to this instance, modifying it in place.

fn refined(self, refinement: Self::Refinement) -> Self

Returns a new instance with the refinement applied, equivalent to cloning self and calling refine on it.

fn is_superset_of(&self, refinement: &Self::Refinement) -> bool

Returns true if this instance would contain all values from the refinement.

fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement

Returns a refinement that represents the difference between this instance and the given refinement.

fn from_cascade(cascade: &Cascade<Self>) -> Self

where Self: Sized + Default,

Creates an instance from a cascade by merging all refinements atop the default value.

impl<T> Serialize for Bounds<T>

where T: Serialize + Clone + Debug + Default + PartialEq,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq + Clone + Debug + Default + PartialEq> StructuralPartialEq for Bounds<T>

impl<T> Sub<Point<T>> for Bounds<T>

where T: Sub<T, Output = T> + Clone + Debug + Default + PartialEq,

type Output = Bounds<T>

The resulting type after applying the - operator.

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

Performs the - operation.