1// Copyright 2021 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
6// Derived from Chromium's accessibility abstraction.
7// Copyright 2021 The Chromium Authors. All rights reserved.
8// Use of this source code is governed by a BSD-style license that can be
9// found in the LICENSE.chromium file.
10
11use accesskit::{
12 Action, Affine, FrozenNode as NodeData, Live, NodeId, Orientation, Point, Rect, Role,
13 TextSelection, Toggled,
14};
15use alloc::{
16 string::{String, ToString},
17 sync::Arc,
18 vec::Vec,
19};
20use core::iter::FusedIterator;
21
22use crate::filters::FilterResult;
23use crate::iterators::{
24 FilteredChildren, FollowingFilteredSiblings, FollowingSiblings, LabelledBy,
25 PrecedingFilteredSiblings, PrecedingSiblings,
26};
27use crate::tree::State as TreeState;
28
29#[derive(Clone, Copy, PartialEq, Eq)]
30pub(crate) struct ParentAndIndex(pub(crate) NodeId, pub(crate) usize);
31
32#[derive(Clone)]
33pub(crate) struct NodeState {
34 pub(crate) parent_and_index: Option<ParentAndIndex>,
35 pub(crate) data: Arc<NodeData>,
36}
37
38#[derive(Copy, Clone)]
39pub struct Node<'a> {
40 pub tree_state: &'a TreeState,
41 pub(crate) id: NodeId,
42 pub(crate) state: &'a NodeState,
43}
44
45impl<'a> Node<'a> {
46 pub(crate) fn data(&self) -> &NodeData {
47 &self.state.data
48 }
49
50 pub fn is_focused(&self) -> bool {
51 self.tree_state.focus_id() == Some(self.id())
52 }
53
54 pub fn is_focused_in_tree(&self) -> bool {
55 self.tree_state.focus == self.id()
56 }
57
58 pub fn is_focusable(&self) -> bool {
59 self.supports_action(Action::Focus) || self.is_focused_in_tree()
60 }
61
62 pub fn is_root(&self) -> bool {
63 // Don't check for absence of a parent node, in case a non-root node
64 // somehow gets detached from the tree.
65 self.id() == self.tree_state.root_id()
66 }
67
68 pub fn parent_id(&self) -> Option<NodeId> {
69 self.state
70 .parent_and_index
71 .as_ref()
72 .map(|ParentAndIndex(id, _)| *id)
73 }
74
75 pub fn parent(&self) -> Option<Node<'a>> {
76 self.parent_id()
77 .map(|id| self.tree_state.node_by_id(id).unwrap())
78 }
79
80 pub fn filtered_parent(&self, filter: &impl Fn(&Node) -> FilterResult) -> Option<Node<'a>> {
81 self.parent().and_then(move |parent| {
82 if filter(&parent) == FilterResult::Include {
83 Some(parent)
84 } else {
85 parent.filtered_parent(filter)
86 }
87 })
88 }
89
90 pub fn parent_and_index(self) -> Option<(Node<'a>, usize)> {
91 self.state
92 .parent_and_index
93 .as_ref()
94 .map(|ParentAndIndex(parent, index)| {
95 (self.tree_state.node_by_id(*parent).unwrap(), *index)
96 })
97 }
98
99 pub fn child_ids(
100 &self,
101 ) -> impl DoubleEndedIterator<Item = NodeId>
102 + ExactSizeIterator<Item = NodeId>
103 + FusedIterator<Item = NodeId>
104 + '_ {
105 let data = &self.state.data;
106 data.children().iter().copied()
107 }
108
109 pub fn children(
110 &self,
111 ) -> impl DoubleEndedIterator<Item = Node<'a>>
112 + ExactSizeIterator<Item = Node<'a>>
113 + FusedIterator<Item = Node<'a>>
114 + 'a {
115 let state = self.tree_state;
116 let data = &self.state.data;
117 data.children()
118 .iter()
119 .map(move |id| state.node_by_id(*id).unwrap())
120 }
121
122 pub fn filtered_children(
123 &self,
124 filter: impl Fn(&Node) -> FilterResult + 'a,
125 ) -> impl DoubleEndedIterator<Item = Node<'a>> + FusedIterator<Item = Node<'a>> + 'a {
126 FilteredChildren::new(*self, filter)
127 }
128
129 pub fn following_sibling_ids(
130 &self,
131 ) -> impl DoubleEndedIterator<Item = NodeId>
132 + ExactSizeIterator<Item = NodeId>
133 + FusedIterator<Item = NodeId>
134 + 'a {
135 FollowingSiblings::new(*self)
136 }
137
138 pub fn following_siblings(
139 &self,
140 ) -> impl DoubleEndedIterator<Item = Node<'a>>
141 + ExactSizeIterator<Item = Node<'a>>
142 + FusedIterator<Item = Node<'a>>
143 + 'a {
144 let state = self.tree_state;
145 self.following_sibling_ids()
146 .map(move |id| state.node_by_id(id).unwrap())
147 }
148
149 pub fn following_filtered_siblings(
150 &self,
151 filter: impl Fn(&Node) -> FilterResult + 'a,
152 ) -> impl DoubleEndedIterator<Item = Node<'a>> + FusedIterator<Item = Node<'a>> + 'a {
153 FollowingFilteredSiblings::new(*self, filter)
154 }
155
156 pub fn preceding_sibling_ids(
157 &self,
158 ) -> impl DoubleEndedIterator<Item = NodeId>
159 + ExactSizeIterator<Item = NodeId>
160 + FusedIterator<Item = NodeId>
161 + 'a {
162 PrecedingSiblings::new(*self)
163 }
164
165 pub fn preceding_siblings(
166 &self,
167 ) -> impl DoubleEndedIterator<Item = Node<'a>>
168 + ExactSizeIterator<Item = Node<'a>>
169 + FusedIterator<Item = Node<'a>>
170 + 'a {
171 let state = self.tree_state;
172 self.preceding_sibling_ids()
173 .map(move |id| state.node_by_id(id).unwrap())
174 }
175
176 pub fn preceding_filtered_siblings(
177 &self,
178 filter: impl Fn(&Node) -> FilterResult + 'a,
179 ) -> impl DoubleEndedIterator<Item = Node<'a>> + FusedIterator<Item = Node<'a>> + 'a {
180 PrecedingFilteredSiblings::new(*self, filter)
181 }
182
183 pub fn deepest_first_child(self) -> Option<Node<'a>> {
184 let mut deepest_child = self.children().next()?;
185 while let Some(first_child) = deepest_child.children().next() {
186 deepest_child = first_child;
187 }
188 Some(deepest_child)
189 }
190
191 pub fn deepest_first_filtered_child(
192 &self,
193 filter: &impl Fn(&Node) -> FilterResult,
194 ) -> Option<Node<'a>> {
195 let mut deepest_child = self.first_filtered_child(filter)?;
196 while let Some(first_child) = deepest_child.first_filtered_child(filter) {
197 deepest_child = first_child;
198 }
199 Some(deepest_child)
200 }
201
202 pub fn deepest_last_child(self) -> Option<Node<'a>> {
203 let mut deepest_child = self.children().next_back()?;
204 while let Some(last_child) = deepest_child.children().next_back() {
205 deepest_child = last_child;
206 }
207 Some(deepest_child)
208 }
209
210 pub fn deepest_last_filtered_child(
211 &self,
212 filter: &impl Fn(&Node) -> FilterResult,
213 ) -> Option<Node<'a>> {
214 let mut deepest_child = self.last_filtered_child(filter)?;
215 while let Some(last_child) = deepest_child.last_filtered_child(filter) {
216 deepest_child = last_child;
217 }
218 Some(deepest_child)
219 }
220
221 pub fn is_descendant_of(&self, ancestor: &Node) -> bool {
222 if self.id() == ancestor.id() {
223 return true;
224 }
225 if let Some(parent) = self.parent() {
226 return parent.is_descendant_of(ancestor);
227 }
228 false
229 }
230
231 /// Returns the transform defined directly on this node, or the identity
232 /// transform, without taking into account transforms on ancestors.
233 pub fn direct_transform(&self) -> Affine {
234 self.data()
235 .transform()
236 .map_or(Affine::IDENTITY, |value| *value)
237 }
238
239 /// Returns the combined affine transform of this node and its ancestors,
240 /// up to and including the root of this node's tree.
241 pub fn transform(&self) -> Affine {
242 self.parent()
243 .map_or(Affine::IDENTITY, |parent| parent.transform())
244 * self.direct_transform()
245 }
246
247 pub(crate) fn relative_transform(&self, stop_at: &Node) -> Affine {
248 let parent_transform = if let Some(parent) = self.parent() {
249 if parent.id() == stop_at.id() {
250 Affine::IDENTITY
251 } else {
252 parent.relative_transform(stop_at)
253 }
254 } else {
255 Affine::IDENTITY
256 };
257 parent_transform * self.direct_transform()
258 }
259
260 pub fn raw_bounds(&self) -> Option<Rect> {
261 self.data().bounds()
262 }
263
264 pub fn has_bounds(&self) -> bool {
265 self.raw_bounds().is_some()
266 }
267
268 /// Returns the node's transformed bounding box relative to the tree's
269 /// container (e.g. window).
270 pub fn bounding_box(&self) -> Option<Rect> {
271 self.raw_bounds()
272 .as_ref()
273 .map(|rect| self.transform().transform_rect_bbox(*rect))
274 }
275
276 pub(crate) fn bounding_box_in_coordinate_space(&self, other: &Node) -> Option<Rect> {
277 self.raw_bounds()
278 .as_ref()
279 .map(|rect| self.relative_transform(other).transform_rect_bbox(*rect))
280 }
281
282 pub(crate) fn hit_test(
283 &self,
284 point: Point,
285 filter: &impl Fn(&Node) -> FilterResult,
286 ) -> Option<(Node<'a>, Point)> {
287 let filter_result = filter(self);
288
289 if filter_result == FilterResult::ExcludeSubtree {
290 return None;
291 }
292
293 for child in self.children().rev() {
294 let point = child.direct_transform().inverse() * point;
295 if let Some(result) = child.hit_test(point, filter) {
296 return Some(result);
297 }
298 }
299
300 if filter_result == FilterResult::Include {
301 if let Some(rect) = &self.raw_bounds() {
302 if rect.contains(point) {
303 return Some((*self, point));
304 }
305 }
306 }
307
308 None
309 }
310
311 /// Returns the deepest filtered node, either this node or a descendant,
312 /// at the given point in this node's coordinate space.
313 pub fn node_at_point(
314 &self,
315 point: Point,
316 filter: &impl Fn(&Node) -> FilterResult,
317 ) -> Option<Node<'a>> {
318 self.hit_test(point, filter).map(|(node, _)| node)
319 }
320
321 pub fn id(&self) -> NodeId {
322 self.id
323 }
324
325 pub fn role(&self) -> Role {
326 self.data().role()
327 }
328
329 pub fn role_description(&self) -> Option<String> {
330 self.data().role_description().map(String::from)
331 }
332
333 pub fn has_role_description(&self) -> bool {
334 self.data().role_description().is_some()
335 }
336
337 pub fn is_hidden(&self) -> bool {
338 self.data().is_hidden()
339 }
340
341 pub fn is_disabled(&self) -> bool {
342 self.data().is_disabled()
343 }
344
345 pub fn is_read_only(&self) -> bool {
346 let data = self.data();
347 if data.is_read_only() {
348 true
349 } else {
350 self.should_have_read_only_state_by_default() || !self.is_read_only_supported()
351 }
352 }
353
354 pub fn is_read_only_or_disabled(&self) -> bool {
355 self.is_read_only() || self.is_disabled()
356 }
357
358 pub fn toggled(&self) -> Option<Toggled> {
359 self.data().toggled()
360 }
361
362 pub fn numeric_value(&self) -> Option<f64> {
363 self.data().numeric_value()
364 }
365
366 pub fn min_numeric_value(&self) -> Option<f64> {
367 self.data().min_numeric_value()
368 }
369
370 pub fn max_numeric_value(&self) -> Option<f64> {
371 self.data().max_numeric_value()
372 }
373
374 pub fn numeric_value_step(&self) -> Option<f64> {
375 self.data().numeric_value_step()
376 }
377
378 pub fn numeric_value_jump(&self) -> Option<f64> {
379 self.data().numeric_value_jump()
380 }
381
382 pub fn is_text_input(&self) -> bool {
383 matches!(
384 self.role(),
385 Role::TextInput
386 | Role::MultilineTextInput
387 | Role::SearchInput
388 | Role::DateInput
389 | Role::DateTimeInput
390 | Role::WeekInput
391 | Role::MonthInput
392 | Role::TimeInput
393 | Role::EmailInput
394 | Role::NumberInput
395 | Role::PasswordInput
396 | Role::PhoneNumberInput
397 | Role::UrlInput
398 | Role::EditableComboBox
399 | Role::SpinButton
400 )
401 }
402
403 pub fn is_multiline(&self) -> bool {
404 self.role() == Role::MultilineTextInput
405 }
406
407 pub fn orientation(&self) -> Option<Orientation> {
408 self.data().orientation()
409 }
410
411 // When probing for supported actions as the next several functions do,
412 // it's tempting to check the role. But it's better to not assume anything
413 // beyond what the provider has explicitly told us. Rationale:
414 // if the provider developer forgot to call `add_action` for an action,
415 // an AT (or even AccessKit itself) can fall back to simulating
416 // a mouse click. But if the provider doesn't handle an action request
417 // and we assume that it will based on the role, the attempted action
418 // does nothing. This stance is a departure from Chromium.
419
420 pub fn is_clickable(&self) -> bool {
421 self.supports_action(Action::Click)
422 }
423
424 pub fn supports_toggle(&self) -> bool {
425 self.toggled().is_some()
426 }
427
428 pub fn supports_expand_collapse(&self) -> bool {
429 self.data().is_expanded().is_some()
430 }
431
432 pub fn is_invocable(&self) -> bool {
433 // A control is "invocable" if it initiates an action when activated but
434 // does not maintain any state. A control that maintains state
435 // when activated would be considered a toggle or expand-collapse
436 // control - these controls are "clickable" but not "invocable".
437 // Similarly, if the action only gives the control keyboard focus,
438 // such as when clicking a text input, the control is not considered
439 // "invocable", as the "invoke" action would be a redundant synonym
440 // for the "set focus" action. The same logic applies to selection.
441 self.is_clickable()
442 && !self.is_text_input()
443 && !matches!(self.role(), Role::Document | Role::Terminal)
444 && !self.supports_toggle()
445 && !self.supports_expand_collapse()
446 && self.is_selected().is_none()
447 }
448
449 // The future of the `Action` enum is undecided, so keep the following
450 // function private for now.
451 fn supports_action(&self, action: Action) -> bool {
452 self.data().supports_action(action)
453 }
454
455 pub fn supports_increment(&self) -> bool {
456 self.supports_action(Action::Increment)
457 }
458
459 pub fn supports_decrement(&self) -> bool {
460 self.supports_action(Action::Decrement)
461 }
462}
463
464fn descendant_label_filter(node: &Node) -> FilterResult {
465 match node.role() {
466 Role::Label | Role::Image => FilterResult::Include,
467 Role::GenericContainer => FilterResult::ExcludeNode,
468 _ => FilterResult::ExcludeSubtree,
469 }
470}
471
472impl<'a> Node<'a> {
473 pub fn labelled_by(
474 &self,
475 ) -> impl DoubleEndedIterator<Item = Node<'a>> + FusedIterator<Item = Node<'a>> + 'a {
476 let explicit = &self.state.data.labelled_by();
477 if explicit.is_empty()
478 && matches!(
479 self.role(),
480 Role::Button
481 | Role::CheckBox
482 | Role::DefaultButton
483 | Role::Link
484 | Role::MenuItem
485 | Role::MenuItemCheckBox
486 | Role::MenuItemRadio
487 | Role::RadioButton
488 )
489 {
490 LabelledBy::FromDescendants(FilteredChildren::new(*self, &descendant_label_filter))
491 } else {
492 LabelledBy::Explicit {
493 ids: explicit.iter(),
494 tree_state: self.tree_state,
495 }
496 }
497 }
498
499 pub fn label_comes_from_value(&self) -> bool {
500 self.role() == Role::Label
501 }
502
503 pub fn label(&self) -> Option<String> {
504 if let Some(label) = &self.data().label() {
505 Some(label.to_string())
506 } else {
507 let labels = self
508 .labelled_by()
509 .filter_map(|node| {
510 if node.label_comes_from_value() {
511 node.value()
512 } else {
513 node.label()
514 }
515 })
516 .collect::<Vec<String>>();
517 (!labels.is_empty()).then(move || labels.join(" "))
518 }
519 }
520
521 pub fn description(&self) -> Option<String> {
522 self.data()
523 .description()
524 .map(|description| description.to_string())
525 }
526
527 pub fn placeholder(&self) -> Option<String> {
528 self.data()
529 .placeholder()
530 .map(|placeholder| placeholder.to_string())
531 }
532
533 pub fn value(&self) -> Option<String> {
534 if let Some(value) = &self.data().value() {
535 Some(value.to_string())
536 } else if self.supports_text_ranges() && !self.is_multiline() {
537 Some(self.document_range().text())
538 } else {
539 None
540 }
541 }
542
543 pub fn has_value(&self) -> bool {
544 self.data().value().is_some() || (self.supports_text_ranges() && !self.is_multiline())
545 }
546
547 pub fn is_read_only_supported(&self) -> bool {
548 self.is_text_input()
549 || matches!(
550 self.role(),
551 Role::CheckBox
552 | Role::ColorWell
553 | Role::ComboBox
554 | Role::Grid
555 | Role::ListBox
556 | Role::MenuItemCheckBox
557 | Role::MenuItemRadio
558 | Role::MenuListPopup
559 | Role::RadioButton
560 | Role::RadioGroup
561 | Role::Slider
562 | Role::Switch
563 | Role::TreeGrid
564 )
565 }
566
567 pub fn should_have_read_only_state_by_default(&self) -> bool {
568 matches!(
569 self.role(),
570 Role::Article
571 | Role::Definition
572 | Role::DescriptionList
573 | Role::DescriptionListTerm
574 | Role::Directory
575 | Role::Document
576 | Role::GraphicsDocument
577 | Role::Image
578 | Role::List
579 | Role::ListItem
580 | Role::PdfRoot
581 | Role::ProgressIndicator
582 | Role::RootWebArea
583 | Role::Term
584 | Role::Timer
585 | Role::Toolbar
586 | Role::Tooltip
587 )
588 }
589
590 pub fn live(&self) -> Live {
591 self.data()
592 .live()
593 .unwrap_or_else(|| self.parent().map_or(Live::Off, |parent| parent.live()))
594 }
595
596 pub fn is_selected(&self) -> Option<bool> {
597 self.data().is_selected()
598 }
599
600 pub fn raw_text_selection(&self) -> Option<&TextSelection> {
601 self.data().text_selection()
602 }
603
604 pub fn raw_value(&self) -> Option<&str> {
605 self.data().value()
606 }
607
608 pub fn author_id(&self) -> Option<&str> {
609 self.data().author_id()
610 }
611
612 pub fn class_name(&self) -> Option<&str> {
613 self.data().class_name()
614 }
615
616 pub fn index_path(&self) -> Vec<usize> {
617 self.relative_index_path(self.tree_state.root_id())
618 }
619
620 pub fn relative_index_path(&self, ancestor_id: NodeId) -> Vec<usize> {
621 let mut result = Vec::new();
622 let mut current = *self;
623 while current.id() != ancestor_id {
624 let (parent, index) = current.parent_and_index().unwrap();
625 result.push(index);
626 current = parent;
627 }
628 result.reverse();
629 result
630 }
631
632 pub(crate) fn first_filtered_child(
633 &self,
634 filter: &impl Fn(&Node) -> FilterResult,
635 ) -> Option<Node<'a>> {
636 for child in self.children() {
637 let result = filter(&child);
638 if result == FilterResult::Include {
639 return Some(child);
640 }
641 if result == FilterResult::ExcludeNode {
642 if let Some(descendant) = child.first_filtered_child(filter) {
643 return Some(descendant);
644 }
645 }
646 }
647 None
648 }
649
650 pub(crate) fn last_filtered_child(
651 &self,
652 filter: &impl Fn(&Node) -> FilterResult,
653 ) -> Option<Node<'a>> {
654 for child in self.children().rev() {
655 let result = filter(&child);
656 if result == FilterResult::Include {
657 return Some(child);
658 }
659 if result == FilterResult::ExcludeNode {
660 if let Some(descendant) = child.last_filtered_child(filter) {
661 return Some(descendant);
662 }
663 }
664 }
665 None
666 }
667}
668
669#[cfg(test)]
670mod tests {
671 use accesskit::{Node, NodeId, Point, Rect, Role, Tree, TreeUpdate};
672 use alloc::vec;
673
674 use crate::tests::*;
675
676 #[test]
677 fn parent_and_index() {
678 let tree = test_tree();
679 assert!(tree.state().root().parent_and_index().is_none());
680 assert_eq!(
681 Some((ROOT_ID, 0)),
682 tree.state()
683 .node_by_id(PARAGRAPH_0_ID)
684 .unwrap()
685 .parent_and_index()
686 .map(|(parent, index)| (parent.id(), index))
687 );
688 assert_eq!(
689 Some((PARAGRAPH_0_ID, 0)),
690 tree.state()
691 .node_by_id(LABEL_0_0_IGNORED_ID)
692 .unwrap()
693 .parent_and_index()
694 .map(|(parent, index)| (parent.id(), index))
695 );
696 assert_eq!(
697 Some((ROOT_ID, 1)),
698 tree.state()
699 .node_by_id(PARAGRAPH_1_IGNORED_ID)
700 .unwrap()
701 .parent_and_index()
702 .map(|(parent, index)| (parent.id(), index))
703 );
704 }
705
706 #[test]
707 fn deepest_first_child() {
708 let tree = test_tree();
709 assert_eq!(
710 LABEL_0_0_IGNORED_ID,
711 tree.state().root().deepest_first_child().unwrap().id()
712 );
713 assert_eq!(
714 LABEL_0_0_IGNORED_ID,
715 tree.state()
716 .node_by_id(PARAGRAPH_0_ID)
717 .unwrap()
718 .deepest_first_child()
719 .unwrap()
720 .id()
721 );
722 assert!(tree
723 .state()
724 .node_by_id(LABEL_0_0_IGNORED_ID)
725 .unwrap()
726 .deepest_first_child()
727 .is_none());
728 }
729
730 #[test]
731 fn filtered_parent() {
732 let tree = test_tree();
733 assert_eq!(
734 ROOT_ID,
735 tree.state()
736 .node_by_id(LABEL_1_1_ID)
737 .unwrap()
738 .filtered_parent(&test_tree_filter)
739 .unwrap()
740 .id()
741 );
742 assert!(tree
743 .state()
744 .root()
745 .filtered_parent(&test_tree_filter)
746 .is_none());
747 }
748
749 #[test]
750 fn deepest_first_filtered_child() {
751 let tree = test_tree();
752 assert_eq!(
753 PARAGRAPH_0_ID,
754 tree.state()
755 .root()
756 .deepest_first_filtered_child(&test_tree_filter)
757 .unwrap()
758 .id()
759 );
760 assert!(tree
761 .state()
762 .node_by_id(PARAGRAPH_0_ID)
763 .unwrap()
764 .deepest_first_filtered_child(&test_tree_filter)
765 .is_none());
766 assert!(tree
767 .state()
768 .node_by_id(LABEL_0_0_IGNORED_ID)
769 .unwrap()
770 .deepest_first_filtered_child(&test_tree_filter)
771 .is_none());
772 }
773
774 #[test]
775 fn deepest_last_child() {
776 let tree = test_tree();
777 assert_eq!(
778 EMPTY_CONTAINER_3_3_IGNORED_ID,
779 tree.state().root().deepest_last_child().unwrap().id()
780 );
781 assert_eq!(
782 EMPTY_CONTAINER_3_3_IGNORED_ID,
783 tree.state()
784 .node_by_id(PARAGRAPH_3_IGNORED_ID)
785 .unwrap()
786 .deepest_last_child()
787 .unwrap()
788 .id()
789 );
790 assert!(tree
791 .state()
792 .node_by_id(BUTTON_3_2_ID)
793 .unwrap()
794 .deepest_last_child()
795 .is_none());
796 }
797
798 #[test]
799 fn deepest_last_filtered_child() {
800 let tree = test_tree();
801 assert_eq!(
802 BUTTON_3_2_ID,
803 tree.state()
804 .root()
805 .deepest_last_filtered_child(&test_tree_filter)
806 .unwrap()
807 .id()
808 );
809 assert_eq!(
810 BUTTON_3_2_ID,
811 tree.state()
812 .node_by_id(PARAGRAPH_3_IGNORED_ID)
813 .unwrap()
814 .deepest_last_filtered_child(&test_tree_filter)
815 .unwrap()
816 .id()
817 );
818 assert!(tree
819 .state()
820 .node_by_id(BUTTON_3_2_ID)
821 .unwrap()
822 .deepest_last_filtered_child(&test_tree_filter)
823 .is_none());
824 assert!(tree
825 .state()
826 .node_by_id(PARAGRAPH_0_ID)
827 .unwrap()
828 .deepest_last_filtered_child(&test_tree_filter)
829 .is_none());
830 }
831
832 #[test]
833 fn is_descendant_of() {
834 let tree = test_tree();
835 assert!(tree
836 .state()
837 .node_by_id(PARAGRAPH_0_ID)
838 .unwrap()
839 .is_descendant_of(&tree.state().root()));
840 assert!(tree
841 .state()
842 .node_by_id(LABEL_0_0_IGNORED_ID)
843 .unwrap()
844 .is_descendant_of(&tree.state().root()));
845 assert!(tree
846 .state()
847 .node_by_id(LABEL_0_0_IGNORED_ID)
848 .unwrap()
849 .is_descendant_of(&tree.state().node_by_id(PARAGRAPH_0_ID).unwrap()));
850 assert!(!tree
851 .state()
852 .node_by_id(LABEL_0_0_IGNORED_ID)
853 .unwrap()
854 .is_descendant_of(&tree.state().node_by_id(PARAGRAPH_2_ID).unwrap()));
855 assert!(!tree
856 .state()
857 .node_by_id(PARAGRAPH_0_ID)
858 .unwrap()
859 .is_descendant_of(&tree.state().node_by_id(PARAGRAPH_2_ID).unwrap()));
860 }
861
862 #[test]
863 fn is_root() {
864 let tree = test_tree();
865 assert!(tree.state().node_by_id(ROOT_ID).unwrap().is_root());
866 assert!(!tree.state().node_by_id(PARAGRAPH_0_ID).unwrap().is_root());
867 }
868
869 #[test]
870 fn bounding_box() {
871 let tree = test_tree();
872 assert!(tree
873 .state()
874 .node_by_id(ROOT_ID)
875 .unwrap()
876 .bounding_box()
877 .is_none());
878 assert_eq!(
879 Some(Rect {
880 x0: 10.0,
881 y0: 40.0,
882 x1: 810.0,
883 y1: 80.0,
884 }),
885 tree.state()
886 .node_by_id(PARAGRAPH_1_IGNORED_ID)
887 .unwrap()
888 .bounding_box()
889 );
890 assert_eq!(
891 Some(Rect {
892 x0: 20.0,
893 y0: 50.0,
894 x1: 100.0,
895 y1: 70.0,
896 }),
897 tree.state()
898 .node_by_id(LABEL_1_1_ID)
899 .unwrap()
900 .bounding_box()
901 );
902 }
903
904 #[test]
905 fn node_at_point() {
906 let tree = test_tree();
907 assert!(tree
908 .state()
909 .root()
910 .node_at_point(Point::new(10.0, 40.0), &test_tree_filter)
911 .is_none());
912 assert_eq!(
913 Some(LABEL_1_1_ID),
914 tree.state()
915 .root()
916 .node_at_point(Point::new(20.0, 50.0), &test_tree_filter)
917 .map(|node| node.id())
918 );
919 assert_eq!(
920 Some(LABEL_1_1_ID),
921 tree.state()
922 .root()
923 .node_at_point(Point::new(50.0, 60.0), &test_tree_filter)
924 .map(|node| node.id())
925 );
926 assert!(tree
927 .state()
928 .root()
929 .node_at_point(Point::new(100.0, 70.0), &test_tree_filter)
930 .is_none());
931 }
932
933 #[test]
934 fn no_label_or_labelled_by() {
935 let update = TreeUpdate {
936 nodes: vec![
937 (NodeId(0), {
938 let mut node = Node::new(Role::Window);
939 node.set_children(vec![NodeId(1)]);
940 node
941 }),
942 (NodeId(1), Node::new(Role::Button)),
943 ],
944 tree: Some(Tree::new(NodeId(0))),
945 focus: NodeId(0),
946 };
947 let tree = crate::Tree::new(update, false);
948 assert_eq!(None, tree.state().node_by_id(NodeId(1)).unwrap().label());
949 }
950
951 #[test]
952 fn label_from_labelled_by() {
953 // The following mock UI probably isn't very localization-friendly,
954 // but it's good for this test.
955 const LABEL_1: &str = "Check email every";
956 const LABEL_2: &str = "minutes";
957
958 let update = TreeUpdate {
959 nodes: vec![
960 (NodeId(0), {
961 let mut node = Node::new(Role::Window);
962 node.set_children(vec![NodeId(1), NodeId(2), NodeId(3), NodeId(4)]);
963 node
964 }),
965 (NodeId(1), {
966 let mut node = Node::new(Role::CheckBox);
967 node.set_labelled_by(vec![NodeId(2), NodeId(4)]);
968 node
969 }),
970 (NodeId(2), {
971 let mut node = Node::new(Role::Label);
972 node.set_value(LABEL_1);
973 node
974 }),
975 (NodeId(3), {
976 let mut node = Node::new(Role::TextInput);
977 node.push_labelled_by(NodeId(4));
978 node
979 }),
980 (NodeId(4), {
981 let mut node = Node::new(Role::Label);
982 node.set_value(LABEL_2);
983 node
984 }),
985 ],
986 tree: Some(Tree::new(NodeId(0))),
987 focus: NodeId(0),
988 };
989 let tree = crate::Tree::new(update, false);
990 assert_eq!(
991 Some([LABEL_1, LABEL_2].join(" ")),
992 tree.state().node_by_id(NodeId(1)).unwrap().label()
993 );
994 assert_eq!(
995 Some(LABEL_2.into()),
996 tree.state().node_by_id(NodeId(3)).unwrap().label()
997 );
998 }
999
1000 #[test]
1001 fn label_from_descendant_label() {
1002 const ROOT_ID: NodeId = NodeId(0);
1003 const DEFAULT_BUTTON_ID: NodeId = NodeId(1);
1004 const DEFAULT_BUTTON_LABEL_ID: NodeId = NodeId(2);
1005 const LINK_ID: NodeId = NodeId(3);
1006 const LINK_LABEL_CONTAINER_ID: NodeId = NodeId(4);
1007 const LINK_LABEL_ID: NodeId = NodeId(5);
1008 const CHECKBOX_ID: NodeId = NodeId(6);
1009 const CHECKBOX_LABEL_ID: NodeId = NodeId(7);
1010 const RADIO_BUTTON_ID: NodeId = NodeId(8);
1011 const RADIO_BUTTON_LABEL_ID: NodeId = NodeId(9);
1012 const MENU_BUTTON_ID: NodeId = NodeId(10);
1013 const MENU_BUTTON_LABEL_ID: NodeId = NodeId(11);
1014 const MENU_ID: NodeId = NodeId(12);
1015 const MENU_ITEM_ID: NodeId = NodeId(13);
1016 const MENU_ITEM_LABEL_ID: NodeId = NodeId(14);
1017 const MENU_ITEM_CHECKBOX_ID: NodeId = NodeId(15);
1018 const MENU_ITEM_CHECKBOX_LABEL_ID: NodeId = NodeId(16);
1019 const MENU_ITEM_RADIO_ID: NodeId = NodeId(17);
1020 const MENU_ITEM_RADIO_LABEL_ID: NodeId = NodeId(18);
1021
1022 const DEFAULT_BUTTON_LABEL: &str = "Play";
1023 const LINK_LABEL: &str = "Watch in browser";
1024 const CHECKBOX_LABEL: &str = "Resume from previous position";
1025 const RADIO_BUTTON_LABEL: &str = "Normal speed";
1026 const MENU_BUTTON_LABEL: &str = "More";
1027 const MENU_ITEM_LABEL: &str = "Share";
1028 const MENU_ITEM_CHECKBOX_LABEL: &str = "Apply volume processing";
1029 const MENU_ITEM_RADIO_LABEL: &str = "Maximize loudness for noisy environment";
1030
1031 let update = TreeUpdate {
1032 nodes: vec![
1033 (ROOT_ID, {
1034 let mut node = Node::new(Role::Window);
1035 node.set_children(vec![
1036 DEFAULT_BUTTON_ID,
1037 LINK_ID,
1038 CHECKBOX_ID,
1039 RADIO_BUTTON_ID,
1040 MENU_BUTTON_ID,
1041 MENU_ID,
1042 ]);
1043 node
1044 }),
1045 (DEFAULT_BUTTON_ID, {
1046 let mut node = Node::new(Role::DefaultButton);
1047 node.push_child(DEFAULT_BUTTON_LABEL_ID);
1048 node
1049 }),
1050 (DEFAULT_BUTTON_LABEL_ID, {
1051 let mut node = Node::new(Role::Image);
1052 node.set_label(DEFAULT_BUTTON_LABEL);
1053 node
1054 }),
1055 (LINK_ID, {
1056 let mut node = Node::new(Role::Link);
1057 node.push_child(LINK_LABEL_CONTAINER_ID);
1058 node
1059 }),
1060 (LINK_LABEL_CONTAINER_ID, {
1061 let mut node = Node::new(Role::GenericContainer);
1062 node.push_child(LINK_LABEL_ID);
1063 node
1064 }),
1065 (LINK_LABEL_ID, {
1066 let mut node = Node::new(Role::Label);
1067 node.set_value(LINK_LABEL);
1068 node
1069 }),
1070 (CHECKBOX_ID, {
1071 let mut node = Node::new(Role::CheckBox);
1072 node.push_child(CHECKBOX_LABEL_ID);
1073 node
1074 }),
1075 (CHECKBOX_LABEL_ID, {
1076 let mut node = Node::new(Role::Label);
1077 node.set_value(CHECKBOX_LABEL);
1078 node
1079 }),
1080 (RADIO_BUTTON_ID, {
1081 let mut node = Node::new(Role::RadioButton);
1082 node.push_child(RADIO_BUTTON_LABEL_ID);
1083 node
1084 }),
1085 (RADIO_BUTTON_LABEL_ID, {
1086 let mut node = Node::new(Role::Label);
1087 node.set_value(RADIO_BUTTON_LABEL);
1088 node
1089 }),
1090 (MENU_BUTTON_ID, {
1091 let mut node = Node::new(Role::Button);
1092 node.push_child(MENU_BUTTON_LABEL_ID);
1093 node
1094 }),
1095 (MENU_BUTTON_LABEL_ID, {
1096 let mut node = Node::new(Role::Label);
1097 node.set_value(MENU_BUTTON_LABEL);
1098 node
1099 }),
1100 (MENU_ID, {
1101 let mut node = Node::new(Role::Menu);
1102 node.set_children([MENU_ITEM_ID, MENU_ITEM_CHECKBOX_ID, MENU_ITEM_RADIO_ID]);
1103 node
1104 }),
1105 (MENU_ITEM_ID, {
1106 let mut node = Node::new(Role::MenuItem);
1107 node.push_child(MENU_ITEM_LABEL_ID);
1108 node
1109 }),
1110 (MENU_ITEM_LABEL_ID, {
1111 let mut node = Node::new(Role::Label);
1112 node.set_value(MENU_ITEM_LABEL);
1113 node
1114 }),
1115 (MENU_ITEM_CHECKBOX_ID, {
1116 let mut node = Node::new(Role::MenuItemCheckBox);
1117 node.push_child(MENU_ITEM_CHECKBOX_LABEL_ID);
1118 node
1119 }),
1120 (MENU_ITEM_CHECKBOX_LABEL_ID, {
1121 let mut node = Node::new(Role::Label);
1122 node.set_value(MENU_ITEM_CHECKBOX_LABEL);
1123 node
1124 }),
1125 (MENU_ITEM_RADIO_ID, {
1126 let mut node = Node::new(Role::MenuItemRadio);
1127 node.push_child(MENU_ITEM_RADIO_LABEL_ID);
1128 node
1129 }),
1130 (MENU_ITEM_RADIO_LABEL_ID, {
1131 let mut node = Node::new(Role::Label);
1132 node.set_value(MENU_ITEM_RADIO_LABEL);
1133 node
1134 }),
1135 ],
1136 tree: Some(Tree::new(ROOT_ID)),
1137 focus: ROOT_ID,
1138 };
1139 let tree = crate::Tree::new(update, false);
1140 assert_eq!(
1141 Some(DEFAULT_BUTTON_LABEL.into()),
1142 tree.state().node_by_id(DEFAULT_BUTTON_ID).unwrap().label()
1143 );
1144 assert_eq!(
1145 Some(LINK_LABEL.into()),
1146 tree.state().node_by_id(LINK_ID).unwrap().label()
1147 );
1148 assert_eq!(
1149 Some(CHECKBOX_LABEL.into()),
1150 tree.state().node_by_id(CHECKBOX_ID).unwrap().label()
1151 );
1152 assert_eq!(
1153 Some(RADIO_BUTTON_LABEL.into()),
1154 tree.state().node_by_id(RADIO_BUTTON_ID).unwrap().label()
1155 );
1156 assert_eq!(
1157 Some(MENU_BUTTON_LABEL.into()),
1158 tree.state().node_by_id(MENU_BUTTON_ID).unwrap().label()
1159 );
1160 assert_eq!(
1161 Some(MENU_ITEM_LABEL.into()),
1162 tree.state().node_by_id(MENU_ITEM_ID).unwrap().label()
1163 );
1164 assert_eq!(
1165 Some(MENU_ITEM_CHECKBOX_LABEL.into()),
1166 tree.state()
1167 .node_by_id(MENU_ITEM_CHECKBOX_ID)
1168 .unwrap()
1169 .label()
1170 );
1171 assert_eq!(
1172 Some(MENU_ITEM_RADIO_LABEL.into()),
1173 tree.state().node_by_id(MENU_ITEM_RADIO_ID).unwrap().label()
1174 );
1175 }
1176}
1177