use gpui::{App, DispatchPhase, MouseMoveEvent, Pixels, Point, VnHitKind, Window};
use sk_runtime::redjs::api::Value;
use sk_runtime::{host_fn, JsRuntime};
use crate::tree::{self, Kind, Tree};
use crate::windows;
const PRESS_BITS: u64 = (1 << tree::EV_CLICK)
| (1 << tree::EV_MOUSEDOWN)
| (1 << tree::EV_MOUSEUP)
| (1 << tree::EV_CONTEXTMENU)
| (1 << tree::EV_AUXCLICK);
pub(crate) fn arm(window: &mut Window) {
if !window.vn_picks_every_box() {
window.set_vn_pick_every_box(true);
}
if !window.has_vn_hit_refiner() {
window.set_vn_hit_refiner(Some(std::rc::Rc::new(refine)));
}
}
fn window_root(t: &Tree, window: &Window) -> u32 {
match windows::root_of(windows::key(window)) {
0 => t.root,
popped => popped,
}
}
fn path_if_hittable(t: &Tree, id: u32, root: u32) -> Option<Vec<u32>> {
let node = t.node(id)?;
if node.kind != Kind::Element {
return None;
}
let inert = node
.computed
.as_ref()
.is_some_and(|cs| cs.extras.pointer_events_none == Some(true));
if inert && id != root {
return None;
}
let mut path = Vec::with_capacity(16);
let mut cur = id;
for _ in 0..4096 {
let n = t.node(cur)?;
if n.computed
.as_ref()
.is_some_and(|cs| cs.base.visibility == Some(gpui::Visibility::Hidden))
{
return None;
}
path.push(cur);
if cur == root {
return Some(path);
}
if n.parent == 0 {
return None;
}
cur = n.parent;
}
None
}
struct Resolved {
target: u32,
path: Vec<u32>,
tags: Vec<u32>,
at: usize,
}
fn resolve(t: &Tree, tags: Vec<u32>, root: u32) -> Resolved {
for (at, &tag) in tags.iter().enumerate() {
if let Some(path) = path_if_hittable(t, tag, root) {
return Resolved {
target: tag,
path,
tags,
at,
};
}
}
let at = tags.len();
Resolved {
target: root,
path: vec![root],
tags,
at,
}
}
pub(crate) fn topmost(window: &Window, p: Point<Pixels>) -> Option<u32> {
let tags = window.vn_tags_at(p);
tree::read_tree(|t| {
let root = window_root(t, window);
tags.into_iter()
.find(|&tag| path_if_hittable(t, tag, root).is_some())
})
}
pub(crate) fn target_at(window: &Window, p: Point<Pixels>) -> u32 {
let tags = window.vn_tags_at(p);
tree::read_tree(|t| {
let root = window_root(t, window);
resolve(t, tags, root).target
})
}
pub(crate) fn captured_target(window: &Window) -> Option<u32> {
let id = windows::here(window, |w| w.pointer_capture)?;
let valid = tree::read_tree(|t| {
t.node(id).is_some_and(|n| n.kind == Kind::Element)
&& windows::window_of_node_in(t, id) == windows::key(window)
&& path_to(t, id, window_root(t, window))
});
if !valid {
windows::here(window, |w| w.pointer_capture = None);
}
valid.then_some(id)
}
fn capture_path(t: &Tree, id: u32, root: u32) -> Option<Vec<u32>> {
if t.node(id)?.kind != Kind::Element {
return None;
}
let mut path = Vec::with_capacity(16);
let mut cur = id;
for _ in 0..4096 {
let n = t.node(cur)?;
path.push(cur);
if cur == root {
return Some(path);
}
cur = n.parent;
}
None
}
pub(crate) fn routed_target(window: &Window) -> Option<u32> {
crate::pointer_lock::target_in(window).or_else(|| captured_target(window))
}
pub(crate) fn capture_listeners(window: &mut Window) {
window.on_mouse_event(|_: &gpui::MouseDownEvent, phase, _, _| {
if phase == DispatchPhase::Capture {
crate::pointer_lock::note_gesture();
}
});
window.on_mouse_event(|ev: &MouseMoveEvent, phase, window, _cx| {
if phase != DispatchPhase::Capture {
return;
}
let moved = window.vn_mouse_movement();
windows::here(window, |w| w.mouse_movement = w.mouse_movement + moved);
let Some(id) = routed_target(window) else {
return;
};
windows::here(window, |w| {
w.pending_mouse_move = Some(windows::PendingMouseMove {
id,
position: ev.position,
button: match ev.pressed_button {
Some(gpui::MouseButton::Left) => 0.0,
Some(gpui::MouseButton::Middle) => 1.0,
Some(gpui::MouseButton::Right) => 2.0,
Some(gpui::MouseButton::Navigate(_)) => 3.0,
None => -1.0,
},
modifiers: ev.modifiers,
});
});
});
}
fn refine(kind: VnHitKind, p: Point<Pixels>, window: &mut Window, cx: &mut App) {
let capture = crate::pointer_lock::target_in(window).or_else(|| {
(kind != VnHitKind::Scroll)
.then(|| captured_target(window))
.flatten()
});
if capture.is_none() && crate::select::refine(kind, p, window, cx) {
return;
}
let tags = window.vn_tags_at(p);
let resolved = tree::read_tree(|t| {
let root = window_root(t, window);
let mut r = resolve(t, tags, root);
if let Some(id) = capture {
if let Some(path) = capture_path(t, id, root) {
r.target = id;
r.path = path;
}
}
if kind == VnHitKind::Down {
note_covered(t, &r, p);
}
r
});
let target = resolved.target;
windows::here(window, |w| {
w.hit = Some(target);
match kind {
VnHitKind::Down => {
w.down_hit = Some(target);
w.active = Some(target);
}
VnHitKind::Up => w.active = None,
VnHitKind::Scroll => {}
}
});
let mut path = resolved.path;
path.sort_unstable();
window.vn_restrict_mouse_hit(
&|tag| path.binary_search(&tag).is_ok(),
kind != VnHitKind::Scroll,
);
}
pub(crate) fn target_or(window: &Window, fallback: u32) -> u32 {
windows::here(window, |w| w.hit).unwrap_or(fallback)
}
pub(crate) fn click_target(window: &Window, down: u32, fallback: u32) -> Option<u32> {
let capture = routed_target(window);
let up = windows::here(window, |w| w.hit).unwrap_or(fallback);
tree::read_tree(|t| click_target_in_tree(t, down, up, window_root(t, window), capture))
}
fn click_target_in_tree(
t: &Tree,
down: u32,
up: u32,
root: u32,
capture: Option<u32>,
) -> Option<u32> {
let enabled_path = |id| {
let path = capture_path(t, id, root)?;
(!path.iter().any(|&id| {
t.node(id).is_some_and(|n| {
t.name(n.tag) != "fieldset" && crate::render::actually_disabled(t, id)
})
}))
.then_some(())
};
enabled_path(down)?;
let up = capture.unwrap_or(up);
enabled_path(up)?;
capture.or_else(|| common_ancestor(t, down, up))
}
fn common_ancestor(t: &Tree, a: u32, b: u32) -> Option<u32> {
let mut seen = Vec::with_capacity(16);
let mut cur = a;
for _ in 0..4096 {
let n = t.node(cur)?;
seen.push(cur);
if n.parent == 0 {
break;
}
cur = n.parent;
}
let mut cur = b;
for _ in 0..4096 {
if seen.contains(&cur) {
return Some(cur);
}
let n = t.node(cur)?;
if n.parent == 0 {
return None;
}
cur = n.parent;
}
None
}
fn hit_ids(window: &Window, p: Point<Pixels>, all: bool) -> Vec<u32> {
let tags = window.vn_tags_at(p);
tree::read_tree(|t| {
let root = window_root(t, window);
let inside = windows::peek(windows::key(window), |w| w.bounds.get(&root).copied())
.flatten()
.is_some_and(|(x, y, w, h)| {
let (px, py) = (f32::from(p.x), f32::from(p.y));
px >= x && px < x + w && py >= y && py < y + h
});
if !inside {
return Vec::new();
}
if !all {
return vec![resolve(t, tags, root).target];
}
let mut out: Vec<u32> = Vec::new();
for tag in tags {
if !out.contains(&tag) && path_if_hittable(t, tag, root).is_some() {
out.push(tag);
}
}
if !out.contains(&root) {
out.push(root);
}
out
})
}
fn hit_ids_in_primary(p: Point<Pixels>, all: bool) -> Vec<u32> {
let primary = windows::primary();
let in_hand = sk_runtime::with_commit(|window, cx| {
if windows::key(window) == primary {
Some(hit_ids(window, p, all))
} else {
other_window(cx, primary, p, all)
}
});
match in_hand {
Some(Some(ids)) => ids,
Some(None) => Vec::new(),
None => sk_runtime::with_app(|cx| other_window(cx, primary, p, all))
.flatten()
.unwrap_or_default(),
}
}
fn other_window(
cx: &mut App,
key: windows::WinKey,
p: Point<Pixels>,
all: bool,
) -> Option<Vec<u32>> {
let handle = cx
.windows()
.into_iter()
.find(|h| h.window_id().as_u64() == key)?;
handle
.update(cx, |_, window, _| hit_ids(window, p, all))
.ok()
}
host_fn!(fn sk_hit_at(_g, args) {
let n = |v: Value| v.as_number().unwrap_or(f64::NAN);
let (x, y) = (n(args.arg(0)), n(args.arg(1)));
let all = n(args.arg(2)) == 1.0;
let ids = if x.is_finite() && y.is_finite() {
hit_ids_in_primary(gpui::point(gpui::px(x as f32), gpui::px(y as f32)), all)
} else {
Vec::new()
};
let s = ids.iter().map(u32::to_string).collect::<Vec<_>>().join(",");
JsRuntime::with(|rt| rt.ctx().string(&s).0)
});
host_fn!(fn sk_pointer_capture(_g, args) {
let id = args.arg(0).as_number().unwrap_or(0.0) as u32;
let pointer = args.arg(1).as_number().unwrap_or(0.0);
if pointer != 1.0 {
return Value::boolean(false).0;
}
let capture = args.arg(2).as_bool().unwrap_or(false);
if !capture {
windows::each(|_, w| {
if w.pointer_capture == Some(id) {
w.pointer_capture = None;
}
});
return Value::boolean(true).0;
}
let k = windows::window_of_node(id);
if !windows::peek(k, |w| w.press.as_ref().is_some_and(crate::render::Press::is_active)).unwrap_or(false) {
return Value::boolean(false).0;
}
let valid = tree::read_tree(|t| {
let root = match windows::root_of(k) { 0 => t.root, popped => popped };
capture_path(t, id, root).is_some()
});
if valid {
windows::each(|_, w| w.pointer_capture = None);
windows::of(k, |w| w.pointer_capture = Some(id));
}
Value::boolean(valid).0
});
pub(crate) fn install(rt: &JsRuntime) {
rt.register("__sk_hit_at", 3, sk_hit_at as *const std::ffi::c_void);
rt.register(
"__sk_pointer_capture",
3,
sk_pointer_capture as *const std::ffi::c_void,
);
}
thread_local! {
static NAMED: std::cell::RefCell<std::collections::HashSet<(u32, u32)>> =
std::cell::RefCell::new(std::collections::HashSet::new());
}
fn note_covered(t: &Tree, r: &Resolved, p: Point<Pixels>) {
let mut listener = None;
for &tag in r.tags.iter().skip(r.at + 1) {
if r.path.contains(&tag) {
continue;
}
let Some(node) = t.node(tag) else { continue };
if node.kind != Kind::Element {
continue;
}
let inert = node
.computed
.as_ref()
.is_some_and(|cs| cs.extras.pointer_events_none == Some(true));
if !inert && node.listeners & PRESS_BITS != 0 {
listener = Some(tag);
break;
}
}
let Some(l) = listener else { return };
let fresh = NAMED.with(|n| {
let mut n = n.borrow_mut();
if n.len() > 256 {
n.clear();
}
n.insert((r.target, l))
});
if fresh {
crate::log::record(
"dev",
format!(
"[hit] a press at ({:.0}, {:.0}) is for {}, painted over {} — which listens for it and, \
as in a browser, does not get it (the cover is not one of its descendants)",
f32::from(p.x),
f32::from(p.y),
describe(t, r.target),
describe(t, l),
),
);
}
}
#[derive(Default)]
pub struct Hover {
path: Vec<u32>,
from: Option<(Point<Pixels>, bool, u64)>,
when: Option<std::time::Instant>,
ticking: bool,
}
const STILL_POINTER_INTERVAL: std::time::Duration = std::time::Duration::from_millis(100);
pub(crate) fn resolve_hover(window: &mut Window, cx: &mut App) {
let pos = window.mouse_position();
if crate::select::covers(window, pos) {
return;
}
let inside = window.vn_pointer_inside();
let built = crate::render::layout_count();
let now = std::time::Instant::now();
let due = windows::here(window, |w| match w.hover.from {
None => true,
Some((p, i, _)) if p != pos || i != inside => true,
Some((_, _, b)) if b != built => w
.hover
.when
.is_none_or(|t| now.duration_since(t) >= STILL_POINTER_INTERVAL),
Some(_) => false,
});
if !due {
return;
}
let path = if inside {
let tags = window.vn_tags_at(pos);
tree::read_tree(|t| match window_root(t, window) {
0 => Vec::new(),
root => resolve(t, tags, root).path,
})
} else {
Vec::new()
};
let old = windows::here(window, |w| {
w.hover.from = Some((pos, inside, built));
w.hover.when = Some(now);
(w.hover.path != path).then(|| std::mem::replace(&mut w.hover.path, path.clone()))
});
if let Some(old) = old {
hover_moved(&old, &path, pos, window, cx);
}
}
fn boundary(old: &[u32], new: &[u32]) -> (Vec<u32>, Vec<u32>) {
let left = old.iter().copied().filter(|id| !new.contains(id)).collect();
let entered = new
.iter()
.rev()
.copied()
.filter(|id| !old.contains(id))
.collect();
(left, entered)
}
fn hover_moved(old: &[u32], new: &[u32], pos: Point<Pixels>, window: &mut Window, cx: &mut App) {
let (left, entered) = boundary(old, new);
for &id in &left {
tree::note_hover(id, false);
}
for &id in &entered {
tree::note_hover(id, true);
}
let restyled = tree::with_tree(|t| {
let mut any = false;
for &id in left.iter().chain(&entered) {
any |= t.touch_hover_styled(id);
}
any
});
if restyled {
crate::render::request_repaint(window, cx);
}
let has =
|t: &Tree, id: u32, ev: u32| t.node(id).is_some_and(|n| n.listeners & (1u64 << ev) != 0);
let (leaves, enters): (Vec<u32>, Vec<u32>) = tree::read_tree(|t| {
let root = window_root(t, window);
(
left.iter()
.copied()
.filter(|&id| has(t, id, tree::EV_MOUSELEAVE) && path_to(t, id, root))
.collect(),
entered
.iter()
.copied()
.filter(|&id| has(t, id, tree::EV_MOUSEENTER))
.collect(),
)
});
if leaves.is_empty() && enters.is_empty() {
return;
}
let payload = crate::render::mouse_payload(pos, -1.0, &window.modifiers());
let events = leaves
.into_iter()
.map(|id| (id, tree::EV_MOUSELEAVE))
.chain(enters.into_iter().map(|id| (id, tree::EV_MOUSEENTER)));
crate::off_input(|| {
for (id, ev) in events {
if tree::read_tree(|t| t.node(id).is_some()) {
crate::render::js_dispatch_app(id, ev, &payload, window, cx);
}
}
});
}
fn path_to(t: &Tree, id: u32, root: u32) -> bool {
let mut cur = id;
for _ in 0..4096 {
if cur == root {
return true;
}
match t.node(cur) {
Some(n) if n.parent != 0 => cur = n.parent,
_ => return false,
}
}
false
}
pub(crate) fn arm_hover_tick(window: &mut Window) {
let k = windows::key(window);
if windows::is_primary(k)
|| windows::here(window, |w| std::mem::replace(&mut w.hover.ticking, true))
{
return;
}
window.on_next_frame(hover_tick);
}
fn hover_tick(window: &mut Window, cx: &mut App) {
crate::render::flush_pending_mouse_move(window, cx);
window.on_next_frame(hover_tick);
}
fn describe(t: &Tree, id: u32) -> String {
let Some(node) = t.node(id) else {
return format!("node {id}");
};
let mut out = format!("node {id} (<{}", t.name(node.tag));
if let Some(el_id) = t.prop(id, "id").filter(|v| !v.is_empty()) {
out.push_str(&format!(" id=\"{el_id}\""));
}
let classes: Vec<&str> = node.classes.iter().map(String::as_str).take(3).collect();
if !classes.is_empty() {
out.push_str(&format!(" class=\"{}\"", classes.join(" ")));
}
out.push_str(">)");
out
}
#[cfg(test)]
mod tests {
use super::*;
fn tree_of(build: impl FnOnce(&mut Tree) -> Vec<u32>) -> Vec<u32> {
tree::with_tree(build)
}
fn set(t: &mut Tree, id: u32, pointer_none: Option<bool>, hidden: bool) {
let mut cs = sk_css::ComputedStates::default();
cs.extras.pointer_events_none = pointer_none;
if hidden {
let mut base = gpui::StyleRefinement::default();
base.visibility = Some(gpui::Visibility::Hidden);
cs.base = std::rc::Rc::new(base);
}
t.node_mut(id).unwrap().computed = Some(cs);
}
#[test]
fn the_common_ancestor_of_a_press_and_its_release() {
let ids = tree_of(|t| {
let root = t.create_root();
let div = t.intern("div");
let list = t.create_element(div);
let a = t.create_element(div);
let b = t.create_element(div);
let a1 = t.create_element(div);
t.insert(list, root, 0);
t.insert(a, list, 0);
t.insert(b, list, 1);
t.insert(a1, a, 0);
vec![root, list, a, b, a1]
});
let [root, list, a, b, a1] = ids[..] else {
unreachable!()
};
tree::read_tree(|t| {
assert_eq!(common_ancestor(t, a1, a1), Some(a1), "the same element");
assert_eq!(
common_ancestor(t, a1, a),
Some(a),
"an ancestor of the other"
);
assert_eq!(common_ancestor(t, a1, b), Some(list), "two branches");
assert_eq!(common_ancestor(t, root, b), Some(root));
});
}
#[test]
fn dom_click_pairing_rejects_removed_or_other_window_presses_and_keeps_capture() {
tree_of(|t| {
let root = t.create_root();
let other_window = t.create_root();
let div = t.intern("div");
let parent = t.create_element(div);
let down = t.create_element(div);
let up = t.create_element(div);
t.insert(parent, root, 0);
t.insert(down, parent, 0);
t.insert(up, parent, 1);
assert_eq!(click_target_in_tree(t, down, up, root, None), Some(parent));
assert_eq!(
click_target_in_tree(t, down, up, root, Some(down)),
Some(down)
);
assert_eq!(click_target_in_tree(t, down, up, other_window, None), None);
t.insert(down, other_window, 0);
assert_eq!(
click_target_in_tree(t, down, up, root, None),
None,
"detached from the original window"
);
t.remove(down);
assert_eq!(
click_target_in_tree(t, down, up, root, None),
None,
"removed press must not retarget to a listener"
);
vec![root, other_window, parent, up]
});
}
#[test]
fn disabled_dom_clicks_include_button_children_but_preserve_the_first_legend() {
tree_of(|t| {
let root = t.create_root();
let button_tag = t.intern("button");
let span_tag = t.intern("span");
let fieldset_tag = t.intern("fieldset");
let legend_tag = t.intern("legend");
let button = t.create_element(button_tag);
let child = t.create_element(span_tag);
t.insert(button, root, 0);
t.insert(child, button, 0);
assert_eq!(
click_target_in_tree(t, child, child, root, None),
Some(child)
);
let disabled = t.intern("disabled");
t.set_prop(button, disabled, Some(String::new()));
assert_eq!(click_target_in_tree(t, child, child, root, None), None);
assert_eq!(
click_target_in_tree(t, root, child, root, None),
None,
"disabled release target"
);
t.set_prop(button, disabled, None);
let fieldset = t.create_element(fieldset_tag);
let legend = t.create_element(legend_tag);
let enabled = t.create_element(button_tag);
let disabled_button = t.create_element(button_tag);
t.insert(fieldset, root, 1);
t.insert(legend, fieldset, 0);
t.insert(enabled, legend, 0);
t.insert(disabled_button, fieldset, 1);
t.set_prop(fieldset, disabled, Some(String::new()));
assert_eq!(
click_target_in_tree(t, enabled, enabled, root, None),
Some(enabled)
);
assert_eq!(
click_target_in_tree(t, disabled_button, disabled_button, root, None),
None
);
vec![
root,
button,
child,
fieldset,
legend,
enabled,
disabled_button,
]
});
}
#[test]
fn the_boundary_between_two_hover_paths() {
let (left, entered) = boundary(&[5, 3, 2, 1], &[6, 4, 2, 1]);
assert_eq!(left, vec![5, 3]);
assert_eq!(entered, vec![4, 6]);
assert_eq!(boundary(&[3, 2, 1], &[5, 3, 2, 1]), (vec![], vec![5]));
assert_eq!(boundary(&[3, 2, 1], &[]), (vec![3, 2, 1], vec![]));
assert_eq!(boundary(&[], &[3, 2, 1]), (vec![], vec![1, 2, 3]));
}
#[test]
fn capture_keeps_its_path_outside_hit_testing_but_not_after_removal() {
tree_of(|t| {
let root = t.create_root();
let div = t.intern("div");
let parent = t.create_element(div);
let child = t.create_element(div);
let other = t.create_element(div);
t.insert(parent, root, 0);
t.insert(child, parent, 0);
t.insert(other, root, 1);
set(t, parent, Some(true), true);
assert!(path_if_hittable(t, child, root).is_none());
assert_eq!(
capture_path(t, child, root),
Some(vec![child, parent, root])
);
assert_eq!(
capture_path(t, child, other),
None,
"capture never crosses windows"
);
t.insert(child, other, 0);
assert_eq!(
capture_path(t, child, parent),
None,
"detached from old painted root"
);
vec![root, parent, child, other]
});
}
#[test]
fn pointer_events_none_and_hidden_subtrees_are_not_targets() {
let ids = tree_of(|t| {
let root = t.create_root();
let div = t.intern("div");
let decor = t.create_element(div);
let inside = t.create_element(div);
let hidden = t.create_element(div);
let under_hidden = t.create_element(div);
let plain = t.create_element(div);
t.insert(decor, root, 0);
t.insert(inside, decor, 0);
t.insert(hidden, root, 1);
t.insert(under_hidden, hidden, 0);
t.insert(plain, root, 2);
set(t, decor, Some(true), false);
set(t, inside, Some(false), false);
set(t, hidden, None, true);
set(t, under_hidden, None, false);
vec![root, decor, inside, hidden, under_hidden, plain]
});
let [root, decor, inside, hidden, under_hidden, plain] = ids[..] else {
unreachable!()
};
tree::read_tree(|t| {
assert!(
path_if_hittable(t, decor, root).is_none(),
"pointer-events: none"
);
assert_eq!(
path_if_hittable(t, inside, root),
Some(vec![inside, decor, root]),
"auto under none is hit, and its path runs through the none parent"
);
assert!(
path_if_hittable(t, hidden, root).is_none(),
"visibility: hidden"
);
assert!(
path_if_hittable(t, under_hidden, root).is_none(),
"inside a hidden subtree"
);
assert_eq!(path_if_hittable(t, plain, root), Some(vec![plain, root]));
let r = resolve(t, vec![decor, under_hidden, plain, root], root);
assert_eq!((r.target, r.at), (plain, 2));
let r = resolve(t, vec![decor], root);
assert_eq!(r.target, root, "nothing hittable: the root");
assert!(path_if_hittable(t, plain, decor).is_none());
});
}
}