Struct Hitbox 

pub struct Hitbox {
    pub id: HitboxId,
    pub bounds: Bounds<Pixels>,
    pub content_mask: ContentMask<Pixels>,
    pub behavior: HitboxBehavior,
    pub fragments: Option<Arc<[Bounds<Pixels>]>>,
    pub tags: Vec<SharedString>,
}

A region that receives mouse input for the frame it was inserted in.

Create one with Window::insert_hitbox during prepaint. Hitboxes are how GPUI decides which element is under the pointer: the pointer is tested against the hitboxes of the last frame, and listeners registered during paint are offered the event only when their element’s hitbox was hit. A Hitbox derefs to its bounds, so hitbox.size and hitbox.origin work directly.

See input dispatch for the full order of events and the frame for when hitboxes are created.

Fields

id: HitboxId

The unique id of this hitbox in its frame.

bounds: Bounds<Pixels>

The rectangle this hitbox covers, in window coordinates.

content_mask: ContentMask<Pixels>

The content mask that was active when the hitbox was inserted.

Parts of the hitbox outside this mask, such as an area scrolled out of a container, don’t receive input.

behavior: HitboxBehavior

How this hitbox affects hitboxes behind it.

fragments: Option<Arc<[Bounds<Pixels>]>>

The disjoint rectangles of an inline element, when it spans several lines.

When this is Some, the hitbox covers these rectangles instead of bounds, which is their bounding box.

tags: Vec<SharedString>

Tags attached to this hitbox, which you can read back with HitTestEntry::tags.

Implementations

impl Hitbox

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

Returns whether point lies inside this hitbox’s content mask and its bounds.

This check ignores occlusion, so a point can be inside a hitbox that is covered by another one. Use Hitbox::is_hovered to check what the mouse is actually over.

pub fn is_hovered(&self, window: &Window) -> bool

Returns whether the mouse is over this hitbox, for hover styles and mouse handlers.

This returns false when a hitbox in front of this one blocks the mouse, with InteractiveElement::occlude or InteractiveElement::block_mouse_except_scroll. It also returns false during keyboard input, so keyboard navigation doesn’t show hover styles. Use this for clicks, moves and hover styling. For scroll handling, use Hitbox::should_handle_scroll, because a scrollable container under an overlay should still scroll.

pub fn is_hovered_at(&self, position: Point<Pixels>, window: &Window) -> bool

Checks whether this hitbox would be hovered at position, regardless of the current input modality or mouse position.

pub fn should_handle_scroll(&self, window: &Window) -> bool

Returns whether the mouse is over this hitbox and this hitbox should handle scroll events.

Use it in ScrollWheelEvent handlers. It returns false only when a HitboxBehavior::BlockMouse hitbox is in front of this one, so overlays can block clicks without blocking scrolling underneath.

Methods from Deref<Target = Bounds<Pixels>>

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 });

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);

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 });

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);

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 },
});

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 },
});

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 },
});

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 });

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 });

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 });

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 },
});

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);

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());

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))),
);

Trait Implementations

impl Clone for Hitbox

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hitbox

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

Formats the value using the given formatter.

impl Deref for Hitbox

type Target = Bounds<Pixels>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.