Struct MultiWindow 

pub struct MultiWindow { /* private fields */ }

Simulator window with support for multiple displays.

Multiple SimulatorDisplays can be added to the window by using the add_display method. To update the window two steps are required, first update_display needs be called for all changed displays, then flush to redraw the window.

To determine if the mouse pointer is over one of the displays the translate_mouse_position can be used to translate window coordinates into display coordinates.

Implementations

impl MultiWindow

pub fn new(title: &str, size: Size) -> Self

Creates a new window with support for multiple displays.

Examples found in repository

examples/multiple-displays.rs (line 75)

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(())
}

pub fn add_display<C>( &mut self, display: &SimulatorDisplay<C>, offset: Point, output_settings: &OutputSettings, )

Adds a display to the window.

Examples found in repository

examples/multiple-displays.rs (line 93)

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(())
}

pub fn clear(&mut self, color: Rgb888)

Fills the internal framebuffer with the given color.

This method can be used to set the background color for the regions of the window that aren’t covered by a display.

Examples found in repository

examples/multiple-displays.rs (line 76)

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(())
}

pub fn update_display<C>(&mut self, display: &SimulatorDisplay<C>)

where C: PixelColor + Into<Rgb888> + From<Rgb888>,

Updates one display.

This method only updates the internal framebuffer. Use flush after all displays have been updated to finally update the window.

Examples found in repository

examples/multiple-displays.rs (line 113)

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(())
}

pub fn flush(&mut self)

Updates the window from the internal framebuffer.

Examples found in repository

examples/multiple-displays.rs (line 116)

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(())
}

pub fn events(&self) -> SimulatorEventsIter<'_>

Returns an iterator of all captured simulator events.

The coordinates in mouse events are in raw window coordinates, use translate_mouse_position to translate them into display coordinates.

Panics

Panics if multiple instances of the iterator are used at the same time.

Examples found in repository

examples/multiple-displays.rs (line 118)

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(())
}

pub fn translate_mouse_position<C>( &self, display: &SimulatorDisplay<C>, position: Point, ) -> Option<Point>

Translate a mouse position into display coordinates.

Returns the corresponding position in the display coordinate system if the mouse is inside the display area, otherwise None is returned.

Examples found in repository

examples/multiple-displays.rs (line 126)

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(())
}

pub fn set_max_fps(&mut self, max_fps: u32)

Sets the FPS limit of the window.