use crate::core::element::ElementId;
use crate::style::Color;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum OverlayLayer {
Modal, Dialog, Popover, Tooltip, }
impl OverlayLayer {
pub fn z_base(self) -> i32 {
match self {
OverlayLayer::Tooltip => 1000,
OverlayLayer::Popover => 900,
OverlayLayer::Dialog => 800,
OverlayLayer::Modal => 700,
}
}
}
pub struct OverlayEntry {
pub element_id: ElementId,
pub layer: OverlayLayer,
pub barrier_color: Option<Color>,
pub dismiss_on_click_outside: bool,
pub dismiss_on_escape: bool,
pub trap_focus: bool,
pub autofocus_first: bool,
pub previous_focus: Option<ElementId>,
pub on_dismiss: Option<Box<dyn FnOnce()>>,
}
#[derive(Default)]
pub struct OverlayDomain {
stack: std::cell::RefCell<Vec<OverlayEntry>>,
pending_pop: std::cell::RefCell<Option<(ElementId, web_time::Instant)>>,
captured_focus: std::cell::Cell<Option<ElementId>>,
}
fn domain() -> std::rc::Rc<OverlayDomain> {
crate::core::app_context::current_app().extension::<OverlayDomain>()
}
pub fn set_captured_focus(id: Option<ElementId>) {
domain().captured_focus.set(id);
}
pub fn push(mut entry: OverlayEntry) {
crate::core::dirty_registry::register_teardown_hook(teardown_cleanup);
let dom = domain();
entry.previous_focus = dom.captured_focus.get();
let element_id = entry.element_id;
let autofocus = entry.trap_focus && entry.autofocus_first;
dom.stack.borrow_mut().push(entry);
if autofocus {
focus_first_in_overlay(element_id);
}
}
fn teardown_cleanup(id: ElementId) {
domain().stack.borrow_mut().retain(|e| e.element_id != id);
}
#[doc(hidden)]
pub fn debug_stack_len() -> usize {
domain().stack.borrow().len()
}
pub fn remove(element_id: ElementId) {
let entry = {
let dom = domain();
let mut stack = dom.stack.borrow_mut();
stack
.iter()
.position(|e| e.element_id == element_id)
.map(|pos| stack.remove(pos))
};
if let Some(mut entry) = entry {
let cb = entry.on_dismiss.take();
let prev_focus = entry.previous_focus;
if let Some(f) = cb {
f();
}
if let Some(prev) = prev_focus {
crate::core::dirty_registry::defer_action(move |_arena, _root, reg| {
reg.request_autofocus(prev);
});
}
}
}
pub fn pop() {
let entry = domain().stack.borrow_mut().pop();
if let Some(mut entry) = entry {
let cb = entry.on_dismiss.take();
let prev_focus = entry.previous_focus;
if let Some(f) = cb {
f();
}
if let Some(prev) = prev_focus {
crate::core::dirty_registry::defer_action(move |_arena, _root, reg| {
reg.request_autofocus(prev);
});
}
}
}
pub fn pop_with_delay(delay_ms: u64) {
let dom = domain();
let target = dom.stack.borrow().last().map(|e| e.element_id);
if let Some(eid) = target {
let deadline = crate::core::clock::now() + std::time::Duration::from_millis(delay_ms);
dom.pending_pop.borrow_mut().replace((eid, deadline));
}
}
pub fn process_pending_pop() {
let dom = domain();
let expired = {
let mut pending = dom.pending_pop.borrow_mut();
match *pending {
Some((eid, deadline)) if crate::core::clock::now() >= deadline => {
*pending = None;
Some(eid)
}
_ => None,
}
};
if let Some(eid) = expired {
let entry = {
let mut stack = dom.stack.borrow_mut();
stack
.iter()
.position(|e| e.element_id == eid)
.map(|pos| stack.remove(pos))
};
if let Some(mut entry) = entry {
if let Some(f) = entry.on_dismiss.take() {
f();
}
}
}
}
pub fn cancel_pending_pop() {
*domain().pending_pop.borrow_mut() = None;
}
pub fn top() -> Option<ElementId> {
domain().stack.borrow().last().map(|e| e.element_id)
}
pub fn is_active() -> bool {
!domain().stack.borrow().is_empty()
}
pub fn should_dismiss_on_click_outside() -> Option<ElementId> {
domain().stack.borrow().last().and_then(|e| {
if e.dismiss_on_click_outside {
Some(e.element_id)
} else {
None
}
})
}
pub fn should_dismiss_on_escape() -> bool {
domain()
.stack
.borrow()
.last()
.is_some_and(|e| e.dismiss_on_escape)
}
pub fn active_focus_trap() -> Option<ElementId> {
domain()
.stack
.borrow()
.iter()
.rev()
.find(|e| e.trap_focus)
.map(|e| e.element_id)
}
pub fn is_inside_overlay(eid: ElementId) -> bool {
domain().stack.borrow().iter().any(|e| {
e.element_id == eid || crate::core::dirty_registry::is_descendant_of(eid, e.element_id)
})
}
pub fn remove_layer(layer: OverlayLayer) {
let removed: Vec<OverlayEntry> = {
let dom = domain();
let mut stack = dom.stack.borrow_mut();
let mut removed = Vec::new();
let mut i = 0;
while i < stack.len() {
if stack[i].layer == layer {
removed.push(stack.remove(i));
} else {
i += 1;
}
}
removed
};
for mut entry in removed {
if let Some(cb) = entry.on_dismiss.take() {
cb();
}
}
}
pub fn clear() {
let drained: Vec<OverlayEntry> = {
let dom = domain();
let mut stack = dom.stack.borrow_mut();
stack.drain(..).collect()
};
for mut entry in drained {
if let Some(cb) = entry.on_dismiss.take() {
cb();
}
}
}
pub fn count() -> usize {
domain().stack.borrow().len()
}
fn focus_first_in_overlay(_overlay_id: ElementId) {
}