Struct embedded_graphics::mock_display::MockDisplay

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

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 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.

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 behaviour 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 behaviour 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 MockDisplay<BinaryColor>

pub fn from_points<I>(points: I) -> 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 Primitive::points method.

The color type used in the returned display is BinaryColor, which can be mapped to another color type using the map method.

Examples

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

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

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

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

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_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.

Trait Implementations

impl<C: Clone> Clone for MockDisplay<C> where
    C: PixelColor, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<C: Copy> Copy for MockDisplay<C> where
    C: PixelColor, 

impl<C> Debug for MockDisplay<C> where
    C: PixelColor + ColorMapping, 

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

Formats the value using the given formatter.

impl<C> Default for MockDisplay<C> where
    C: PixelColor, 

pub 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.

pub 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.

pub 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.

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

Fill a given area with a solid color.

pub 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, 

pub fn size(&self) -> Size

Returns the size of the bounding box.

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

pub fn eq(&self, other: &MockDisplay<C>) -> bool

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.