feat: Implement text attributes for AT-SPI (#695)

Author: mwcampbell

Cargo.lock

@@ -18,5 +18,6 @@ simplified-api = []
 accesskit = { version = "0.24.0", path = "../../common" }
 accesskit_consumer = { version = "0.34.0", path = "../../consumer" }
 atspi-common = { version = "0.13", default-features = false }
+phf = { version = "0.13.1", features = ["macros"] }
 serde = "1.0"
 zvariant = { version = "5.4", default-features = false }

platforms/atspi-common/Cargo.toml

@@ -14,6 +14,7 @@ mod node;
 mod rect;
 #[cfg(feature = "simplified-api")]
 pub mod simplified;
+mod text_attributes;
 mod util;
 
 pub use accesskit_consumer::NodeId;

platforms/atspi-common/src/lib.rs

@@ -28,6 +28,7 @@ use crate::{
     adapter::Adapter,
     context::{AppContext, Context},
     filters::filter,
+    text_attributes::ATTRIBUTE_GETTERS,
     util::*,
     Action as AtspiAction, Error, ObjectEvent, Property, Rect as AtspiRect, Result,
 };
@@ -1309,19 +1310,33 @@ impl PlatformNode {
         })
     }
 
-    pub fn text_attribute_value(&self, _offset: i32, _attribute_name: &str) -> Result<String> {
-        // TODO: Implement rich text.
-        Err(Error::UnsupportedInterface)
+    pub fn text_attribute_value(&self, offset: i32, attribute_name: &str) -> Result<String> {
+        self.resolve_for_text(|node| {
+            let pos = text_position_from_offset(&node, offset).ok_or(Error::IndexOutOfRange)?;
+            Ok(ATTRIBUTE_GETTERS
+                .get(attribute_name)
+                .and_then(|getter| (*getter)(pos.inner_node()))
+                .unwrap_or_default())
+        })
     }
 
-    pub fn text_attributes(&self, _offset: i32) -> Result<(HashMap<String, String>, i32, i32)> {
-        // TODO: Implement rich text.
-        Err(Error::UnsupportedInterface)
+    pub fn text_attributes(
+        &self,
+        offset: i32,
+    ) -> Result<(HashMap<&'static str, String>, i32, i32)> {
+        self.text_attribute_run(offset, false)
     }
 
-    pub fn default_text_attributes(&self) -> Result<HashMap<String, String>> {
-        // TODO: Implement rich text.
-        Err(Error::UnsupportedInterface)
+    pub fn default_text_attributes(&self) -> Result<HashMap<&'static str, String>> {
+        self.resolve_for_text(|node| {
+            let mut result = HashMap::with_capacity(ATTRIBUTE_GETTERS.len());
+            for (name, getter) in ATTRIBUTE_GETTERS.entries() {
+                if let Some(value) = (*getter)(&node) {
+                    result.insert(*name, value);
+                }
+            }
+            Ok(result)
+        })
     }
 
     pub fn character_extents(&self, offset: i32, coord_type: CoordType) -> Result<AtspiRect> {
@@ -1469,14 +1484,41 @@ impl PlatformNode {
 
     pub fn text_attribute_run(
         &self,
-        _offset: i32,
-        _include_defaults: bool,
-    ) -> Result<(HashMap<String, String>, i32, i32)> {
-        // TODO: Implement rich text.
-        // For now, just report a range spanning the entire text with no attributes,
-        // this is required by Orca to announce selection content and caret movements.
-        let character_count = self.character_count()?;
-        Ok((HashMap::new(), 0, character_count))
+        offset: i32,
+        include_defaults: bool,
+    ) -> Result<(HashMap<&'static str, String>, i32, i32)> {
+        self.resolve_for_text(|node| {
+            let pos = text_position_from_offset(&node, offset).ok_or(Error::IndexOutOfRange)?;
+            let mut result = HashMap::with_capacity(ATTRIBUTE_GETTERS.len());
+            for (name, getter) in ATTRIBUTE_GETTERS.entries() {
+                if let Some(value) = (*getter)(pos.inner_node()) {
+                    if !include_defaults {
+                        if let Some(default) = (*getter)(&node) {
+                            if value == default {
+                                continue;
+                            }
+                        }
+                    }
+                    result.insert(*name, value);
+                }
+            }
+            let start = if pos.is_format_start() {
+                pos
+            } else {
+                pos.backward_to_format_start()
+            };
+            let end = pos.forward_to_format_end();
+            Ok((
+                result,
+                start
+                    .to_global_usv_index()
+                    .try_into()
+                    .map_err(|_| Error::TooManyCharacters)?,
+                end.to_global_usv_index()
+                    .try_into()
+                    .map_err(|_| Error::TooManyCharacters)?,
+            ))
+        })
     }
 
     pub fn scroll_substring_to(

platforms/atspi-common/src/node.rs

@@ -407,14 +407,17 @@ impl Accessible {
         }
     }
 
-    pub fn text_attributes(&self, offset: i32) -> Result<(HashMap<String, String>, i32, i32)> {
+    pub fn text_attributes(
+        &self,
+        offset: i32,
+    ) -> Result<(HashMap<&'static str, String>, i32, i32)> {
         match self {
             Self::Node(node) => node.text_attributes(offset),
             Self::Root(_) => Err(Error::UnsupportedInterface),
         }
     }
 
-    pub fn default_text_attributes(&self) -> Result<HashMap<String, String>> {
+    pub fn default_text_attributes(&self) -> Result<HashMap<&'static str, String>> {
         match self {
             Self::Node(node) => node.default_text_attributes(),
             Self::Root(_) => Err(Error::UnsupportedInterface),
@@ -491,7 +494,7 @@ impl Accessible {
         &self,
         offset: i32,
         include_defaults: bool,
-    ) -> Result<(HashMap<String, String>, i32, i32)> {
+    ) -> Result<(HashMap<&'static str, String>, i32, i32)> {
         match self {
             Self::Node(node) => node.text_attribute_run(offset, include_defaults),
             Self::Root(_) => Err(Error::UnsupportedInterface),

platforms/atspi-common/src/simplified.rs

@@ -0,0 +1,79 @@
+// Copyright 2026 The AccessKit Authors. All rights reserved.
+// Licensed under the Apache License, Version 2.0 (found in
+// the LICENSE-APACHE file) or the MIT license (found in
+// the LICENSE-MIT file), at your option.
+
+use accesskit::{Color, TextAlign, TextDecorationStyle};
+use accesskit_consumer::Node;
+use phf::phf_map;
+
+fn color_to_string(color: Color) -> String {
+    format!("{},{},{}", color.red, color.green, color.blue)
+}
+
+fn family_name(node: &Node) -> Option<String> {
+    node.font_family().map(String::from)
+}
+
+fn size(node: &Node) -> Option<String> {
+    node.font_size().map(|value| value.to_string())
+}
+
+fn weight(node: &Node) -> Option<String> {
+    node.font_weight().map(|value| value.to_string())
+}
+
+fn style(node: &Node) -> Option<String> {
+    node.is_italic().then(|| "italic".into())
+}
+
+fn strikethrough(node: &Node) -> Option<String> {
+    node.strikethrough().map(|_| "true".into())
+}
+
+fn underline(node: &Node) -> Option<String> {
+    node.underline().map(|deco| {
+        match deco.style {
+            TextDecorationStyle::Double => "double",
+            _ => "single",
+        }
+        .into()
+    })
+}
+
+fn bg_color(node: &Node) -> Option<String> {
+    node.background_color().map(color_to_string)
+}
+
+fn fg_color(node: &Node) -> Option<String> {
+    node.foreground_color().map(color_to_string)
+}
+
+fn language(node: &Node) -> Option<String> {
+    node.language().map(String::from)
+}
+
+fn justification(node: &Node) -> Option<String> {
+    node.text_align().map(|align| {
+        match align {
+            TextAlign::Left => "left",
+            TextAlign::Center => "center",
+            TextAlign::Right => "right",
+            TextAlign::Justify => "fill",
+        }
+        .into()
+    })
+}
+
+pub(crate) const ATTRIBUTE_GETTERS: phf::Map<&'static str, fn(&Node) -> Option<String>> = phf_map! {
+    "family-name" => family_name,
+    "size" => size,
+    "weight" => weight,
+    "style" => style,
+    "strikethrough" => strikethrough,
+    "underline" => underline,
+    "bg-color" => bg_color,
+    "fg-color" => fg_color,
+    "language" => language,
+    "justification" => justification,
+};

platforms/atspi-common/src/text_attributes.rs

@@ -60,11 +60,14 @@ impl TextInterface {
             .map_err(self.map_error())
     }
 
-    fn get_attributes(&self, offset: i32) -> fdo::Result<(HashMap<String, String>, i32, i32)> {
+    fn get_attributes(
+        &self,
+        offset: i32,
+    ) -> fdo::Result<(HashMap<&'static str, String>, i32, i32)> {
         self.node.text_attributes(offset).map_err(self.map_error())
     }
 
-    fn get_default_attributes(&self) -> fdo::Result<HashMap<String, String>> {
+    fn get_default_attributes(&self) -> fdo::Result<HashMap<&'static str, String>> {
         self.node
             .default_text_attributes()
             .map_err(self.map_error())
@@ -128,7 +131,7 @@ impl TextInterface {
         &self,
         offset: i32,
         include_defaults: bool,
-    ) -> fdo::Result<(HashMap<String, String>, i32, i32)> {
+    ) -> fdo::Result<(HashMap<&'static str, String>, i32, i32)> {
         self.node
             .text_attribute_run(offset, include_defaults)
             .map_err(self.map_error())