Struct embedded_graphics::primitives::Styled

pub struct Styled<T, S> {
    pub primitive: T,
    pub style: S,
}

Styled.

Fields

primitive: T

Primitive.

style: S

Style.

Implementations

impl<T, S> Styled<T, S>

pub const fn new(primitive: T, style: S) -> Self

Creates a styled.

impl<T: OffsetOutline, C: PixelColor> Styled<T, PrimitiveStyle<C>>

pub fn fill_area(&self) -> T

Returns the fill area.

The returned primitive coincides with the area that would be filled by calling draw on this styled primitive.

Examples

use embedded_graphics::{
    pixelcolor::Rgb888,
    prelude::*,
    primitives::{Circle, PrimitiveStyleBuilder},
};

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

let center = Point::new(10, 20);
let diameter = 10;

let circle = Circle::with_center(center, diameter).into_styled(style);

assert_eq!(circle.fill_area(), Circle::with_center(center, diameter - style.stroke_width));

pub fn stroke_area(&self) -> T

Returns the stroke area.

The outer edge of the returned primitive coincides with the outer edge of the stroke that would be drawn by calling draw on this styled primitive.

Examples

This example tests if a point lies on the stroke. Because the stoke area surrounds the stoke and fill an additional test is required to check that the point is not inside the fill area.

use embedded_graphics::{
    pixelcolor::Rgb888,
    prelude::*,
    primitives::{Circle, PrimitiveStyle},
};

let style = PrimitiveStyle::with_stroke(Rgb888::RED, 6);

let center = Point::new(10, 20);
let diameter = 10;

let circle = Circle::with_center(center, diameter).into_styled(style);

// A point lies on the stroke if it is inside the stroke area but not in the fill area.
let is_on_stroke = |p| circle.stroke_area().contains(p) && !circle.fill_area().contains(p);

assert!(is_on_stroke(center + Size::new(0, diameter / 2)));
assert!(!is_on_stroke(center));

impl<T: StyledPixels<S>, S> Styled<T, S>

pub fn pixels(&self) -> T::Iter

Returns an iterator over the pixels in this styled primitive.

Trait Implementations

impl<T: Clone, S: Clone> Clone for Styled<T, S>

fn clone(&self) -> Styled<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, S: Debug> Debug for Styled<T, S>

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

Formats the value using the given formatter.

impl<T: Default, S: Default> Default for Styled<T, S>

fn default() -> Styled<T, S>

Returns the “default value” for a type.

impl<T: StyledDimensions<S>, S> Dimensions for Styled<T, S>

fn bounding_box(&self) -> Rectangle

Returns the bounding box.

impl<T: StyledDrawable<S>, S> Drawable for Styled<T, S>

type Color = <T as StyledDrawable<S>>::Color

The pixel color type.

type Output = <T as StyledDrawable<S>>::Output

The return type of the draw method.

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

Draw the graphics object using the supplied DrawTarget.

impl<T: Hash, S: Hash> Hash for Styled<T, S>

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<T: Ord, S: Ord> Ord for Styled<T, S>

fn cmp(&self, other: &Styled<T, S>) -> 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<T: PartialEq, S: PartialEq> PartialEq<Styled<T, S>> for Styled<T, S>

fn eq(&self, other: &Styled<T, S>) -> 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<T: PartialOrd, S: PartialOrd> PartialOrd<Styled<T, S>> for Styled<T, S>

fn partial_cmp(&self, other: &Styled<T, S>) -> 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<T: Transform, S: Clone> Transform for Styled<T, S>

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

Move the origin of an object by a given number of (x, y) pixels, returning a new object

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

Move the origin of an object by a given number of (x, y) pixels, mutating the object in place

impl<T: Copy, S: Copy> Copy for Styled<T, S>

impl<T: Eq, S: Eq> Eq for Styled<T, S>

impl<T, S> StructuralEq for Styled<T, S>

impl<T, S> StructuralPartialEq for Styled<T, S>