use super::{FocusTarget, Tree, find_path_by_id, tab_navigation};
use crate::{app::ctx::ModalLayer, layout::layout_engine::OverlayLayoutRecord};
impl Tree {
pub(super) fn sync_modal_focus(&mut self) {
let built = std::mem::take(&mut self.built_focus_modals);
let mut index = self.modal_focus.len();
while index > 0 {
index -= 1;
if built.contains(&self.modal_focus[index].0) {
continue;
}
let (_, returns_to, start) = self.modal_focus.remove(index);
if self.focus_is_in_tree() {
continue;
}
if let Some(target) = returns_to {
self.focus_node(target);
}
if self.focused_node.is_none() && start.is_some() {
self.focus_start = start;
}
}
for origin in built {
if self.modal_focus.iter().any(|(open, ..)| *open == origin) {
continue;
}
let had = self
.focused_node
.zip(self.focused_event_node)
.map(|(input_id, event_id)| FocusTarget { input_id, event_id });
let start = match (self.root.as_ref(), self.focused_node, self.focused_path.as_ref()) {
(Some(root), Some(id), Some(path)) => Some(tab_navigation::FocusStart::new(root, id, path.clone())),
_ => self.focus_start.clone(),
};
self.modal_focus.push((origin, had, start));
let first = self.root.as_ref().and_then(|root| {
match tab_navigation::tab_move(root, &self.dropped_nodes, &[], None, None, None, false) {
tab_navigation::TabMove::Focus(target) => Some(target),
_ => None,
}
});
if let Some(target) = first {
self.focus_node(target);
}
}
}
pub(super) fn stack_modals_in_open_order(&mut self, records: &mut Vec<OverlayLayoutRecord>) {
let mut slots = Vec::new();
for (slot, record) in records.iter().enumerate() {
if let OverlayLayoutRecord::Modal { origin, spec, .. } = record
&& spec.layer == ModalLayer::Dialog
{
if let Some(origin) = *origin {
self.modals_met.push(origin);
if !self.modal_open_order.contains(&origin) {
self.modal_open_order.push(origin);
}
}
slots.push(slot);
}
}
if slots.len() < 2 {
return;
}
let rank = |record: &OverlayLayoutRecord| {
match record {
OverlayLayoutRecord::Modal {
origin: Some(origin), ..
} => self.modal_open_order.iter().position(|open| open == origin),
_ => None,
}
.unwrap_or(usize::MAX)
};
let mut stacked = slots.clone();
stacked.sort_by_key(|&slot| rank(&records[slot]));
if stacked == slots {
return;
}
let mut taken: Vec<Option<OverlayLayoutRecord>> = std::mem::take(records).into_iter().map(Some).collect();
let modals: Vec<OverlayLayoutRecord> = stacked.iter().filter_map(|&slot| taken[slot].take()).collect();
for (&slot, modal) in slots.iter().zip(modals) {
taken[slot] = Some(modal);
}
*records = taken.into_iter().flatten().collect();
}
pub(super) fn forget_closed_modals(&mut self) {
let met = std::mem::take(&mut self.modals_met);
self.modal_open_order.retain(|open| met.contains(open));
}
fn focus_is_in_tree(&self) -> bool {
let (Some(root), Some(focused)) = (self.root.as_ref(), self.focused_node) else {
return false;
};
find_path_by_id(root, focused).is_some()
}
}