use std::collections::{HashMap, HashSet};
use accesskit::{Node, NodeId};
use super::WidgetTree;
use crate::language::LanguageTag;
use crate::widget_id::WidgetId;
impl WidgetTree {
pub(super) fn emit_content_languages(
&self,
nodes: &mut [(NodeId, Node)],
named_from: &HashMap<NodeId, NodeId>,
) {
if self.arena.content_language_count == 0 {
return;
}
let root = crate::accessibility::root_node_id();
let index: HashMap<NodeId, usize> = nodes
.iter()
.enumerate()
.map(|(i, (id, _))| (*id, i))
.collect();
let locale = self.locale_signal.get();
let mut memo = LanguageMemo::default();
let mut writes: Vec<(usize, String)> = Vec::new();
let mut visited: HashSet<NodeId> = HashSet::new();
let mut stack: Vec<(NodeId, Option<String>)> = vec![(root, locale.clone())];
while let Some((nid, inherited)) = stack.pop() {
let Some(&i) = index.get(&nid) else { continue };
if !visited.insert(nid) {
continue;
}
let node = &nodes[i].1;
let own = if nid == root {
inherited
} else if let Some(set) = node.language() {
Some(set.to_owned())
} else if let Some(widget) = crate::accessibility::node_id_to_widget_id_maybe(nid)
.filter(|w| self.arena.get(*w).is_some())
{
let speaks = named_from
.get(&nid)
.copied()
.or_else(|| named_after_its_cells_content(node))
.and_then(|source| {
crate::accessibility::node_id_to_widget_id_maybe(source)
.filter(|w| self.arena.get(*w).is_some())
})
.unwrap_or(widget);
let wanted = memo
.resolve(self, speaks)
.map(|tag| tag.as_str().to_owned())
.or_else(|| locale.clone());
match wanted {
Some(wanted) if Some(&wanted) != inherited.as_ref() => {
writes.push((i, wanted.clone()));
Some(wanted)
}
_ => inherited,
}
} else {
inherited
};
for child in node.children().iter().rev() {
stack.push((*child, own.clone()));
}
}
for (i, language) in writes {
nodes[i].1.set_language(language);
}
}
}
fn named_after_its_cells_content(node: &Node) -> Option<NodeId> {
use accesskit::Role;
let cell = matches!(
node.role(),
Role::Cell | Role::GridCell | Role::RowHeader | Role::ColumnHeader
);
(cell && node.label().is_none())
.then(|| node.labelled_by().first().copied())
.flatten()
}
#[derive(Default)]
struct LanguageMemo {
resolved: HashMap<WidgetId, Option<LanguageTag>>,
}
impl LanguageMemo {
fn resolve(&mut self, tree: &WidgetTree, id: WidgetId) -> Option<LanguageTag> {
let mut chain: Vec<WidgetId> = Vec::new();
let mut crossed: Vec<WidgetId> = Vec::new();
let mut current = Some(id);
let answer = loop {
let Some(at) = current else { break None };
if let Some(known) = self.resolved.get(&at) {
break known.clone();
}
if chain.contains(&at) {
break None;
}
chain.push(at);
if let Some(tag) = tree.arena.own_content_language(at) {
break Some(tag);
}
current = match tree.arena.parent(at) {
Some(parent) => Some(parent),
None if crossed.contains(&at) => None,
None => {
crossed.push(at);
tree.overlay_manager
.find_by_content(at)
.and_then(|overlay| tree.overlay_manager.anchor_for(overlay))
}
};
};
for at in chain {
self.resolved.insert(at, answer.clone());
}
answer
}
}