mirui 0.1.6

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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::types::Rect;

use super::node::{AlignItems, FlexDirection, JustifyContent, LayoutNode, Position};

pub fn compute_layout(node: &mut LayoutNode, x: i32, y: i32, available_w: u16, available_h: u16) {
    let pad = &node.style.padding;
    let w = node.style.width.unwrap_or(available_w);
    let h = node.style.height.unwrap_or(available_h);

    node.rect = Rect { x, y, w, h };

    if node.children.is_empty() {
        return;
    }

    let inner_w = w.saturating_sub(pad.left + pad.right);
    let inner_h = h.saturating_sub(pad.top + pad.bottom);
    let inner_x = x + pad.left as i32;
    let inner_y = y + pad.top as i32;

    let is_row = node.style.direction == FlexDirection::Row;
    let main_size = if is_row { inner_w } else { inner_h } as f32;
    let cross_size = if is_row { inner_h } else { inner_w };

    // Calculate fixed sizes and total grow (only flex children)
    let mut fixed_total: f32 = 0.0;
    let mut grow_total: f32 = 0.0;
    for child in &node.children {
        if child.style.position == Position::Absolute {
            continue;
        }
        let child_main = if is_row {
            child.style.width
        } else {
            child.style.height
        };
        if let Some(s) = child_main {
            fixed_total += s as f32;
        } else if child.style.grow > 0.0 {
            grow_total += child.style.grow;
        }
    }

    let remaining = (main_size - fixed_total).max(0.0);

    // Compute each child's main axis size
    let child_count = node
        .children
        .iter()
        .filter(|c| c.style.position != Position::Absolute)
        .count();
    let mut sizes: alloc::vec::Vec<(u16, u16)> =
        alloc::vec::Vec::with_capacity(node.children.len());

    for child in &node.children {
        if child.style.position == Position::Absolute {
            sizes.push((0, 0));
            continue;
        }
        let child_main = if is_row {
            child.style.width
        } else {
            child.style.height
        };
        let m = if let Some(s) = child_main {
            s
        } else if child.style.grow > 0.0 && grow_total > 0.0 {
            (remaining * child.style.grow / grow_total) as u16
        } else {
            0
        };

        let child_cross = if is_row {
            child.style.height
        } else {
            child.style.width
        };
        let c = match node.style.align {
            AlignItems::Stretch => child_cross.unwrap_or(cross_size),
            _ => child_cross.unwrap_or(cross_size),
        };

        sizes.push((m, c));
    }

    // Justify: compute starting offset and gap (flex children only)
    let total_main: f32 = sizes
        .iter()
        .enumerate()
        .filter(|(i, _)| node.children[*i].style.position != Position::Absolute)
        .map(|(_, (m, _))| *m as f32)
        .sum();
    let free_space = (main_size - total_main).max(0.0);

    let (mut offset, gap) = match node.style.justify {
        JustifyContent::FlexStart => (0.0, 0.0),
        JustifyContent::FlexEnd => (free_space, 0.0),
        JustifyContent::Center => (free_space / 2.0, 0.0),
        JustifyContent::SpaceBetween => {
            if child_count > 1 {
                (0.0, free_space / (child_count - 1) as f32)
            } else {
                (0.0, 0.0)
            }
        }
        JustifyContent::SpaceAround => {
            let g = free_space / child_count as f32;
            (g / 2.0, g)
        }
        JustifyContent::SpaceEvenly => {
            let g = free_space / (child_count + 1) as f32;
            (g, g)
        }
    };

    // Position children
    for (i, child) in node.children.iter_mut().enumerate() {
        if child.style.position == Position::Absolute {
            // Absolute: position relative to parent's top-left
            let abs_x = x + child.style.left.unwrap_or(0);
            let abs_y = y + child.style.top.unwrap_or(0);
            let abs_w = child.style.width.unwrap_or(0);
            let abs_h = child.style.height.unwrap_or(0);
            compute_layout(child, abs_x, abs_y, abs_w, abs_h);
            continue;
        }

        let (m, c) = sizes[i];

        // Cross axis alignment
        let cross_offset = match node.style.align {
            AlignItems::FlexStart => 0.0,
            AlignItems::FlexEnd => (cross_size - c) as f32,
            AlignItems::Center => (cross_size - c) as f32 / 2.0,
            AlignItems::Stretch => 0.0,
        };

        let (cx, cy, cw, ch) = if is_row {
            (inner_x + offset as i32, inner_y + cross_offset as i32, m, c)
        } else {
            (inner_x + cross_offset as i32, inner_y + offset as i32, c, m)
        };

        compute_layout(child, cx, cy, cw, ch);
        offset += m as f32 + gap;
    }
}