Struct SimulatorDisplay 

pub struct SimulatorDisplay<C> { /* private fields */ }

Simulator display.

Implementations

impl<C: PixelColor> SimulatorDisplay<C>

pub fn with_default_color(size: Size, default_color: C) -> Self

Creates a new display filled with a color.

This constructor can be used if C doesn’t implement From<BinaryColor> or another default color is wanted.

pub fn get_pixel(&self, point: Point) -> C

Returns the color of the pixel at a point.

Panics

Panics if point is outside the display.

pub fn diff( &self, other: &SimulatorDisplay<C>, ) -> Option<SimulatorDisplay<BinaryColor>>

Compares the content of this display with another display.

If both displays are equal None is returned, otherwise a difference image is returned. All pixels that are different will be filled with BinaryColor::On and all equal pixels with BinaryColor::Off.

Panics

Panics if the both display don’t have the same size.

pub fn output_size(&self, output_settings: &OutputSettings) -> Size

Calculates the rendered size of this display based on the output settings.

This method takes into account the scale and pixel_spacing settings to determine the size of this display in output pixels.

Examples found in repository

examples/multiple-displays.rs (line 82)

fn main() -> Result<(), core::convert::Infallible> {
    // Create three simulated monochrome 128x64 OLED displays.

    let mut oled_displays = Vec::new();
    for i in 0..3 {
        let mut oled: SimulatorDisplay<BinaryColor> = SimulatorDisplay::new(Size::new(128, 64));

        Text::with_text_style(
            &format!("Display {i}"),
            oled.bounding_box().center(),
            OLED_TEXT,
            CENTERED,
        )
        .draw(&mut oled)
        .unwrap();

        oled_displays.push(oled);
    }

    // Create a simulated color 320x240 TFT display.

    let mut tft: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(320, 240));
    tft.clear(Rgb565::new(5, 10, 5)).unwrap();

    Text::with_text_style(
        &format!("Draw here"),
        tft.bounding_box().center(),
        TFT_TEXT,
        CENTERED,
    )
    .draw(&mut tft)
    .unwrap();

    // The simulated displays can now be added to common simulator window.

    let window_size = Size::new(1300, 500);
    let mut window = MultiWindow::new("Multiple displays example", window_size);
    window.clear(Rgb888::CSS_DIM_GRAY);

    let oled_settings = OutputSettingsBuilder::new()
        .theme(BinaryColorTheme::OledBlue)
        .scale(2)
        .build();
    let oled_size = oled_displays[0].output_size(&oled_settings);

    for (oled, anchor) in oled_displays.iter().zip(
        [
            AnchorPoint::TopLeft,
            AnchorPoint::TopCenter,
            AnchorPoint::TopRight,
        ]
        .into_iter(),
    ) {
        let offset = display_offset(window_size, oled_size, anchor);
        window.add_display(&oled, offset, &oled_settings);
    }

    let tft_settings = OutputSettings::default();
    let tft_size = tft.output_size(&tft_settings);
    let tft_offset = display_offset(window_size, tft_size, AnchorPoint::BottomCenter);

    window.add_display(&tft, tft_offset, &tft_settings);

    let border_style = PrimitiveStyleBuilder::new()
        .stroke_width(5)
        .stroke_alignment(StrokeAlignment::Inside)
        .build();

    let mut mouse_down = false;

    'running: loop {
        // Call `update_display` for all display. Note that the window won't be
        // updated until `window.flush` is called.
        for oled in &oled_displays {
            window.update_display(oled);
        }
        window.update_display(&tft);
        window.flush();

        for event in window.events() {
            match event {
                SimulatorEvent::MouseMove { point } => {
                    // Mouse events use the window coordinate system.
                    // `translate_mouse_position` can be used to translate the
                    // mouse position into the display coordinate system.

                    for oled in &mut oled_displays {
                        let is_inside = window.translate_mouse_position(oled, point).is_some();

                        let style = PrimitiveStyleBuilder::from(&border_style)
                            .stroke_color(BinaryColor::from(is_inside))
                            .build();

                        oled.bounding_box().into_styled(style).draw(oled).unwrap();
                    }

                    if mouse_down {
                        if let Some(point) = window.translate_mouse_position(&tft, point) {
                            Circle::with_center(point, 10)
                                .into_styled(PrimitiveStyle::with_fill(Rgb565::CSS_DODGER_BLUE))
                                .draw(&mut tft)
                                .unwrap();
                        }
                    }
                }
                SimulatorEvent::MouseButtonDown {
                    mouse_btn: MouseButton::Left,
                    ..
                } => {
                    mouse_down = true;
                }
                SimulatorEvent::MouseButtonUp {
                    mouse_btn: MouseButton::Left,
                    ..
                } => {
                    mouse_down = false;
                }
                SimulatorEvent::Quit => break 'running,
                _ => {}
            }
        }
    }

    Ok(())
}

