embedded-gui 0.1.5

no_std GUI and HUD primitives for embedded-graphics displays
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! Present helpers for swap-chain integration.

use embedded_graphics_framebuf::backends::DMACapableFrameBufferBackend;

use crate::{
    GuiContext,
    display_backend::{AsyncDmaTransfer, DisplayBackend, DisplayError},
    swapchain::SwapChain,
};

impl<'a, const NODES: usize, const EVENTS: usize, const DIRTY: usize>
    GuiContext<'a, NODES, EVENTS, DIRTY>
{
    /// Non-blocking present of the dirty bounding box after rendering into the back buffer.
    ///
    /// Returns [`DisplayError::Busy`] if a DMA transfer is still in flight. For multiple
    /// disjoint dirty rects, this issues one partial DMA covering the bounding box.
    pub fn try_present_dirty<const W: usize, const H: usize, FB, B>(
        &self,
        swap: &mut SwapChain<W, H, FB, B>,
    ) -> Result<(), DisplayError>
    where
        FB: DMACapableFrameBufferBackend<Color = embedded_graphics_core::pixelcolor::Rgb565>,
        B: DisplayBackend<W, H, FB>,
    {
        let Some(region) = self.bounding_present_region() else {
            return Ok(());
        };
        if region.is_empty() {
            return Ok(());
        }
        swap.try_present_region(region)
    }

    /// Async present of the dirty bounding box after rendering into the back buffer.
    pub async fn present_dirty_async<const W: usize, const H: usize, FB, B>(
        &self,
        swap: &mut SwapChain<W, H, FB, B>,
    ) -> Result<(), DisplayError>
    where
        FB: DMACapableFrameBufferBackend<Color = embedded_graphics_core::pixelcolor::Rgb565>,
        B: DisplayBackend<W, H, FB>,
        B::Transfer: AsyncDmaTransfer<
            Buffer = embedded_graphics_framebuf::FrameBuf<
                embedded_graphics_core::pixelcolor::Rgb565,
                FB,
            >,
        >,
    {
        let Some(region) = self.bounding_present_region() else {
            return Ok(());
        };
        if region.is_empty() {
            return Ok(());
        }
        swap.present_region_async(region).await
    }

    /// Full-frame non-blocking present (ignores dirty region geometry).
    pub fn try_present_frame<const W: usize, const H: usize, FB, B>(
        &self,
        swap: &mut SwapChain<W, H, FB, B>,
    ) -> Result<(), DisplayError>
    where
        FB: DMACapableFrameBufferBackend<Color = embedded_graphics_core::pixelcolor::Rgb565>,
        B: DisplayBackend<W, H, FB>,
    {
        let _ = self;
        swap.try_present()
    }
}

#[cfg(test)]
mod tests {
    extern crate std;
    use super::*;
    use crate::{
        display_backend::SimulatorBackend, geometry::Rect, style::Style,
        swapchain::StandardSwapChain,
    };
    use embedded_graphics_core::pixelcolor::{Rgb565, RgbColor};
    use std::vec;

    fn make_swap() -> StandardSwapChain<64, 64, SimulatorBackend> {
        let fb0: &'static mut [Rgb565] = vec![Rgb565::BLACK; 64 * 64].leak();
        let fb1: &'static mut [Rgb565] = vec![Rgb565::BLACK; 64 * 64].leak();
        StandardSwapChain::from_static_slices(fb0, fb1, false, SimulatorBackend::new())
    }

    #[test]
    fn try_present_dirty_uses_bounding_region() {
        let mut gui = GuiContext::<4, 4, 4>::new(Rect::new(0, 0, 64, 64));
        gui.add_label(Rect::new(4, 4, 20, 8), "hi", Style::label())
            .unwrap();
        let mut swap = make_swap();
        assert!(gui.try_present_dirty(&mut swap).is_ok());
    }
}