rlvgl-playit 0.2.1

Mini-playwright test driver for rlvgl: input injection, widget queries, and pixel inspection.
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

//! Depth-first tag lookup in a [`WidgetNode`] tree.

use rlvgl_core::WidgetNode;

/// Find the first node with the given tag (depth-first).
pub fn find_by_tag<'a>(root: &'a WidgetNode, tag: &str) -> Option<&'a WidgetNode> {
    if root.tag == Some(tag) {
        return Some(root);
    }
    for child in &root.children {
        if let Some(found) = find_by_tag(child, tag) {
            return Some(found);
        }
    }
    None
}

/// Mutable version of [`find_by_tag`].
pub fn find_by_tag_mut<'a>(root: &'a mut WidgetNode, tag: &str) -> Option<&'a mut WidgetNode> {
    if root.tag == Some(tag) {
        return Some(root);
    }
    for child in &mut root.children {
        if let Some(found) = find_by_tag_mut(child, tag) {
            return Some(found);
        }
    }
    None
}

#[cfg(test)]
mod tests {
    use super::*;
    use rlvgl_core::event::Event;
    use rlvgl_core::renderer::Renderer;
    use rlvgl_core::widget::{Rect, Widget};
    use std::cell::RefCell;
    use std::rc::Rc;

    struct Dummy;

    impl Widget for Dummy {
        fn bounds(&self) -> Rect {
            Rect {
                x: 0,
                y: 0,
                width: 10,
                height: 10,
            }
        }
        fn draw(&self, _r: &mut dyn Renderer) {}
        fn handle_event(&mut self, _e: &Event) -> bool {
            false
        }
    }

    fn dummy() -> Rc<RefCell<dyn Widget>> {
        Rc::new(RefCell::new(Dummy))
    }

    #[test]
    fn find_root_tag() {
        let root = WidgetNode {
            widget: dummy(),
            children: Vec::new(),
            tag: Some("root"),
        };
        assert!(find_by_tag(&root, "root").is_some());
        assert!(find_by_tag(&root, "other").is_none());
    }

    #[test]
    fn find_nested_tag() {
        let root = WidgetNode {
            widget: dummy(),
            children: vec![
                WidgetNode {
                    widget: dummy(),
                    children: Vec::new(),
                    tag: Some("a"),
                },
                WidgetNode {
                    widget: dummy(),
                    children: vec![WidgetNode {
                        widget: dummy(),
                        children: Vec::new(),
                        tag: Some("deep"),
                    }],
                    tag: Some("b"),
                },
            ],
            tag: None,
        };
        assert!(find_by_tag(&root, "a").is_some());
        assert!(find_by_tag(&root, "b").is_some());
        assert!(find_by_tag(&root, "deep").is_some());
        assert!(find_by_tag(&root, "missing").is_none());
    }

    #[test]
    fn find_mut_returns_correct_node() {
        let mut root = WidgetNode {
            widget: dummy(),
            children: vec![WidgetNode {
                widget: dummy(),
                children: Vec::new(),
                tag: Some("child"),
            }],
            tag: Some("root"),
        };
        let node = find_by_tag_mut(&mut root, "child").unwrap();
        assert_eq!(node.tag, Some("child"));
    }

    #[test]
    fn untagged_tree_returns_none() {
        let root = WidgetNode {
            widget: dummy(),
            children: vec![WidgetNode {
                widget: dummy(),
                children: Vec::new(),
                tag: None,
            }],
            tag: None,
        };
        assert!(find_by_tag(&root, "anything").is_none());
    }
}