fret-ui 0.1.0

Mechanism-layer UI engine for Fret with tree, layout, focus, routing, and interaction contracts.
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

use super::*;

#[derive(Default)]
struct FocusableLeaf;

impl<H: UiHost> Widget<H> for FocusableLeaf {
    fn is_focusable(&self) -> bool {
        true
    }

    fn layout(&mut self, cx: &mut LayoutCx<'_, H>) -> Size {
        cx.available
    }
}

#[test]
fn focus_barrier_can_remain_active_while_layer_is_hit_test_inert() {
    let mut app = crate::test_host::TestHost::new();
    app.set_global(PlatformCapabilities::default());

    let window = AppWindowId::default();
    let mut ui: UiTree<crate::test_host::TestHost> = UiTree::new();
    ui.set_window(window);

    let base_root = ui.create_node(TestStack);
    let underlay_focusable = ui.create_node(FocusableLeaf);
    ui.set_root(base_root);
    ui.add_child(base_root, underlay_focusable);

    let overlay_root = ui.create_node(TestStack);
    let overlay_a = ui.create_node(FocusableLeaf);
    let overlay_b = ui.create_node(FocusableLeaf);
    ui.add_child(overlay_root, overlay_a);
    ui.add_child(overlay_root, overlay_b);

    // Simulate a close-transition style barrier: the overlay layer is still visible and blocks
    // underlay focus, but it is hit-test-inert for pointer events.
    let overlay_layer = ui.push_overlay_root_with_options(
        overlay_root,
        crate::OverlayRootOptions {
            blocks_underlay_input: false,
            hit_testable: false,
        },
    );

    let mut services = FakeUiServices;
    let bounds = Rect::new(Point::new(Px(0.0), Px(0.0)), Size::new(Px(200.0), Px(80.0)));
    ui.layout_all(&mut app, &mut services, bounds, 1.0);

    // Without an active focus barrier, focusing inside the overlay must be allowed.
    ui.set_focus(Some(overlay_a));
    assert_eq!(ui.focus(), Some(overlay_a));

    // Activating the focus barrier must not clear focus, even if the barrier layer is not
    // hit-testable.
    ui.set_layer_blocks_underlay_focus(overlay_layer, true);
    assert_eq!(ui.focus(), Some(overlay_a));

    // Focus movement within the barrier scope must remain allowed.
    ui.set_focus(Some(overlay_b));
    assert_eq!(ui.focus(), Some(overlay_b));

    // Focus must not be allowed to escape to the underlay while the barrier is active.
    ui.set_focus(Some(underlay_focusable));
    assert_eq!(
        ui.focus(),
        Some(overlay_b),
        "expected focus barrier to reject underlay focus while active"
    );

    // Dispatch-time barrier enforcement must not clear focus under the same conditions.
    ui.dispatch_event(
        &mut app,
        &mut services,
        &Event::Timer {
            token: fret_core::TimerToken(1),
        },
    );
    assert_eq!(ui.focus(), Some(overlay_b));
}

#[test]
fn focus_traversal_dispatch_uses_focus_barrier_scope_when_input_barrier_is_off() {
    let mut app = crate::test_host::TestHost::new();
    app.set_global(PlatformCapabilities::default());

    let window = AppWindowId::default();
    let mut ui: UiTree<crate::test_host::TestHost> = UiTree::new();
    ui.set_window(window);

    let base_root = ui.create_node(TestStack);
    let underlay_focusable = ui.create_node(FocusableLeaf);
    ui.set_root(base_root);
    ui.add_child(base_root, underlay_focusable);

    let overlay_root = ui.create_node(TestStack);
    let overlay_a = ui.create_node(FocusableLeaf);
    let overlay_b = ui.create_node(FocusableLeaf);
    ui.add_child(overlay_root, overlay_a);
    ui.add_child(overlay_root, overlay_b);

    let overlay_layer = ui.push_overlay_root_with_options(
        overlay_root,
        crate::OverlayRootOptions {
            blocks_underlay_input: false,
            hit_testable: false,
        },
    );

    let mut services = FakeUiServices;
    let bounds = Rect::new(Point::new(Px(0.0), Px(0.0)), Size::new(Px(200.0), Px(80.0)));
    ui.layout_all(&mut app, &mut services, bounds, 1.0);

    ui.set_layer_blocks_underlay_focus(overlay_layer, true);
    assert_eq!(
        ui.command_availability(&mut app, &CommandId::from("focus.next")),
        crate::CommandAvailability::Available
    );

    ui.set_focus(Some(overlay_a));
    let did_handle = ui.dispatch_command(&mut app, &mut services, &CommandId::from("focus.next"));
    assert!(did_handle);
    assert_eq!(
        ui.focus(),
        Some(overlay_b),
        "focus traversal should stay inside the focus barrier scope even when the layer is not part of active input roots"
    );

    let did_handle = ui.dispatch_command(&mut app, &mut services, &CommandId::from("focus.next"));
    assert!(did_handle);
    assert_eq!(
        ui.focus(),
        Some(overlay_a),
        "focus traversal should wrap within the focused overlay instead of escaping to the underlay"
    );
}