feat: Expose text properties on consumer Node with inheritance (#617)

Author: mwcampbell

consumer/src/node.rs

@@ -42,7 +42,7 @@ pub struct Node<'a> {
 }
 
 impl<'a> Node<'a> {
-    pub fn data(&self) -> &NodeData {
+    pub fn data(&self) -> &'a NodeData {
         &self.state.data
     }
 
@@ -406,6 +406,20 @@ impl<'a> Node<'a> {
         self.data().scroll_y_max()
     }
 
+    pub(crate) fn fetch_inherited_property<T>(
+        &self,
+        getter: fn(&'a NodeData) -> Option<T>,
+    ) -> Option<T> {
+        let mut node = *self;
+        loop {
+            let value = getter(node.data());
+            if value.is_some() {
+                return value;
+            }
+            node = node.parent()?;
+        }
+    }
+
     pub fn is_text_input(&self) -> bool {
         matches!(
             self.role(),

consumer/src/text.rs

@@ -4,7 +4,8 @@
 // the LICENSE-MIT file), at your option.
 
 use accesskit::{
-    NodeId, Point, Rect, Role, TextDirection, TextPosition as WeakPosition, TextSelection,
+    Node as NodeData, NodeId, Point, Rect, Role, TextAlign, TextDecoration, TextDirection,
+    TextPosition as WeakPosition, TextSelection, VerticalOffset,
 };
 use alloc::{string::String, vec::Vec};
 use core::{cmp::Ordering, fmt, iter::FusedIterator};
@@ -647,7 +648,7 @@ impl<'a> Range<'a> {
                     return Some(Vec::new());
                 }
             };
-            let direction = match node.data().text_direction() {
+            let direction = match node.text_direction() {
                 Some(direction) => direction,
                 None => {
                     return Some(Vec::new());
@@ -844,7 +845,7 @@ fn character_index_at_point(node: &Node, point: Point) -> usize {
             return 0;
         }
     };
-    let direction = match node.data().text_direction() {
+    let direction = match node.text_direction() {
         Some(direction) => direction,
         None => {
             return 0;
@@ -867,6 +868,92 @@ fn character_index_at_point(node: &Node, point: Point) -> usize {
     character_lengths.len()
 }
 
+macro_rules! inherited_properties {
+    ($(($getter:ident, $type:ty, $setter:ident, $test_value:expr)),+) => {
+        impl Node<'_> {
+            $(pub fn $getter(&self) -> Option<$type> {
+                self.fetch_inherited_property(NodeData::$getter)
+            })*
+        }
+        $(#[cfg(test)]
+        mod $getter {
+            use accesskit::{Node, NodeId, Role, Tree, TreeUpdate};
+            use alloc::vec;
+            #[test]
+            fn directly_set() {
+                let update = TreeUpdate {
+                    nodes: vec![
+                        (NodeId(0), {
+                            let mut node = Node::new(Role::TextInput);
+                            node.set_children(vec![NodeId(1)]);
+                            node
+                        }),
+                        (NodeId(1), {
+                            let mut node = Node::new(Role::TextRun);
+                            node.$setter($test_value);
+                            node
+                        }),
+                    ],
+                    tree: Some(Tree::new(NodeId(0))),
+                    focus: NodeId(0),
+                };
+                let tree = crate::Tree::new(update, false);
+                assert_eq!(tree.state().node_by_id(NodeId(1)).unwrap().$getter(), Some($test_value));
+            }
+            #[test]
+            fn set_on_parent() {
+                let update = TreeUpdate {
+                    nodes: vec![
+                        (NodeId(0), {
+                            let mut node = Node::new(Role::TextInput);
+                            node.set_children(vec![NodeId(1)]);
+                            node.$setter($test_value);
+                            node
+                        }),
+                        (NodeId(1), Node::new(Role::TextRun)),
+                    ],
+                    tree: Some(Tree::new(NodeId(0))),
+                    focus: NodeId(0),
+                };
+                let tree = crate::Tree::new(update, false);
+                assert_eq!(tree.state().node_by_id(NodeId(1)).unwrap().$getter(), Some($test_value));
+            }
+            #[test]
+            fn unset() {
+                let update = TreeUpdate {
+                    nodes: vec![
+                        (NodeId(0), {
+                            let mut node = Node::new(Role::TextInput);
+                            node.set_children(vec![NodeId(1)]);
+                            node
+                        }),
+                        (NodeId(1), Node::new(Role::TextRun)),
+                    ],
+                    tree: Some(Tree::new(NodeId(0))),
+                    focus: NodeId(0),
+                };
+                let tree = crate::Tree::new(update, false);
+                assert!(tree.state().node_by_id(NodeId(1)).unwrap().$getter().is_none());
+            }
+        })*
+    }
+}
+
+inherited_properties! {
+    (text_direction, TextDirection, set_text_direction, accesskit::TextDirection::RightToLeft),
+    (font_family, &str, set_font_family, "Inconsolata"),
+    (language, &str, set_language, "fr"),
+    (font_size, f64, set_font_size, 24.0),
+    (font_weight, f64, set_font_weight, 700.0),
+    (background_color, u32, set_background_color, 0xff),
+    (foreground_color, u32, set_foreground_color, 0xff00),
+    (overline, TextDecoration, set_overline, accesskit::TextDecoration::Dotted),
+    (strikethrough, TextDecoration, set_strikethrough, accesskit::TextDecoration::Dashed),
+    (underline, TextDecoration, set_underline, accesskit::TextDecoration::Double),
+    (text_align, TextAlign, set_text_align, accesskit::TextAlign::Justify),
+    (vertical_offset, VerticalOffset, set_vertical_offset, accesskit::VerticalOffset::Superscript)
+}
+
 impl<'a> Node<'a> {
     pub(crate) fn text_runs(
         &self,
@@ -985,7 +1072,7 @@ impl<'a> Node<'a> {
 
         for node in self.text_runs().rev() {
             if let Some(rect) = node.bounding_box_in_coordinate_space(self) {
-                if let Some(direction) = node.data().text_direction() {
+                if let Some(direction) = node.text_direction() {
                     let is_past_end = match direction {
                         TextDirection::LeftToRight => {
                             point.y >= rect.y0 && point.y < rect.y1 && point.x >= rect.x1