mirui 0.33.1

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

//! Multi-representation bundle demo — one row where each character is
//! a step larger than the last, all from a single bundled `Font`. Small
//! sizes resolve to baked pixel tables (crisp 1-bit, 10px then 12px);
//! once a size outgrows the largest pixel table it falls to the SDF
//! table, scaled to the request. The caller only sets a size per glyph;
//! the bundle picks the representation.

extern crate alloc;

use crate::prelude::*;
use crate::render::font::{FontManager, multi};
use crate::ui::widgets::Text;

const BUNDLE: &[u8] = include_bytes!("assets/multi_font_bundle.mirx");

// One glyph per ascending size. 10/12 land on the pixel tables; the
// rest outgrow them and resolve to the scaled SDF.
const STEPS: [(&str, u16); 6] = [
    ("你", 10),
    ("好", 12),
    ("世", 16),
    ("界", 22),
    ("文", 32),
    ("字", 44),
];

fn token(size: u16) -> FontToken {
    match size {
        10 => FontToken::Custom("step10"),
        12 => FontToken::Custom("step12"),
        16 => FontToken::Custom("step16"),
        22 => FontToken::Custom("step22"),
        32 => FontToken::Custom("step32"),
        _ => FontToken::Custom("step44"),
    }
}

pub fn register_font(world: &mut World) {
    let Some(mgr) = world.resource::<FontManager>() else {
        return;
    };
    for (_, size) in STEPS {
        let mut font = multi::font_from_mirx_bundle("Bundle", BUNDLE).expect("bundle parses");
        font.size = size;
        mgr.add_static(token(size).cache_key(), font);
    }
}

pub fn build_widgets(world: &mut World, parent: Entity) {
    //~focus-start
    ui! {
        :(
            parent: parent
            world: world
        :)

        Row (
            grow: 1.0,
            padding: Padding::all(8),
            justify: JustifyContent::SpaceEvenly,
            align: AlignItems::Center
        ) {
            walk STEPS.iter() with step {
                Text (
                    step.0,
                    font: token(step.1),
                    text_color: Color::rgb(255, 210, 130)
                )
            }
        }
    };
    //~focus-end
}

#[cfg(feature = "std")]
pub fn setup_app<B, F>(app: &mut App<B, F>, parent: Entity)
where
    B: Surface,
    F: RendererFactory<B>,
{
    register_font(&mut app.world);
    build_widgets(&mut app.world, parent);
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ui::Children;
    use crate::ui::IdMap;

    #[test]
    fn bundle_font_reports_a_pixel_default_size() {
        let font = multi::font_from_mirx_bundle("Bundle", BUNDLE).unwrap();
        assert_eq!(font.size, 12);
    }

    #[test]
    fn build_widgets_smoke() {
        let mut world = World::new();
        world.insert_resource(IdMap::new());
        world.insert_resource(crate::render::font::default_font_manager());
        register_font(&mut world);
        let parent = WidgetBuilder::new(&mut world).id();
        build_widgets(&mut world, parent);
        let row = world
            .get::<Children>(parent)
            .and_then(|c| c.0.first().copied())
            .expect("demo did not add a row to parent");
        assert!(
            world
                .get::<Children>(row)
                .is_some_and(|c| c.0.len() == STEPS.len()),
            "row did not hold one Text per step",
        );
    }
}