Struct AccessNode 

pub struct AccessNode {

    pub role: Role,
    pub semantic_key: Option<String>,
    pub action_target: Option<String>,
    pub name: Option<String>,
    pub description: Option<String>,
    pub value: Option<String>,
    pub text_selection: Option<AccessibleTextSelection>,
    pub state: AccessState,
    pub live: Option<Politeness>,
    pub set_size: Option<usize>,
    pub pos_in_set: Option<usize>,
    pub level: Option<usize>,
    pub key: Option<u64>,
    pub bounds: Option<AccessBounds>,
    pub children: Vec<AccessNode>,
}

The per-widget local accessibility semantics returned by Widget::accessibility; name/description must already be FTL-resolved strings (via i18n!), not translation keys, since AccessKit/AT-SPI consume final text.

Fields

role: Role

semantic_key: Option<String>

Stable identity of a retained actionable widget within its semantic parent. Unlike a layout id, this survives rebuilds and sibling moves.

action_target: Option<String>

Opaque stable identity used to route actions on a synthetic child back to the widget that produced it. It has meaning only to that widget.

name: Option<String>

The primary label a screen reader announces.

description: Option<String>

value: Option<String>

Never populated for protected elements.

text_selection: Option<AccessibleTextSelection>

Direction-preserving UTF-8 byte endpoints for editable text. The AccessKit bridge converts these to grapheme indices in a TextRun.

state: AccessState

live: Option<Politeness>

The App watches its spoken text each frame and announces changes at the given politeness without moving focus. None = not a live region.

set_size: Option<usize>

Total items in the owning collection, pairs with pos_in_set to let the reader say “2 of 4”.

pos_in_set: Option<usize>

1-based position within the collection. See set_size.

level: Option<usize>

1-based hierarchy depth, read out as “level N”.

key: Option<u64>

Stable identity of THIS node within its parent’s children list, for nodes that are synthetic (no backing Widget).

The export layer derives a synthetic node’s assistive-technology id by chaining these keys from the owning widget downwards, so an AT that holds a reference to “the clip named intro” keeps pointing at that clip across repaints — and the same key path is what comes back on Widget::perform_action when the AT operates the node.

None (the default) means “key me by my ordinal position among my siblings”. That is the right choice for position-addressed structures — a table’s rows and cells, where “row 3” is the identity the user means even after a re-sort. Set an explicit key for identity-addressed structures — a clip on a timeline, a layer, a note — whose position moves but which stay the same object; use with_hashed_key to derive one from a string id.

Do not mix keyed and unkeyed siblings in one list: an explicit key of 3 and an ordinal of 3 are indistinguishable downstream.

bounds: Option<AccessBounds>

Absolute logical-pixel bounds for a synthetic node. Retained widgets receive their bounds from Widget::get_rect; virtual rows and cells use this field because they have no widget of their own. The AccessKit bridge applies the window scale factor.

children: Vec<AccessNode>

Accessible children with no backing Widget of their own — a table’s rows and cells, a virtualized list’s items. The export layer emits them as this node’s subtree, nested as deeply as needed (rows containing cells).

Implementations

impl AccessNode

pub fn new(role: Role) -> AccessNode

pub fn with_semantic_key(self, key: impl Into<String>) -> AccessNode

pub fn with_action_target(self, target: impl Into<String>) -> AccessNode

Attach an opaque, widget-local target for actions on this synthetic node. Prefer stable model keys over visible indices.

pub fn with_keyed_action_routes(self, namespace: &str) -> AccessNode

Route every keyed actionable descendant through its existing Widget::perform_action implementation. This is the high-complexity custom-canvas adapter: timeline/editor authors keep one stable keyed semantic tree instead of duplicating an action id and handler for every painted affordance.

pub fn with_name(self, name: impl Into<String>) -> AccessNode

pub fn with_optional_name(self, name: Option<String>) -> AccessNode

Handy when an empty label should collapse to None.

pub fn with_description(self, description: impl Into<String>) -> AccessNode

pub fn with_value(self, value: impl Into<String>) -> AccessNode

pub fn with_optional_value(self, value: Option<String>) -> AccessNode

pub fn with_text_selection(self, anchor: usize, focus: usize) -> AccessNode

Publish an editable caret (anchor == focus) or selection. Endpoints are UTF-8 bytes and are clamped to extended grapheme boundaries by the bridge, matching the toolkit editing contract.

pub fn with_state(self, state: AccessState) -> AccessNode

pub fn with_live(self, politeness: Politeness) -> AccessNode

pub fn with_position(self, pos_in_set: usize, set_size: usize) -> AccessNode

pos_in_set is 1-based within a total of set_size. Read out as “N of M”.

pub fn with_level(self, level: usize) -> AccessNode

pub fn with_key(self, key: u64) -> AccessNode

Set this node’s stable key within its sibling list.

Use this for a synthetic node whose identity outlives its position — a clip that can be dragged along a track, a layer that can be reordered. The key must be unique among the node’s siblings and stable for as long as the element it describes exists.

pub fn with_hashed_key(self, key: impl Hash) -> AccessNode

Set this node’s stable key by hashing any hashable value — the ergonomic form of with_key for elements identified by a string (clip.id), a tuple ((track, clip)), or a UUID.

let clip = AccessNode::new(Role::ListItem).with_hashed_key("clip-intro");
assert_eq!(clip.key, Some(tilo_ui::a11y::hash_key(&"clip-intro")));

pub fn with_bounds(self, bounds: Rect) -> AccessNode

Attach absolute logical-pixel geometry to a synthetic semantic node.

pub fn with_children(self, children: Vec<AccessNode>) -> AccessNode

Attach synthetic children — accessible elements with no backing widget (a table’s rows/cells).

Trait Implementations

impl Clone for AccessNode

fn clone(&self) -> AccessNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AccessNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for AccessNode

fn eq(&self, other: &AccessNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AccessNode

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for AccessNode