Struct embedded_graphics::primitives::rounded_rectangle::RoundedRectangle

pub struct RoundedRectangle {
    pub rectangle: Rectangle,
    pub corners: CornerRadii,
}

Rounded rectangle primitive.

Creates a rectangle with rounded corners. Corners can be circular or elliptical in shape, and each corner may have a separate radius applied to it. To create a rounded rectangle with the same radius for each corner, use the with_equal_corners method.

Rounded rectangles with different radii for each corner can be created by passing a CornerRadii configuration struct to the new method.

Overlapping corners

It is possible to create a RoundedRectangle with corner radii too large to be contained within its edges. When this happens, the corner radii will be confined to fit within the rounded rectangle before use by other parts of embedded-graphics.

This is similar but not identical to how the CSS specification works as it relies on floating point calculations.

Examples

Create a uniform rounded rectangle

This example creates a rounded rectangle 50px wide by 60px tall. Using with_equal_corners, all corners are given the same 10px circular radius. The rectangle is drawn using a solid green fill with a 5px red stroke.

use embedded_graphics::{
    pixelcolor::Rgb565,
    prelude::*,
    primitives::{Rectangle, RoundedRectangle, PrimitiveStyle, PrimitiveStyleBuilder},
};

let style = PrimitiveStyleBuilder::new()
    .stroke_width(5)
    .stroke_color(Rgb565::RED)
    .fill_color(Rgb565::GREEN)
    .build();

RoundedRectangle::with_equal_corners(
    Rectangle::new(Point::new(5, 5), Size::new(40, 50)),
    Size::new(10, 10),
)
.into_styled(style)
.draw(&mut display)?;

Different corner radii

This example creates a rounded rectangle 50px wide by 60px tall. Each corner is given a distinct radius in the x and y direction by creating a CornerRadii object and passing that to RoundedRectangle::new.

use embedded_graphics::{
    pixelcolor::Rgb565,
    prelude::*,
    primitives::{CornerRadiiBuilder, Rectangle, RoundedRectangle, PrimitiveStyle, PrimitiveStyleBuilder},
};

let style = PrimitiveStyleBuilder::new()
    .stroke_width(5)
    .stroke_color(Rgb565::RED)
    .fill_color(Rgb565::GREEN)
    .build();

let radii = CornerRadiiBuilder::new()
    .top_left(Size::new(5, 6))
    .top_right(Size::new(7, 8))
    .bottom_right(Size::new(9, 10))
    .bottom_left(Size::new(11, 12))
    .build();

RoundedRectangle::new(Rectangle::new(Point::new(5, 5), Size::new(40, 50)), radii)
    .into_styled(style)
    .draw(&mut display)?;

Using CornerRadiiBuilder

This example creates a rounded rectangle 50px wide by 60px tall. Corner radii are set using the CornerRadiiBuilder builder.

use embedded_graphics::{
    pixelcolor::Rgb565,
    prelude::*,
    primitives::{CornerRadii, CornerRadiiBuilder, Rectangle, RoundedRectangle, PrimitiveStyle, PrimitiveStyleBuilder},
};

let style = PrimitiveStyleBuilder::new()
    .stroke_width(5)
    .stroke_color(Rgb565::RED)
    .fill_color(Rgb565::GREEN)
    .build();

let radii = CornerRadiiBuilder::new()
    // Set the top left and top right corner radii to 10 x 20px
    .top(Size::new(10, 20))
    // Set the bottom right corner radius to 5 x 8px
    .bottom_right(Size::new(5, 8))
    .build();

RoundedRectangle::new(Rectangle::new(Point::new(5, 5), Size::new(40, 50)), radii)
    .into_styled(style)
    .draw(&mut display)?;

Fields

rectangle: Rectangle

The base rectangle

corners: CornerRadii

The radius of each corner

Implementations

impl RoundedRectangle

pub const fn new(rectangle: Rectangle, corners: CornerRadii) -> Self

Creates a new rounded rectangle with the given corner radii.

The size and position of the rounded rectangle is determined by the given base rectangle.

pub const fn with_equal_corners( rectangle: Rectangle, corner_radius: Size ) -> Self

Creates a new rounded rectangle with equal corner radius for all corners.

The size and position of the rounded rectangle is determined by the given base rectangle.

pub fn confine_radii(&self) -> Self

Return the rounded rectangle with confined corner radii.

This method will return a rounded rectangle of the same width and height, but with all corner radii confined to fit within its base rectangle.

