// Copyright © SixtyFPS GmbH // SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0 use std::collections::HashMap; use std::pin::Pin; use std::ptr::NonNull; use std::rc::Weak; use accesskit::{ Action, ActionRequest, Live, Node, NodeId, Orientation, Role, Toggled, Tree, TreeId, TreeUpdate, }; use i_slint_core::SharedString; use i_slint_core::accessibility::{ AccessibilityAction, AccessibleStringProperty, SupportedAccessibilityAction, find_exposed_text_input, nearest_accessible_item, }; use i_slint_core::api::Window; use i_slint_core::input::FocusReason; use i_slint_core::item_tree::{ItemTreeRc, ItemTreeRef, ItemTreeWeak}; use i_slint_core::items::{ItemRc, WindowItem}; use i_slint_core::lengths::{LogicalPoint, ScaleFactor}; use i_slint_core::window::{PopupWindowLocation, WindowInner}; use i_slint_core::{properties::PropertyTracker, window::WindowAdapter}; use super::WinitWindowAdapter; use crate::SlintEvent; use winit::event_loop::{ActiveEventLoop, EventLoopProxy}; /// The AccessKit adapter tries to keep the given window adapter's item tree in sync with accesskit's node tree. /// /// The entire item tree is mapped to accesskit's node tree. Any changes to an individual accessible item results /// in an access kit tree update with just changed nodes. Any changes in the tree structure result in a complete /// tree rebuild. This could be implemented more efficiently, but that isn't essential; AccessKit will avoid firing /// gratuitous events for full-tree updates as long as the node IDs are stable. /// /// For unix it's necessary to inform accesskit about any changes to the position or size of the window, hence /// the `on_event` function that needs calling. /// /// Similarly, when the window adapter is informed about a focus change, handle_focus_change must be called. /// Finally, when a component is destroyed, `unregister_item_tree` must be called, which rebuilds the entire /// tree at the moment. /// /// If we wanted to move this to corelib, `on_event` gets replaced with listening to the events sent from the /// platform adapter to the slint::Window. `handle_focus_change` is already internal to WindowInner, as well /// as `component_destroyed`. The `WindowInner` would own this `AccessKit`. pub struct AccessKitAdapter { inner: accesskit_winit::Adapter, window_adapter_weak: Weak, nodes: NodeCollection, global_property_tracker: Pin>, pending_update: bool, initial_tree_sent: bool, } impl AccessKitAdapter { pub fn new( window_adapter_weak: Weak, active_event_loop: &ActiveEventLoop, winit_window: &winit::window::Window, proxy: EventLoopProxy, ) -> Self { Self { inner: accesskit_winit::Adapter::with_event_loop_proxy( active_event_loop, winit_window, proxy, ), window_adapter_weak: window_adapter_weak.clone(), nodes: NodeCollection { next_component_id: 1, free_component_ids: Default::default(), root_node_id: NodeId(0), components_by_id: Default::default(), component_ids: Default::default(), all_nodes: Default::default(), focused_node_tracker: Box::pin(PropertyTracker::new_with_dirty_handler( DelegateFocusPropertyTracker { window_adapter_weak: window_adapter_weak.clone(), }, )), text_state: Default::default(), }, global_property_tracker: Box::pin(PropertyTracker::new_with_dirty_handler( AccessibilityPropertyDirtyHandler { window_adapter_weak: window_adapter_weak.clone(), }, )), pending_update: false, initial_tree_sent: false, } } pub fn process_event( &mut self, window: &winit::window::Window, event: &winit::event::WindowEvent, ) { if matches!(event, winit::event::WindowEvent::Focused(_)) { self.global_property_tracker.set_dirty(); self.invoke_later(|self_cell, _| self_cell.borrow_mut().rebuild_tree_of_dirty_nodes()); } self.inner.process_event(window, event); } pub fn process_accesskit_event( &mut self, window_event: accesskit_winit::WindowEvent, ) -> Option { match window_event { accesskit_winit::WindowEvent::InitialTreeRequested => { self.inner.update_if_active(|| { self.nodes.build_new_tree( &self.window_adapter_weak, self.global_property_tracker.as_ref(), ) }); self.initial_tree_sent = true; None } accesskit_winit::WindowEvent::ActionRequested(r) => self.handle_request(r), accesskit_winit::WindowEvent::AccessibilityDeactivated => { self.initial_tree_sent = false; self.nodes.text_state.clear_all(); None } } } pub fn handle_focus_item_change(&mut self) { // Ignore focus changes until an initial tree was sent, to avoid sending `tree: None`. if !self.initial_tree_sent { return; } // Don't send a tree update now with an empty tree/node list when we know that the structure // if the tree has changed. It might be that the focus node is not known yet to AccessKit. // The pending update will take care of setting the focus node. if self.pending_update { return; } self.inner.update_if_active(|| TreeUpdate { nodes: Vec::new(), tree: None, tree_id: TreeId::ROOT, focus: self.nodes.focus_node(&self.window_adapter_weak), }) } fn handle_request(&self, request: ActionRequest) -> Option { let a = match request.action { Action::Click => AccessibilityAction::Default, Action::Focus => { return self .nodes .item_rc_for_node_id(request.target_node) .map(DeferredAccessKitAction::SetFocus); } Action::Decrement => AccessibilityAction::Decrement, Action::Increment => AccessibilityAction::Increment, Action::ReplaceSelectedText => { let Some(accesskit::ActionData::Value(v)) = request.data else { return None }; AccessibilityAction::ReplaceSelectedText(SharedString::from(&*v)) } Action::SetValue => match request.data { Some(accesskit::ActionData::Value(v)) => { AccessibilityAction::SetValue(SharedString::from(&*v)) } Some(accesskit::ActionData::NumericValue(v)) => { AccessibilityAction::SetValue(i_slint_core::format!("{v}")) } _ => return None, }, Action::Expand => AccessibilityAction::Expand, Action::SetTextSelection => { let Some(accesskit::ActionData::SetTextSelection(sel)) = request.data.as_ref() else { return None; }; // A TextPosition names a TextRun sub-NodeId, so decode it back to the wrapper. let (wrapper_parent, _) = decode_sub_node_id(sel.focus.node)?; if wrapper_parent != request.target_node { return None; } let wrapper_item = self.nodes.item_rc_for_node_id(wrapper_parent)?; let window_adapter = self.window_adapter_weak.upgrade()?; let (inner_item_rc, text_input) = find_exposed_text_input(&wrapper_item)?; let state = self .nodes .text_state .get_or_update_cache_entry_ref(&inner_item_rc, Default::default); let (anchor, focus) = state.decode_selection( window_adapter.renderer().as_core_renderer(), text_input.as_pin_ref(), &inner_item_rc, inner_item_rc.geometry().size, &sel.anchor, &sel.focus, )?; AccessibilityAction::SetSelectionOffsets(anchor as i32, focus as i32) } _ => return None, }; self.nodes .item_rc_for_node_id(request.target_node) .map(|item| DeferredAccessKitAction::InvokeAccessibleAction(item, a)) } pub fn reload_tree(&mut self) { if self.pending_update { return; } self.pending_update = true; self.invoke_later(|self_cell, win| { let mut self_ = self_cell.borrow_mut(); let self_ = &mut *self_; self_.pending_update = false; self_.inner.update_if_active(|| { self_.nodes.build_new_tree(&win, self_.global_property_tracker.as_ref()) }) }); } pub fn unregister_item_tree(&mut self, component: ItemTreeRef) { let component_ptr = ItemTreeRef::as_ptr(component); if let Some(component_id) = self.nodes.component_ids.remove(&component_ptr) { self.nodes.components_by_id.remove(&component_id); self.nodes.free_component_ids.push(component_id); } self.nodes.text_state.component_destroyed(component); self.reload_tree(); } fn rebuild_tree_of_dirty_nodes(&mut self) { if !self.global_property_tracker.is_dirty() && !self.nodes.focused_node_tracker.is_dirty() { return; } // It's possible that we may have been triggered by a timer, but in the meantime // the node tree has been emptied due to a tree structure change. if self.nodes.all_nodes.is_empty() { return; } // Don't end a tree update now with an empty tree/node list when we know that the structure // if the tree has changed. It might be that the focus node is not known yet to AccessKit. // The pending update will take care rebuilding the entire tree anyway. if self.pending_update { return; } let Some(window_adapter) = self.window_adapter_weak.upgrade() else { return }; let window = window_adapter.window(); self.inner.update_if_active(|| { self.global_property_tracker.as_ref().evaluate_as_dependency_root(|| { let nodes_vec: Vec<(NodeId, Node)> = self .nodes .all_nodes .iter() .flat_map(|cached_node| { cached_node .tracker .as_ref() .evaluate_if_dirty(|| { let scale_factor = ScaleFactor::new(window.scale_factor()); let Some(item) = self.nodes.item_rc_for_node_id(cached_node.id) else { return Vec::new(); }; let mut node = self.nodes.build_node_without_children( &item, scale_factor, Default::default(), ); node.set_children(cached_node.children.clone()); let mut emitted: Vec<(NodeId, Node)> = Vec::new(); self.nodes.try_emit_text_input_accessibility( &item, &mut node, cached_node.id, scale_factor, Default::default(), &mut emitted, &window_adapter, ); let mut out = Vec::with_capacity(1 + emitted.len()); out.push((cached_node.id, node)); out.extend(emitted); out }) .unwrap_or_default() }) .collect(); TreeUpdate { nodes: nodes_vec, tree: None, tree_id: TreeId::ROOT, focus: self.nodes.focus_node(&self.window_adapter_weak), } }) }) } fn invoke_later( &self, callback: impl FnOnce(&std::cell::RefCell, Weak) + 'static, ) { let win = self.window_adapter_weak.clone(); i_slint_core::timers::Timer::single_shot(Default::default(), move || { WinitWindowAdapter::with_access_kit_adapter_from_weak_window_adapter( win.clone(), move |self_cell| callback(self_cell, win), ); }); } } const NODE_ID_INDEX_BITS: u32 = 16; const NODE_ID_INDEX_MASK: u64 = (1 << NODE_ID_INDEX_BITS) - 1; // 0xFFFF const NODE_ID_COMPONENT_BITS: u32 = 22; const NODE_ID_COMPONENT_MASK: u64 = (1 << NODE_ID_COMPONENT_BITS) - 1; // 0x3FFFFF // NodeIds for the TextRun children of a text input: // // bits 38..=63 : sub-index, allocated per parent, never 0 // bits 0..=37 : the parent NodeId, which `encode_item_node_id` fits in exactly these bits // // A regular NodeId leaves the sub-index bits clear, so a non-zero sub-index is what tells the two // apart. const NODE_ID_PARENT_BITS: u32 = NODE_ID_INDEX_BITS + NODE_ID_COMPONENT_BITS; const NODE_ID_PARENT_MASK: u64 = (1u64 << NODE_ID_PARENT_BITS) - 1; const NODE_ID_SUB_INDEX_BITS: u32 = u64::BITS - NODE_ID_PARENT_BITS; const NODE_ID_SUB_INDEX_MASK: u64 = (1u64 << NODE_ID_SUB_INDEX_BITS) - 1; fn encode_sub_node_id(parent: NodeId, sub_index: u32) -> NodeId { debug_assert!(sub_index >= 1, "sub_index 0 would collide with the parent NodeId"); debug_assert!( (sub_index as u64) <= NODE_ID_SUB_INDEX_MASK, "sub_index exceeds {NODE_ID_SUB_INDEX_BITS} bits" ); debug_assert_eq!( parent.0 & !NODE_ID_PARENT_MASK, 0, "parent NodeId occupies more than {NODE_ID_PARENT_BITS} bits" ); NodeId(((sub_index as u64) << NODE_ID_PARENT_BITS) | (parent.0 & NODE_ID_PARENT_MASK)) } fn decode_sub_node_id(id: NodeId) -> Option<(NodeId, u32)> { let sub_index = (id.0 >> NODE_ID_PARENT_BITS) as u32; (sub_index != 0).then_some((NodeId(id.0 & NODE_ID_PARENT_MASK), sub_index)) } fn is_text_input_role(role: Role) -> bool { matches!( role, Role::TextInput | Role::MultilineTextInput | Role::PasswordInput | Role::SearchInput | Role::NumberInput ) } fn wraps_text_input(role: Role) -> bool { is_text_input_role(role) || role == Role::SpinButton } struct NodeCollection { next_component_id: u32, free_component_ids: Vec, components_by_id: HashMap, component_ids: HashMap, u32>, all_nodes: Vec, root_node_id: NodeId, focused_node_tracker: Pin>>, /// Emission state, keyed by the inner `TextInput`'s `ItemRc`. Its per-entry property tracker /// stays empty on purpose: the state has to outlive the edits it describes, so that NodeIds /// stay stable and screen readers see "node updated" rather than "subtree replaced". text_state: i_slint_core::item_rendering::ItemCache< i_slint_core::textlayout::sharedparley::CachedTextInputAccessibilityState, >, } impl NodeCollection { fn focus_node(&mut self, window_adapter_weak: &Weak) -> NodeId { window_adapter_weak .upgrade() .filter(|window_adapter| { window_adapter.winit_window().is_some_and(|winit_window| winit_window.has_focus()) }) .and_then(|window_adapter| { let window_inner = WindowInner::from_pub(window_adapter.window()); window_inner .focus_item .borrow() .upgrade() .map(|focus_item| { let parent = nearest_accessible_item(focus_item); self.focused_node_tracker .as_ref() .evaluate(|| { parent.accessible_string_property( AccessibleStringProperty::DelegateFocus, ) }) .and_then(|s| s.parse::().ok()) .and_then(|i| { i_slint_core::accessibility::accessible_descendents(&parent).nth(i) }) .unwrap_or(parent) }) .or_else(|| window_inner.try_component().map(ItemRc::new_root)) .map(|focus_item| self.find_node_id_by_item_rc(focus_item)) }) .unwrap_or(self.root_node_id) } fn item_rc_for_node_id(&self, id: NodeId) -> Option { let component_id: u32 = ((id.0 >> NODE_ID_INDEX_BITS) & NODE_ID_COMPONENT_MASK) as _; let index: u32 = (id.0 & NODE_ID_INDEX_MASK) as _; let component = self.components_by_id.get(&component_id)?.upgrade()?; Some(ItemRc::new(component, index)) } fn find_node_id_by_item_rc(&mut self, mut item: ItemRc) -> NodeId { item = nearest_accessible_item(item); self.encode_item_node_id(&item) } fn alloc_component_id(&mut self) -> u32 { self.free_component_ids.pop().unwrap_or_else(|| { let id = self.next_component_id; self.next_component_id += 1; id }) } fn encode_item_node_id(&mut self, item: &ItemRc) -> NodeId { let component = item.item_tree(); let component_ptr = ItemTreeRef::as_ptr(ItemTreeRc::borrow(component)); let component_id = match self.component_ids.get(&component_ptr) { Some(&component_id) => component_id, None => { let component_id = self.alloc_component_id(); self.component_ids.insert(component_ptr, component_id); self.components_by_id.insert(component_id, ItemTreeRc::downgrade(component)); component_id } }; debug_assert!( (component_id as u64) <= NODE_ID_COMPONENT_MASK, "component_id exceeds {NODE_ID_COMPONENT_BITS} bits" ); let index = item.index(); NodeId((component_id as u64) << NODE_ID_INDEX_BITS | (index as u64 & NODE_ID_INDEX_MASK)) } fn build_node_for_item_recursively( &mut self, item: ItemRc, nodes: &mut Vec<(NodeId, Node)>, popups: &[AccessiblePopup], scale_factor: ScaleFactor, window_position: LogicalPoint, window_adapter: &std::rc::Rc, ) -> NodeId { let id = self.encode_item_node_id(&item); let popup_children = popups .iter() .filter_map(|popup| { if popup.parent_node != id { return None; } let popup_item = ItemRc::new_root(popup.component.clone()); Some(self.build_node_for_item_recursively( popup_item, nodes, popups, scale_factor, popup.location, window_adapter, )) }) .collect::>(); let descendant_children = i_slint_core::accessibility::accessible_descendents(&item) .map(|child| { self.build_node_for_item_recursively( child, nodes, popups, scale_factor, window_position, window_adapter, ) }) .chain(popup_children) .collect::>(); let tracker = Box::pin(PropertyTracker::default()); // One tracker for both the wrapper attributes and the text emission, so that either // going dirty rebuilds the node. let (node, text_run_nodes) = { let mut text_run_nodes: Vec<(NodeId, Node)> = Vec::new(); let node = tracker.as_ref().evaluate(|| { let mut n = self.build_node_without_children(&item, scale_factor, window_position); n.set_children(descendant_children.clone()); self.try_emit_text_input_accessibility( &item, &mut n, id, scale_factor, window_position, &mut text_run_nodes, window_adapter, ); n }); (node, text_run_nodes) }; // Only the regular descendants: every emit pushes the TextRun children again, and // `accesskit_consumer` rejects a child that appears twice. self.all_nodes.push(CachedNode { id, children: descendant_children, tracker }); nodes.push((id, node)); nodes.extend(text_run_nodes); id } /// Emits the TextRun children of a text input, and the value and selection on `wrapper_node`. fn try_emit_text_input_accessibility( &self, item: &ItemRc, wrapper_node: &mut Node, wrapper_id: NodeId, scale_factor: ScaleFactor, window_position: LogicalPoint, text_run_nodes: &mut Vec<(NodeId, Node)>, window_adapter: &std::rc::Rc, ) { if !wraps_text_input(wrapper_node.role()) { return; } let Some((inner_item_rc, text_input)) = find_exposed_text_input(item) else { return; }; let mut state = self.text_state.get_or_update_cache_entry_ref(&inner_item_rc, Default::default); // The inner `TextInput`'s geometry: a `LineEdit` insets it for its border, so measuring // from the wrapper's origin would place every TextRun off by the padding. let inner_geometry = inner_item_rc.geometry(); let inner_absolute_origin = inner_item_rc.map_to_window(inner_geometry.origin) + window_position.to_vector(); let physical_origin = (inner_absolute_origin * scale_factor).cast::(); let mut update = TreeUpdate { nodes: Vec::new(), tree: None, tree_id: TreeId::ROOT, focus: NodeId(0) }; // Borrows the font context itself, so we must not be holding it here. let emitted_runs = state.emit( window_adapter.renderer().as_core_renderer(), text_input.as_pin_ref(), &inner_item_rc, inner_geometry.size, &mut update, wrapper_node, wrapper_id, (physical_origin.x, physical_origin.y), encode_sub_node_id, ); if emitted_runs && item .supported_accessibility_actions() .contains(SupportedAccessibilityAction::SetSelectionOffsets) { wrapper_node.add_action(Action::SetTextSelection); } text_run_nodes.extend(update.nodes); } fn tree_info(&self, root: NodeId) -> Tree { let mut tree = Tree::new(root); tree.toolkit_name = Some("Slint".into()); tree.toolkit_version = Some(env!("CARGO_PKG_VERSION").into()); tree } fn build_new_tree( &mut self, window_adapter_weak: &Weak, property_tracker: Pin<&AccessibilityPropertyTracker>, ) -> TreeUpdate { let Some(window_adapter) = window_adapter_weak.upgrade() else { return TreeUpdate { nodes: Default::default(), tree: Default::default(), tree_id: TreeId::ROOT, focus: self.root_node_id, }; }; let window = window_adapter.window(); let window_inner = i_slint_core::window::WindowInner::from_pub(window); window_inner.ensure_tree_instantiated(); let Some(component) = window_inner.try_component() else { return TreeUpdate { nodes: Default::default(), tree: Default::default(), tree_id: TreeId::ROOT, focus: self.root_node_id, }; }; let root_item = ItemRc::new_root(component); let popups = window_inner .active_popups() .iter() .filter_map(|popup| { let PopupWindowLocation::ChildWindow(location) = popup.location else { return None; }; let parent_item = nearest_accessible_item(popup.parent_item.upgrade()?); let parent_node = self.encode_item_node_id(if parent_item.is_accessible() { &parent_item } else { &root_item }); Some(AccessiblePopup { location, parent_node, component: popup.component.clone() }) }) .collect::>(); self.all_nodes.clear(); let mut nodes = Vec::new(); let root_id = property_tracker.evaluate_as_dependency_root(|| { self.build_node_for_item_recursively( root_item, &mut nodes, &popups, ScaleFactor::new(window.scale_factor()), Default::default(), &window_adapter, ) }); self.root_node_id = root_id; TreeUpdate { nodes, tree: Some(self.tree_info(root_id)), tree_id: TreeId::ROOT, focus: self.focus_node(window_adapter_weak), } } fn build_node_without_children( &self, item: &ItemRc, scale_factor: ScaleFactor, window_position: LogicalPoint, ) -> Node { let is_checkable = item .accessible_string_property(AccessibleStringProperty::Checkable) .is_some_and(|x| x == "true"); let (role, label) = if let Some(window_item) = item.downcast::() { (Role::Window, Some(window_item.as_pin_ref().title().to_string())) } else { ( match item.accessible_role() { i_slint_core::items::AccessibleRole::None => Role::Unknown, i_slint_core::items::AccessibleRole::Button => Role::Button, i_slint_core::items::AccessibleRole::Checkbox => Role::CheckBox, i_slint_core::items::AccessibleRole::Combobox => Role::ComboBox, i_slint_core::items::AccessibleRole::Groupbox => Role::Group, i_slint_core::items::AccessibleRole::List => Role::ListBox, i_slint_core::items::AccessibleRole::Slider => Role::Slider, i_slint_core::items::AccessibleRole::Spinbox => Role::SpinButton, i_slint_core::items::AccessibleRole::Tab => Role::Tab, i_slint_core::items::AccessibleRole::TabList => Role::TabList, i_slint_core::items::AccessibleRole::TabPanel => Role::TabPanel, i_slint_core::items::AccessibleRole::Text => Role::Label, i_slint_core::items::AccessibleRole::Table => Role::Table, i_slint_core::items::AccessibleRole::Tree => Role::Tree, i_slint_core::items::AccessibleRole::TextInput => { if let Some(text_input) = i_slint_core::accessibility::find_text_input(item) { if !text_input.single_line.get_internal() { Role::MultilineTextInput } else { match text_input.input_type.get_internal() { i_slint_core::items::InputType::Decimal | i_slint_core::items::InputType::Number => Role::NumberInput, i_slint_core::items::InputType::Password => Role::PasswordInput, i_slint_core::items::InputType::Search => Role::SearchInput, i_slint_core::items::InputType::Text | _ => Role::TextInput, } } } else { Role::TextInput } } i_slint_core::items::AccessibleRole::ProgressIndicator => { Role::ProgressIndicator } i_slint_core::items::AccessibleRole::Switch => Role::Switch, i_slint_core::items::AccessibleRole::ListItem => Role::ListBoxOption, i_slint_core::items::AccessibleRole::Image => Role::Image, i_slint_core::items::AccessibleRole::RadioButton => Role::RadioButton, i_slint_core::items::AccessibleRole::RadioGroup => Role::RadioGroup, i_slint_core::items::AccessibleRole::WindowTitleBar => Role::TitleBar, i_slint_core::items::AccessibleRole::Banner => Role::Banner, i_slint_core::items::AccessibleRole::Complementary => Role::Complementary, i_slint_core::items::AccessibleRole::ContentInfo => Role::ContentInfo, i_slint_core::items::AccessibleRole::Form => Role::Form, i_slint_core::items::AccessibleRole::Main => Role::Main, i_slint_core::items::AccessibleRole::Navigation => Role::Navigation, i_slint_core::items::AccessibleRole::Region => Role::Region, i_slint_core::items::AccessibleRole::Search => Role::Search, _ => Role::Unknown, }, item.accessible_string_property( i_slint_core::accessibility::AccessibleStringProperty::Label, ) .map(|x| x.to_string()), ) }; let mut node = Node::new(role); if let Some(label) = label { if role == Role::Label { node.set_value(label); } else { node.set_label(label); } } if item .accessible_string_property(AccessibleStringProperty::Enabled) .is_some_and(|x| x != "true") { node.set_disabled(); } if !item.is_visible() { node.set_hidden(); } if item.borrow().as_ref().clips_children() { node.set_clips_children(); } let geometry = item.geometry(); let absolute_origin = item.map_to_window(geometry.origin) + window_position.to_vector(); let physical_origin = (absolute_origin * scale_factor).cast::(); let physical_size = (geometry.size * scale_factor).cast::(); node.set_bounds(accesskit::Rect { x0: physical_origin.x, y0: physical_origin.y, x1: physical_origin.x + physical_size.width, y1: physical_origin.y + physical_size.height, }); let is_checked = is_checkable && item .accessible_string_property(AccessibleStringProperty::Checked) .is_some_and(|x| x == "true"); if is_checkable { node.set_toggled(if is_checked { Toggled::True } else { Toggled::False }); } if let Some(description) = item.accessible_string_property(AccessibleStringProperty::Description) { node.set_description(description.to_string()); } if let Some(id) = item.accessible_string_property(AccessibleStringProperty::Id) { node.set_author_id(id.to_string()); } if item .accessible_string_property(AccessibleStringProperty::Expandable) .is_some_and(|x| x == "true") { node.set_expanded( item.accessible_string_property(AccessibleStringProperty::Expanded) .is_some_and(|x| x == "true"), ); } if matches!( role, Role::Button | Role::CheckBox | Role::ComboBox | Role::ListBoxOption | Role::MultilineTextInput | Role::NumberInput | Role::PasswordInput | Role::SearchInput | Role::Slider | Role::SpinButton | Role::Tab | Role::TextInput ) { node.add_action(Action::Focus); } if let Some(min) = item .accessible_string_property(AccessibleStringProperty::ValueMinimum) .and_then(|min| min.parse().ok()) { node.set_min_numeric_value(min); } if let Some(max) = item .accessible_string_property(AccessibleStringProperty::ValueMaximum) .and_then(|max| max.parse().ok()) { node.set_max_numeric_value(max); } if let Some(step) = item .accessible_string_property(AccessibleStringProperty::ValueStep) .and_then(|step| step.parse().ok()) { node.set_numeric_value_step(step); } if let Some(value) = item.accessible_string_property(AccessibleStringProperty::Value) { match value.parse() { Ok(numeric) if role == Role::SpinButton => { node.set_numeric_value(numeric); node.set_value(value.to_string()); } Ok(numeric) if !is_text_input_role(role) => node.set_numeric_value(numeric), _ => node.set_value(value.to_string()), } } if let Some(placeholder) = item.accessible_string_property(AccessibleStringProperty::PlaceholderText) { node.set_placeholder(placeholder.to_string()); } if item .accessible_string_property(AccessibleStringProperty::ReadOnly) .is_some_and(|x| x == "true") { node.set_read_only(); } if let Some(orientation) = item .accessible_string_property(AccessibleStringProperty::Orientation) .and_then(|s| s.parse::().ok()) { node.set_orientation(match orientation { i_slint_core::items::Orientation::Horizontal => Orientation::Horizontal, i_slint_core::items::Orientation::Vertical => Orientation::Vertical, }); } if let Some(live) = item .accessible_string_property(AccessibleStringProperty::LiveRegion) .and_then(|s| s.parse::().ok()) { node.set_live(match live { i_slint_core::items::AccessibleLiveness::Off => Live::Off, i_slint_core::items::AccessibleLiveness::Polite => Live::Polite, i_slint_core::items::AccessibleLiveness::Assertive => Live::Assertive, _ => Live::Off, }); } if item .accessible_string_property(AccessibleStringProperty::ItemSelectable) .is_some_and(|x| x == "true") { node.set_selected( item.accessible_string_property(AccessibleStringProperty::ItemSelected) .is_some_and(|x| x == "true"), ); } if let Some(position_in_set) = item .accessible_string_property(AccessibleStringProperty::ItemIndex) .and_then(|s| s.parse::().ok()) { node.set_position_in_set(position_in_set); } if let Some(size_of_set) = item .accessible_string_property(AccessibleStringProperty::ItemCount) .and_then(|s| s.parse::().ok()) { node.set_size_of_set(size_of_set); } let supported = item.supported_accessibility_actions(); if supported.contains(SupportedAccessibilityAction::Default) { node.add_action(accesskit::Action::Click); } if supported.contains(SupportedAccessibilityAction::Decrement) { node.add_action(accesskit::Action::Decrement); } if supported.contains(SupportedAccessibilityAction::Increment) { node.add_action(accesskit::Action::Increment); } if supported.contains(SupportedAccessibilityAction::SetValue) { node.add_action(accesskit::Action::SetValue); } if supported.contains(SupportedAccessibilityAction::ReplaceSelectedText) { node.add_action(accesskit::Action::ReplaceSelectedText); } if supported.contains(SupportedAccessibilityAction::Expand) { node.add_action(accesskit::Action::Expand); } node } } type AccessibilityPropertyTracker = PropertyTracker; struct AccessibilityPropertyDirtyHandler { window_adapter_weak: Weak, } impl i_slint_core::properties::PropertyDirtyHandler for AccessibilityPropertyDirtyHandler { fn notify(self: Pin<&Self>) { let win = self.window_adapter_weak.clone(); i_slint_core::timers::Timer::single_shot(Default::default(), move || { WinitWindowAdapter::with_access_kit_adapter_from_weak_window_adapter( win, |self_cell| { self_cell.borrow_mut().rebuild_tree_of_dirty_nodes(); }, ); }) } } struct DelegateFocusPropertyTracker { window_adapter_weak: Weak, } impl i_slint_core::properties::PropertyDirtyHandler for DelegateFocusPropertyTracker { fn notify(self: Pin<&Self>) { let win = self.window_adapter_weak.clone(); i_slint_core::timers::Timer::single_shot(Default::default(), move || { WinitWindowAdapter::with_access_kit_adapter_from_weak_window_adapter( win, |self_cell| { self_cell.borrow_mut().handle_focus_item_change(); }, ); }) } } struct CachedNode { id: NodeId, children: Vec, tracker: Pin>, } impl From for SlintEvent { fn from(value: accesskit_winit::Event) -> Self { SlintEvent(crate::event_loop::CustomEvent::Accesskit(value)) } } pub enum DeferredAccessKitAction { SetFocus(ItemRc), InvokeAccessibleAction(ItemRc, AccessibilityAction), } impl DeferredAccessKitAction { pub fn invoke(&self, window: &Window) { match self { DeferredAccessKitAction::SetFocus(item) => { // pretend this event was caused by a mouse for compatibility purposes WindowInner::from_pub(window).set_focus_item(item, true, FocusReason::PointerClick); } DeferredAccessKitAction::InvokeAccessibleAction(item, accessibility_action) => { item.accessible_action(accessibility_action); } } } } struct AccessiblePopup { location: LogicalPoint, parent_node: NodeId, component: ItemTreeRc, }