Add support for multiple displays per window

Author: rfuest

examples/multiple-displays.rs

@@ -0,0 +1,128 @@
+//! # Example: Multiple displays
+//!
+//! TODO: add description
+
+extern crate embedded_graphics;
+extern crate embedded_graphics_simulator;
+
+use embedded_graphics::{
+    mono_font::{ascii::FONT_10X20, MonoTextStyle},
+    pixelcolor::{BinaryColor, Rgb565},
+    prelude::*,
+    primitives::{Circle, PrimitiveStyle, PrimitiveStyleBuilder, StrokeAlignment},
+    text::{Alignment, Baseline, Text, TextStyleBuilder},
+};
+use embedded_graphics_simulator::{
+    sdl2::MouseButton, BinaryColorTheme, MultiWindow, OutputSettings, OutputSettingsBuilder,
+    SimulatorDisplay, SimulatorEvent,
+};
+
+fn main() -> Result<(), core::convert::Infallible> {
+    let character_style = MonoTextStyle::new(&FONT_10X20, BinaryColor::On);
+    let centered = TextStyleBuilder::new()
+        .alignment(Alignment::Center)
+        .baseline(Baseline::Middle)
+        .build();
+
+    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(),
+            character_style,
+            centered,
+        )
+        .draw(&mut oled)
+        .unwrap();
+
+        oled_displays.push(oled);
+    }
+
+    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(),
+        MonoTextStyle::new(&FONT_10X20, Rgb565::CSS_LIGHT_SLATE_GRAY),
+        centered,
+    )
+    .draw(&mut tft)
+    .unwrap();
+
+    let mut window = MultiWindow::new("Multiple displays example", Size::new(1200, 500));
+
+    let oled_settings = OutputSettingsBuilder::new()
+        .theme(BinaryColorTheme::OledBlue)
+        .scale(2)
+        .pixel_spacing(1)
+        .build();
+    for (i, oled) in oled_displays.iter().enumerate() {
+        window.add_display(
+            &oled,
+            Point::new((128 * 3 + 10) * (i as i32), 0),
+            &oled_settings,
+        );
+    }
+
+    let tft_settings = OutputSettings::default();
+    window.add_display(&tft, Point::new(50, 230), &tft_settings);
+
+    let border_style = PrimitiveStyleBuilder::new()
+        .stroke_width(5)
+        .stroke_alignment(StrokeAlignment::Inside)
+        .build();
+
+    let mut mouse_down = false;
+
+    'running: loop {
+        for oled in &oled_displays {
+            window.update_display(oled);
+        }
+        window.update_display(&tft);
+        window.update();
+
+        for event in window.events() {
+            match event {
+                SimulatorEvent::MouseMove { point } => {
+                    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(())
+}

src/display.rs

@@ -1,4 +1,10 @@
-use std::{convert::TryFrom, fs::File, io::BufReader, path::Path};
+use std::{
+    convert::TryFrom,
+    fs::File,
+    io::BufReader,
+    path::Path,
+    sync::atomic::{AtomicUsize, Ordering},
+};
 
 use embedded_graphics::{
     pixelcolor::{raw::ToBytes, BinaryColor, Gray8, Rgb888},
@@ -7,14 +13,23 @@ use embedded_graphics::{
 
 use crate::{output_image::OutputImage, output_settings::OutputSettings};
 
+static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
+
 /// Simulator display.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, Eq, PartialOrd, Ord, Hash)]
 pub struct SimulatorDisplay<C> {
     size: Size,
     pub(crate) pixels: Box<[C]>,
+    pub(crate) id: usize,
 }
 
 impl<C: PixelColor> SimulatorDisplay<C> {
+    fn new_common(size: Size, pixels: Box<[C]>) -> Self {
+        let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);
+
+        Self { size, pixels, id }
+    }
+
     /// Creates a new display filled with a color.
     ///
     /// This constructor can be used if `C` doesn't implement `From<BinaryColor>` or another
@@ -23,7 +38,7 @@ impl<C: PixelColor> SimulatorDisplay<C> {
         let pixel_count = size.width as usize * size.height as usize;
         let pixels = vec![default_color; pixel_count].into_boxed_slice();
 
-        SimulatorDisplay { size, pixels }
+        SimulatorDisplay::new_common(size, pixels)
     }
 
     /// Returns the color of the pixel at a point.
@@ -75,10 +90,7 @@ impl<C: PixelColor> SimulatorDisplay<C> {
             .into_boxed_slice();
 
         if pixels.iter().any(|p| *p == BinaryColor::On) {
-            Some(SimulatorDisplay {
-                pixels,
-                size: self.size,
-            })
+            Some(SimulatorDisplay::new_common(self.size, pixels))
         } else {
             None
         }
@@ -122,8 +134,9 @@ where
     /// // example: output_image.save_png("out.png")?;
     /// ```
     pub fn to_rgb_output_image(&self, output_settings: &OutputSettings) -> OutputImage<Rgb888> {
-        let mut output = OutputImage::new(self, output_settings);
-        output.update(self);
+        let size = output_settings.framebuffer_size(self);
+        let mut output = OutputImage::new(size);
+        output.update(self, Point::zero(), output_settings);
 
         output
     }
@@ -152,8 +165,9 @@ where
         &self,
         output_settings: &OutputSettings,
     ) -> OutputImage<Gray8> {
-        let mut output = OutputImage::new(self, output_settings);
-        output.update(self);
+        let size = output_settings.framebuffer_size(self);
+        let mut output = OutputImage::new(size);
+        output.update(self, Point::zero(), output_settings);
 
         output
     }
@@ -226,10 +240,10 @@ where
             .map(|p| Rgb888::new(p[0], p[1], p[2]).into())
             .collect();
 
-        Ok(Self {
-            size: Size::new(image.width(), image.height()),
+        Ok(Self::new_common(
+            Size::new(image.width(), image.height()),
             pixels,
-        })
+        ))
     }
 }
 
@@ -257,6 +271,12 @@ impl<C> OriginDimensions for SimulatorDisplay<C> {
     }
 }
 
+impl<C: PartialEq> PartialEq for SimulatorDisplay<C> {
+    fn eq(&self, other: &Self) -> bool {
+        self.size == other.size && self.pixels == other.pixels
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -321,6 +341,7 @@ mod tests {
             .map(|c| BinaryColor::from(*c != 0))
             .collect::<Vec<_>>()
             .into_boxed_slice(),
+            id: 0,
         };
 
         let expected = [
@@ -345,6 +366,7 @@ mod tests {
             .map(|c| Gray2::new(*c))
             .collect::<Vec<_>>()
             .into_boxed_slice(),
+            id: 0,
         };
 
         let expected = [
@@ -370,6 +392,7 @@ mod tests {
             .map(|c| Gray4::new(*c))
             .collect::<Vec<_>>()
             .into_boxed_slice(),
+            id: 0,
         };
 
         let expected = [
@@ -398,6 +421,7 @@ mod tests {
                 .map(Gray8::new)
                 .collect::<Vec<_>>()
                 .into_boxed_slice(),
+            id: 0,
         };
 
         assert_eq!(&display.to_be_bytes(), &expected);
@@ -412,6 +436,7 @@ mod tests {
         let display = SimulatorDisplay {
             size: Size::new(2, 1),
             pixels: expected.clone().into_boxed_slice(),
+            id: 0,
         };
 
         assert_eq!(&display.to_be_bytes(), &[0x80, 0x00, 0x00, 0x01]);
@@ -425,6 +450,7 @@ mod tests {
         let display = SimulatorDisplay {
             size: Size::new(2, 1),
             pixels: expected.clone().into_boxed_slice(),
+            id: 0,
         };
 
         assert_eq!(

src/lib.rs

@@ -158,9 +158,6 @@ mod output_settings;
 mod theme;
 mod window;
 
-#[cfg(feature = "with-sdl")]
-pub use window::SimulatorEvent;
-
 /// Re-exported types from sdl2 crate.
 ///
 /// The types in this module are used in the [`SimulatorEvent`] enum and are re-exported from the
@@ -180,3 +177,6 @@ pub use crate::{
     theme::BinaryColorTheme,
     window::Window,
 };
+
+#[cfg(feature = "with-sdl")]
+pub use window::{MultiWindow, SimulatorEvent};