use super::{FocusTarget, find_node_by_path};
use crate::{
core::{ElementRef as OwnedElementRef, NodeId},
layout::layout_result::LayoutResult,
node::{Node, SyntheticNodeRole},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(super) enum StartPoint {
On(NodeId),
Before(NodeId),
After(NodeId),
}
pub(super) enum TabMove {
Focus(FocusTarget),
Stay,
Unhandled,
}
type StopKey = (u8, i32, usize);
struct Stop {
target: FocusTarget,
key: StopKey,
entry: bool,
autofocus: bool,
owner: Option<NodeId>,
apart: Option<usize>,
}
struct Walk<'a> {
focused: Option<NodeId>,
focused_order: Option<usize>,
visited: usize,
stops: Vec<Stop>,
moved: &'a [(OwnedElementRef, &'a Node)],
walked: Vec<NodeId>,
in_one_stop: usize,
pending: Vec<&'a Node>,
owner: Option<NodeId>,
apart: Option<usize>,
start: Option<StartPoint>,
start_bounds: Option<(usize, usize)>,
}
pub(super) fn tab_move(
root: &Node,
dropped: &[NodeId],
moved: &[(OwnedElementRef, &Node)],
trap: Option<&Node>,
focused: Option<(NodeId, &[usize])>,
start: Option<StartPoint>,
reverse: bool,
) -> TabMove {
if let Some(trap) = trap {
return match next_stop(trap, dropped, moved, focused.map(|(id, _)| id), None, reverse, true) {
Some(target) => TabMove::Focus(target),
None => TabMove::Stay,
};
}
let modal = top_modal_path(root);
let focused = focused.filter(|(_, path)| modal.as_deref().is_none_or(|modal| path.starts_with(modal)));
let scope = match &modal {
Some(path) => find_node_by_path(root, path),
None => Some(root),
};
match scope.and_then(|scope| next_stop(scope, dropped, moved, focused.map(|(id, _)| id), start, reverse, true)) {
Some(target) => TabMove::Focus(target),
None if modal.is_some() => TabMove::Stay,
None => TabMove::Unhandled,
}
}
pub(super) fn onward_stop(
root: &Node,
dropped: &[NodeId],
moved: &[(OwnedElementRef, &Node)],
focused: Option<(NodeId, &[usize])>,
start: Option<StartPoint>,
) -> Option<FocusTarget> {
let modal = top_modal_path(root);
let focused = focused.filter(|(_, path)| modal.as_deref().is_none_or(|modal| path.starts_with(modal)));
let scope = match &modal {
Some(path) => find_node_by_path(root, path)?,
None => root,
};
let focused = focused.map(|(id, _)| id);
next_stop(scope, dropped, moved, focused, start, false, false)
.or_else(|| next_stop(scope, dropped, moved, focused, start, true, false))
}
fn top_modal_path(root: &Node) -> Option<Vec<usize>> {
if !root.has_synthetic_role(SyntheticNodeRole::OverlayHost) {
return None;
}
root
.children()
.iter()
.rposition(|child| child.has_synthetic_role(SyntheticNodeRole::Modal))
.map(|index| vec![index])
}
pub(super) fn dropped_node_ids(root: &Node, layout: &LayoutResult) -> Vec<NodeId> {
fn collect(node: &Node, layout: &LayoutResult, dropped: &mut Vec<NodeId>) {
if layout.dropped {
dropped.push(node.node_id());
return;
}
for (child, child_layout) in node.children().iter().zip(&layout.children) {
if child.layout_cache.subtree().droppable {
collect(child, &child_layout.result, dropped);
}
}
}
let mut dropped = Vec::new();
collect(root, layout, &mut dropped);
dropped
}
pub(super) fn path_is_disabled(root: &Node, path: &[usize]) -> bool {
let mut node = root;
if node.is_disabled() {
return true;
}
for &index in path {
let Some(child) = node.children().get(index) else {
return false;
};
node = child;
if node.is_disabled() {
return true;
}
}
false
}
pub(super) fn path_is_inert(root: &Node, path: &[usize]) -> bool {
let mut node = root;
if node.is_inert() {
return true;
}
for &index in path {
let Some(child) = node.children().get(index) else {
return false;
};
node = child;
if node.is_inert() {
return true;
}
}
false
}
pub(super) fn path_is_dropped(root: &Node, dropped: &[NodeId], path: &[usize]) -> bool {
if dropped.is_empty() {
return false;
}
let mut node = root;
for &index in path {
let Some(child) = node.children().get(index) else {
return false;
};
node = child;
if dropped.contains(&node.node_id()) {
return true;
}
}
false
}
fn next_stop<'a>(
scope: &'a Node,
dropped: &[NodeId],
moved: &'a [(OwnedElementRef, &'a Node)],
focused: Option<NodeId>,
start: Option<StartPoint>,
reverse: bool,
wrap: bool,
) -> Option<FocusTarget> {
let mut walk = Walk {
focused,
focused_order: None,
visited: 0,
stops: Vec::new(),
moved,
walked: Vec::new(),
in_one_stop: 0,
pending: Vec::new(),
owner: None,
apart: None,
start: if focused.is_none() { start } else { None },
start_bounds: None,
};
if moved.iter().any(|(_, layer)| std::ptr::eq(*layer, scope)) {
walk.walked.push(scope.node_id());
collect_node(scope, dropped, None, false, &mut walk);
} else {
collect_stops(scope, dropped, None, false, &mut walk);
}
for (_, layer) in moved {
if !walk.walked.contains(&layer.node_id()) && scope.children().iter().any(|child| std::ptr::eq(child, *layer)) {
walk.walked.push(layer.node_id());
collect_node(layer, dropped, None, false, &mut walk);
}
}
let start = walk.start_bounds;
let stops = &mut walk.stops;
if stops.is_empty() {
return None;
}
stops.sort_by_key(|stop| stop.key);
let last = stops.len() - 1;
let current = focused.and_then(|id| stops.iter().position(|stop| stop.target.input_id == id));
let round = |at: usize| wrap.then_some(at);
let next = match (current, walk.focused_order) {
(Some(index), _) if reverse => index.checked_sub(1).or_else(|| round(last))?,
(Some(index), _) => Some(index + 1).filter(|next| *next <= last).or_else(|| round(0))?,
(None, Some(order)) => {
let key = stop_key(0, order);
if reverse {
stops.iter().rposition(|stop| stop.key < key).or_else(|| round(last))?
} else {
stops.iter().position(|stop| stop.key > key).or_else(|| round(0))?
}
}
(None, None) => match start {
Some((_, back)) if reverse => stops
.iter()
.rposition(|stop| stop.key < stop_key(0, back))
.or_else(|| round(last))?,
Some((forward, _)) => stops
.iter()
.position(|stop| stop.key >= stop_key(0, forward))
.or_else(|| round(0))?,
None if reverse => last,
None => stops.iter().position(|stop| stop.autofocus).unwrap_or(0),
},
};
Some(stops[next].target)
}
fn collect_stops<'a>(
node: &'a Node,
dropped: &[NodeId],
focus_event_id: Option<NodeId>,
in_form: bool,
walk: &mut Walk<'a>,
) {
if walk.moved.iter().any(|(_, layer)| std::ptr::eq(*layer, node)) {
return;
}
collect_node(node, dropped, focus_event_id, in_form, walk);
let Some(anchor) = &node.element_ref else {
return;
};
let moved = walk.moved;
for (_, layer) in moved.iter().filter(|(owner, _)| owner.same_handle(anchor)) {
if walk.walked.contains(&layer.node_id()) {
continue;
}
walk.walked.push(layer.node_id());
if walk.in_one_stop > 0 {
walk.pending.push(layer);
} else {
collect_node(layer, dropped, None, false, walk);
}
}
}
fn collect_node<'a>(
node: &'a Node,
dropped: &[NodeId],
focus_event_id: Option<NodeId>,
in_form: bool,
walk: &mut Walk<'a>,
) {
let id = node.node_id();
let before = walk.visited;
if walk.start == Some(StartPoint::Before(id)) {
walk.start_bounds = Some((before, before));
}
visit_node(node, dropped, focus_event_id, in_form, walk);
if walk.start == Some(StartPoint::On(id)) {
walk.start_bounds = Some(if walk.visited > before {
(before + 1, before)
} else {
(before, before)
});
}
if walk.start == Some(StartPoint::After(id)) {
walk.start_bounds = Some((walk.visited, walk.visited));
}
}
fn visit_node<'a>(
node: &'a Node,
dropped: &[NodeId],
focus_event_id: Option<NodeId>,
in_form: bool,
walk: &mut Walk<'a>,
) {
if dropped.contains(&node.node_id()) || node.is_disabled() || node.is_inert() || node.is_leaving_layer() {
return;
}
let order = walk.visited;
walk.visited += 1;
if walk.focused == Some(node.node_id()) {
walk.focused_order = Some(order);
}
let focus_event_id = if !node.events.on_focus.is_empty() || !node.events.on_blur.is_empty() {
Some(node.node_id())
} else {
focus_event_id
};
let in_form = in_form || is_form(node);
let tab_index = node.tab_index_value().or(in_form.then_some(0));
if let Some(tab_index) = tab_index
&& tab_index >= 0
&& node.is_focusable()
{
if !node.events.skips_tab {
walk.stops.push(Stop {
target: FocusTarget {
input_id: node.node_id(),
event_id: focus_event_id.unwrap_or_else(|| node.node_id()),
},
key: stop_key(tab_index, order),
entry: node.is_focus_entry(),
autofocus: node.is_autofocus(),
owner: walk.owner,
apart: walk.apart,
});
}
if node.button_kind_value().is_some() && !node.has_stops_inside() {
return;
}
}
let owner = walk.owner;
if tab_index.is_some_and(|index| index >= 0) && node.is_focusable() && node.has_stops_inside() {
walk.owner = Some(node.node_id());
}
let first_inside = walk.stops.len();
let one_stop = node.focus_group_value().is_some_and(|group| group.one_stop);
if one_stop {
walk.in_one_stop += 1;
}
let apart = walk.apart;
if walk.in_one_stop > 0 && node.focus_group_value().is_some_and(|group| group.is_none()) {
walk.apart = Some(walk.in_one_stop);
}
for child in node.children() {
collect_stops(child, dropped, focus_event_id, in_form, walk);
}
walk.apart = apart;
walk.owner = owner;
let depth = walk.in_one_stop;
if one_stop {
walk.in_one_stop -= 1;
}
if one_stop && walk.stops.len() > first_inside + 1 {
let inside = &walk.stops[first_inside..];
let is_inside = |id: NodeId| inside.iter().any(|stop| stop.target.input_id == id);
let apart_here = |stop: &Stop| stop.apart == Some(depth) && !stop.owner.is_some_and(is_inside);
let ours = || inside.iter().filter(|stop| !apart_here(stop));
let kept = ours()
.find(|stop| walk.focused == Some(stop.target.input_id))
.map(|stop| {
stop
.owner
.filter(|owner| is_inside(*owner))
.unwrap_or(stop.target.input_id)
})
.or_else(|| ours().find(|stop| stop.entry).map(|stop| stop.target.input_id))
.or_else(|| ours().next().map(|stop| stop.target.input_id));
let apart: Vec<bool> = inside.iter().map(apart_here).collect();
let held: Vec<Stop> = walk
.stops
.drain(first_inside..)
.zip(apart)
.filter(|(stop, apart)| {
*apart || kept.is_some_and(|kept| stop.target.input_id == kept || stop.owner == Some(kept))
})
.map(|(mut stop, _)| {
if stop.apart == Some(depth) {
stop.apart = None;
}
stop
})
.collect();
walk.stops.extend(held);
}
if one_stop && walk.in_one_stop == 0 {
for layer in std::mem::take(&mut walk.pending) {
collect_node(layer, dropped, None, false, walk);
}
}
}
#[derive(Clone, Debug)]
pub(super) struct FocusStart {
node: NodeId,
path: Vec<usize>,
hosted: bool,
}
impl FocusStart {
pub(super) fn new(root: &Node, node: NodeId, path: Vec<usize>) -> Self {
Self {
node,
path,
hosted: root.has_synthetic_role(SyntheticNodeRole::OverlayHost),
}
}
pub(super) fn point(&self, root: &Node, dropped: &[NodeId]) -> StartPoint {
let passed = |node: &Node| {
dropped.contains(&node.node_id()) || node.is_disabled() || node.is_inert() || node.is_leaving_layer()
};
let (path, found) = match super::find_path_by_id(root, self.node) {
Some(path) => (path, true),
None => {
let hosted = root.has_synthetic_role(SyntheticNodeRole::OverlayHost);
let path = match (self.hosted, hosted) {
(true, false) => match self.path.split_first() {
Some((0, page)) => page.to_vec(),
_ => return StartPoint::After(root.node_id()),
},
(false, true) => std::iter::once(0).chain(self.path.iter().copied()).collect(),
_ => self.path.clone(),
};
(path, false)
}
};
let mut at = root;
if passed(at) {
return StartPoint::Before(at.node_id());
}
for &index in &path {
let Some(child) = at.children().get(index) else {
return StartPoint::After(at.node_id());
};
if passed(child) {
return StartPoint::Before(child.node_id());
}
at = child;
}
if found {
StartPoint::On(self.node)
} else {
StartPoint::Before(at.node_id())
}
}
}
pub(super) fn group_stops(group: &Node, dropped: &[NodeId]) -> Vec<FocusTarget> {
group_stops_around(group, dropped, None).0
}
pub(super) fn group_stops_around(
group: &Node,
dropped: &[NodeId],
around: Option<NodeId>,
) -> (Vec<FocusTarget>, Option<usize>) {
let walk = walk_group(group, dropped, around);
(walk.stops, walk.before)
}
pub(super) fn group_stop_nodes<'a>(group: &'a Node, dropped: &[NodeId]) -> (Vec<FocusTarget>, Vec<&'a Node>) {
let walk = walk_group(group, dropped, None);
(walk.stops, walk.nodes)
}
struct GroupWalk<'a> {
stops: Vec<FocusTarget>,
nodes: Vec<&'a Node>,
around: Option<NodeId>,
before: Option<usize>,
}
fn walk_group<'a>(group: &'a Node, dropped: &[NodeId], around: Option<NodeId>) -> GroupWalk<'a> {
fn collect<'a>(
node: &'a Node,
root: bool,
dropped: &[NodeId],
focus_event_id: Option<NodeId>,
in_form: bool,
walk: &mut GroupWalk<'a>,
) {
if walk.around == Some(node.node_id()) {
walk.before = Some(walk.stops.len());
}
if dropped.contains(&node.node_id()) || node.is_disabled() || node.is_inert() || node.is_leaving_layer() {
return;
}
if !root && node.focus_group_value().is_some_and(|group| group.is_none()) {
return;
}
let focus_event_id = if !node.events.on_focus.is_empty() || !node.events.on_blur.is_empty() {
Some(node.node_id())
} else {
focus_event_id
};
let in_form = in_form || is_form(node);
if node
.tab_index_value()
.or(in_form.then_some(0))
.is_some_and(|index| index >= 0)
&& node.is_focusable()
{
walk.stops.push(FocusTarget {
input_id: node.node_id(),
event_id: focus_event_id.unwrap_or_else(|| node.node_id()),
});
walk.nodes.push(node);
if node.button_kind_value().is_some() && !node.has_stops_inside() {
return;
}
}
for child in node.children() {
collect(child, false, dropped, focus_event_id, in_form, walk);
}
}
let mut walk = GroupWalk {
stops: Vec::new(),
nodes: Vec::new(),
around,
before: None,
};
collect(group, true, dropped, None, false, &mut walk);
walk
}
fn stop_key(tab_index: i32, order: usize) -> StopKey {
if tab_index > 0 {
(0, tab_index, order)
} else {
(1, 0, order)
}
}
#[cfg(feature = "form")]
fn is_form(node: &Node) -> bool {
node.events.on_submit.is_some()
}
#[cfg(not(feature = "form"))]
fn is_form(_: &Node) -> bool {
false
}