rust_native 1.4.0

A modern, cross-platform UI framework for building native applications
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

use crate::style::Style;
use crate::layout::Layout;
use crate::renderer::Renderer;
use crate::event::Event;
use crate::geometry::Rect;
use super::Component;

pub struct View {
    children: Vec<Box<dyn Component>>,
    style: Style,
    layout: Layout,
    bounds: Rect,
}

impl View {
    pub fn new() -> Self {
        Self {
            children: Vec::new(),
            style: Style::default(),
            layout: Layout::Column,
            bounds: Rect::default(),
        }
    }

    pub fn child<C: Component + 'static>(mut self, component: C) -> Self {
        self.children.push(Box::new(component));
        self
    }

    pub fn with_layout(mut self, layout: Layout) -> Self {
        self.layout = layout;
        self
    }

    pub fn with_style(mut self, style: Style) -> Self {
        self.style = style;
        self
    }

    pub fn style(&self) -> &Style {
        &self.style
    }

    pub fn style_mut(&mut self) -> &mut Style {
        &mut self.style
    }
}

impl Component for View {
    fn render(&self, renderer: &mut dyn Renderer) {
        renderer.begin_group(&self.style);
        
        match self.layout {
            Layout::Row => {
                let mut x = 0.0;
                for child in &self.children {
                    renderer.translate(x, 0.0);
                    child.render(renderer);
                    x += self.style.get_gap();
                }
            }
            Layout::Column => {
                let mut y = 0.0;
                for child in &self.children {
                    renderer.translate(0.0, y);
                    child.render(renderer);
                    y += self.style.get_gap();
                }
            }
        }
        
        renderer.end_group();
    }

    fn handle_event(&mut self, event: Event) {
        for child in &mut self.children {
            child.handle_event(event.clone());
        }
    }

    fn bounds(&self) -> Rect {
        self.bounds.clone()
    }

    fn apply_style(&mut self, style: Style) {
        self.style = style;
    }

    fn style(&self) -> &Style {
        &self.style
    }

    fn style_mut(&mut self) -> &mut Style {
        &mut self.style
    }
}