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>,
    pub interface_name: bool,
    pub role_description: Option<String>,
    pub item: Option<String>,
}

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).

interface_name: bool

Whether name is the app’s own fixed, localized copy (a button’s label, a heading), the same for everyone, rather than something a person or a resource put there. Unset means content: a feedback report hides it until the reporter shows it.

role_description: Option<String>

What kind of thing this is in the app’s own words, where its role says too little (“Message” for a chat row that is a list item), in the reader’s language. Always the app’s own copy, never content.

item: Option<String>

The item of its app’s collection this node shows: a note’s block id, a task’s issue. What an action naming that item is drawn on, so an invocation’s target is found in the view by identity rather than by its label or its place among its siblings.

Implementations

impl AccessNode

pub fn new(role: Role) -> AccessNode

pub fn with_item(self, item: impl Into<String>) -> AccessNode

Say which item of its collection this node shows (Self::item).

pub fn with_interface_name(self, interface: bool) -> AccessNode

Mark the name as the app’s own fixed, localized copy (Self::interface_name).

pub fn with_role_description(self, kind: impl Into<String>) -> AccessNode

Say what kind of thing this is in the app’s own words (Self::role_description).

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