use super::{FocusTarget, OverlayDismissEntry, Tree, find_node_by_path};
use crate::{
app::ctx::OutsidePress,
core::{ElementRect, ElementRef as OwnedElementRef, NodeId, Signal},
node::Node,
};
pub(super) struct HiddenDismiss {
pub(super) open: Option<Signal<bool>>,
pub(super) on_outside_click: bool,
pub(super) on_escape: bool,
pub(super) on_dismiss: Option<crate::app::ctx::OverlayDismiss>,
}
#[derive(Default)]
pub(super) struct OverlayLayers {
pub(super) dismiss_entries: Vec<OverlayDismissEntry>,
pub(super) anchors: Vec<Option<OwnedElementRef>>,
pub(super) takes_focus: Vec<bool>,
pub(super) origins: Vec<Option<NodeId>>,
pub(super) placings: Vec<Option<super::OverlayPlacing>>,
hidden_anchors: Vec<OwnedElementRef>,
pub(super) focus_movers: Vec<OwnedElementRef>,
pub(super) focus_takers: Vec<OwnedElementRef>,
pub(super) tab_traps: Vec<OwnedElementRef>,
pub(super) focus_modals: Vec<NodeId>,
}
impl OverlayLayers {
pub(super) fn hide(&mut self, anchor: &OwnedElementRef, dismiss: HiddenDismiss, layer: usize) {
self.hidden_anchors.push(anchor.clone());
let Some(open) = dismiss.open else {
return;
};
if !dismiss.on_outside_click && !dismiss.on_escape {
return;
}
self.dismiss_entries.push(OverlayDismissEntry {
anchor: anchor.clone(),
bounds: ElementRect::default(),
open,
dismiss_on_outside_click: dismiss.on_outside_click,
outside_press: OutsidePress::PassThrough,
dismiss_on_escape: dismiss.on_escape,
on_dismiss: dismiss.on_dismiss,
layer,
shown: false,
});
}
pub(super) fn is_hidden(&self, anchor: &OwnedElementRef) -> bool {
self.hidden_anchors.iter().any(|hidden| hidden.same_handle(anchor))
}
}
impl Tree {
pub(super) fn focused_overlay_hidden(&self, had_host: bool, layers: &OverlayLayers) -> Option<OwnedElementRef> {
if !had_host {
return None;
}
let layer = *self.focused_path.as_deref()?.first()?;
let anchor = self.overlay_layer_anchors.get(layer.checked_sub(1)?)?.as_ref()?;
layers.is_hidden(anchor).then(|| anchor.clone())
}
pub(super) fn anchor_before(&self, anchor: &OwnedElementRef, layers: &OverlayLayers) -> Option<&OwnedElementRef> {
let index = layers
.anchors
.iter()
.position(|now| now.as_ref().is_some_and(|now| now.same_handle(anchor)))?;
let origin = (*layers.origins.get(index)?)?;
let old = self
.overlay_layer_origins
.iter()
.position(|declared| *declared == Some(origin))?;
let before = self.overlay_layer_anchors.get(old)?.as_ref()?;
let moved = self.overlay_focus_movers.iter().any(|mover| mover.same_handle(before));
let open = layers.focus_movers.iter().any(|mover| mover.same_handle(before));
(moved && !open && !before.same_handle(anchor)).then_some(before)
}
fn anchor_after<'a>(&self, anchor: &OwnedElementRef, layers: &'a OverlayLayers) -> Option<&'a OwnedElementRef> {
let old = self
.overlay_layer_anchors
.iter()
.position(|before| before.as_ref().is_some_and(|before| before.same_handle(anchor)))?;
let origin = (*self.overlay_layer_origins.get(old)?)?;
let index = layers.origins.iter().position(|declared| *declared == Some(origin))?;
let now = layers.anchors.get(index)?.as_ref()?;
let moves = layers.focus_movers.iter().any(|mover| mover.same_handle(now));
(moves && !now.same_handle(anchor)).then_some(now)
}
pub(super) fn focused_overlay_closed(&self, had_host: bool, layers: &OverlayLayers) -> Option<OwnedElementRef> {
if !had_host {
return None;
}
let closed = |layer: usize| -> Option<&OwnedElementRef> {
let anchor = self.overlay_layer_anchors.get(layer.checked_sub(1)?)?.as_ref()?;
let moved = self.overlay_focus_movers.iter().any(|mover| mover.same_handle(anchor));
let open = layers.focus_movers.iter().any(|mover| mover.same_handle(anchor));
(moved && !open && self.anchor_after(anchor, layers).is_none()).then_some(anchor)
};
let mut layer = *self.focused_path.as_deref()?.first()?;
let mut anchor = closed(layer)?;
for _ in 0..self.overlay_layer_parents.len() {
let Some(outer) = self.overlay_layer_parents.get(layer - 1).copied().flatten() else {
break;
};
let Some(outer_anchor) = closed(outer) else {
break;
};
(layer, anchor) = (outer, outer_anchor);
}
Some(anchor.clone())
}
pub(super) fn focus_layer_parents(&self) -> Vec<Option<usize>> {
let Some(host) = self.root.as_ref() else {
return Vec::new();
};
let layers = host.children().get(1..).unwrap_or_default();
self
.overlay_layer_anchors
.iter()
.map(|anchor| {
let anchor = anchor.as_ref()?;
if !self.overlay_focus_movers.iter().any(|mover| mover.same_handle(anchor)) {
return None;
}
layers
.iter()
.position(|layer| path_to_ref(layer, anchor).is_some())
.map(|index| index + 1)
})
.collect()
}
pub(super) fn focus_moving_layers(&self) -> Vec<(OwnedElementRef, &Node)> {
let Some(host) = self.root.as_ref() else {
return Vec::new();
};
self
.overlay_layer_anchors
.iter()
.enumerate()
.filter_map(|(index, anchor)| {
let anchor = anchor.as_ref()?;
self
.overlay_focus_movers
.iter()
.any(|mover| mover.same_handle(anchor))
.then(|| Some((anchor.clone(), host.children().get(index + 1)?)))?
})
.collect()
}
pub(super) fn tab_trap(&self) -> Option<&Node> {
let host = self.root.as_ref()?;
if self.overlay_tab_traps.is_empty() || !host.has_synthetic_role(crate::node::SyntheticNodeRole::OverlayHost) {
return None;
}
let mut layer = *self.focused_path.as_deref()?.first()?;
for _ in 0..=self.overlay_layer_parents.len() {
let anchor = self.overlay_layer_anchors.get(layer.checked_sub(1)?)?.as_ref();
if anchor.is_some_and(|anchor| self.overlay_tab_traps.iter().any(|trap| trap.same_handle(anchor))) {
let over = host.children().get(layer + 1..).unwrap_or_default();
let under_modal = over
.iter()
.any(|above| above.has_synthetic_role(crate::node::SyntheticNodeRole::Modal));
return host.children().get(layer).filter(|_| !under_modal);
}
layer = self.overlay_layer_parents.get(layer - 1).copied().flatten()?;
}
None
}
pub(super) fn opened_overlay_focus(&self, layers: &OverlayLayers) -> Option<NodeId> {
let host = self.root.as_ref()?;
layers
.focus_takers
.iter()
.filter(|mover| !self.overlay_focus_movers.iter().any(|old| old.same_handle(mover)))
.filter(|mover| self.anchor_before(mover, layers).is_none())
.filter_map(|mover| {
layers
.anchors
.iter()
.zip(&layers.takes_focus)
.rposition(|(anchor, takes)| *takes && anchor.as_ref().is_some_and(|anchor| anchor.same_handle(mover)))
})
.max()
.and_then(|layer| host.children().get(layer + 1))
.and_then(|layer| autofocused(layer).or_else(|| first_focusable(layer)))
}
pub(super) fn note_focus_returns(&mut self, layers: &OverlayLayers, returning: Option<&OwnedElementRef>) {
let movers = &layers.focus_movers;
let had = self
.focused_node
.zip(self.focused_event_node)
.map(|(input_id, event_id)| FocusTarget { input_id, event_id });
for mover in movers {
if !self.overlay_focus_movers.iter().any(|old| old.same_handle(mover)) {
if let Some(before) = self.anchor_before(mover, layers).cloned()
&& let Some(kept) = self
.overlay_focus_returns
.iter_mut()
.find(|(anchor, _)| anchor.same_handle(&before))
{
kept.0 = mover.clone();
continue;
}
let takes = layers.focus_takers.iter().any(|taker| taker.same_handle(mover));
self.overlay_focus_returns.push((mover.clone(), had.filter(|_| takes)));
}
}
self.overlay_focus_returns.retain(|(anchor, _)| {
movers.iter().any(|mover| mover.same_handle(anchor)) || returning.is_some_and(|back| back.same_handle(anchor))
});
}
pub(super) fn return_focus_to_anchor(&mut self, anchor: &OwnedElementRef) {
let had = self
.overlay_focus_returns
.iter()
.position(|(held, _)| held.same_handle(anchor))
.and_then(|index| {
let open = self.overlay_focus_movers.iter().any(|mover| mover.same_handle(anchor));
if open {
self.overlay_focus_returns[index].1
} else {
self.overlay_focus_returns.remove(index).1
}
});
if self.focused_node.is_some() {
return;
}
let root = self.root.as_ref();
let back = had
.filter(|had| root.is_some_and(|root| super::find_path_by_id(root, had.input_id).is_some()))
.or_else(|| {
let target = root.and_then(|root| focus_home(root, anchor))?;
Some(FocusTarget {
input_id: target,
event_id: target,
})
});
if let Some(target) = back {
self.focus_node(target);
}
}
}
fn focus_home(root: &Node, anchor: &OwnedElementRef) -> Option<NodeId> {
let path = path_to_ref(root, anchor)?;
let anchor_node = find_node_by_path(root, &path)?;
if let Some(trigger) = first_focusable(anchor_node) {
return Some(trigger);
}
(0..path.len())
.rev()
.filter_map(|depth| find_node_by_path(root, &path[..depth]))
.find(|node| takes_focus(node))
.map(Node::node_id)
}
fn takes_focus(node: &Node) -> bool {
node.is_focusable() && !node.is_focus_disabled()
}
fn autofocused(node: &Node) -> Option<NodeId> {
if node.is_autofocus() && takes_focus(node) {
return Some(node.node_id());
}
node.children().iter().find_map(autofocused)
}
fn first_focusable(node: &Node) -> Option<NodeId> {
if takes_focus(node) {
return Some(node.node_id());
}
node.children().iter().find_map(first_focusable)
}
pub(super) fn path_to_ref(node: &Node, anchor: &OwnedElementRef) -> Option<Vec<usize>> {
if node
.element_ref
.as_ref()
.is_some_and(|current| current.same_handle(anchor))
{
return Some(Vec::new());
}
node.children().iter().enumerate().find_map(|(index, child)| {
let mut path = path_to_ref(child, anchor)?;
path.insert(0, index);
Some(path)
})
}