impl<C> SimulatorDisplay<C>

where C: PixelColor + From<BinaryColor>,

pub fn new(size: Size) -> Self

Creates a new display.

The display is filled with C::from(BinaryColor::Off).

Examples found in repository

examples/png-base64.rs (line 10)

fn main() {
    let mut display = SimulatorDisplay::<BinaryColor>::new(Size::new(256, 64));

    let large_text = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
    let centered = TextStyleBuilder::new()
        .baseline(Baseline::Middle)
        .alignment(Alignment::Center)
        .build();

    Text::with_text_style(
        "embedded-graphics",
        display.bounding_box().center(),
        large_text,
        centered,
    )
    .draw(&mut display)
    .unwrap();

    let output_settings = OutputSettingsBuilder::new().scale(2).build();
    let output_image = display.to_grayscale_output_image(&output_settings);

    println!(
        "<img src=\"data:image/png;base64,{}\">",
        output_image.to_base64_png().unwrap()
    );
}

examples/png-file.rs (line 10)

fn main() {
    let mut display = SimulatorDisplay::<BinaryColor>::new(Size::new(256, 64));

    let large_text = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
    let centered = TextStyleBuilder::new()
        .baseline(Baseline::Middle)
        .alignment(Alignment::Center)
        .build();

    Text::with_text_style(
        "embedded-graphics",
        display.bounding_box().center(),
        large_text,
        centered,
    )
    .draw(&mut display)
    .unwrap();

    let output_settings = OutputSettingsBuilder::new().scale(2).build();
    let output_image = display.to_rgb_output_image(&output_settings);

    let path = std::env::args_os()
        .nth(1)
        .expect("expected PNG file name argument");
    output_image.save_png(path).unwrap();
}

examples/themes.rs (line 12)

fn main() {
    let mut display = SimulatorDisplay::<BinaryColor>::new(Size::new(256, 64));

    let large_text = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
    let centered = TextStyleBuilder::new()
        .baseline(Baseline::Middle)
        .alignment(Alignment::Center)
        .build();

    Text::with_text_style(
        "embedded-graphics",
        display.bounding_box().center(),
        large_text,
        centered,
    )
    .draw(&mut display)
    .unwrap();

    // Uncomment one of the `theme` lines to use a different theme.
    let output_settings = OutputSettingsBuilder::new()
        //.theme(BinaryColorTheme::LcdGreen)
        //.theme(BinaryColorTheme::LcdWhite)
        .theme(BinaryColorTheme::LcdBlue)
        //.theme(BinaryColorTheme::OledBlue)
        //.theme(BinaryColorTheme::OledWhite)
        .build();

    let mut window = Window::new("Themes", &output_settings);
    window.show_static(&display);
}

examples/input-handling.rs (line 43)

