use super::{
FocusTarget, OverlayHostReuse, Tree, find_node_by_id, find_node_by_id_mut, overlay_layers::OverlayLayers,
reset_element_ref_flags_recursive,
};
use crate::{core::NodeId, node::Node, time::Instant};
pub(super) struct LeavingLayer {
pub(super) root: NodeId,
pub(super) until: Instant,
pub(super) origin: Option<NodeId>,
pub(super) focus: Option<FocusTarget>,
}
impl Tree {
pub(super) fn leaving_layers(
&mut self,
old_parts: &mut OverlayHostReuse,
layers: &OverlayLayers,
old_origins: &[Option<NodeId>],
now: Instant,
) -> Vec<(usize, Node)> {
let mut records = Vec::new();
let mut leaving = Vec::new();
for (position, layer) in std::mem::take(&mut old_parts.leaving) {
let record = self.leaving_layers.iter().find(|record| record.root == layer.node_id());
match record {
Some(record) if now < record.until => {
records.push(LeavingLayer {
root: record.root,
until: record.until,
origin: record.origin,
focus: record.focus,
});
leaving.push((position, layer));
}
_ => old_parts.dropped.push(layer),
}
}
for index in 0..old_parts.old_overlays.len() {
if !old_parts.is_free(index) || !old_parts.old_overlays[index].has_exit_animation() {
continue;
}
let position = old_parts.old_overlay_positions[index];
let origin = old_parts.old_origin(index, old_origins);
let hidden = self
.overlay_layer_anchors
.get(position)
.and_then(Option::as_ref)
.is_some_and(|anchor| layers.is_hidden(anchor));
if hidden {
continue;
}
let layer = &mut old_parts.old_overlays[index];
let animations = &mut self.animation_engine;
let until = layer
.begin_exit(&mut |node| animations.forget_node(node))
.and_then(|lasts| now.checked_add(lasts));
let Some(until) = until else {
continue;
};
let mut layer = std::mem::take(layer);
old_parts.old_overlay_used[index] = true;
reset_element_ref_flags_recursive(&layer);
layer.turn_into_leaving_layer();
records.push(LeavingLayer {
root: layer.node_id(),
until,
origin,
focus: None,
});
self.layers_left.push(layer.node_id());
leaving.push((position, layer));
}
self.leaving_layers = records;
leaving.sort_by_key(|(position, _)| *position);
leaving
}
pub(super) fn leaving_origins(&self) -> Vec<(NodeId, Option<NodeId>)> {
self
.leaving_layers
.iter()
.map(|layer| (layer.root, layer.origin))
.collect()
}
pub(super) fn leaving_layer_due(&self, now: Instant) -> bool {
self.leaving_layers.iter().any(|layer| now >= layer.until)
}
pub(super) fn begin_leaving_children(&mut self) {
let ended = crate::node::presence::take_ended_leaving();
if !ended.is_empty() {
let focus_back = self
.leaving_children
.iter()
.filter(|child| ended.contains(&child.root))
.find_map(|child| child.focus);
self.leaving_children.retain(|child| !ended.contains(&child.root));
if let Some(target) = focus_back {
self.focus_node(target);
}
let now = self.now();
let mut ids = Vec::new();
if let Some(root) = self.root.as_ref() {
for id in &ended {
if let Some(node) = find_node_by_id(root, *id) {
node.subtree_ids(&mut ids);
}
}
}
self.animation_engine.turn_round(&ids, now);
}
let began = crate::node::presence::take_began_leaving();
if began.is_empty() {
return;
}
let now = self.now();
let Some(root) = self.root.as_mut() else {
return;
};
for id in began {
let Some(node) = find_node_by_id_mut(root, id) else {
continue;
};
let animations = &mut self.animation_engine;
let until = node
.begin_exit(&mut |node| animations.forget_node(node))
.and_then(|lasts| now.checked_add(lasts));
let Some(until) = until else {
if let Some(mut removed) = remove_child_by_id(root, id) {
removed.free_ids(&self.id_gen);
}
continue;
};
reset_element_ref_flags_recursive(node);
node.turn_into_leaving_layer();
self.leaving_children.push(LeavingLayer {
root: id,
until,
origin: None,
focus: None,
});
self.layers_left.push(id);
}
self.cached_render_list = None;
self.needs_redraw = true;
}
pub(super) fn drop_leaving_children(&mut self, now: Instant) {
if !self.leaving_children.iter().any(|child| now >= child.until) {
return;
}
let (due, leaving): (Vec<_>, Vec<_>) = std::mem::take(&mut self.leaving_children)
.into_iter()
.partition(|child| now >= child.until);
self.leaving_children = leaving;
let mut removed_any = false;
for child in due {
let removed = self.root.as_mut().and_then(|root| remove_child_by_id(root, child.root));
let Some(mut removed) = removed else {
continue;
};
#[cfg(feature = "canvas")]
super::detach_canvases_not_carried(super::canvas_bindings(&removed), self.root.as_ref());
removed.free_ids(&self.id_gen);
removed_any = true;
}
if removed_any {
self.tree_rebuilt_since_layout = true;
self.cached_render_list = None;
self.needs_redraw = true;
self.reapply_interaction_state();
}
}
pub(super) fn release_input_in_leaving_layers(&mut self) {
let left = std::mem::take(&mut self.layers_left);
if left.is_empty() {
return;
}
let Some(root) = self.root.as_ref() else {
return;
};
let inside = |id: &NodeId| {
left
.iter()
.filter_map(|leaving| find_node_by_id(root, *leaving))
.any(|leaving| find_node_by_id(leaving, *id).is_some())
};
let loses_focus = self.focused_node.iter().chain(&self.focused_event_node).any(inside);
if loses_focus && let Some(input_id) = self.focused_node {
let target = FocusTarget {
input_id,
event_id: self.focused_event_node.unwrap_or(input_id),
};
let holder = left.iter().copied().find(|leaving| {
find_node_by_id(root, *leaving).is_some_and(|layer| find_node_by_id(layer, input_id).is_some())
});
for record in self.leaving_layers.iter_mut().chain(self.leaving_children.iter_mut()) {
if Some(record.root) == holder {
record.focus = Some(target);
}
}
}
let hover_path = self.hover_path.iter().copied().filter(|id| !inside(id)).collect();
let active_path = self.active_path.iter().copied().filter(|id| !inside(id)).collect();
self.hover_path = hover_path;
self.active_path = active_path;
if loses_focus {
self.blur_focus();
}
}
}
pub(super) fn stack_layers(overlays: Vec<Node>, leaving: Vec<(usize, Node)>, layers: &mut OverlayLayers) -> Vec<Node> {
if leaving.is_empty() {
return overlays;
}
let leaving_count = leaving.len();
let mut stack = Vec::with_capacity(overlays.len() + leaving_count);
let mut anchors = Vec::with_capacity(stack.capacity());
let mut origins = Vec::with_capacity(stack.capacity());
let mut takes_focus = Vec::with_capacity(stack.capacity());
let mut places = Vec::with_capacity(overlays.len());
let mut leaving = leaving.into_iter().peekable();
let mut open = overlays
.into_iter()
.zip(std::mem::take(&mut layers.anchors))
.zip(std::mem::take(&mut layers.origins))
.zip(std::mem::take(&mut layers.takes_focus))
.peekable();
loop {
let leaving_is_next = match (leaving.peek(), open.peek()) {
(Some((position, _)), Some(_)) => *position <= stack.len(),
(Some(_), None) => true,
(None, Some(_)) => false,
(None, None) => break,
};
if leaving_is_next {
let (_, layer) = leaving.next().expect("peeked");
stack.push(layer);
anchors.push(None);
origins.push(None);
takes_focus.push(false);
} else {
let (((layer, anchor), origin), takes) = open.next().expect("peeked");
places.push(stack.len());
stack.push(layer);
anchors.push(anchor);
origins.push(origin);
takes_focus.push(takes);
}
}
layers.anchors = anchors;
layers.origins = origins;
layers.takes_focus = takes_focus;
for entry in &mut layers.dismiss_entries {
entry.layer = match entry.layer.checked_sub(1).and_then(|place| places.get(place)) {
Some(place) => place + 1,
None => entry.layer + leaving_count,
};
}
stack
}
fn remove_child_by_id(node: &mut Node, id: NodeId) -> Option<Node> {
if let Some(index) = node.children.iter().position(|child| child.node_id() == id) {
node.layout_cache.invalidate();
return Some(node.children.remove(index));
}
node.children.iter_mut().find_map(|child| remove_child_by_id(child, id))
}