argui-accessibility 0.2.1

Native and web accessibility bridges for Argui interfaces
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

use argui_accessibility::{
    Role, SemanticAction, SemanticNode, SemanticNodeId, SemanticTree, Semantics,
};
use argui_core::{Point, Rect, Size};

fn node(id: u64, label: &str) -> SemanticNode {
    SemanticNode {
        id: SemanticNodeId::new(id),
        bounds: Rect::new(Point::new(0.0, 0.0), Size::new(40.0, 20.0)),
        semantics: Semantics::new(Role::Button)
            .label(label)
            .action(SemanticAction::Click),
        children: Vec::new(),
    }
}

#[test]
fn diff_only_contains_changed_semantics() {
    let old = SemanticTree {
        root: SemanticNodeId::new(1),
        focus: SemanticNodeId::new(2),
        nodes: vec![node(1, "root"), node(2, "Save")],
    };
    let next = SemanticTree {
        root: old.root,
        focus: old.focus,
        nodes: vec![node(1, "root"), node(2, "Saved")],
    };
    let patch = old.diff(&next);
    assert_eq!(patch.upserts, vec![node(2, "Saved")]);
    assert!(patch.removed.is_empty());
    assert_eq!(patch.focus, None);
}

#[test]
fn diff_reports_removed_nodes_and_focus() {
    let old = SemanticTree {
        root: SemanticNodeId::new(1),
        focus: SemanticNodeId::new(2),
        nodes: vec![node(1, "root"), node(2, "Save")],
    };
    let next = SemanticTree {
        root: old.root,
        focus: old.root,
        nodes: vec![node(1, "root")],
    };
    let patch = old.diff(&next);
    assert_eq!(patch.removed, vec![SemanticNodeId::new(2)]);
    assert_eq!(patch.focus, Some(SemanticNodeId::new(1)));
}

#[test]
fn node_lookup_root_changes_and_empty_patches_are_explicit() {
    let old = SemanticTree {
        root: SemanticNodeId::new(1),
        focus: SemanticNodeId::new(1),
        nodes: vec![node(1, "old")],
    };
    let unchanged = old.clone();
    let replacement = SemanticTree {
        root: SemanticNodeId::new(2),
        focus: SemanticNodeId::new(2),
        nodes: vec![node(2, "new")],
    };

    assert_eq!(old.node(old.root), Some(&old.nodes[0]));
    assert_eq!(old.node(SemanticNodeId::new(99)), None);
    assert!(old.diff(&unchanged).is_empty());
    let patch = old.diff(&replacement);
    assert!(!patch.is_empty());
    assert_eq!(patch.root, Some(replacement.root));
    assert_eq!(patch.removed, vec![old.root]);
}

#[test]
fn nested_host_coordinates_follow_parent_movement_and_reparenting() {
    use argui_core::{Point, Size};
    let mut tree = SemanticTree {
        root: SemanticNodeId::new(1),
        focus: SemanticNodeId::new(3),
        nodes: vec![node(1, "root"), node(2, "group"), node(3, "handle")],
    };
    tree.nodes[0].bounds.origin = Point::new(10.0, 15.0);
    tree.nodes[0].children = vec![SemanticNodeId::new(2)];
    tree.nodes[1].bounds.origin = Point::new(100.0, 200.0);
    tree.nodes[1].children = vec![SemanticNodeId::new(3)];
    tree.nodes[2].bounds.origin = Point::new(150.0, 230.0);
    tree.nodes[2].bounds.size = Size::new(12.0, 40.0);
    let local = tree.parent_relative_bounds();
    assert_eq!(local[&tree.nodes[0].id].origin, Point::new(10.0, 15.0));
    assert_eq!(local[&tree.nodes[1].id].origin, Point::new(90.0, 185.0));
    assert_eq!(local[&tree.nodes[2].id].origin, Point::new(50.0, 30.0));
    assert_eq!(local[&tree.nodes[2].id].size, Size::new(12.0, 40.0));
    tree.nodes[1].bounds.origin.x = 120.0;
    assert_eq!(
        tree.parent_relative_bounds()[&tree.nodes[2].id].origin.x,
        30.0
    );
    tree.nodes[1].children.clear();
    tree.nodes[0].children.push(SemanticNodeId::new(3));
    assert_eq!(
        tree.parent_relative_bounds()[&tree.nodes[2].id].origin,
        Point::new(140.0, 215.0)
    );
    tree.nodes[0].children.push(SemanticNodeId::new(99));
    assert_eq!(tree.parent_relative_bounds().len(), 3);
}