fn main() -> Result<(), core::convert::Infallible> {
    let mut display: SimulatorDisplay<Rgb888> = SimulatorDisplay::new(Size::new(800, 480));
    let mut window = Window::new("Click to move circle", &OutputSettings::default());

    let mut position = Point::new(200, 200);
    Circle::with_center(position, 200)
        .into_styled(PrimitiveStyle::with_fill(FOREGROUND_COLOR))
        .draw(&mut display)?;

    'running: loop {
        window.update(&display);

        for event in window.events() {
            match event {
                SimulatorEvent::Quit => break 'running,
                SimulatorEvent::KeyDown { keycode, .. } => {
                    let delta = match keycode {
                        Keycode::Left => Point::new(-KEYBOARD_DELTA, 0),
                        Keycode::Right => Point::new(KEYBOARD_DELTA, 0),
                        Keycode::Up => Point::new(0, -KEYBOARD_DELTA),
                        Keycode::Down => Point::new(0, KEYBOARD_DELTA),
                        _ => Point::zero(),
                    };
                    let new_position = position + delta;
                    move_circle(&mut display, position, new_position)?;
                    position = new_position;
                }
                SimulatorEvent::MouseButtonUp { point, .. } => {
                    move_circle(&mut display, position, point)?;
                    position = point;
                }
                _ => {}
            }
        }
    }

    Ok(())
}

examples/sdl-audio.rs (line 68)

fn main() -> Result<(), core::convert::Infallible> {
    // Prepare the audio "engine" with gate control
    let gate = Arc::new(AtomicBool::new(false));
    let audio_wrapper = AudioWrapper::new(gate.clone());

    let audio_spec = AudioSpecDesired {
        freq: Some(SAMPLE_RATE),
        channels: Some(1),
        samples: Some(32),
    };

    // Initialize the SDL audio subsystem.
    //
    // `sdl2` allows multiple instances of the SDL context to exist, which makes
    // it possible to access SDL subsystems which aren't used by the simulator.
    // But keep in mind that only one `EventPump` can exists and the simulator
    // window creation will fail if the `EventPump` is claimed in advance.
    let sdl = sdl2::init().unwrap();
    let audio_subsystem = sdl.audio().unwrap();

    // Start audio playback by opening the device and setting the custom callback.
    let audio_device = audio_subsystem
        .open_playback(None, &audio_spec, |_| audio_wrapper)
        .unwrap();
    audio_device.resume();

    let output_settings = OutputSettingsBuilder::new()
        .scale(4)
        .theme(embedded_graphics_simulator::BinaryColorTheme::OledWhite)
        .build();

    let mut window = Window::new("Simulator audio example", &output_settings);

    let text_style = MonoTextStyle::new(&FONT_6X10, BinaryColor::On);
    let text_position = Point::new(25, 30);
    let text = Text::new("Press space...", text_position, text_style);

    let mut display: SimulatorDisplay<BinaryColor> = SimulatorDisplay::new(Size::new(128, 64));
    text.draw(&mut display).unwrap();
    'running: loop {
        window.update(&display);

        for event in window.events() {
            match event {
                SimulatorEvent::Quit => break 'running,
                SimulatorEvent::KeyDown {
                    keycode, repeat, ..
                } if keycode == Keycode::Space && !repeat => {
                    gate.store(true, Ordering::SeqCst);
                    display.clear(BinaryColor::On).unwrap();
                }
                SimulatorEvent::KeyUp { keycode, .. } => match keycode {
                    Keycode::Space => {
                        gate.store(false, Ordering::SeqCst);
                        display.clear(BinaryColor::Off).unwrap();
                        text.draw(&mut display).unwrap();
                    }
                    _ => {}
                },
                _ => {}
            }
        }
    }

    Ok(())
}

examples/multiple-displays.rs (line 44)

