ansiq-runtime 0.1.0

Application loop, focus routing, subtree replacement, and redraw orchestration for Ansiq.
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

use ansiq_core::{
    BoxProps, Direction, Element, ElementKind, InputProps, Layout, Length, Rect, TextProps,
};
use ansiq_layout::layout_tree;
use ansiq_runtime::FocusState;

fn text(content: &str) -> Element<()> {
    Element::new(ElementKind::Text(TextProps {
        content: content.to_string(),
    }))
}

fn input(value: &str) -> Element<()> {
    Element::new(ElementKind::Input(InputProps {
        value: value.to_string(),
        placeholder: String::new(),
        on_change: None,
        on_submit: None,
        cursor: value.chars().count(),
    }))
    .with_layout(Layout {
        width: Length::Fill,
        height: Length::Fixed(3),
    })
    .with_focusable(true)
}

#[test]
fn focus_state_collects_focusable_nodes_in_preorder() {
    let tree = layout_tree(
        Element::new(ElementKind::Box(BoxProps {
            direction: Direction::Column,
            gap: 0,
        }))
        .with_children(vec![input("a"), text("label"), input("b")]),
        Rect::new(0, 0, 20, 7),
    );

    let mut focus = FocusState::default();
    focus.sync_from_tree(&tree);

    assert_eq!(focus.current(), Some(tree.children[0].id));
    focus.next();
    assert_eq!(focus.current(), Some(tree.children[2].id));
    focus.next();
    assert_eq!(focus.current(), Some(tree.children[0].id));
    focus.prev();
    assert_eq!(focus.current(), Some(tree.children[2].id));
}

#[test]
fn focus_state_preserves_current_node_when_tree_is_rebuilt() {
    let first_tree = layout_tree(
        Element::new(ElementKind::Box(BoxProps {
            direction: Direction::Column,
            gap: 0,
        }))
        .with_children(vec![input("a"), input("b")]),
        Rect::new(0, 0, 20, 6),
    );

    let mut focus = FocusState::default();
    focus.sync_from_tree(&first_tree);
    focus.next();

    let second_tree = layout_tree(
        Element::new(ElementKind::Box(BoxProps {
            direction: Direction::Column,
            gap: 0,
        }))
        .with_children(vec![input("a"), input("b")]),
        Rect::new(0, 0, 20, 6),
    );

    focus.sync_from_tree(&second_tree);
    assert_eq!(focus.current(), Some(second_tree.children[1].id));
}

#[test]
fn focus_state_can_trap_tab_order_inside_a_continuity_scoped_subtree() {
    let tree = layout_tree(
        Element::new(ElementKind::Box(BoxProps {
            direction: Direction::Column,
            gap: 0,
        }))
        .with_children(vec![
            Element::new(ElementKind::Box(BoxProps {
                direction: Direction::Column,
                gap: 0,
            }))
            .with_continuity_key("outside")
            .with_children(vec![input("a")]),
            Element::new(ElementKind::Box(BoxProps {
                direction: Direction::Column,
                gap: 0,
            }))
            .with_continuity_key("modal")
            .with_children(vec![input("b"), input("c")]),
        ]),
        Rect::new(0, 0, 20, 9),
    );

    let modal_first = tree.children[1].children[0].id;
    let modal_second = tree.children[1].children[1].id;

    let mut focus = FocusState::default();
    focus.set_scope_key(Some("modal".to_string()));
    focus.sync_from_tree(&tree);

    assert_eq!(focus.scope_key(), Some("modal"));
    assert_eq!(focus.current(), Some(modal_first));
    focus.next();
    assert_eq!(focus.current(), Some(modal_second));
    focus.next();
    assert_eq!(focus.current(), Some(modal_first));
}