Struct gsk4::RoundedRect

pub struct RoundedRect(_);

A rectangular region with rounded corners.

Application code should normalize rectangles using normalize(); this function will ensure that the bounds of the rectangle are normalized and ensure that the corner values are positive and the corners do not overlap.

All functions taking a RoundedRect as an argument will internally operate on a normalized copy; all functions returning a RoundedRect will always return a normalized one.

The algorithm used for normalizing corner sizes is described in the CSS specification.

Implementations

impl RoundedRect

pub fn new(
    bounds: Rect,
    top_left: Size,
    top_right: Size,
    bottom_right: Size,
    bottom_left: Size
) -> Self

pub fn from_rect(bounds: Rect, radius: f32) -> Self

pub fn init(
    &mut self,
    bounds: Rect,
    top_left: Size,
    top_right: Size,
    bottom_right: Size,
    bottom_left: Size
)

Initializes the given RoundedRect with the given values.

This function will implicitly normalize the RoundedRect before returning.

bounds

a graphene_rect_t describing the bounds

top_left

the rounding radius of the top left corner

top_right

the rounding radius of the top right corner

bottom_right

the rounding radius of the bottom right corner

bottom_left

the rounding radius of the bottom left corner

Returns

the initialized rectangle

pub fn init_from_rect(&mut self, bounds: Rect, radius: f32)

Initializes self to the given bounds and sets the radius of all four corners to radius.

bounds

a graphene_rect_t

radius

the border radius

Returns

the initialized rectangle

pub fn normalize(&mut self)

Normalizes the passed rectangle.

This function will ensure that the bounds of the rectangle are normalized and ensure that the corner values are positive and the corners do not overlap.

Returns

the normalized rectangle

pub fn offset(&mut self, dx: f32, dy: f32)

Offsets the bound’s origin by dx and dy.

The size and corners of the rectangle are unchanged.

dx

the horizontal offset

dy

the vertical offset

Returns

the offset rectangle

pub fn shrink(&mut self, top: f32, right: f32, bottom: f32, left: f32)

Shrinks (or grows) the given rectangle by moving the 4 sides according to the offsets given.

The corner radii will be changed in a way that tries to keep the center of the corner circle intact. This emulates CSS behavior.

This function also works for growing rectangles if you pass negative values for the top, right, bottom or left.

top

How far to move the top side downwards

right

How far to move the right side to the left

bottom

How far to move the bottom side upwards

left

How far to move the left side to the right

Returns

the resized RoundedRect

pub fn is_rectilinear(&self) -> bool

Checks if all corners of self are right angles and the rectangle covers all of its bounds.

This information can be used to decide if ClipNode::new() or RoundedClipNode::new() should be called.

Returns

true if the rectangle is rectilinear

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

Checks if the given point is inside the rounded rectangle.

point

the point to check

Returns

true if the point is inside the rounded rectangle

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

Checks if the given rect is contained inside the rounded rectangle.

rect

the rectangle to check

Returns

true if the rect is fully contained inside the rounded rectangle

pub fn intersects_rect(&self, rect: Rect) -> bool

Checks if part of the given rect is contained inside the rounded rectangle.

rect

the rectangle to check

Returns

true if the rect intersects with the rounded rectangle

Trait Implementations

impl Clone for RoundedRect

fn clone(&self) -> RoundedRect

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RoundedRect

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

Formats the value using the given formatter.