Files
craft-libs/crates/ui-contract/src/runtime/pointer.rs
T
aiongg c19abe8663 Dock a native window by dragging its title row
A floating dock group in its own OS window now moves through a window move
gesture the app runs, which reports Begin, Update, Commit and Cancel like a
layer's move, so the dock marks the target under the pointer and docks the
whole window on release.

- macOS (Caps::OS_MOVES_TRACKED): the OS moves the window (StartMove), and the
  app follows the system pointer, button and Cmd through SystemWindows, the
  running platform's WindowSystem in craft-window. The hand-off ends when the
  system reports the button up.
- X11 and Windows: the app moves the window with SetOuterPosition so the
  pressed point stays under the pointer; Escape puts it back.
- A drag started by a container shown in its own OS window follows that
  window's pointer, not its parent's.
- The runtime's end hook sets NSWindow.movable for every window; a window
  whose move the app runs is never moved by AppKit from its band.
2026-11-12 14:32:39 +00:00

429 lines
20 KiB
Rust

//! The pointer snapshot, press targets, the shape record and press cancels (8.1, 8.3).
//!
//! The begin hook converts the pass's pointer input once. The sensing core in `primitives` runs the press
//! lifecycle over it and writes the shapes it registers into the record the focus service reads.
use crate::runtime::drag;
use crate::runtime::egui::areas::{self, Layer};
use crate::runtime::egui::{input, pass};
use crate::runtime::frame::{PerViewport, Stamped};
use craft_behavior::{
Buttons, MultiTouch, PartRef, PointerButton, PointerEvent, PointerKind, PointerSample, PressCancel, PressStart, ResolveFor, Shape, Winner,
count_clicks, resolve,
};
use craft_keymap::Mods;
use craft_theme::HitSizes;
use egui::{Context, Id, Pos2, Rect, Vec2, ViewportId};
use std::collections::HashMap;
use std::sync::Arc;
/// Points one wheel line adds to `PointerFrame.scroll`; scroll owners apply their own notch (the wheel service).
pub(crate) const WHEEL_LINE_POINTS: f32 = 40.0;
/// Points one wheel page adds to `PointerFrame.scroll`.
pub(crate) const WHEEL_PAGE_POINTS: f32 = 400.0;
/// The pointer input of one pass of one viewport, egui-converted.
#[derive(Clone, Debug)]
#[non_exhaustive]
pub struct PointerFrame {
/// The latest pointer position, `None` while the pointer is not in the window.
pub pos: Option<Pos2>,
/// The pointer movement of the pass.
pub delta: Vec2,
/// The buttons held.
pub buttons: Buttons,
/// The primary press of the pass.
pub press: Option<PressStart>,
/// The button released in the pass.
pub release: Option<PointerButton>,
/// The modifiers held.
pub mods: Mods,
/// The pass's time in seconds.
pub time: f64,
/// The device.
pub kind: PointerKind,
/// Pressure and tilt of the current contact.
pub sample: Option<PointerSample>,
/// The two-finger gesture.
pub multi_touch: Option<MultiTouch>,
/// Wheel and trackpad scroll, in points.
pub scroll: Vec2,
/// Pinch and Ctrl or Cmd with the wheel, folded into one factor.
pub zoom: f32,
/// The movement that turns a press into a drag.
pub slop: f32,
/// The least hit size across for this pointer kind.
pub target: f32,
}
/// egui's click and drag widgets for the latest press.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
#[doc(hidden)]
pub struct PressTargets {
pub click: Option<Id>,
pub drag: Option<Id>,
}
/// What the begin hook read of the pass, for the sensing core and the services.
#[derive(Clone, Debug, Default)]
#[doc(hidden)]
pub struct PassPointer {
pub frame: Option<PointerFrame>,
/// The primary events, presses carrying their click counts.
pub events: Vec<PointerEvent>,
pub hover: Option<Pos2>,
pub primary_down: bool,
pub press_targets: PressTargets,
pub focus_lost: bool,
/// Whether the real pointer moved or entered, or its modifiers changed, in the pass.
pub stirred: bool,
}
#[derive(Default)]
pub(crate) struct Memory {
last_press: Option<(Pos2, f64, u32)>,
press_targets: PressTargets,
/// A cancel a service requested for the running pass.
requested: Option<(u64, PressCancel)>,
/// Whether any arena of the viewport holds an open press; sensing registers it, as the layer above.
press_probe: Option<fn(&Context) -> bool>,
}
/// What one root registered on one layer: its shapes and its egui widgets.
#[derive(Clone, Default)]
struct RootRecord {
shapes: Vec<Shape<Id>>,
/// The root's egui widgets: the click and drag targets that stand for it.
widgets: Vec<Id>,
/// The root's widgets sense a click.
click: bool,
}
type LayerRecord = HashMap<Layer, HashMap<Id, RootRecord>>;
#[derive(Default)]
pub(crate) struct Shapes {
this: LayerRecord,
last: LayerRecord,
}
/// The begin hook (H5): converts the pass's pointer input.
pub(crate) fn begin(ctx: &Context, hit: HitSizes) {
let viewport = pass::current_viewport(ctx);
let pass_nr = pass::pass_nr(ctx, viewport);
let mut read = input::pointer_read(ctx);
// A drag that started in another window reaches this one through the desktop pointer (8.4).
if read.pos.is_none() {
read.pos = drag::cross_window_pointer(ctx, viewport);
}
let wheel = input::wheel_read(ctx, WHEEL_LINE_POINTS, WHEEL_PAGE_POINTS);
let hits = input::hit_targets(ctx);
let other_pressed =
read.events.iter().any(|event| matches!(event, PointerEvent::Pressed { button: PointerButton::Middle | PointerButton::Secondary, .. }));
let (events, targets) = PerViewport::<Memory>::with(ctx, viewport, |memory| {
let mut events = read.events.clone();
for event in &mut events {
if let PointerEvent::Pressed { button: PointerButton::Primary, pos, time, clicks, .. } = event {
*clicks = count_clicks(memory.last_press, *pos, *time, read.slop);
memory.last_press = Some((*pos, *time, *clicks));
}
}
if read.primary_pressed || other_pressed {
memory.press_targets = PressTargets { click: hits.0, drag: hits.1 };
}
(events, memory.press_targets)
});
let press = events.iter().rev().find_map(|event| match event {
PointerEvent::Pressed { button, pos, time, clicks, .. } => Some(PressStart::new(*pos, *button, *time, *clicks)),
_ => None,
});
let press = press.or_else(|| read.other_press.map(|(button, at)| PressStart::new(at, button, read.time, 1)));
let (scroll, wheel_zoom) = (wheel.map_or(Vec2::ZERO, |(scroll, ..)| scroll), read.zoom);
let frame = PointerFrame {
pos: read.pos,
delta: read.delta,
buttons: read.buttons,
press,
release: read.release,
mods: read.mods,
time: read.time,
kind: read.kind,
sample: read.sample,
multi_touch: read.multi_touch.map(|(translation, zoom, rotation, center)| MultiTouch::new(translation, zoom, rotation, center)),
scroll,
zoom: wheel_zoom,
slop: read.slop,
target: hit.target,
};
let pass_pointer = PassPointer {
frame: Some(frame),
events,
hover: read.hover,
primary_down: read.primary_down,
press_targets: targets,
focus_lost: read.focus_lost,
stirred: read.stirred,
};
PerViewport::<Stamped<Arc<PassPointer>>>::with_pass(ctx, viewport, pass_nr, |_, _| {}, |record| *record = Arc::new(pass_pointer));
PerViewport::<Shapes>::with(ctx, viewport, |shapes| shapes.last = std::mem::take(&mut shapes.this));
}
/// The running viewport's pass number.
pub(crate) fn pass_of(ctx: &Context) -> u64 {
pass::pass_nr(ctx, pass::current_viewport(ctx))
}
/// What the begin hook read of the running pass.
pub(crate) fn pass_pointer(ctx: &Context) -> Arc<PassPointer> {
let viewport = pass::current_viewport(ctx);
PerViewport::<Stamped<Arc<PassPointer>>>::with_pass(ctx, viewport, pass::pass_nr(ctx, viewport), |_, _| {}, |record| Arc::clone(record))
}
/// Reads what the begin hook read of the running pass in place, without cloning its events.
#[doc(hidden)]
pub fn with_pass_pointer<R>(ctx: &Context, f: impl FnOnce(&PassPointer) -> R) -> R {
let viewport = pass::current_viewport(ctx);
let pass_nr = pass::pass_nr(ctx, viewport);
PerViewport::<Stamped<Arc<PassPointer>>>::with_pass(ctx, viewport, pass_nr, |_, _| {}, |record| f(record))
}
/// The buttons held in the latest pass of `viewport`, which may be a child window whose pass ran inside this one.
pub(crate) fn buttons_of(ctx: &Context, viewport: ViewportId) -> Buttons {
PerViewport::<Stamped<Arc<PassPointer>>>::with_pass(
ctx,
viewport,
pass::pass_nr(ctx, viewport),
|_, _| {},
|record| record.frame.as_ref().map_or(Buttons::empty(), |frame| frame.buttons),
)
}
/// Reads the running pass's pointer frame, `None` before the begin hook, and its hover position in place.
pub(crate) fn with_frame<R>(ctx: &Context, f: impl FnOnce(Option<&PointerFrame>, Option<Pos2>) -> R) -> R {
with_pass_pointer(ctx, |pointer| f(pointer.frame.as_ref(), pointer.hover))
}
/// The running pass's pointer input.
pub fn frame(ctx: &Context) -> PointerFrame {
with_pass_pointer(ctx, |pointer| pointer.frame.clone()).unwrap_or_else(|| PointerFrame {
pos: None,
delta: Vec2::ZERO,
buttons: Buttons::empty(),
press: None,
release: None,
mods: Mods::NONE,
time: 0.0,
kind: PointerKind::Mouse,
sample: None,
multi_touch: None,
scroll: Vec2::ZERO,
zoom: 1.0,
slop: 0.0,
target: 0.0,
})
}
/// Ends every captured press of the running viewport at its next lifecycle run in this pass (Escape, a part
/// turning disabled). The next begin hook ends egui's own drag so hover reaches other widgets again.
pub(crate) fn cancel_press(ctx: &Context, reason: PressCancel) {
let viewport = pass::current_viewport(ctx);
let pass_nr = pass::pass_nr(ctx, viewport);
PerViewport::<Memory>::with(ctx, viewport, |memory| memory.requested = Some((pass_nr, reason)));
}
/// Registers how the viewport tells that a press is captured. Sensing owns the arenas' machines.
pub(crate) fn register_press_probe(ctx: &Context, probe: fn(&Context) -> bool) {
PerViewport::<Memory>::with(ctx, pass::current_viewport(ctx), |memory| memory.press_probe = Some(probe));
}
/// Whether a press of the running viewport is open: Escape cancels it before anything else.
pub(crate) fn press_captured(ctx: &Context) -> bool {
let probe = PerViewport::<Memory>::with(ctx, pass::current_viewport(ctx), |memory| memory.press_probe);
probe.is_some_and(|probe| probe(ctx))
}
/// Why captured presses end in the running pass: a cancel a service requested, else the window losing focus.
pub(crate) fn cancel_of_pass(ctx: &Context) -> Option<PressCancel> {
let viewport = pass::current_viewport(ctx);
let pass_nr = pass::pass_nr(ctx, viewport);
let requested = PerViewport::<Memory>::with(ctx, viewport, |memory| memory.requested.filter(|(nr, _)| *nr == pass_nr).map(|(_, reason)| reason));
requested.or_else(|| with_pass_pointer(ctx, |pointer| pointer.focus_lost).then_some(PressCancel::FocusLost))
}
/// Writes `shapes` of the arena rooted at `root` into the running pass's shape record under `layer`. Stack
/// positions are per arena, so each root's shapes stay apart.
pub(crate) fn record_shapes(ctx: &Context, layer: Layer, root: Id, shapes: impl IntoIterator<Item = Shape<Id>>) {
record_shapes_in(ctx, pass::current_viewport(ctx), layer, root, shapes);
}
/// `record_shapes` for a caller that already read the running viewport.
pub(crate) fn record_shapes_in(ctx: &Context, viewport: ViewportId, layer: Layer, root: Id, shapes: impl IntoIterator<Item = Shape<Id>>) {
PerViewport::<Shapes>::with(ctx, viewport, |record| record.this.entry(layer).or_default().entry(root).or_default().shapes.extend(shapes));
}
/// Records the egui widgets that stand for the root at `root` (`click` when they sense a click): the root's own at
/// step 8, and the `over` widgets of its members after their bodies.
pub(crate) fn record_widgets(ctx: &Context, layer: Layer, root: Id, widgets: &[Id], click: bool) {
record_widgets_in(ctx, pass::current_viewport(ctx), layer, root, widgets, click);
}
/// `record_widgets` for a caller that already read the running viewport.
pub(crate) fn record_widgets_in(ctx: &Context, viewport: ViewportId, layer: Layer, root: Id, widgets: &[Id], click: bool) {
PerViewport::<Shapes>::with(ctx, viewport, |record| {
let entry = record.this.entry(layer).or_default().entry(root).or_default();
entry.widgets.extend_from_slice(widgets);
entry.click |= click;
});
}
/// What the root `root` registered in the running pass of `viewport`, read for its part `part`: the egui widgets
/// that stand for the root, and the screen bounds of the root's shapes that take a press and outrank the part.
pub(crate) struct OverPart {
/// The root's egui widgets: a press on them resolves among the root's shapes, not as a widget over the part.
pub widgets: Vec<Id>,
/// The shapes a press on the part goes to instead: a higher stack position (a member, an `over` part), level or
/// sub-level (8.3). A shape of the same rank wins only by its distance to the point, so it is not one of them.
pub above: Vec<Rect>,
}
/// What lies over the part `part` of the root `root` in the running pass of `viewport`, among the root's widgets and
/// shapes. Read at the end of the pass, when the record is complete.
pub(crate) fn over_part(ctx: &Context, viewport: ViewportId, root: Id, part: PartRef) -> OverPart {
let (widgets, layers) = PerViewport::<Shapes>::with(ctx, viewport, |record| {
let entries = || record.this.iter().filter_map(|(layer, roots)| roots.get(&root).map(|entry| (*layer, entry)));
let rank = |shape: &Shape<Id>| (shape.position, shape.priority.level, shape.priority.sub);
let own =
entries().flat_map(|(_, entry)| entry.shapes.iter()).filter(|shape| shape.owner == root && shape.part == Some(part)).map(rank).max();
let widgets: Vec<Id> = entries().flat_map(|(_, entry)| entry.widgets.iter().copied()).collect();
let layers: Vec<(Layer, Vec<Rect>)> = entries()
.map(|(layer, entry)| {
let above = entry.shapes.iter().filter(|shape| shape.sense.takes_press() && own.is_some_and(|own| rank(shape) > own));
(layer, above.map(|shape| shape.shape.bounds()).collect())
})
.collect();
(widgets, layers)
});
let above = layers
.into_iter()
.flat_map(|(layer, bounds)| {
let to_screen = areas::layer_to_screen(ctx, layer);
bounds.into_iter().map(move |rect| to_screen * rect)
})
.collect();
OverPart { widgets, above }
}
/// The parts of the root `root` that sense `sense` in last pass's shape record, in registration order.
#[cfg(feature = "testing")]
pub(crate) fn sensing_parts(ctx: &Context, root: Id, sense: craft_behavior::Sense) -> Vec<craft_behavior::PartRef> {
let viewport = pass::current_viewport(ctx);
PerViewport::<Shapes>::with(ctx, viewport, |record| {
let mut parts = Vec::new();
for layer in record.last.values() {
if let Some(entry) = layer.get(&root) {
parts.extend(entry.shapes.iter().filter(|shape| shape.sense.contains(sense)).filter_map(|shape| shape.part));
}
}
parts
})
}
/// The bounds of the part `part` of `owner` (the arena root or a member) in last pass's shape record: pointer-only
/// parts have no access node, so this record is where their place is read.
pub(crate) fn part_bounds(ctx: &Context, owner: Id, part: craft_behavior::PartRef) -> Option<egui::Rect> {
let viewport = pass::current_viewport(ctx);
PerViewport::<Shapes>::with(ctx, viewport, |record| {
record
.last
.values()
.flat_map(|roots| roots.values())
.flat_map(|root| root.shapes.iter())
.find(|shape| shape.owner == owner && shape.part == Some(part))
.map(|shape| shape.shape.bounds())
})
}
/// The bounds of the part `part` that senses `sense`, on a component other than `subject` and lying inside the
/// subject's own shapes in last pass's shape record: where a component's child keeps the part a drive acts on. When
/// several children match, the first by top edge, then start edge, then root id.
#[cfg(feature = "testing")]
pub(crate) fn child_part_bounds(ctx: &Context, subject: Id, part: craft_behavior::PartRef, sense: craft_behavior::Sense) -> Option<egui::Rect> {
let viewport = pass::current_viewport(ctx);
PerViewport::<Shapes>::with(ctx, viewport, |record| {
let shapes = || record.last.values().flat_map(|roots| roots.values()).flat_map(|root| root.shapes.iter());
let room = shapes().filter(|shape| shape.owner == subject).map(|shape| shape.shape.bounds()).reduce(|all, next| all.union(next))?;
shapes()
.filter(|shape| {
shape.owner != subject && shape.part == Some(part) && shape.sense.contains(sense) && room.contains_rect(shape.shape.bounds())
})
.min_by(|a, b| {
let (a_bounds, b_bounds) = (a.shape.bounds(), b.shape.bounds());
a_bounds.min.y.total_cmp(&b_bounds.min.y).then(a_bounds.min.x.total_cmp(&b_bounds.min.x)).then(a.owner.value().cmp(&b.owner.value()))
})
.map(|shape| shape.shape.bounds())
})
}
/// The roots and egui widgets the root viewport's latest pass registered: what bypass detection counts as made by
/// components.
#[cfg(feature = "testing")]
pub(crate) fn registered_widgets(ctx: &Context) -> std::collections::HashSet<Id> {
PerViewport::<Shapes>::with(ctx, egui::ViewportId::ROOT, |record| {
record
.this
.values()
.flat_map(|roots| roots.iter())
.flat_map(|(root, rec)| std::iter::once(*root).chain(rec.widgets.iter().copied()))
.collect()
})
}
/// The winner of a press at `at` among last pass's shapes of the root egui hands the press to, on the topmost
/// layer under it, with that root: what the focus service classifies the press by (8.3, H7). A press whose egui
/// target is no root's widget has no winner. A root's widget covers its whole rect, so when no shape of the click
/// root lies under the press (a title row between its parts), the press goes to the drag root below it. Shapes of
/// transformed bodies lie on their own layers.
pub(crate) fn press_winner(ctx: &Context, at: Pos2, targets: PressTargets) -> Option<(Winner<Id>, Id)> {
let layer = areas::layer_at(ctx, at)?;
let viewport = pass::current_viewport(ctx);
let candidates = PerViewport::<Shapes>::with(ctx, viewport, |record| {
let roots = || record.last.values().flat_map(|roots| roots.iter());
let root_of = |widget: Option<Id>| {
let widget = widget?;
roots().find(|(_, root)| root.widgets.contains(&widget)).map(|(id, _)| *id)
};
let mut found: Vec<(Id, Vec<Shape<Id>>)> = Vec::new();
for root in [root_of(targets.click), root_of(targets.drag)].into_iter().flatten() {
if found.iter().all(|(seen, _)| *seen != root)
&& let Some(shapes) = record.last.get(&layer).and_then(|roots| roots.get(&root))
{
found.push((root, shapes.shapes.clone()));
}
}
found
});
let at = areas::layer_map(ctx, layer).map_or(at, |map| map.to_layer(at));
candidates.into_iter().find_map(|(root, shapes)| resolve(&shapes, at, ResolveFor::Press).map(|winner| (winner, root)))
}
/// The screen bounds of the root `root` from its shape record, with the viewport and layer they were recorded in: the
/// running pass's shapes when the root has registered in it, else the previous pass's. Searched over the live
/// viewports, so the input hook reads it before the pass begins.
pub(crate) fn root_bounds(ctx: &Context, root: Id) -> Option<(ViewportId, Layer, egui::Rect)> {
pass::live_viewports(ctx).into_iter().find_map(|viewport| {
let (layer, bounds) = PerViewport::<Shapes>::with(ctx, viewport, |record| {
[&record.this, &record.last].into_iter().find_map(|layers| {
layers.iter().find_map(|(layer, roots)| {
let shapes = &roots.get(&root)?.shapes;
let bounds = shapes.iter().fold(egui::Rect::NOTHING, |bounds, shape| bounds.union(shape.shape.bounds()));
bounds.is_positive().then_some((*layer, bounds))
})
})
})?;
let screen =
areas::layer_map(ctx, layer).map_or(bounds, |map| egui::Rect::from_two_pos(map.to_screen(bounds.min), map.to_screen(bounds.max)));
Some((viewport, layer, screen))
})
}