use super::{
FocusTarget, Tree, find_node_by_id, find_path_by_id, focus_visible, hovered_cursor, scrollbar_hit_at,
set_node_hovered, take_disabled_hit, trim_hits_to_scrollbar,
};
use crate::{
app::{
events::{InputSource, input_source, with_input_source},
hit_test::{HitRect, hit_test_tree},
},
core::NodeId,
node::{Node, VoidEventHandler},
};
#[derive(Clone, Copy)]
pub(super) struct PointerAt {
x: f32,
y: f32,
source: InputSource,
}
#[derive(Clone, Copy, Default)]
pub(super) struct HoverMove {
pub(super) changed: bool,
pub(super) shows: bool,
}
impl std::ops::BitOr for HoverMove {
type Output = Self;
fn bitor(self, other: Self) -> Self {
Self {
changed: self.changed || other.changed,
shows: self.shows || other.shows,
}
}
}
impl std::ops::BitOrAssign for HoverMove {
fn bitor_assign(&mut self, other: Self) {
*self = *self | other;
}
}
impl Tree {
pub(super) fn track_pointer(&mut self, x: f32, y: f32) {
self.hover_held_by_keys = false;
self.pointer = Some(PointerAt {
x,
y,
source: input_source(),
});
}
pub(super) fn pointer_position(&self) -> Option<(f32, f32)> {
self.pointer.map(|pointer| (pointer.x, pointer.y))
}
pub(super) fn refresh_hover_at_pointer(&mut self) -> bool {
let Some(PointerAt { x, y, source }) = self.pointer else {
return false;
};
if self.has_active_input_interaction() || self.hover_held_by_keys {
return false;
}
let scale = self.scale_factor();
let (lx, ly) = (x / scale, y / scale);
let (Some(root), Some(result)) = (&self.root, &self.last_layout) else {
return false;
};
let mut hits = Vec::new();
hit_test_tree(root, result, 0.0, 0.0, lx, ly, &self.layout_engine.radii(), &mut hits);
let disabled = take_disabled_hit(&mut hits);
trim_hits_to_scrollbar(&mut hits, lx, ly);
let before = self.disabled_hover;
let moved = with_input_source(source, || {
leave_disabled(root, before, disabled)
| move_hover(root, &self.hover_path, &hits)
| enter_disabled(before, disabled)
});
self.disabled_hover = disabled.map(Node::node_id);
let scrollable_in_disabled = if disabled.is_some() {
super::scroll_containers_in_disabled(root, result, lx, ly, &self.layout_engine.radii(), &hits)
} else {
Vec::new()
};
let mut thumb_changed = false;
for (node, _) in scrollable_in_disabled.iter().chain(&hits) {
if let Some((state, _)) = node.scroll_container() {
let bar = scrollbar_hit_at(node, lx, ly).map(|(axis, _)| axis);
if bar != state.hovered_bar() {
state.set_hovered_bar(bar);
thumb_changed = true;
}
}
}
let follow = pointer_focus(root, &self.hover_path, self.focused_path.as_deref(), &hits);
self.hover_path = hits.iter().map(|(node, _)| node.node_id()).collect();
self.cursor = hovered_cursor(disabled.into_iter().chain(hits.iter().map(|(node, _)| *node)));
let draws_hover = self.draws_hover(moved);
if draws_hover {
self.cached_render_list = None;
}
if draws_hover || thumb_changed {
self.needs_redraw = true;
}
self.follow_pointer_focus(follow);
moved.changed
}
pub(super) fn follow_pointer_focus(&mut self, target: Option<NodeId>) {
if let Some(target) = target
&& self.focused_node != Some(target)
{
self.set_input_modality(focus_visible::InputModality::Pointer);
self.focus_node(FocusTarget {
input_id: target,
event_id: target,
});
self.needs_redraw = true;
}
}
pub(super) fn draws_hover(&self, moved: HoverMove) -> bool {
#[cfg(feature = "devtools")]
if moved.changed && self.devtools_is_open() {
return true;
}
moved.shows
}
}
pub(super) fn pointer_focus(
root: &Node,
hover_path: &[NodeId],
focused_path: Option<&[usize]>,
hits: &[(&Node, HitRect)],
) -> Option<NodeId> {
let focused_path = focused_path?;
let stop = hits
.iter()
.rev()
.map(|(node, _)| *node)
.find(|node| node.is_focusable() && !node.is_focus_disabled())?;
if hover_path.contains(&stop.node_id()) {
return None;
}
let path = find_path_by_id(root, stop.node_id())?;
let mut group = None;
let mut node = root;
for (depth, &index) in path.iter().enumerate() {
if node.focus_group_value().is_some_and(|group| group.follow_pointer) {
group = Some(depth);
}
node = node.children().get(index)?;
}
let depth = group?;
(focused_path.len() > depth && focused_path[..depth] == path[..depth]).then(|| stop.node_id())
}
pub(super) fn move_hover(root: &Node, hover_path: &[NodeId], hits: &[(&Node, HitRect)]) -> HoverMove {
let mut moved = HoverMove::default();
for old_id in hover_path {
if hits.iter().any(|(node, _)| node.node_id() == *old_id) {
continue;
}
let Some(node) = find_node_by_id(root, *old_id) else {
continue;
};
moved.changed = true;
moved.shows |= leave(node);
}
for (node, _) in hits {
if hover_path.contains(&node.node_id()) {
continue;
}
moved.changed = true;
moved.shows |= set_hover(node, true, &node.events.on_mouse_enter);
}
moved
}
pub(super) fn leave_disabled(root: &Node, before: Option<NodeId>, now: Option<&Node>) -> HoverMove {
let Some(before) = before.filter(|before| Some(*before) != now.map(Node::node_id)) else {
return HoverMove::default();
};
let Some(node) = find_node_by_id(root, before) else {
return HoverMove::default();
};
run(&node.events.on_mouse_leave)
}
pub(super) fn enter_disabled(before: Option<NodeId>, now: Option<&Node>) -> HoverMove {
match now {
Some(node) if Some(node.node_id()) != before => run(&node.events.on_mouse_enter),
_ => HoverMove::default(),
}
}
fn run(handlers: &[VoidEventHandler]) -> HoverMove {
for handler in handlers {
handler.call();
}
HoverMove {
changed: false,
shows: !handlers.is_empty(),
}
}
pub(super) fn leave(node: &Node) -> bool {
set_hover(node, false, &node.events.on_mouse_leave)
}
fn set_hover(node: &Node, hovered: bool, handlers: &[VoidEventHandler]) -> bool {
let relaid = set_node_hovered(node, hovered);
for handler in handlers {
handler.call();
}
relaid || node.shows_hover() || !handlers.is_empty()
}