Skip to main content

webizen_render/
ui_layout.rs

1//! Zero-Heap Flexbox & CSS-Grid-Lite UI Layout Constraint Solver (`ui_layout.rs`)
2//!
3//! Re-exports the canonical zero-heap UI layout constraint solver from `etalon_render::ui_canvas`.
4
5pub use etalon_render::ui_canvas::{
6    AlignItems, ComputedUiRect, Edges, FlexDirection, HudComputedUiRect, HudUiLayoutTree,
7    HudVertex, JustifyContent, Margin, Padding, SizeRule, UiLayoutNode, UiLayoutStyle,
8    UiLayoutTree, ZeroHeapUiLayoutTree, MAX_UI_LAYOUT_NODES, MAX_UI_NODES, NO_UI_NODE,
9};
10
11#[cfg(test)]
12mod tests {
13    use super::*;
14
15    #[test]
16    fn flex_row_grow_and_padding_distributes_exact_widths() {
17        let mut tree = ZeroHeapUiLayoutTree::new();
18        let root = tree
19            .add_node(
20                1,
21                NO_UI_NODE,
22                UiLayoutStyle {
23                    direction: FlexDirection::Row,
24                    width: SizeRule::Fixed(400.0),
25                    height: SizeRule::Fixed(100.0),
26                    padding: Padding::all(10.0),
27                    gap: 10.0,
28                    align_items: AlignItems::Stretch,
29                    ..Default::default()
30                },
31                [0.0, 0.0],
32            )
33            .unwrap();
34
35        let c0 = tree
36            .add_node(
37                2,
38                root,
39                UiLayoutStyle {
40                    width: SizeRule::Fixed(80.0),
41                    height: SizeRule::Auto,
42                    ..Default::default()
43                },
44                [0.0, 0.0],
45            )
46            .unwrap();
47        let c1 = tree
48            .add_node(
49                3,
50                root,
51                UiLayoutStyle {
52                    width: SizeRule::FlexGrow(1.0),
53                    height: SizeRule::Auto,
54                    ..Default::default()
55                },
56                [0.0, 0.0],
57            )
58            .unwrap();
59        let c2 = tree
60            .add_node(
61                4,
62                root,
63                UiLayoutStyle {
64                    width: SizeRule::FlexGrow(3.0),
65                    height: SizeRule::Auto,
66                    ..Default::default()
67                },
68                [0.0, 0.0],
69            )
70            .unwrap();
71
72        tree.solve(400.0, 100.0);
73
74        let r0 = tree.nodes[c0 as usize].computed;
75        let r1 = tree.nodes[c1 as usize].computed;
76        let r2 = tree.nodes[c2 as usize].computed;
77
78        assert!((r0.x - 10.0).abs() < 1e-4);
79        assert!((r0.width - 80.0).abs() < 1e-4);
80        assert!((r0.height - 80.0).abs() < 1e-4);
81
82        assert!((r1.x - 100.0).abs() < 1e-4);
83        assert!((r1.width - 70.0).abs() < 1e-4);
84
85        assert!((r2.x - 180.0).abs() < 1e-4);
86        assert!((r2.width - 210.0).abs() < 1e-4);
87    }
88
89    #[test]
90    fn grid_layout_arranges_2d_columns_and_rows() {
91        let mut tree = ZeroHeapUiLayoutTree::new();
92        let root = tree
93            .add_node(
94                10,
95                NO_UI_NODE,
96                UiLayoutStyle {
97                    width: SizeRule::Fixed(310.0),
98                    height: SizeRule::Fixed(200.0),
99                    grid_columns: 3,
100                    column_gap: 5.0,
101                    row_gap: 10.0,
102                    ..Default::default()
103                },
104                [0.0, 0.0],
105            )
106            .unwrap();
107
108        let mut items = [0u16; 6];
109        for i in 0..6 {
110            items[i] = tree
111                .add_node(
112                    100 + i as u32,
113                    root,
114                    UiLayoutStyle {
115                        width: SizeRule::FlexGrow(1.0),
116                        height: SizeRule::Fixed(40.0),
117                        ..Default::default()
118                    },
119                    [0.0, 0.0],
120                )
121                .unwrap();
122        }
123
124        tree.solve(310.0, 200.0);
125        // 3 columns across 310px with 2 * 5px gap -> 100px per cell
126        let cell0 = tree.nodes[items[0] as usize].computed;
127        let cell1 = tree.nodes[items[1] as usize].computed;
128        let cell3 = tree.nodes[items[3] as usize].computed;
129        assert!((cell0.width - 100.0).abs() < 1e-4);
130        assert!((cell1.x - 105.0).abs() < 1e-4);
131        assert!((cell3.x - 0.0).abs() < 1e-4);
132        assert!((cell3.y - 50.0).abs() < 1e-4);
133    }
134}