canvas-widgets-w2: net change of 4 commits

- canvas-widgets-w2: written from its sheet
- canvas-widgets-w2: repair 1
- canvas-widgets-w2: review fixes (review-1)
- canvas-widgets-w2: the view-tool rig's frames are dt apart (the fixture's own step included), and the zoom press-point trial runs with Overscroll on (fwcw round 3)
This commit is contained in:
aiongg
2026-11-15 04:46:06 +00:00
parent 45aa93e89e
commit 58ef53128a
3 changed files with 356 additions and 17 deletions
+20 -10
View File
@@ -74,7 +74,6 @@ pub struct Momentary {
hand: HandTool,
zoom: ZoomTool,
/// The selected tool is the Hand: Cmd and Alt at a press then give Zoom In and Zoom Out.
#[allow(dead_code)] // P3(canvas-widgets-w2): cw.C15
hand_selected: bool,
}
@@ -90,6 +89,11 @@ impl Momentary {
self.hand_selected = selected;
}
/// The command whose key is down, if any: the signal an app reads to know the Hand key is held.
pub fn held(&self) -> Option<MomentaryCommands> {
self.held
}
/// Follows a change of the navigation options.
pub fn set_options(&mut self, options: NavigationOptions) {
self.hand.options = options;
@@ -116,16 +120,22 @@ impl Momentary {
if in_gesture {
return self.latched;
}
let tool = self.held.map(|held| {
let tool = MomentaryTool::from(held);
if mods.alt {
MomentaryTool::ZoomOut
} else if tool == MomentaryTool::Hand && (mods.cmd || mods.ctrl) {
MomentaryTool::ZoomIn
} else {
tool
let tool = match self.held {
Some(held) => {
let tool = MomentaryTool::from(held);
Some(if mods.alt {
MomentaryTool::ZoomOut
} else if tool == MomentaryTool::Hand && (mods.cmd || mods.ctrl) {
MomentaryTool::ZoomIn
} else {
tool
})
}
});
// The selected Hand: Alt and Cmd at the press zoom, with the same latch as a held key.
None if self.hand_selected && mods.alt => Some(MomentaryTool::ZoomOut),
None if self.hand_selected && (mods.cmd || mods.ctrl) => Some(MomentaryTool::ZoomIn),
None => None,
};
self.latched = tool;
tool
}
+6 -5
View File
@@ -242,8 +242,7 @@ pub struct HandTool {
flick: FlickPan,
/// Lent by the momentary set: a secondary press pans too.
lent: bool,
/// The press's scroll-all-windows choice, reported with the pan.
#[allow(dead_code)] // P3(canvas-widgets-w2): cw.C14
/// The press's scroll-all-windows choice, reported with every pan of the gesture and of its glide.
scroll_all: bool,
}
@@ -296,7 +295,7 @@ impl CanvasTool for HandTool {
let Some(space) = cx.space() else { return };
// The glide steps from the view it set, not the shown one, so steps under half a device pixel add up.
if let Some(view) = self.glide(&space.target(), cx.time) {
cx.set_view(view);
cx.pan_view(view, self.scroll_all);
}
if self.flick.gliding() {
cx.request_repaint();
@@ -307,6 +306,8 @@ impl CanvasTool for HandTool {
self.flick.stop();
self.start = cx.space().map(|space| (space.view, pointer.pos));
self.last = pointer.pos;
// Chosen here so a Shift released during the drag or the glide does not change where the pan goes.
self.scroll_all = self.options.scroll_all_windows || pointer.mods.shift;
ToolAction::Claimed
}
@@ -316,7 +317,7 @@ impl CanvasTool for HandTool {
self.last = pointer.pos;
let mut next = view;
pan(&mut next, pointer.pos - from);
cx.set_view(next);
cx.pan_view(next, self.scroll_all);
self.flick.drag(pointer.time, delta);
if delta != egui::Vec2::ZERO {
cx.request_repaint();
@@ -335,7 +336,7 @@ impl CanvasTool for HandTool {
if self.flick.gliding() {
cx.request_repaint();
}
cx.set_view(next);
cx.pan_view(next, self.scroll_all);
}
fn cancel(&mut self, _reason: CancelReason, cx: &mut ToolContext<'_>) {
+330 -2
View File
@@ -3,8 +3,126 @@
use craft_behavior::CanvasView;
use craft_behavior::canvas::zoom;
use craft_behavior::kurbo::{Point, Rect, Size};
use craft_ui::canvas::{HandTool, NavigationOptions, RotateViewTool, ViewCommands, ViewTarget, ZoomTool};
use craft_ui::testing::{ToolFixture, trial};
use craft_behavior::kurbo::Vec2 as DocVec;
use craft_ui::canvas::{Canvas, CanvasTool, HandTool, NavigationOptions, RotateViewTool, ToolHost, ViewCommands, ViewTarget, ZoomTool};
use craft_ui::contract::ShowContainer as _;
use craft_ui::testing::{Fixture, ToolFixture, pointer, trial};
use egui::{Event, Modifiers, Pos2};
use std::cell::{Cell, RefCell};
use std::rc::Rc;
/// The document the rigs show.
const DOCUMENT: Size = Size::new(1200.0, 900.0);
/// The step of one pass, in seconds: the clock step `Fixture::frame` takes on its own.
const FRAME: f64 = 1.0 / 60.0;
/// A tool on a canvas whose view the rig keeps across frames as the host reports it, with the pans the host reported.
struct Rig<T: CanvasTool + 'static> {
fixture: Fixture,
tool: Rc<RefCell<T>>,
view: Rc<Cell<Option<CanvasView>>>,
pans: Rc<RefCell<Vec<(DocVec, bool)>>>,
}
impl<T: CanvasTool + 'static> Rig<T> {
fn new(tool: T, start: impl Fn(egui::Rect) -> CanvasView + 'static) -> Self {
Self::scaled(tool, 1.0, NavigationOptions::default(), start)
}
/// A rig whose canvas shows at `ppp` pixels per point from its first frame, with the canvas's navigation options
/// `navigation`.
fn scaled(tool: T, ppp: f32, navigation: NavigationOptions, start: impl Fn(egui::Rect) -> CanvasView + 'static) -> Self {
let tool = Rc::new(RefCell::new(tool));
let view = Rc::new(Cell::new(None::<CanvasView>));
let pans = Rc::new(RefCell::new(Vec::<(DocVec, bool)>::new()));
let (shown_tool, shown_view, shown_pans) = (Rc::clone(&tool), Rc::clone(&view), Rc::clone(&pans));
let mut fixture = Fixture::new(move |ui| {
let room = ui.available_rect_before_wrap();
let current = shown_view.get().unwrap_or_else(|| start(room));
let shown = Canvas::new("Document").document(ViewTarget::from(DOCUMENT)).navigation(navigation).view(current).show(ui, |_, _| {});
let reply = ToolHost::new().run(ui, &shown.output, &mut *shown_tool.borrow_mut());
if let Some(pan) = reply.pan {
shown_pans.borrow_mut().push((pan.delta, pan.scroll_all));
}
shown_view.set(Some(reply.view.unwrap_or(current)));
});
fixture.ctx().set_pixels_per_point(ppp);
fixture.settle();
Rig { fixture, tool, view, pans }
}
fn view(&self) -> CanvasView {
self.view.get().expect("the rig has shown a frame")
}
fn ppp(&self) -> f32 {
self.fixture.ctx().pixels_per_point()
}
fn device(&self) -> f64 {
zoom::device(&self.view(), self.ppp())
}
fn centre(&self) -> Pos2 {
self.view().rect.center()
}
/// One frame `dt` seconds after the previous one: the fixture's frame moves the clock by [`FRAME`], the rig by the
/// rest.
fn tick(&mut self, dt: f64, events: Vec<Event>) {
self.fixture.advance(dt - FRAME);
self.fixture.frame(events);
}
/// Hovers and presses at `at` in separate frames.
fn press(&mut self, at: Pos2) {
self.tick(FRAME, vec![pointer::moved(at)]);
self.tick(FRAME, vec![pointer::press(at)]);
}
/// Moves from `from` to `to` in `steps` frames of `dt` seconds.
fn drag_to(&mut self, from: Pos2, to: Pos2, steps: usize, dt: f64) {
for step in 1..=steps {
let at = from + (to - from) * (step as f32 / steps as f32);
self.tick(dt, vec![pointer::moved(at)]);
}
}
/// Releases at `at` in a frame `dt` seconds on, then one idle frame of the same step.
fn release(&mut self, at: Pos2, dt: f64) {
self.tick(dt, vec![pointer::release(at)]);
self.tick(dt, Vec::new());
}
fn click(&mut self, at: Pos2) {
self.press(at);
self.release(at, FRAME);
}
}
/// `set` applied to the default navigation options.
fn options(set: impl FnOnce(&mut NavigationOptions)) -> NavigationOptions {
let mut options = NavigationOptions::default();
set(&mut options);
options
}
fn plain(room: egui::Rect) -> CanvasView {
CanvasView::new(room, Point::new(600.0, 450.0), 2.0)
}
fn turned(room: egui::Rect, rotation: f64, flip_x: bool) -> CanvasView {
let mut view = CanvasView::new(room, Point::new(600.0, 450.0), 0.5);
view.rotation = rotation;
view.flip_x = flip_x;
view
}
/// Whether the document point `before` showed at `at` is still at `at` in `after`.
fn pinned(before: &CanvasView, after: &CanvasView, at: Pos2) -> bool {
(after.to_screen(before.to_doc(at)) - at).length() < 0.5
}
#[trial]
fn each_view_tool_owes_the_canvas_its_checks() {
@@ -50,3 +168,213 @@ fn view_commands_run_with_their_facts_and_are_disabled_without() {
assert!(!command.apply(&mut view, &bare, ppp) && view == start, "{command:?} leaves the view without its fact");
}
}
#[trial]
fn zoom_drag_keeps_the_press_point_and_fits_the_rectangle() {
// Device zoom is the view's zoom times the pixels per point, so each case runs at 1 and at 2. Overscroll is on, so
// the canvas keeps the view the tool set: off, a zoom out that leaves the document smaller than the view centres it.
let free = options(|o| o.overscroll = true);
for (rotation, ppp) in [(-45.0, 1.0f32), (-45.0, 2.0), (90.0, 1.0), (90.0, 2.0)] {
for flip_x in [false, true] {
let start = move |room: egui::Rect| turned(room, rotation, flip_x);
let label = format!("rotation {rotation}, flip {flip_x}, {ppp} pixels per point");
// A click zooms in (Alt: out) about the clicked point.
for out in [false, true] {
let mut rig = Rig::scaled(ZoomTool::new(options(|o| o.animated_zoom = false)), ppp, free, start);
let (before, at, device) = (rig.view(), rig.centre() + egui::vec2(80.0, 50.0), rig.device());
if out {
rig.fixture.hold(Modifiers::ALT);
}
rig.click(at);
assert!(pinned(&before, &rig.view(), at), "{label}: the clicked point stays under the pointer (out {out})");
assert_eq!(rig.device() > device, !out, "{label}: a click zooms {}", if out { "out" } else { "in" });
assert_ne!(rig.device(), device, "{label}: the click changes the zoom");
}
// A scrub of one doubling keeps the press point.
let mut rig = Rig::scaled(ZoomTool::new(options(|o| (o.animated_zoom, o.scrubby_zoom) = (false, true))), ppp, free, start);
let (before, at, device) = (rig.view(), rig.centre() + egui::vec2(-70.0, 30.0), rig.device());
rig.press(at);
rig.drag_to(at, at + egui::vec2(100.0, 0.0), 5, FRAME);
rig.release(at + egui::vec2(100.0, 0.0), FRAME);
assert!(pinned(&before, &rig.view(), at), "{label}: a scrub keeps the press point");
assert!(rig.device() > device, "{label}: dragging right scrubs the zoom in, got {}", rig.device() / device);
// A rectangle changes nothing until the release, which centres it and fits it; Alt steps out once.
for out in [false, true] {
let mut rig = Rig::scaled(ZoomTool::new(options(|o| (o.animated_zoom, o.scrubby_zoom) = (false, false))), ppp, free, start);
let (before, centre, device) = (rig.view(), rig.centre(), rig.device());
let (a, b) = (centre + egui::vec2(-60.0, -40.0), centre + egui::vec2(60.0, 40.0));
if out {
rig.fixture.hold(Modifiers::ALT);
}
rig.press(a);
rig.drag_to(a, b, 6, FRAME);
assert_eq!(rig.view(), before, "{label}: the rectangle changes no view before the release");
rig.release(b, FRAME);
let after = rig.view();
if out {
assert!(rig.device() < device, "{label}: Alt steps the zoom out");
assert!(pinned(&before, &after, a), "{label}: stepping out keeps the press point");
} else {
assert!(rig.device() > device, "{label}: the rectangle zooms in");
assert!((after.to_screen(before.to_doc(centre)) - after.rect.center()).length() < 0.5, "{label}: the rectangle's centre is the view centre");
}
}
}
}
}
#[trial]
fn a_hand_pan_reports_its_document_distance_and_its_scroll_all_choice() {
// (Shift at the press, the Scroll All Windows option) and the choice the pans carry.
let rows = [(false, false, false), (true, false, true), (false, true, true)];
for (shift, option, expected) in rows {
let mut rig = Rig::new(HandTool::new(options(|o| (o.scroll_all_windows, o.flick_panning) = (option, true))), plain);
let (before, c) = (rig.view().center, rig.centre());
if shift {
rig.fixture.hold(Modifiers::SHIFT);
}
rig.press(c);
// Shift comes up during the drag; the choice made at the press holds through the drag and the glide.
rig.fixture.hold(Modifiers::NONE);
let to = c + egui::vec2(120.0, 0.0);
rig.drag_to(c, to, 8, FRAME);
rig.release(to, FRAME);
let dragged = rig.pans.borrow().len();
assert!(dragged > 0, "a drag reports its pans (shift {shift}, option {option})");
for _ in 0..10 {
rig.tick(FRAME, Vec::new());
}
let pans = rig.pans.borrow().clone();
assert!(pans.len() > dragged, "the flick glide reports pans too (shift {shift}, option {option})");
assert!(pans.iter().all(|(_, all)| *all == expected), "scroll all is {expected}: {pans:?}");
// The pans are document distances: together they are how far the view centre moved, against the pointer.
let sum = pans.iter().fold(DocVec::ZERO, |sum, (delta, _)| sum + *delta);
let moved = rig.view().center - before;
assert!((sum - moved).hypot() < 1e-6, "the pans sum to the centre's move: {sum:?} against {moved:?}");
assert!(sum.x < 0.0 && sum.y.abs() < 1e-6, "dragging right moves the centre left in document units: {sum:?}");
}
// A view at its Overscroll limit (Overscroll is off) cannot move: dragging on outward reports a pan of 0.
// The view starts 20 units inside the document's left edge, so the drag reaches the limit part way.
let at_edge = |room: egui::Rect| CanvasView::new(room, Point::new(f64::from(room.width()) / 4.0 + 20.0, 450.0), 2.0);
let mut rig = Rig::new(HandTool::new(options(|o| o.flick_panning = false)), at_edge);
let c = rig.centre();
rig.press(c);
rig.drag_to(c, c + egui::vec2(240.0, 0.0), 12, FRAME);
let pans = rig.pans.borrow().clone();
assert!(pans.iter().any(|(delta, _)| *delta != DocVec::ZERO), "the drag moves the view before it reaches the limit");
assert_eq!(pans.last().map(|(delta, _)| *delta), Some(DocVec::ZERO), "a drag on past the limit reports no distance: {pans:?}");
rig.release(c + egui::vec2(240.0, 0.0), FRAME);
}
#[trial]
fn a_rotate_view_drag_follows_the_pointer_in_a_flipped_view_and_shift_steps_fifteen_degrees() {
let probe = Point::new(700.0, 480.0);
// The screen angle of the probe about the view's centre, in degrees.
let angle = |view: &CanvasView| {
let v = view.to_screen(probe) - view.rect.center();
f64::from(v.y).atan2(f64::from(v.x)).to_degrees()
};
for flip_x in [false, true] {
let start = move |room: egui::Rect| {
let mut view = CanvasView::new(room, Point::new(600.0, 450.0), 0.5);
view.rotation = 20.0;
view.flip_x = flip_x;
view
};
let mut rig = Rig::new(RotateViewTool::default(), start);
let (before, c) = (rig.view(), rig.centre());
let (from, to) = (c + egui::vec2(100.0, 0.0), c + egui::vec2(100.0 * 30f32.to_radians().cos(), 100.0 * 30f32.to_radians().sin()));
rig.press(from);
rig.drag_to(from, to, 6, FRAME);
rig.release(to, FRAME);
let turned_by = (angle(&rig.view()) - angle(&before) + 540.0).rem_euclid(360.0) - 180.0;
assert!((turned_by - 30.0).abs() < 0.01, "flip {flip_x}: a 30 degree drag turns the image 30 degrees the pointer's way, got {turned_by}");
}
let mut rig = Rig::new(RotateViewTool::default(), |room| CanvasView::new(room, Point::new(600.0, 450.0), 0.5));
let c = rig.centre();
let (from, to) = (c + egui::vec2(100.0, 0.0), c + egui::vec2(100.0 * 37f32.to_radians().cos(), 100.0 * 37f32.to_radians().sin()));
rig.fixture.hold(Modifiers::SHIFT);
rig.press(from);
rig.drag_to(from, to, 6, FRAME);
rig.release(to, FRAME);
let rotation = rig.view().rotation;
assert!(rotation != 0.0, "the drag turned the view");
assert!((rotation - (rotation / 15.0).round() * 15.0).abs() < 1e-6, "Shift lands the angle on 15 degree steps, got {rotation}");
}
#[trial]
fn a_flicked_hand_release_glides_and_stops_only_when_fast() {
// Drags 8 passes of `step` points, waits `pause` seconds, releases; returns whether the view kept moving after the
// release and whether it came to rest.
let run = |flick: bool, step: f32, pause: f64| {
let mut rig = Rig::new(HandTool::new(options(|o| o.flick_panning = flick)), plain);
let c = rig.centre();
let to = c + egui::vec2(step * 8.0, 0.0);
rig.press(c);
rig.drag_to(c, to, 8, FRAME);
if pause > 0.0 {
rig.tick(pause, Vec::new());
}
rig.release(to, 0.0);
let at = rig.view().center;
for _ in 0..5 {
rig.tick(FRAME, Vec::new());
}
let moved = rig.view().center != at;
for _ in 0..40 {
rig.tick(0.1, Vec::new());
}
let rest = rig.view().center;
rig.tick(0.1, Vec::new());
(moved, rig.view().center == rest)
};
assert_eq!(run(true, 12.0, 0.0), (true, true), "a fast release glides and decays to a stop");
assert!(!run(true, 1.6, 0.0).0, "a slow release does not glide");
assert!(!run(false, 12.0, 0.0).0, "with Flick Panning off a fast release does not glide");
assert!(!run(true, 12.0, 0.3).0, "the velocity is that of the last moments: a pause before the release gives no glide");
}
#[trial]
fn a_held_zoom_press_zooms_about_its_point_at_a_frame_rate_independent_rate() {
let held = |dt: f64, animated: bool| {
let mut rig = Rig::new(ZoomTool::new(options(|o| o.animated_zoom = animated)), |room| turned(room, 0.0, false));
let (before, at, device) = (rig.view(), rig.centre() + egui::vec2(80.0, 50.0), rig.device());
rig.press(at);
for _ in 0..(0.9 / dt).round() as usize {
rig.tick(dt, Vec::new());
}
// The release comes in the pass of the last frame, so both rates end at the same time.
rig.release(at, 0.0);
(rig.device() / device, pinned(&before, &rig.view(), at))
};
let (slow, slow_pinned) = held(1.0 / 30.0, true);
let (fast, fast_pinned) = held(1.0 / 120.0, true);
assert!(slow_pinned && fast_pinned, "the hold zooms about the press point");
assert!(slow > 1.0, "a hold zooms in: {slow}");
assert!((slow / fast - 1.0).abs() < 0.03, "the same hold zooms the same at 30 and 120 passes a second: {slow} against {fast}");
// Animated Zoom off: a hold is one step, as a click.
let step = |animated: bool| {
let mut rig = Rig::new(ZoomTool::new(options(|o| o.animated_zoom = animated)), |room| turned(room, 0.0, false));
let device = rig.device();
rig.click(rig.centre() + egui::vec2(80.0, 50.0));
rig.device() / device
};
let (still, _) = held(1.0 / 30.0, false);
assert!((still - step(false)).abs() < 1e-9, "with Animated Zoom off a hold gives one step: {still}");
assert!(still < slow, "one step is less than a hold's zoom");
assert!((step(true) - step(false)).abs() < 1e-9, "a quick click steps one rung with or without easing");
// A drag within the delay scrubs.
let mut rig = Rig::new(ZoomTool::new(NavigationOptions::default()), |room| turned(room, 0.0, false));
let (at, device) = (rig.centre(), rig.device());
rig.press(at);
rig.drag_to(at, at + egui::vec2(100.0, 0.0), 4, FRAME);
rig.release(at + egui::vec2(100.0, 0.0), FRAME);
assert!((rig.device() / device - 2.0).abs() < 1e-3, "a drag scrubs one doubling per 100 points: {}", rig.device() / device);
}