[−][src]Struct embedded_graphics::primitives::rounded_rectangle::RoundedRectangle
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}, style::{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}, style::{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}, style::{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
[src]
pub const fn new(rectangle: Rectangle, corners: CornerRadii) -> Self
[src]
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
[src]
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
[src]
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
[src]
fn clone(&self) -> RoundedRectangle
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl ContainsPoint for RoundedRectangle
[src]
impl Copy for RoundedRectangle
[src]
impl Debug for RoundedRectangle
[src]
impl Dimensions for RoundedRectangle
[src]
fn bounding_box(&self) -> Rectangle
[src]
impl Eq for RoundedRectangle
[src]
impl Hash for RoundedRectangle
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl OffsetOutline for RoundedRectangle
[src]
impl Ord for RoundedRectangle
[src]
fn cmp(&self, other: &RoundedRectangle) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialEq<RoundedRectangle> for RoundedRectangle
[src]
fn eq(&self, other: &RoundedRectangle) -> bool
[src]
fn ne(&self, other: &RoundedRectangle) -> bool
[src]
impl PartialOrd<RoundedRectangle> for RoundedRectangle
[src]
fn partial_cmp(&self, other: &RoundedRectangle) -> Option<Ordering>
[src]
fn lt(&self, other: &RoundedRectangle) -> bool
[src]
fn le(&self, other: &RoundedRectangle) -> bool
[src]
fn gt(&self, other: &RoundedRectangle) -> bool
[src]
fn ge(&self, other: &RoundedRectangle) -> bool
[src]
impl Primitive for RoundedRectangle
[src]
type PointsIter = Points
Iterator over all points inside the primitive.
fn points(&self) -> Self::PointsIter
[src]
fn into_styled<C>(
self,
style: PrimitiveStyle<C>
) -> Styled<Self, PrimitiveStyle<C>> where
C: PixelColor,
Self: Sized,
[src]
self,
style: PrimitiveStyle<C>
) -> Styled<Self, PrimitiveStyle<C>> where
C: PixelColor,
Self: Sized,
impl StructuralEq for RoundedRectangle
[src]
impl StructuralPartialEq for RoundedRectangle
[src]
impl Transform for RoundedRectangle
[src]
fn translate(&self, by: Point) -> Self
[src]
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
[src]
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));
Auto Trait Implementations
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Dimensions for T where
T: OriginDimensions,
[src]
T: OriginDimensions,
fn bounding_box(&Self) -> Rectangle
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<Src, Dst> LosslessTryInto<Dst> for Src where
Dst: LosslessTryFrom<Src>,
[src]
Dst: LosslessTryFrom<Src>,
fn lossless_try_into(self) -> Option<Dst>
[src]
impl<Src, Dst> LossyInto<Dst> for Src where
Dst: LossyFrom<Src>,
[src]
Dst: LossyFrom<Src>,
fn lossy_into(self) -> Dst
[src]
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Scalar for T where
T: PartialEq<T> + Copy + Any + Debug,
[src]
T: PartialEq<T> + Copy + Any + Debug,
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
SS: SubsetOf<SP>,
fn to_subset(&self) -> Option<SS>
fn is_in_subset(&self) -> bool
unsafe fn to_subset_unchecked(&self) -> SS
fn from_subset(element: &SS) -> SP
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,