Struct embedded_graphics::mock_display::MockDisplay

pub struct MockDisplay<C>
where
    C: PixelColor,
{ /* private fields */ }

Mock display struct

See the module documentation for usage and examples.

Implementations

impl<C> MockDisplay<C>

where C: PixelColor,

pub fn new() -> Self

Creates a new empty mock display.

pub fn from_points<I>(points: I, color: C) -> Self

where I: IntoIterator<Item = Point>,

Create a mock display from an iterator of Points.

This method can be used to create a mock display from the iterator produced by the PointsIter::points method.

Panics

This method will panic if the iterator returns a point that is outside the display bounding box.

Examples

use embedded_graphics::{prelude::*, pixelcolor::BinaryColor, primitives::Circle, mock_display::MockDisplay};

let circle = Circle::new(Point::new(0, 0), 4);

let mut display = MockDisplay::from_points(circle.points(), BinaryColor::On);

display.assert_pattern(&[
    " ## ",
    "####",
    "####",
    " ## ",
]);

pub fn set_allow_out_of_bounds_drawing(&mut self, value: bool)

Sets if out of bounds drawing is allowed.

If this is set to true the bounds checks during drawing are disabled.

pub fn set_allow_overdraw(&mut self, value: bool)

Sets if overdrawing is allowed.

If this is set to true the overdrawing is allowed.

pub fn get_pixel(&self, p: Point) -> Option<C>

Returns the color of a pixel.

pub fn set_pixel(&mut self, point: Point, color: Option<C>)

Changes the value of a pixel without bounds checking.

Panics

This method will panic if point is outside the display bounding box.

pub fn set_pixels( &mut self, points: impl IntoIterator<Item = Point>, color: Option<C>, )

Sets the points in an iterator to the given color.

Panics

This method will panic if the iterator returns points outside the display bounding box.

pub fn affected_area(&self) -> Rectangle

Returns the area that was affected by drawing operations.

pub fn draw_pixel(&mut self, point: Point, color: C)

Changes the color of a pixel.

Panics

If out of bounds draw checking is enabled (default), this method will panic if the point lies outside the display area. This behavior can be disabled by calling set_allow_out_of_bounds_drawing(true).

Similarly, overdraw is checked by default and will panic if a point is drawn to the same coordinate twice. This behavior can be disabled by calling set_allow_overdraw(true).

pub fn swap_xy(&self) -> MockDisplay<C>

Returns a copy of with the content mirrored by swapping x and y.

Examples

use embedded_graphics::{mock_display::MockDisplay, pixelcolor::BinaryColor};

let display: MockDisplay<BinaryColor> = MockDisplay::from_pattern(&[
    "#### ####",
    "#    #   ",
    "###  # ##",
    "#    #  #",
    "#### ####",
]);

let mirrored = display.swap_xy();
mirrored.assert_pattern(&[
    "#####",
    "# # #",
    "# # #",
    "#   #",
    "     ",
    "#####",
    "#   #",
    "# # #",
    "# ###",
]);

pub fn map<CT, F>(&self, f: F) -> MockDisplay<CT>

where CT: PixelColor, F: Fn(C) -> CT + Copy,

Maps a MockDisplay<C>' to a MockDisplay` by applying a function to each pixel.

Examples

Invert a MockDisplay by applying BinaryColor::invert to the color of each pixel.

use embedded_graphics::{mock_display::MockDisplay, pixelcolor::BinaryColor};

let display: MockDisplay<BinaryColor> = MockDisplay::from_pattern(&[
    "####",
    "#  .",
    "....",
]);

let inverted = display.map(|c| c.invert());
inverted.assert_pattern(&[
    "....",
    ".  #",
    "####",
]);

pub fn diff(&self, other: &MockDisplay<C>) -> MockDisplay<Rgb888>

Compares the display to another display.

The following color code is used to show the difference between the displays:

Color	Description
None	The color of the pixel is equal in both displays.
Some(Rgb888::GREEN)	The pixel was only set in self
Some(Rgb888::RED)	The pixel was only set in other
Some(Rgb888::BLUE)	The pixel was set to a different colors in self and other

impl<C> MockDisplay<C>

where C: PixelColor + ColorMapping,

pub fn from_pattern(pattern: &[&str]) -> MockDisplay<C>

Creates a new mock display from a character pattern.

The color pattern is specified by a slice of string slices. Each string slice represents a row of pixels and every character a single pixel.

A space character in the pattern represents a pixel which wasn’t modified by any drawing routine and is left in the default state. All other characters are converted by implementations of the ColorMapping trait.

pub fn assert_eq(&self, other: &MockDisplay<C>)

Checks if the displays are equal.

An advanced output for failing tests can be enabled by setting the environment variable EG_FANCY_PANIC=1. See the module-level documentation for more details.

Panics

Panics if the displays aren’t equal.

pub fn assert_eq_with_message<F>(&self, other: &MockDisplay<C>, msg: F)

where F: Fn(&mut Formatter<'_>) -> Result,

Checks if the displays are equal.

An advanced output for failing tests can be enabled by setting the environment variable EG_FANCY_PANIC=1. See the module-level documentation for more details.

The output of the msg function will be prepended to the output if the assertion fails.

Panics

Panics if the displays aren’t equal.

pub fn assert_pattern(&self, pattern: &[&str])

Checks if the display is equal to the given pattern.

An advanced output for failing tests can be enabled, see the module-level documentation for more details.

Panics

Panics if the display content isn’t equal to the pattern.

pub fn assert_pattern_with_message<F>(&self, pattern: &[&str], msg: F)

where F: Fn(&mut Formatter<'_>) -> Result,

Checks if the display is equal to the given pattern.

An advanced output for failing tests can be enabled, see the module-level documentation for more details.

The output of the msg function will be prepended to the output if the assertion fails.

Panics

Panics if the display content isn’t equal to the pattern.

Trait Implementations

impl<C> Clone for MockDisplay<C>

where C: PixelColor + Clone,

fn clone(&self) -> MockDisplay<C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C> Debug for MockDisplay<C>

where C: PixelColor + ColorMapping,

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

Formats the value using the given formatter.

impl<C> Default for MockDisplay<C>

where C: PixelColor,

fn default() -> Self

Returns the “default value” for a type.

impl<C> DrawTarget for MockDisplay<C>

where C: PixelColor,

type Color = C

The pixel color type the targetted display supports.

type Error = Infallible

Error type to return when a drawing operation fails.

fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>

where I: IntoIterator<Item = Pixel<Self::Color>>,

Draw individual pixels to the display without a defined order.

fn fill_contiguous<I>( &mut self, area: &Rectangle, colors: I, ) -> Result<(), Self::Error>

where I: IntoIterator<Item = Self::Color>,

Fill a given area with an iterator providing a contiguous stream of pixel colors.

fn fill_solid( &mut self, area: &Rectangle, color: Self::Color, ) -> Result<(), Self::Error>

Fill a given area with a solid color.

fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error>

Fill the entire display with a solid color.

impl<C> OriginDimensions for MockDisplay<C>

where C: PixelColor,

fn size(&self) -> Size

Returns the size of the bounding box.

impl<C: PixelColor> PartialEq for MockDisplay<C>

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

Tests for self and other values to be equal, and is used by ==.

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

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