Calling this method is not necessary when using operations provided by embedded-graphics (.into_styled(), .contains(), etc) as these confine the corner radii internally.

Examples

Confine corner radii that are too large

This example creates a rounded rectangle 50px x 60px in size. Each corner is set to an equal radius of 40px x 40px. Each edge of the rectangle would thus need to be at least 80px long to contain all corner radii completely. By using confine_radii, the corner radii are reduced to 25px x 25px so that they fit within the 50px x 60px base rectangle.

use embedded_graphics::{
    geometry::{Point, Size},
    primitives::{CornerRadii, CornerRadiiBuilder, Rectangle, RoundedRectangle},
};

let radii = CornerRadiiBuilder::new().all(Size::new(40, 40)).build();

let base_rectangle = Rectangle::new(Point::zero(), Size::new(50, 60));

let rounded_rectangle = RoundedRectangle::new(base_rectangle, radii);

let confined = rounded_rectangle.confine_radii();

assert_eq!(
    confined.corners,
    CornerRadii {
        top_left: Size::new(25, 25),
        top_right: Size::new(25, 25),
        bottom_right: Size::new(25, 25),
        bottom_left: Size::new(25, 25),
    }
);

Trait Implementations

impl Clone for RoundedRectangle

fn clone(&self) -> RoundedRectangle

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContainsPoint for RoundedRectangle

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

Returns true if the given point is inside the shape.

impl Debug for RoundedRectangle

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

Formats the value using the given formatter.

impl Dimensions for RoundedRectangle

fn bounding_box(&self) -> Rectangle

Returns the bounding box.

impl Format for RoundedRectangle

fn format(&self, f: Formatter<'_>)

Writes the defmt representation of self to fmt.

impl Hash for RoundedRectangle

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 OffsetOutline for RoundedRectangle

fn offset(&self, offset: i32) -> Self

Offsets the outline of the shape.

impl Ord for RoundedRectangle

fn cmp(&self, other: &RoundedRectangle) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<RoundedRectangle> for RoundedRectangle

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<RoundedRectangle> for RoundedRectangle

fn partial_cmp(&self, other: &RoundedRectangle) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PointsIter for RoundedRectangle

type Iter = Points

Iterator over all points inside the primitive.

fn points(&self) -> Self::Iter

Returns an iterator over all points inside the primitive.

impl Primitive for RoundedRectangle

fn into_styled<S>(self, style: S) -> Styled<Self, S>where Self: Sized,

Converts this primitive into a Styled.

impl<C: PixelColor> StyledDimensions<PrimitiveStyle<C>> for RoundedRectangle

fn styled_bounding_box(&self, style: &PrimitiveStyle<C>) -> Rectangle

Returns the bounding box using the given style.

impl<C: PixelColor> StyledDrawable<PrimitiveStyle<C>> for RoundedRectangle

type Color = C

Color type.

type Output = ()

Output type.

fn draw_styled<D>( &self, style: &PrimitiveStyle<C>, target: &mut D ) -> Result<Self::Output, D::Error>where D: DrawTarget<Color = C>,

Draws the primitive using the given style.

impl Transform for RoundedRectangle

fn translate(&self, by: Point) -> Self

Translate the rounded rectangle from its current position to a new position by (x, y) pixels, returning a new RoundedRectangle. For a mutating transform, see translate_mut.

use embedded_graphics::primitives::{Rectangle, RoundedRectangle};

let original = RoundedRectangle::with_equal_corners(
    Rectangle::new(Point::new(5, 10), Size::new(20, 30)),
    Size::new(10, 15),
);
let moved = original.translate(Point::new(10, 12));

assert_eq!(original.bounding_box().top_left, Point::new(5, 10));
assert_eq!(moved.bounding_box().top_left, Point::new(15, 22));

fn translate_mut(&mut self, by: Point) -> &mut Self

Translate the rounded rectangle from its current position to a new position by (x, y) pixels.

use embedded_graphics::primitives::{Rectangle, RoundedRectangle};

let mut shape = RoundedRectangle::with_equal_corners(
    Rectangle::new(Point::new(5, 10), Size::new(20, 30)),
    Size::new(10, 15),
);

shape.translate_mut(Point::new(10, 12));

assert_eq!(shape.bounding_box().top_left, Point::new(15, 22));

impl Copy for RoundedRectangle

impl Eq for RoundedRectangle

impl StructuralEq for RoundedRectangle

impl StructuralPartialEq for RoundedRectangle