fn main() -> Result<(), core::convert::Infallible> {
    // Create three simulated monochrome 128x64 OLED displays.

    let mut oled_displays = Vec::new();
    for i in 0..3 {
        let mut oled: SimulatorDisplay<BinaryColor> = SimulatorDisplay::new(Size::new(128, 64));

        Text::with_text_style(
            &format!("Display {i}"),
            oled.bounding_box().center(),
            OLED_TEXT,
            CENTERED,
        )
        .draw(&mut oled)
        .unwrap();

        oled_displays.push(oled);
    }

    // Create a simulated color 320x240 TFT display.

    let mut tft: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(320, 240));
    tft.clear(Rgb565::new(5, 10, 5)).unwrap();

    Text::with_text_style(
        &format!("Draw here"),
        tft.bounding_box().center(),
        TFT_TEXT,
        CENTERED,
    )
    .draw(&mut tft)
    .unwrap();

    // The simulated displays can now be added to common simulator window.

    let window_size = Size::new(1300, 500);
    let mut window = MultiWindow::new("Multiple displays example", window_size);
    window.clear(Rgb888::CSS_DIM_GRAY);

    let oled_settings = OutputSettingsBuilder::new()
        .theme(BinaryColorTheme::OledBlue)
        .scale(2)
        .build();
    let oled_size = oled_displays[0].output_size(&oled_settings);

    for (oled, anchor) in oled_displays.iter().zip(
        [
            AnchorPoint::TopLeft,
            AnchorPoint::TopCenter,
            AnchorPoint::TopRight,
        ]
        .into_iter(),
    ) {
        let offset = display_offset(window_size, oled_size, anchor);
        window.add_display(&oled, offset, &oled_settings);
    }

    let tft_settings = OutputSettings::default();
    let tft_size = tft.output_size(&tft_settings);
    let tft_offset = display_offset(window_size, tft_size, AnchorPoint::BottomCenter);

    window.add_display(&tft, tft_offset, &tft_settings);

    let border_style = PrimitiveStyleBuilder::new()
        .stroke_width(5)
        .stroke_alignment(StrokeAlignment::Inside)
        .build();

    let mut mouse_down = false;

    'running: loop {
        // Call `update_display` for all display. Note that the window won't be
        // updated until `window.flush` is called.
        for oled in &oled_displays {
            window.update_display(oled);
        }
        window.update_display(&tft);
        window.flush();

        for event in window.events() {
            match event {
                SimulatorEvent::MouseMove { point } => {
                    // Mouse events use the window coordinate system.
                    // `translate_mouse_position` can be used to translate the
                    // mouse position into the display coordinate system.

                    for oled in &mut oled_displays {
                        let is_inside = window.translate_mouse_position(oled, point).is_some();

                        let style = PrimitiveStyleBuilder::from(&border_style)
                            .stroke_color(BinaryColor::from(is_inside))
                            .build();

                        oled.bounding_box().into_styled(style).draw(oled).unwrap();
                    }

                    if mouse_down {
                        if let Some(point) = window.translate_mouse_position(&tft, point) {
                            Circle::with_center(point, 10)
                                .into_styled(PrimitiveStyle::with_fill(Rgb565::CSS_DODGER_BLUE))
                                .draw(&mut tft)
                                .unwrap();
                        }
                    }
                }
                SimulatorEvent::MouseButtonDown {
                    mouse_btn: MouseButton::Left,
                    ..
                } => {
                    mouse_down = true;
                }
                SimulatorEvent::MouseButtonUp {
                    mouse_btn: MouseButton::Left,
                    ..
                } => {
                    mouse_down = false;
                }
                SimulatorEvent::Quit => break 'running,
                _ => {}
            }
        }
    }

    Ok(())
}

impl<C> SimulatorDisplay<C>

where C: PixelColor + Into<Rgb888>,

pub fn to_rgb_output_image( &self, output_settings: &OutputSettings, ) -> OutputImage<Rgb888>

Converts the display contents into a RGB output image.

Examples

use embedded_graphics::{pixelcolor::Rgb888, prelude::*};
use embedded_graphics_simulator::{OutputSettingsBuilder, SimulatorDisplay};

let output_settings = OutputSettingsBuilder::new().scale(2).build();

