use super::{OverlayDismissEntry, Tree, close_open_selects_except, point_in_element_rect};
use crate::{
app::{ctx::OutsidePress, hit_test::hit_test_tree},
core::{NodeId, Signal},
layout::layout_result::LayoutResult,
node::{Node, SyntheticNodeRole, node_kind::NodeKind},
};
impl Tree {
pub(super) fn consume_outside_press(&mut self, x: f32, y: f32) -> bool {
self.rebuild_if_dirty();
let (Some(root), Some(result)) = (&self.root, &self.last_layout) else {
return false;
};
if !root.has_synthetic_role(SyntheticNodeRole::OverlayHost) {
return false;
}
let layer = pressed_layer(root, result, x, y);
let overlays: Vec<&OverlayDismissEntry> = self
.overlay_dismiss_entries
.iter()
.filter(|entry| is_outside(entry, x, y, layer) && entry.open.get_untracked())
.collect();
let selects = selects_closed_by_press(root, result, x, y);
let consumed = overlays
.iter()
.any(|entry| entry.outside_press == OutsidePress::Consume)
|| selects
.as_ref()
.is_some_and(|selects| any_open_select_consumes(root, selects.pressed));
if !consumed {
return false;
}
let close: Vec<Signal<bool>> = overlays.iter().map(|entry| entry.open.clone()).collect();
if let Some(selects) = selects {
close_open_selects_except(root, selects.pressed);
}
for open in close {
open.set(false);
}
self.needs_redraw = true;
true
}
pub(super) fn overlay_dismiss_signals_at(&self, x: f32, y: f32) -> Vec<Signal<bool>> {
let layer = match (&self.root, &self.last_layout) {
(Some(root), Some(result)) => pressed_layer(root, result, x, y),
_ => 0,
};
self
.overlay_dismiss_entries
.iter()
.filter(|entry| is_outside(entry, x, y, layer))
.map(|entry| entry.open.clone())
.collect()
}
}
fn is_outside(entry: &OverlayDismissEntry, x: f32, y: f32, pressed_layer: usize) -> bool {
entry.dismiss_on_outside_click
&& pressed_layer < entry.layer
&& !point_in_element_rect(x, y, entry.anchor.bounds())
&& !point_in_element_rect(x, y, entry.bounds)
}
fn pressed_layer(root: &Node, result: &LayoutResult, x: f32, y: f32) -> usize {
if !root.has_synthetic_role(SyntheticNodeRole::OverlayHost) {
return 0;
}
root
.children()
.iter()
.zip(result.children.iter())
.enumerate()
.skip(1)
.rev()
.filter(|(_, (layer, _))| !layer.has_synthetic_role(SyntheticNodeRole::WindowChromeLayer))
.find(|(_, (layer, layout))| {
let mut hits = Vec::new();
hit_test_tree(layer, &layout.result, layout.offset.x, layout.offset.y, x, y, &mut hits);
!hits.is_empty()
})
.map_or(0, |(index, _)| index)
}
struct ClosedSelects {
pressed: Option<NodeId>,
}
fn selects_closed_by_press(root: &Node, result: &LayoutResult, x: f32, y: f32) -> Option<ClosedSelects> {
let mut hits = Vec::new();
hit_test_tree(root, result, 0.0, 0.0, x, y, &mut hits);
if hits
.iter()
.any(|(node, _)| node.has_synthetic_role(SyntheticNodeRole::SelectMenu))
{
return None;
}
let pressed = hits
.iter()
.find(|(node, _)| matches!(node.node_kind(), NodeKind::Select { .. }))
.map(|(node, _)| node.node_id());
Some(ClosedSelects { pressed })
}
fn any_open_select_consumes(node: &Node, except: Option<NodeId>) -> bool {
if let NodeKind::Select { state } = node.node_kind()
&& Some(node.node_id()) != except
&& state.is_open()
&& state.outside_press() == OutsidePress::Consume
{
return true;
}
node
.children()
.iter()
.any(|child| any_open_select_consumes(child, except))
}