accesskit_unix/atspi/interfaces/
accessible.rs

1// Copyright 2022 The AccessKit Authors. All rights reserved.
2// Licensed under the Apache License, Version 2.0 (found in
3// the LICENSE-APACHE file) or the MIT license (found in
4// the LICENSE-MIT file), at your option.
5
6use std::collections::HashMap;
7
8use accesskit_atspi_common::{NodeIdOrRoot, PlatformNode, PlatformRoot};
9use atspi::{Interface, InterfaceSet, RelationType, Role, StateSet};
10use zbus::{fdo, interface, names::OwnedUniqueName};
11
12use super::map_root_error;
13use crate::atspi::{ObjectId, OwnedObjectAddress};
14
15pub(crate) struct NodeAccessibleInterface {
16    bus_name: OwnedUniqueName,
17    node: PlatformNode,
18}
19
20impl NodeAccessibleInterface {
21    pub fn new(bus_name: OwnedUniqueName, node: PlatformNode) -> Self {
22        Self { bus_name, node }
23    }
24
25    fn map_error(&self) -> impl '_ + FnOnce(accesskit_atspi_common::Error) -> fdo::Error {
26        |error| crate::util::map_error_from_node(&self.node, error)
27    }
28}
29
30#[interface(name = "org.a11y.atspi.Accessible")]
31impl NodeAccessibleInterface {
32    #[zbus(property)]
33    fn name(&self) -> fdo::Result<String> {
34        self.node.name().map_err(self.map_error())
35    }
36
37    #[zbus(property)]
38    fn description(&self) -> fdo::Result<String> {
39        self.node.description().map_err(self.map_error())
40    }
41
42    #[zbus(property)]
43    fn parent(&self) -> fdo::Result<OwnedObjectAddress> {
44        self.node.parent().map_err(self.map_error()).map(|parent| {
45            match parent {
46                NodeIdOrRoot::Node(node) => ObjectId::Node {
47                    adapter: self.node.adapter_id(),
48                    node,
49                },
50                NodeIdOrRoot::Root => ObjectId::Root,
51            }
52            .to_address(self.bus_name.inner())
53        })
54    }
55
56    #[zbus(property)]
57    fn child_count(&self) -> fdo::Result<i32> {
58        self.node.child_count().map_err(self.map_error())
59    }
60
61    #[zbus(property)]
62    fn locale(&self) -> &str {
63        ""
64    }
65
66    #[zbus(property)]
67    fn accessible_id(&self) -> fdo::Result<String> {
68        self.node.accessible_id().map_err(self.map_error())
69    }
70
71    fn get_child_at_index(&self, index: i32) -> fdo::Result<(OwnedObjectAddress,)> {
72        let index = index
73            .try_into()
74            .map_err(|_| fdo::Error::InvalidArgs("Index can't be negative.".into()))?;
75        let child = self
76            .node
77            .child_at_index(index)
78            .map_err(self.map_error())?
79            .map(|child| ObjectId::Node {
80                adapter: self.node.adapter_id(),
81                node: child,
82            });
83        Ok(super::optional_object_address(&self.bus_name, child))
84    }
85
86    fn get_children(&self) -> fdo::Result<Vec<OwnedObjectAddress>> {
87        self.node
88            .map_children(|child| {
89                ObjectId::Node {
90                    adapter: self.node.adapter_id(),
91                    node: child,
92                }
93                .to_address(self.bus_name.inner())
94            })
95            .map_err(self.map_error())
96    }
97
98    fn get_index_in_parent(&self) -> fdo::Result<i32> {
99        self.node.index_in_parent().map_err(self.map_error())
100    }
101
102    fn get_relation_set(&self) -> fdo::Result<Vec<(RelationType, Vec<OwnedObjectAddress>)>> {
103        self.node
104            .relation_set(|relation| {
105                ObjectId::Node {
106                    adapter: self.node.adapter_id(),
107                    node: relation,
108                }
109                .to_address(self.bus_name.inner())
110            })
111            .map(|set| {
112                set.into_iter()
113                    .collect::<Vec<(RelationType, Vec<OwnedObjectAddress>)>>()
114            })
115            .map_err(self.map_error())
116    }
117
118    fn get_role(&self) -> fdo::Result<Role> {
119        self.node.role().map_err(self.map_error())
120    }
121
122    fn get_localized_role_name(&self) -> fdo::Result<String> {
123        self.node.localized_role_name().map_err(self.map_error())
124    }
125
126    fn get_state(&self) -> StateSet {
127        self.node.state()
128    }
129
130    fn get_attributes(&self) -> fdo::Result<HashMap<&str, String>> {
131        self.node.attributes().map_err(self.map_error())
132    }
133
134    fn get_application(&self) -> (OwnedObjectAddress,) {
135        (ObjectId::Root.to_address(self.bus_name.inner()),)
136    }
137
138    fn get_interfaces(&self) -> fdo::Result<InterfaceSet> {
139        self.node.interfaces().map_err(self.map_error())
140    }
141}
142
143pub(crate) struct RootAccessibleInterface {
144    bus_name: OwnedUniqueName,
145    root: PlatformRoot,
146}
147
148impl RootAccessibleInterface {
149    pub fn new(bus_name: OwnedUniqueName, root: PlatformRoot) -> Self {
150        Self { bus_name, root }
151    }
152}
153
154#[interface(name = "org.a11y.atspi.Accessible")]
155impl RootAccessibleInterface {
156    #[zbus(property)]
157    fn name(&self) -> fdo::Result<String> {
158        self.root.name().map_err(map_root_error)
159    }
160
161    #[zbus(property)]
162    fn description(&self) -> &str {
163        ""
164    }
165
166    #[zbus(property)]
167    fn parent(&self) -> OwnedObjectAddress {
168        OwnedObjectAddress::null()
169    }
170
171    #[zbus(property)]
172    fn child_count(&self) -> fdo::Result<i32> {
173        self.root.child_count().map_err(map_root_error)
174    }
175
176    #[zbus(property)]
177    fn locale(&self) -> &str {
178        ""
179    }
180
181    #[zbus(property)]
182    fn accessible_id(&self) -> &str {
183        ""
184    }
185
186    fn get_child_at_index(&self, index: i32) -> fdo::Result<(OwnedObjectAddress,)> {
187        let index = index
188            .try_into()
189            .map_err(|_| fdo::Error::InvalidArgs("Index can't be negative.".into()))?;
190        let child = self
191            .root
192            .child_id_at_index(index)
193            .map_err(map_root_error)?
194            .map(|(adapter, node)| ObjectId::Node { adapter, node });
195        Ok(super::optional_object_address(&self.bus_name, child))
196    }
197
198    fn get_children(&self) -> fdo::Result<Vec<OwnedObjectAddress>> {
199        self.root
200            .map_child_ids(|(adapter, node)| {
201                ObjectId::Node { adapter, node }.to_address(self.bus_name.inner())
202            })
203            .map_err(map_root_error)
204    }
205
206    fn get_index_in_parent(&self) -> i32 {
207        -1
208    }
209
210    fn get_relation_set(&self) -> Vec<(RelationType, Vec<OwnedObjectAddress>)> {
211        Vec::new()
212    }
213
214    fn get_role(&self) -> Role {
215        Role::Application
216    }
217
218    fn get_state(&self) -> StateSet {
219        StateSet::empty()
220    }
221
222    fn get_application(&self) -> (OwnedObjectAddress,) {
223        (ObjectId::Root.to_address(self.bus_name.inner()),)
224    }
225
226    fn get_interfaces(&self) -> InterfaceSet {
227        InterfaceSet::new(Interface::Accessible | Interface::Application)
228    }
229}
accesskit_unix/atspi/interfaces/accessible.rs

accesskit_unix/atspi/interfaces/
accessible.rs
