feature: Expose most state aria_properties to UIA

Author: lukewarlow

consumer/src/node.rs

@@ -9,8 +9,8 @@
 // found in the LICENSE.chromium file.
 
 use accesskit::{
-    Action, Affine, Live, Node as NodeData, NodeId, Orientation, Point, Rect, Role, TextSelection,
-    Toggled,
+    Action, Affine, HasPopup, Invalid, Live, Node as NodeData, NodeId, Orientation, Point, Rect,
+    Role, TextSelection, Toggled,
 };
 use alloc::{
     string::{String, ToString},
@@ -333,6 +333,14 @@ impl<'a> Node<'a> {
         self.data().role_description().is_some()
     }
 
+    pub fn is_live_atomic(&self) -> bool {
+        self.data().is_live_atomic()
+    }
+
+    pub fn is_busy(&self) -> bool {
+        self.data().is_busy()
+    }
+
     pub fn braille_label(&self) -> Option<&str> {
         self.data().braille_label()
     }
@@ -349,14 +357,30 @@ impl<'a> Node<'a> {
         self.data().braille_role_description().is_some()
     }
 
+    pub fn has_popup(&self) -> Option<HasPopup> {
+        self.data().has_popup()
+    }
+
     pub fn is_hidden(&self) -> bool {
         self.data().is_hidden()
     }
 
+    pub fn invalid(&self) -> Option<Invalid> {
+        self.data().invalid()
+    }
+
+    pub fn level(&self) -> Option<usize> {
+        self.data().level()
+    }
+
     pub fn is_disabled(&self) -> bool {
         self.data().is_disabled()
     }
 
+    pub fn is_expanded(&self) -> Option<bool> {
+        self.data().is_expanded()
+    }
+
     pub fn is_read_only(&self) -> bool {
         let data = self.data();
         if data.is_read_only() {

platforms/windows/src/node.rs

@@ -11,8 +11,8 @@
 #![allow(non_upper_case_globals)]
 
 use accesskit::{
-    Action, ActionData, ActionRequest, Live, NodeId, NodeIdContent, Orientation, Point, Role,
-    Toggled,
+    Action, ActionData, ActionRequest, HasPopup, Live, NodeId, NodeIdContent, Orientation, Point,
+    Role, Toggled,
 };
 use accesskit_consumer::{FilterResult, Node, TreeState};
 use std::sync::{atomic::Ordering, Arc, Weak};
@@ -292,6 +292,11 @@ impl NodeWrapper<'_> {
         let mut result = WideString::default();
         let mut properties = AriaProperties::new(&mut result);
 
+        // TODO: Atomic, busy, and required flags should include false when explicitly set to that
+        if self.0.is_live_atomic() {
+            properties.write_property("atomic", "true").unwrap()
+        }
+
         if let Some(label) = self.0.braille_label() {
             properties.write_property("braillelabel", label).unwrap();
         }
@@ -302,6 +307,150 @@ impl NodeWrapper<'_> {
                 .unwrap();
         }
 
+        if self.0.is_busy() {
+            properties.write_property("busy", "true").unwrap()
+        }
+
+        if let Some(toggled) = self.0.toggled() {
+            let role = self.0.role();
+
+            fn val(t: Toggled) -> &'static str {
+                match t {
+                    Toggled::False => "false",
+                    Toggled::True => "true",
+                    Toggled::Mixed => "mixed",
+                }
+            }
+
+            match role {
+                Role::Button => {
+                    properties.write_property("pressed", val(toggled)).unwrap();
+                }
+                Role::Switch => {
+                    // Switches don't support the mixed state
+                    if let Toggled::True | Toggled::False = toggled {
+                        let s = val(toggled);
+                        // UIA treats switches as toggle buttons, but for maximum compatability
+                        // we set both pressed and checked states.
+                        properties.write_property("pressed", s).unwrap();
+                        properties.write_property("checked", s).unwrap();
+                    }
+                }
+                _ => {
+                    properties.write_property("checked", val(toggled)).unwrap();
+                }
+            }
+        }
+
+        if self.0.is_disabled() {
+            properties.write_property("disabled", "true").unwrap()
+        }
+
+        if let Some(is_expanded) = self.0.is_expanded() {
+            properties
+                .write_property("expanded", if is_expanded { "true" } else { "false" })
+                .unwrap()
+        }
+
+        if let Some(has_popup) = self.0.has_popup() {
+            fn val(h: HasPopup) -> &'static str {
+                match h {
+                    HasPopup::Menu => "menu",
+                    HasPopup::Listbox => "listbox",
+                    HasPopup::Tree => "tree",
+                    HasPopup::Grid => "grid",
+                    HasPopup::Dialog => "dialog",
+                }
+            }
+
+            properties
+                .write_property("haspopup", val(has_popup))
+                .unwrap();
+        }
+
+        if self.0.is_hidden() {
+            properties.write_property("hidden", "true").unwrap()
+        }
+
+        if self.0.invalid() {
+            // We don't need to distinguish between actual values here.
+            properties.write_property("invalid", "true").unwrap();
+        }
+
+        if let Some(level) = self.0.level() {
+            properties
+                .write_property("level", &*level.to_string())
+                .unwrap();
+        }
+
+        match self.live_setting() {
+            Live::Polite => {
+                properties.write_property("live", "polite").unwrap();
+            }
+            Live::Assertive => {
+                properties.write_property("live", "assertive").unwrap();
+            }
+            Live::Off => {}
+        }
+
+        if self.0.is_multiline() {
+            properties.write_property("multiline", "true").unwrap();
+        }
+
+        if self.is_multiselectable() {
+            properties
+                .write_property("multiselectable", "true")
+                .unwrap();
+        }
+
+        if let Some(posinset) = self.0.position_in_set() {
+            properties
+                .write_property("posinset", &*posinset.to_string())
+                .unwrap();
+        }
+
+        if self.is_read_only() {
+            properties.write_property("readonly", "true").unwrap();
+        }
+
+        if self.is_required() {
+            properties.write_property("required", "true").unwrap();
+        }
+
+        if let Some(selected) = self.0.is_selected() {
+            properties
+                .write_property("selected", if selected { "true" } else { "false" })
+                .unwrap()
+        }
+
+        if let Some(setsize) = self.0.size_of_set() {
+            properties
+                .write_property("setsize", &*setsize.to_string())
+                .unwrap();
+        }
+
+        if let Some(valuemax) = self.0.max_numeric_value() {
+            properties
+                .write_property("valuemax", &*valuemax.to_string())
+                .unwrap();
+        }
+
+        if let Some(valuemin) = self.0.min_numeric_value() {
+            properties
+                .write_property("valuemin", &*valuemin.to_string())
+                .unwrap();
+        }
+
+        if let Some(valuenow) = self.0.numeric_value() {
+            properties
+                .write_property("valuenow", &*valuenow.to_string())
+                .unwrap();
+
+            if let Some(valuetext) = self.0.value() {
+                properties.write_property("valuetext", &*valuetext).unwrap();
+            }
+        }
+
         if properties.has_properties() {
             Some(result)
         } else {