Struct AccessibilityTree 

pub struct AccessibilityTree {
    nodes: FxHashMap<NodeId, ArcRefCell<AccessibilityNode>>,
    opaque_node_to_id: FxHashMap<OpaqueNode, NodeId>,
    tree_id: TreeId,
    root_node_id: Option<NodeId>,
    embedder_epoch: Epoch,
    debug: DiagnosticsLogging,
}

A retained, internal representation of the accessibility tree for a document.

accesskit only provides interchange types for tree updates and action requests, so we need to define our own representation for incremental tree building.

Fields

nodes: FxHashMap<NodeId, ArcRefCell<AccessibilityNode>>

All nodes currently in the tree as of the most recent update. New nodes are added and stale nodes are pruned during AccessibilityTree::update_tree().

opaque_node_to_id: FxHashMap<OpaqueNode, NodeId>

A map to allow retrieving the AccessibilityNode which corresponds to a particular DOM node, if any.

tree_id: TreeId

Sent with each accesskit::TreeUpdate. This allows this tree to be grafted into an application’s tree.

root_node_id: Option<NodeId>

Sent with each accesskit::TreeUpdate to identify the root node, and also used in Self::assert_integrity().

embedder_epoch: Epoch

Sent to the embedder alongside each accesskit::TreeUpdate, so that the embedder can drop updates from documents which have been navigated away from.

debug: DiagnosticsLogging

Debug options, copied from configuration to this AccessibilityTree in order to avoid having to constantly access the thread-safe global options.

Implementations

impl AccessibilityTree

pub(crate) fn new(tree_id: TreeId, embedder_epoch: Epoch) -> Self

See Self::tree_id and Self::embedder_epoch for explanations of the parameters.

pub(crate) fn update_tree( &mut self, root_dom_node: &ServoLayoutNode<'_>, rooted_nodes: Option<FxHashSet<OpaqueNode>>, ) -> Option<TreeUpdate>

Update this tree based on the current state of the given DOM tree, and if anything changed, return an accesskit::TreeUpdate representing what changed.

fn update_node_and_descendants_from_dom_node( &mut self, node: &ArcRefCell<AccessibilityNode>, dom_node: &ServoLayoutNode<'_>, update: &mut AccessibilityUpdate, ) -> LocalAccessibilityDamage

Update the given AccessibilityNode from its corresponding DOM node. If it has new children, those will be recursively populated here.

fn get_or_create_node( &mut self, dom_node: &ServoLayoutNode<'_>, update: &mut AccessibilityUpdate, ) -> (NodeId, ArcRefCell<AccessibilityNode>)

fn node_for_id(&self, id: &NodeId) -> Option<ArcRefCell<AccessibilityNode>>

fn assert_node_for_id(&self, id: &NodeId) -> ArcRefCell<AccessibilityNode>

fn remove_stale_nodes(&mut self, update: AccessibilityUpdate)

Consume the AccessibilityUpdate by deleting all nodes it detected as being removed from the tree.

fn assert_removed_nodes_were_rooted( &mut self, update: &AccessibilityUpdate, rooted_nodes: FxHashSet<OpaqueNode>, )

If we got rooted_nodes from the document’s AccessibilityData, assert that every node we removed during this update was rooted, and any leftover rooted nodes were never known to the accessibility tree.

fn id_for_opaque(&mut self, opaque: OpaqueNode) -> NodeId

pub(crate) fn embedder_epoch(&self) -> Epoch

fn assert_integrity(&self)

Assert that the tree is a tree without any dangling references or orphaned nodes.

For accessibility tests only, because it’s expensive.

fn print(&self)

Trait Implementations

impl Debug for AccessibilityTree

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

Formats the value using the given formatter.