mirui 0.6.0

A lightweight, no_std ECS-driven UI framework for embedded, desktop, and WebAssembly
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

#[cfg(test)]
mod tests {
    use mirui::draw::{DrawCommand, Renderer};
    use mirui::ecs::World;
    use mirui::layout::*;
    use mirui::types::{Color, CoordTransform, Dimension, Fixed, Rect};
    use mirui::widget::builder::WidgetBuilder;
    use mirui::widget::render_system;

    struct RecordingRenderer {
        commands: Vec<(Rect, Color)>,
    }

    impl RecordingRenderer {
        fn new() -> Self {
            Self {
                commands: Vec::new(),
            }
        }
    }

    impl Renderer for RecordingRenderer {
        fn draw(&mut self, cmd: &DrawCommand, _clip: &Rect) {
            if let DrawCommand::Fill { area, color, .. } = cmd {
                self.commands.push((*area, *color));
            }
        }
        fn flush(&mut self) {}
    }

    #[test]
    fn render_system_produces_draw_commands() {
        let mut world = World::new();

        let child = WidgetBuilder::new(&mut world)
            .bg_color(Color::rgb(255, 0, 0))
            .layout(LayoutStyle {
                width: Dimension::px(50),
                height: Dimension::px(50),
                ..Default::default()
            })
            .id();

        let root = WidgetBuilder::new(&mut world)
            .bg_color(Color::rgb(0, 0, 0))
            .layout(LayoutStyle {
                direction: FlexDirection::Row,
                width: Dimension::px(200),
                height: Dimension::px(100),
                ..Default::default()
            })
            .child(child)
            .id();

        let mut recorder = RecordingRenderer::new();
        let transform = CoordTransform::new(200, 100, Fixed::ONE);
        render_system::render(&world, root, &transform, &mut recorder);

        // Should have 2 draw commands: root bg + child bg
        assert_eq!(recorder.commands.len(), 2);

        // Root fills entire area
        assert_eq!(
            recorder.commands[0].0,
            Rect {
                x: Fixed::from_int(0),
                y: Fixed::from_int(0),
                w: Fixed::from_int(200),
                h: Fixed::from_int(100)
            }
        );
        assert_eq!(recorder.commands[0].1, Color::rgb(0, 0, 0));

        // Child at (0,0) with 50x50
        assert_eq!(
            recorder.commands[1].0,
            Rect {
                x: Fixed::from_int(0),
                y: Fixed::from_int(0),
                w: Fixed::from_int(50),
                h: Fixed::from_int(50)
            }
        );
        assert_eq!(recorder.commands[1].1, Color::rgb(255, 0, 0));
    }

    #[test]
    fn render_system_respects_layout() {
        let mut world = World::new();

        let c1 = WidgetBuilder::new(&mut world)
            .bg_color(Color::rgb(255, 0, 0))
            .layout(LayoutStyle {
                grow: Fixed::from_f32(1.0),
                height: Dimension::px(100),
                ..Default::default()
            })
            .id();

        let c2 = WidgetBuilder::new(&mut world)
            .bg_color(Color::rgb(0, 255, 0))
            .layout(LayoutStyle {
                grow: Fixed::from_f32(1.0),
                height: Dimension::px(100),
                ..Default::default()
            })
            .id();

        let root = WidgetBuilder::new(&mut world)
            .layout(LayoutStyle {
                direction: FlexDirection::Row,
                width: Dimension::px(200),
                height: Dimension::px(100),
                ..Default::default()
            })
            .child(c1)
            .child(c2)
            .id();

        let mut recorder = RecordingRenderer::new();
        let transform = CoordTransform::new(200, 100, Fixed::ONE);
        render_system::render(&world, root, &transform, &mut recorder);

        // Root has no bg_color, so only 2 commands for children
        assert_eq!(recorder.commands.len(), 2);
        // Each child gets half: 100px wide
        assert_eq!(recorder.commands[0].0.w, Fixed::from_int(100));
        assert_eq!(recorder.commands[1].0.w, Fixed::from_int(100));
        assert_eq!(recorder.commands[1].0.x, Fixed::from_int(100));
    }
}