mtk-rs 0.1.0-beta.3

Muse Toolkit
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

use crate::{Context, Node};
use accesskit::{
    Node as AkNode, NodeId as AkNodeId, Rect as AkRect, Role, TreeId, TreeInfo, TreeUpdate,
};

/// Converts an MTK layout `Node` into an `accesskit::NodeId` by packing generation and index.
#[inline(always)]
pub fn to_accesskit_id(node: Node) -> AkNodeId {
    let val = ((node.0.generation as u64) << 32) | (node.0.index as u64);
    AkNodeId(val)
}

/// Unpacks an `accesskit::NodeId` back into an MTK layout `Node`.
#[inline(always)]
pub fn from_accesskit_id(id: AkNodeId) -> Node {
    let val = id.0;
    Node(crate::layout::NodeId {
        index: val as u32,
        generation: (val >> 32) as u32,
    })
}

/// Builds an `accesskit::TreeUpdate` from the current MTK `Context`.
pub fn build_tree_update(ctx: &mut Context, is_full: bool) -> TreeUpdate {
    let root = match ctx.root_node() {
        Some(r) => r,
        None => {
            return TreeUpdate {
                nodes: Vec::new(),
                tree: None,
                tree_id: TreeId::ROOT,
                focus: AkNodeId(0),
            };
        }
    };

    let root_id = to_accesskit_id(root);
    let focus = ctx.focused_node.map(to_accesskit_id).unwrap_or(root_id);

    let tree = if is_full {
        let mut t = TreeInfo::new(root_id);
        t.toolkit_name = Some("MTK".to_string());
        Some(t)
    } else {
        None
    };

    let mut nodes = Vec::new();
    let mut stack = vec![root];

    while let Some(curr) = stack.pop() {
        let curr_id = to_accesskit_id(curr);
        let children_list = curr.children(ctx);
        let child_ids: Vec<AkNodeId> = children_list.iter().copied().map(to_accesskit_id).collect();

        let mut ak_node = if let Some(info) = ctx.accessibility_nodes.get(&curr) {
            let mut n = AkNode::new(info.role);
            if let Some(label) = &info.label {
                n.set_label(label.as_str());
            }
            if let Some(val) = &info.value {
                n.set_value(val.as_str());
            }
            if let Some(desc) = &info.description {
                n.set_description(desc.as_str());
            }
            if info.disabled {
                n.set_disabled();
            }
            if info.hidden {
                n.set_hidden();
            }
            if let Some(toggled) = info.toggled {
                n.set_toggled(if toggled {
                    accesskit::Toggled::True
                } else {
                    accesskit::Toggled::False
                });
            }
            if let Some(num) = info.numeric_value {
                n.set_numeric_value(num);
            }
            if let Some(min) = info.min_numeric_value {
                n.set_min_numeric_value(min);
            }
            if let Some(max) = info.max_numeric_value {
                n.set_max_numeric_value(max);
            }
            if let Some(step) = info.step {
                n.set_numeric_value_step(step);
            }
            for &action in &info.actions {
                n.add_action(action);
            }
            n
        } else if let Some(text) = curr.get_text(ctx) {
            let mut n = AkNode::new(Role::Label);
            n.set_label(text);
            n
        } else if curr == root {
            AkNode::new(Role::Window)
        } else {
            AkNode::new(Role::GenericContainer)
        };

        if let Some(computed) = curr.get_computed(ctx) {
            ak_node.set_bounds(AkRect {
                x0: computed.x as f64,
                y0: computed.y as f64,
                x1: (computed.x + computed.w) as f64,
                y1: (computed.y + computed.h) as f64,
            });
        }

        ak_node.set_children(child_ids);
        nodes.push((curr_id, ak_node));

        for child in children_list.into_iter().rev() {
            stack.push(child);
        }
    }

    ctx.dirty_accessibility.clear();

    TreeUpdate {
        nodes,
        tree,
        tree_id: TreeId::ROOT,
        focus,
    }
}