use crate::core::element::{DirtyFlags, ElementArena};
use crate::core::id::ElementId;
use crate::style::{Point, Rect};
use std::cell::RefCell;
#[derive(Default)]
pub(crate) struct PortalDomain {
portals: RefCell<Vec<ElementId>>,
dismiss_handlers: RefCell<Vec<(ElementId, Box<dyn Fn()>)>>,
removals: RefCell<Vec<ElementId>>,
persistent: RefCell<Vec<ElementId>>,
owners: RefCell<Vec<(ElementId, ElementId)>>,
}
fn domain() -> std::rc::Rc<PortalDomain> {
crate::core::app_context::current_app().extension::<PortalDomain>()
}
pub fn register_portal(el_id: ElementId) {
let dom = domain();
dom.portals.borrow_mut().push(el_id);
dom.persistent.borrow_mut().push(el_id);
}
pub fn register_portal_owner(owner_id: ElementId, portal_id: ElementId) {
domain().owners.borrow_mut().push((owner_id, portal_id));
}
pub fn take_portals_of(owner_id: ElementId) -> Vec<ElementId> {
let dom = domain();
let mut owners = dom.owners.borrow_mut();
if owners.iter().all(|(own, _)| *own != owner_id) {
return Vec::new();
}
let mut taken = Vec::new();
owners.retain(|(own, portal)| {
if *own == owner_id {
taken.push(*portal);
false
} else {
true
}
});
taken
}
pub fn portal_ids() -> Vec<ElementId> {
domain().portals.borrow().clone()
}
pub fn drain_portals() -> Vec<ElementId> {
domain().portals.borrow_mut().drain(..).collect()
}
pub fn push_portal(el_id: ElementId) {
register_portal(el_id);
}
pub fn remove_portal(el_id: ElementId) {
let dom = domain();
dom.removals.borrow_mut().push(el_id);
dom.persistent.borrow_mut().retain(|&id| id != el_id);
dom.dismiss_handlers
.borrow_mut()
.retain(|(id, _)| *id != el_id);
dom.owners
.borrow_mut()
.retain(|(_, portal)| *portal != el_id);
}
pub fn drain_portal_removals() -> Vec<ElementId> {
domain().removals.borrow_mut().drain(..).collect()
}
pub fn portal_position_ids() -> Vec<ElementId> {
domain().persistent.borrow().clone()
}
pub struct PortalHeight(pub std::rc::Rc<std::cell::Cell<f32>>);
pub struct PortalWidth(pub std::rc::Rc<std::cell::Cell<f32>>);
#[derive(Clone, Copy, Debug)]
pub struct PortalAnchorStrategy {
pub gap: f32,
pub auto_flip: bool,
pub clamp_to_viewport: bool,
}
impl Default for PortalAnchorStrategy {
fn default() -> Self {
Self {
gap: 4.0,
auto_flip: true,
clamp_to_viewport: true,
}
}
}
pub fn register_dismiss(portal_id: ElementId, on_dismiss: impl Fn() + 'static) {
domain()
.dismiss_handlers
.borrow_mut()
.push((portal_id, Box::new(on_dismiss)));
}
pub fn fire_dismiss(arena: &ElementArena, click_pos: Point) {
let hit = crate::core::dirty_registry::hit_test_with_fallback(arena, click_pos);
let dom = domain();
let decisions: Vec<(bool, usize)> = {
let handlers = dom.dismiss_handlers.borrow();
handlers
.iter()
.enumerate()
.map(|(i, (portal_id, _))| {
let anchor_id = arena
.get(*portal_id)
.and_then(|el| el.get_user_data::<ElementId>().copied());
let inside = match hit {
Some(h) => {
h == *portal_id
|| crate::core::dirty_registry::is_descendant_of(h, *portal_id)
|| anchor_id.is_some_and(|aid| {
h == aid || crate::core::dirty_registry::is_descendant_of(h, aid)
})
}
None => false,
};
(inside, i)
})
.collect()
};
let handlers = dom.dismiss_handlers.borrow();
for (inside, i) in &decisions {
if *inside {
continue;
}
let (_, handler) = &handlers[*i];
handler();
}
}
pub(crate) fn update_portal_positions(arena: &ElementArena, root_id: ElementId) {
let viewport_h = arena.get(root_id).map_or(768.0, |r| r.bounds().height);
let portals = portal_position_ids();
for &portal_id in &portals {
if let Some(child) = arena.get(portal_id) {
if !child.is_visible() {
continue;
}
if let Some(anchor_id) = child.get_user_data::<crate::core::ElementId>().copied() {
if let Some(pos) =
child.get_user_data::<std::rc::Rc<std::cell::Cell<(f32, f32, f32)>>>()
{
let sb = arena.get(anchor_id).map(|a| a.screen_bounds);
let padding = arena.comp_layout(anchor_id).map(|l| l.padding);
if let (Some(sb), Some(padding)) = (sb, padding) {
let strat = child
.get_user_data::<PortalAnchorStrategy>()
.copied()
.unwrap_or(PortalAnchorStrategy {
gap: 4.0,
auto_flip: true,
clamp_to_viewport: false,
});
let intrinsic_w = child
.get_user_data::<PortalWidth>()
.map(|pw| pw.0.get())
.filter(|w| *w > 0.0);
let _ = padding;
let pw = intrinsic_w.unwrap_or_else(|| sb.width.max(1.0));
let (scroll_x, scroll_y) = arena.accumulated_scroll(anchor_id);
let anchor_screen_y = sb.y - scroll_y;
let anchor_screen_x = sb.x - scroll_x;
let portal_h = child
.get_user_data::<PortalHeight>()
.map(|ph| ph.0.get())
.filter(|h| *h > 0.0)
.unwrap_or_else(|| child.bounds().height);
let below_y = anchor_screen_y + sb.height + strat.gap;
let window_y = if strat.auto_flip
&& below_y + portal_h > viewport_h
&& anchor_screen_y - portal_h > 0.0
{
anchor_screen_y - portal_h } else {
below_y
};
if strat.clamp_to_viewport {
if let Some(ph_cell) = child.get_user_data::<PortalHeight>() {
let max_h = (viewport_h - window_y).max(0.0);
let cur = ph_cell.0.get();
if cur > max_h && max_h > 0.0 {
ph_cell.0.set(max_h);
}
}
}
let new_pos = (anchor_screen_x, window_y, pw);
if pos.get() != new_pos {
pos.set(new_pos);
crate::core::dirty_registry::bump_subtree_gen(portal_id);
crate::core::dirty_registry::register_dirty(
portal_id,
DirtyFlags::MEASURE,
);
}
}
}
if let Some(geo_cell) = child.get_user_data::<std::rc::Rc<std::cell::Cell<crate::widgets::overlay::PopoverGeometry>>>() {
if let Some(placement) = child.get_user_data::<crate::widgets::overlay::PopoverPlacement>().copied() {
let sb = arena.get(anchor_id).map(|a| a.screen_bounds);
if let Some(sb) = sb {
let (scroll_x, scroll_y) = arena.accumulated_scroll(anchor_id);
let anchor = crate::style::Rect::new(
sb.x - scroll_x,
sb.y - scroll_y,
sb.width,
sb.height,
);
let viewport_rect = crate::style::Rect::new(0.0, 0.0, arena.get(root_id).map_or(1024.0, |r| r.bounds().width), viewport_h);
let content_w = placement.min_width
.unwrap_or_else(|| (sb.width).max(1.0));
let content_h = child
.get_user_data::<PortalHeight>()
.map(|ph| ph.0.get())
.filter(|h| *h > 0.0)
.unwrap_or_else(|| child.bounds().height.max(1.0));
let new_geo = crate::widgets::overlay::compute_popover_geometry(
anchor, viewport_rect, content_w, content_h, placement,
);
if let Some(ph_cell) = child
.get_user_data::<PortalHeight>()
{
let max_h = (viewport_h - new_geo.y - placement.viewport_margin).max(0.0);
let cur = ph_cell.0.get();
if cur > max_h && max_h > 0.0 {
ph_cell.0.set(max_h);
}
}
let old = geo_cell.get();
if old != new_geo {
geo_cell.set(new_geo);
crate::core::dirty_registry::bump_subtree_gen(portal_id);
crate::core::dirty_registry::register_dirty(portal_id, DirtyFlags::MEASURE);
}
}
}
}
}
}
}
}
pub(crate) fn stretch_visible_anchored_portals(arena: &mut ElementArena) {
for portal_id in portal_position_ids() {
let (has_strategy, has_intrinsic_w, visible, dims) = arena
.get(portal_id)
.map(|el| {
(
el.get_user_data::<PortalAnchorStrategy>().is_some(),
el.get_user_data::<PortalWidth>().is_some(),
el.is_visible(),
(el.screen_bounds.width, el.screen_bounds.height),
)
})
.unwrap_or((false, false, false, (0.0, 0.0)));
if has_strategy && visible && !has_intrinsic_w {
stretch_children_to_width(arena, portal_id, dims.0, dims.1);
}
}
}
fn stretch_children_to_width(
arena: &mut ElementArena,
parent_id: ElementId,
parent_w: f32,
_parent_h: f32,
) {
let children: Vec<ElementId> = arena
.get(parent_id)
.map(|el| el.children.clone())
.unwrap_or_default();
for cid in children {
let (old_w, fg, fs, pad_left, pad_right, x, y, h) = {
if let Some(el) = arena.get(cid) {
let p = el.padding();
(
el.screen_bounds.width,
el.flex_grow(),
el.flex_shrink(),
p.left,
p.right,
el.screen_bounds.x,
el.screen_bounds.y,
el.screen_bounds.height,
)
} else {
continue;
}
};
let avail_w = (parent_w - pad_left - pad_right).max(0.0);
if (fg > 0.0 || fs > 0.0) && (old_w - avail_w).abs() > 0.5 {
let new_b = Rect::new(x, y, avail_w, h);
if let Some(el_mut) = arena.get_mut(cid) {
el_mut.set_bounds(new_b);
el_mut.screen_bounds = new_b;
}
crate::core::dirty_registry::update_bounds(cid, new_b);
crate::core::dirty_registry::mark_dirty(cid, crate::core::element::DirtyFlags::REPAINT);
crate::core::dirty_registry::register_dirty(
cid,
crate::core::element::DirtyFlags::REPAINT,
);
}
stretch_children_to_width(arena, cid, avail_w, 0.0);
}
}