let display = SimulatorDisplay::<Rgb888>::new(Size::new(128, 64));

// draw something to the display

let output_image = display.to_rgb_output_image(&output_settings);
assert_eq!(output_image.size(), Size::new(256, 128));

// use output image:
// example: output_image.save_png("out.png")?;

Examples found in repository

examples/png-file.rs (line 28)

fn main() {
    let mut display = SimulatorDisplay::<BinaryColor>::new(Size::new(256, 64));

    let large_text = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
    let centered = TextStyleBuilder::new()
        .baseline(Baseline::Middle)
        .alignment(Alignment::Center)
        .build();

    Text::with_text_style(
        "embedded-graphics",
        display.bounding_box().center(),
        large_text,
        centered,
    )
    .draw(&mut display)
    .unwrap();

    let output_settings = OutputSettingsBuilder::new().scale(2).build();
    let output_image = display.to_rgb_output_image(&output_settings);

    let path = std::env::args_os()
        .nth(1)
        .expect("expected PNG file name argument");
    output_image.save_png(path).unwrap();
}

pub fn to_grayscale_output_image( &self, output_settings: &OutputSettings, ) -> OutputImage<Gray8>

Converts the display contents into a grayscale output image.

Examples

use embedded_graphics::{pixelcolor::Gray8, prelude::*};
use embedded_graphics_simulator::{OutputSettingsBuilder, SimulatorDisplay};

let output_settings = OutputSettingsBuilder::new().scale(2).build();

let display = SimulatorDisplay::<Gray8>::new(Size::new(128, 64));

// draw something to the display

let output_image = display.to_grayscale_output_image(&output_settings);
assert_eq!(output_image.size(), Size::new(256, 128));

// use output image:
// example: output_image.save_png("out.png")?;

Examples found in repository

examples/png-base64.rs (line 28)

fn main() {
    let mut display = SimulatorDisplay::<BinaryColor>::new(Size::new(256, 64));

    let large_text = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
    let centered = TextStyleBuilder::new()
        .baseline(Baseline::Middle)
        .alignment(Alignment::Center)
        .build();

    Text::with_text_style(
        "embedded-graphics",
        display.bounding_box().center(),
        large_text,
        centered,
    )
    .draw(&mut display)
    .unwrap();

    let output_settings = OutputSettingsBuilder::new().scale(2).build();
    let output_image = display.to_grayscale_output_image(&output_settings);

    println!(
        "<img src=\"data:image/png;base64,{}\">",
        output_image.to_base64_png().unwrap()
    );
}

impl<C> SimulatorDisplay<C>

where C: PixelColor + ToBytes, <C as ToBytes>::Bytes: AsRef<[u8]>,

pub fn to_be_bytes(&self) -> Vec<u8>

Converts the display content to big endian raw data.

pub fn to_le_bytes(&self) -> Vec<u8>

Converts the display content to little endian raw data.

pub fn to_ne_bytes(&self) -> Vec<u8>

Converts the display content to native endian raw data.

impl<C> SimulatorDisplay<C>

where C: PixelColor + From<Rgb888>,

pub fn load_png<P: AsRef<Path>>(path: P) -> ImageResult<Self>

Loads a PNG file.

Trait Implementations

impl<C: Clone> Clone for SimulatorDisplay<C>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: Debug> Debug for SimulatorDisplay<C>

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

Formats the value using the given formatter.

impl<C: PixelColor> DrawTarget for SimulatorDisplay<C>

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: Hash> Hash for SimulatorDisplay<C>

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<C: Ord> Ord for SimulatorDisplay<C>

fn cmp(&self, other: &SimulatorDisplay<C>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<C> OriginDimensions for SimulatorDisplay<C>

fn size(&self) -> Size

Returns the size of the bounding box.

impl<C: PartialEq> PartialEq for SimulatorDisplay<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.

impl<C: PartialOrd> PartialOrd for SimulatorDisplay<C>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<C: Eq> Eq for SimulatorDisplay<C>