mirui 0.15.2

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

use crate::ecs::{Entity, World};
use crate::types::Opa;
use crate::widget::Parent;
use crate::widget::dirty::Dirty;
use crate::widget::visibility::Hidden;

use super::Style;

/// Marker that disables interaction on the entity and its
/// descendants. Layout and render still run, but pointer / key
/// events are swallowed at dispatch entry, focus traversal skips,
/// and visuals dim through `Style.disabled_alpha`.
///
/// Walk semantics mirror `Hidden`: an ancestor carrying `Disabled`
/// disables the whole subtree. Toggle by inserting / removing.
pub struct Disabled;

/// Hardcoded 38% × 255 ≈ 97. Tracks Material 3's disabled-state alpha.
const DISABLED_ALPHA: Opa = 97;

// Hidden short-circuits: the entity is already invisible, so writing
// `disabled_alpha` would only dirty-trash a hidden subtree.
fn entity_is_disabled(world: &World, entity: Entity) -> bool {
    let mut cur = Some(entity);
    while let Some(e) = cur {
        if world.get::<Hidden>(e).is_some() {
            return false;
        }
        if world.get::<Disabled>(e).is_some() {
            return true;
        }
        cur = world.get::<Parent>(e).map(|p| p.0);
    }
    false
}

#[crate::system(order = ANIMATION)]
pub fn disabled_visual_system(world: &mut World) {
    let entities: alloc::vec::Vec<Entity> = world.query::<Style>().collect();
    for entity in entities {
        let want = if entity_is_disabled(world, entity) {
            Some(DISABLED_ALPHA)
        } else {
            None
        };
        let cur = world.get::<Style>(entity).and_then(|s| s.disabled_alpha);
        if cur != want {
            if let Some(style) = world.get_mut::<Style>(entity) {
                style.disabled_alpha = want;
            }
            world.insert(entity, Dirty);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn make_child(world: &mut World, parent: Entity) -> Entity {
        let child = world.spawn();
        world.insert(child, Style::default());
        world.insert(child, Parent(parent));
        child
    }

    fn make_root(world: &mut World) -> Entity {
        let root = world.spawn();
        world.insert(root, Style::default());
        root
    }

    #[test]
    fn marks_self_disabled_alpha() {
        let mut world = World::new();
        let e = make_root(&mut world);
        world.insert(e, Disabled);
        disabled_visual_system(&mut world);
        assert_eq!(
            world.get::<Style>(e).unwrap().disabled_alpha,
            Some(DISABLED_ALPHA)
        );
    }

    #[test]
    fn descendant_inherits_disabled_alpha() {
        let mut world = World::new();
        let parent = make_root(&mut world);
        let child = make_child(&mut world, parent);
        world.insert(parent, Disabled);
        disabled_visual_system(&mut world);
        assert_eq!(
            world.get::<Style>(child).unwrap().disabled_alpha,
            Some(DISABLED_ALPHA)
        );
    }

    #[test]
    fn removing_disabled_clears_alpha() {
        let mut world = World::new();
        let e = make_root(&mut world);
        world.insert(e, Disabled);
        disabled_visual_system(&mut world);
        world.remove::<Disabled>(e);
        disabled_visual_system(&mut world);
        assert_eq!(world.get::<Style>(e).unwrap().disabled_alpha, None);
    }

    #[test]
    fn hidden_ancestor_skips_disabled_alpha() {
        let mut world = World::new();
        let parent = make_root(&mut world);
        let child = make_child(&mut world, parent);
        world.insert(parent, Hidden);
        world.insert(parent, Disabled);
        disabled_visual_system(&mut world);
        assert_eq!(world.get::<Style>(child).unwrap().disabled_alpha, None);
    }

    #[test]
    fn unrelated_entity_unaffected() {
        let mut world = World::new();
        let a = make_root(&mut world);
        let b = make_root(&mut world);
        world.insert(a, Disabled);
        disabled_visual_system(&mut world);
        assert_eq!(world.get::<Style>(b).unwrap().disabled_alpha, None);
    }
}