# Struct gsk4::RoundedRect [−][src]

`pub struct RoundedRect(_);`

## Expand description

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

#### pub fn new(

bounds: Rect,

top_left: Size,

top_right: Size,

bottom_right: Size,

bottom_left: Size

) -> Self

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

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

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`

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

## Trait Implementations

## Auto Trait Implementations

### impl RefUnwindSafe for RoundedRect

### impl Send for RoundedRect

### impl Sync for RoundedRect

### impl Unpin for RoundedRect

### impl UnwindSafe for RoundedRect

## Blanket Implementations

Mutably borrows from an owned value. Read more