mirror of
https://github.com/storytold/craft-libs.git
synced 2026-11-17 00:34:25 +00:00
519 lines
18 KiB
Rust
519 lines
18 KiB
Rust
//! The selection tools on the tool host: each test drives one tool through a `ToolFixture` with injected pointer input
|
|
//! and a fake `SelectionProbe`, then reads the events the tool reports.
|
|
|
|
use craft_behavior::geometry::{Constraint, SelectionOperation};
|
|
use craft_behavior::{CancelReason, EditEvent, PixelSize, PointerButton};
|
|
use craft_imaging::ui::select::{
|
|
EdgeSearch, EdgeTracer, MagneticLassoTool, MarqueeKind, MarqueeTool, PolygonLassoTool, SelectEvent, SelectPhase, SelectToolPass, SelectionProbe,
|
|
SelectionShape,
|
|
};
|
|
use craft_keymap::Mods;
|
|
use craft_ui::canvas::{CanvasTool, ToolAccess, ToolContext, ToolHost, ToolInput, ToolKey, ToolPath, ToolPointer};
|
|
use craft_ui::primitives::Draw;
|
|
use craft_ui::testing::{ToolFixture, pointer, trial};
|
|
use egui::{Key, Modifiers, Pos2, Rect as ScreenRect, pos2};
|
|
use kurbo::{Point, Rect, Vec2};
|
|
use std::cell::{Cell, RefCell};
|
|
use std::rc::Rc;
|
|
|
|
const SIZE: PixelSize = PixelSize::new(400, 300);
|
|
const NONE: Mods = Mods::NONE;
|
|
|
|
/// A document with an optional rectangle selection.
|
|
#[derive(Default)]
|
|
struct Fake {
|
|
selection: Option<Rect>,
|
|
document: u64,
|
|
}
|
|
|
|
impl Fake {
|
|
fn empty() -> Self {
|
|
Fake { document: 1, ..Fake::default() }
|
|
}
|
|
|
|
fn selected(selection: Rect) -> Self {
|
|
Fake { selection: Some(selection), ..Fake::empty() }
|
|
}
|
|
}
|
|
|
|
impl SelectionProbe for Fake {
|
|
fn document(&self) -> u64 {
|
|
self.document
|
|
}
|
|
|
|
fn size(&self) -> PixelSize {
|
|
SIZE
|
|
}
|
|
|
|
fn has_selection(&self) -> bool {
|
|
self.selection.is_some()
|
|
}
|
|
|
|
fn inside_selection(&self, at: Point) -> bool {
|
|
self.selection.is_some_and(|rect| rect.contains(at))
|
|
}
|
|
}
|
|
|
|
/// What the tests read from every tool.
|
|
trait Reports {
|
|
fn events(&mut self) -> Vec<SelectEvent>;
|
|
fn phase(&self) -> SelectPhase;
|
|
fn reset(&mut self);
|
|
}
|
|
|
|
macro_rules! reports {
|
|
($tool:ty $(, $param:ident: $bound:path)?) => {
|
|
impl$(<$param: $bound>)? Reports for $tool {
|
|
fn events(&mut self) -> Vec<SelectEvent> {
|
|
self.take_events()
|
|
}
|
|
|
|
fn phase(&self) -> SelectPhase {
|
|
self.phase()
|
|
}
|
|
|
|
fn reset(&mut self) {
|
|
self.reset();
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
reports!(MarqueeTool);
|
|
reports!(PolygonLassoTool);
|
|
reports!(MagneticLassoTool<T>, T: EdgeTracer);
|
|
|
|
/// A tool with its probe, owning both so a fixture can hold them: every call builds the pass the app builds.
|
|
struct Owned<T> {
|
|
tool: RefCell<T>,
|
|
probe: Fake,
|
|
}
|
|
|
|
impl<T: Reports> Owned<T> {
|
|
fn new(tool: T, probe: Fake) -> Self {
|
|
Owned { tool: RefCell::new(tool), probe }
|
|
}
|
|
|
|
fn tool(&mut self) -> &mut T {
|
|
self.tool.get_mut()
|
|
}
|
|
|
|
fn events(&mut self) -> Vec<SelectEvent> {
|
|
self.tool().events()
|
|
}
|
|
|
|
fn phase(&self) -> SelectPhase {
|
|
self.tool.borrow().phase()
|
|
}
|
|
}
|
|
|
|
impl<T: Reports + 'static> CanvasTool for Owned<T>
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
fn each_pass(&mut self, cx: &mut ToolContext<'_>) {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).each_pass(cx);
|
|
}
|
|
|
|
fn press(&mut self, pointer: &ToolPointer, cx: &mut ToolContext<'_>) -> craft_ui::canvas::ToolAction {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).press(pointer, cx)
|
|
}
|
|
|
|
fn drag(&mut self, pointer: &ToolPointer, cx: &mut ToolContext<'_>) {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).drag(pointer, cx);
|
|
}
|
|
|
|
fn release(&mut self, pointer: &ToolPointer, cx: &mut ToolContext<'_>) {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).release(pointer, cx);
|
|
}
|
|
|
|
fn hover(&mut self, pointer: &ToolPointer, cx: &mut ToolContext<'_>) {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).hover(pointer, cx);
|
|
}
|
|
|
|
fn cancel(&mut self, reason: CancelReason, cx: &mut ToolContext<'_>) {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).cancel(reason, cx);
|
|
}
|
|
|
|
fn key(&mut self, key: &ToolKey, cx: &mut ToolContext<'_>) -> bool {
|
|
SelectToolPass::new(self.tool.get_mut(), &self.probe).key(key, cx)
|
|
}
|
|
|
|
fn paint(&self, draw: &Draw<'_>, cx: &ToolContext<'_>) {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).paint(draw, cx);
|
|
}
|
|
|
|
fn cursor(&self, cx: &ToolContext<'_>) -> craft_behavior::Cursor {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).cursor(cx)
|
|
}
|
|
|
|
fn takes(&self, button: PointerButton, mods: Mods) -> bool {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).takes(button, mods)
|
|
}
|
|
|
|
fn claims(&self) -> craft_ui::canvas::ToolClaims {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).claims()
|
|
}
|
|
|
|
fn access(&self, cx: &ToolContext<'_>) -> Option<ToolAccess> {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).access(cx)
|
|
}
|
|
|
|
fn command_form(&self) -> ToolPath {
|
|
SelectToolPass::new(&mut *self.tool.borrow_mut(), &self.probe).command_form()
|
|
}
|
|
}
|
|
|
|
type Rig<T> = ToolFixture<Owned<T>>;
|
|
|
|
/// A canvas whose document point and screen point coincide.
|
|
fn rig<T: Reports + 'static>(label: &'static str, tool: T, probe: Fake) -> Rig<T>
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
let view = |room: ScreenRect| {
|
|
let centre = room.center();
|
|
craft_behavior::CanvasView::new(room, Point::new(f64::from(centre.x), f64::from(centre.y)), 1.0)
|
|
};
|
|
ToolFixture::with_view(label, Owned::new(tool, probe), view, |_, _| {})
|
|
}
|
|
|
|
fn at(point: (f64, f64)) -> Pos2 {
|
|
pos2(point.0 as f32, point.1 as f32)
|
|
}
|
|
|
|
fn inject<T: Reports + 'static>(rig: &mut Rig<T>, input: ToolInput)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
let (ctx, id) = (rig.fixture().ctx().clone(), rig.canvas_id());
|
|
ToolHost::inject(&ctx, id, input);
|
|
rig.fixture().frame(Vec::new());
|
|
}
|
|
|
|
fn down<T: Reports + 'static>(rig: &mut Rig<T>, point: (f64, f64), mods: Mods)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
inject(rig, ToolInput::down(PointerButton::Primary, at(point)).mods(mods));
|
|
}
|
|
|
|
fn drag_to<T: Reports + 'static>(rig: &mut Rig<T>, point: (f64, f64), mods: Mods)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
inject(rig, ToolInput::moved(at(point)).mods(mods));
|
|
}
|
|
|
|
fn up<T: Reports + 'static>(rig: &mut Rig<T>, point: (f64, f64), mods: Mods)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
inject(rig, ToolInput::up(at(point)).mods(mods));
|
|
}
|
|
|
|
fn click<T: Reports + 'static>(rig: &mut Rig<T>, point: (f64, f64), mods: Mods)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
down(rig, point, mods);
|
|
up(rig, point, mods);
|
|
}
|
|
|
|
/// A press, a drag and a release; the events.
|
|
fn stroke(rig: &mut Rig<MarqueeTool>, from: (f64, f64), to: (f64, f64), at_press: Mods, later: Mods) -> Vec<SelectEvent> {
|
|
down(rig, from, at_press);
|
|
drag_to(rig, to, later);
|
|
up(rig, to, later);
|
|
rig.tool_mut().events()
|
|
}
|
|
|
|
/// Holds `mods` from now on; one pass shows them to the tool.
|
|
fn hold<T: Reports + 'static>(rig: &mut Rig<T>, mods: Modifiers)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
rig.fixture().hold(mods).frame(Vec::new());
|
|
}
|
|
|
|
/// Gives the canvas the keyboard with a click that the tool then forgets.
|
|
fn focus<T: Reports + 'static>(rig: &mut Rig<T>)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
let corner = rig.canvas().rect.left_top() + egui::vec2(2.0, 2.0);
|
|
rig.press_at(corner).release_at(corner);
|
|
let mut tool = rig.tool_mut();
|
|
tool.tool().reset();
|
|
tool.events();
|
|
drop(tool);
|
|
// One pass drops the node the click's outline left in the tree.
|
|
rig.fixture().frame(Vec::new());
|
|
}
|
|
|
|
fn press_key<T: Reports + 'static>(rig: &mut Rig<T>, key: Key, mods: Modifiers)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
rig.fixture().key(key, mods);
|
|
}
|
|
|
|
fn commit(rect: (f64, f64, f64, f64), operation: SelectionOperation) -> SelectEvent {
|
|
SelectEvent::commit(SelectionShape::Rectangle(Rect::new(rect.0, rect.1, rect.2, rect.3)), operation)
|
|
}
|
|
|
|
/// "begin", "update 1,0", "commit 2,0", "cancel"; other events as `Debug`.
|
|
fn tags(events: &[SelectEvent]) -> Vec<String> {
|
|
events
|
|
.iter()
|
|
.map(|event| match event {
|
|
SelectEvent::DragSelection(EditEvent::Begin { .. }) => "begin".to_owned(),
|
|
SelectEvent::DragSelection(EditEvent::Update { value, .. }) => format!("update {},{}", value.delta[0], value.delta[1]),
|
|
SelectEvent::DragSelection(EditEvent::Commit { after, .. }) => format!("commit {},{}", after.delta[0], after.delta[1]),
|
|
SelectEvent::DragSelection(EditEvent::Cancel { .. }) => "cancel".to_owned(),
|
|
other => format!("{other:?}"),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
/// Cancels the gesture the tool holds, as the app does on a tool switch.
|
|
fn cancel_with<T: Reports + 'static>(rig: &mut Rig<T>, reason: CancelReason)
|
|
where
|
|
for<'a> SelectToolPass<'a, T>: CanvasTool,
|
|
{
|
|
let (ctx, id) = (rig.fixture().ctx().clone(), rig.canvas_id());
|
|
let _ = ToolHost::cancel(&ctx, id, &mut *rig.tool_mut(), reason);
|
|
rig.fixture().frame(Vec::new());
|
|
}
|
|
|
|
// ---- the shared tool row ----
|
|
|
|
// ---- the marquees ----
|
|
|
|
// Normal style: Shift pressed after the press squares, Alt pressed after it centres, Shift held at the press does not
|
|
// (it is Add); Fixed Ratio and Fixed Size give whole-pixel rectangles.
|
|
#[trial]
|
|
fn marquee_corners_follow_constraint_and_modifiers() {
|
|
let mut rig = rig("Marquee", MarqueeTool::new(MarqueeKind::Rectangle), Fake::empty());
|
|
let events = stroke(&mut rig, (10.5, 10.5), (50.5, 30.5), NONE, NONE);
|
|
assert_eq!(events, [commit((10.0, 10.0, 51.0, 31.0), SelectionOperation::New)]);
|
|
|
|
let events = stroke(&mut rig, (10.5, 10.5), (50.5, 30.5), NONE, Mods::SHIFT);
|
|
assert_eq!(events, [commit((10.0, 10.0, 51.0, 51.0), SelectionOperation::New)], "Shift after the press squares");
|
|
|
|
let events = stroke(&mut rig, (10.5, 10.5), (50.5, 30.5), Mods::SHIFT, Mods::SHIFT);
|
|
assert_eq!(events, [commit((10.0, 10.0, 51.0, 31.0), SelectionOperation::Add)], "Shift at the press is Add, not square");
|
|
|
|
let events = stroke(&mut rig, (100.0, 100.0), (110.0, 120.0), NONE, Mods::ALT);
|
|
assert_eq!(events, [commit((90.0, 80.0, 110.0, 120.0), SelectionOperation::New)], "Alt after the press centres");
|
|
|
|
rig.tool_mut().tool().constraint(Constraint::Ratio(2.0, 1.0));
|
|
let events = stroke(&mut rig, (10.0, 10.0), (50.0, 12.0), NONE, NONE);
|
|
assert_eq!(events, [commit((10.0, 10.0, 50.0, 30.0), SelectionOperation::New)]);
|
|
|
|
rig.tool_mut().tool().constraint(Constraint::Size(10.0, 10.0));
|
|
let events = stroke(&mut rig, (20.0, 20.0), (40.4, 60.4), NONE, NONE);
|
|
assert_eq!(events, [commit((40.0, 60.0, 50.0, 70.0), SelectionOperation::New)], "the box follows the pointer");
|
|
}
|
|
|
|
// Cmd inside the selection drags pixels, Cmd+Alt a copy; Cmd outside it is the Move tool's, so the host starts no
|
|
// gesture.
|
|
|
|
// A selection drag reports Begin, whole-pixel Updates (only when the rounded delta changes) and Commit; a cancel reports
|
|
// Cancel and nothing else; a release without travel commits a zero delta.
|
|
#[trial]
|
|
fn marquee_selection_drag_reports_whole_pixel_deltas_and_cancel() {
|
|
let mut rig = rig("Marquee", MarqueeTool::new(MarqueeKind::Rectangle), Fake::selected(Rect::new(100.0, 100.0, 200.0, 200.0)));
|
|
down(&mut rig, (150.0, 150.0), NONE);
|
|
drag_to(&mut rig, (150.2, 150.2), NONE);
|
|
drag_to(&mut rig, (150.6, 150.0), NONE);
|
|
drag_to(&mut rig, (150.7, 150.0), NONE);
|
|
up(&mut rig, (152.0, 150.0), NONE);
|
|
assert_eq!(tags(&rig.tool_mut().events()), ["begin", "update 1,0", "commit 2,0"]);
|
|
|
|
click(&mut rig, (150.0, 150.0), NONE);
|
|
assert_eq!(tags(&rig.tool_mut().events()), ["begin", "commit 0,0"]);
|
|
|
|
down(&mut rig, (150.0, 150.0), NONE);
|
|
drag_to(&mut rig, (170.0, 150.0), NONE);
|
|
cancel_with(&mut rig, CancelReason::Removed);
|
|
let events = rig.tool_mut().events();
|
|
assert_eq!(tags(&events), ["begin", "update 20,0", "cancel"]);
|
|
assert!(matches!(events.last(), Some(SelectEvent::DragSelection(EditEvent::Cancel { reason: CancelReason::Removed, .. }))), "{events:?}");
|
|
assert_eq!(rig.tool().phase(), SelectPhase::Idle);
|
|
}
|
|
|
|
// ---- the Lasso ----
|
|
|
|
// A plain press inside the selection drags the outline instead of drawing.
|
|
|
|
// A press and release that draw fewer than 3 points (a click, or a two-point drag) deselect.
|
|
|
|
// ---- the Polygonal Lasso ----
|
|
|
|
// Shift turns a segment to 45 degree steps from the last vertex, not for the first vertex and not with Alt.
|
|
#[trial]
|
|
fn polygon_shift_constrains_to_45_degrees() {
|
|
let mut rig = rig("Polygonal Lasso", PolygonLassoTool::new(), Fake::empty());
|
|
focus(&mut rig);
|
|
hold(&mut rig, Modifiers::SHIFT);
|
|
click(&mut rig, (50.0, 50.0), Mods::SHIFT);
|
|
// 11 degrees from the last vertex rounds to 0, keeping the distance.
|
|
click(&mut rig, (150.0, 70.0), Mods::SHIFT);
|
|
hold(&mut rig, Modifiers::SHIFT | Modifiers::ALT);
|
|
click(&mut rig, (140.0, 170.0), Mods { shift: true, alt: true, ..NONE });
|
|
hold(&mut rig, Modifiers::NONE);
|
|
press_key(&mut rig, Key::Enter, Modifiers::NONE);
|
|
let events = rig.tool_mut().events();
|
|
let [SelectEvent::Commit { shape: SelectionShape::Polygon(points), operation, .. }] = events.as_slice() else { panic!("one commit: {events:?}") };
|
|
assert_eq!(*operation, SelectionOperation::Add);
|
|
let turned = Point::new(50.0 + 100.0_f64.hypot(20.0), 50.0);
|
|
assert_eq!(points.len(), 3);
|
|
assert_eq!(points[0], Point::new(50.0, 50.0), "the first vertex is never turned");
|
|
assert!((points[1] - turned).hypot() < 1e-9, "{:?}", points[1]);
|
|
assert_eq!(points[2], Point::new(140.0, 170.0), "Shift with Alt keeps the point");
|
|
}
|
|
|
|
// A new outline replaces the selection while it is open: true only for the operation New.
|
|
|
|
// ---- the Magnetic Lasso ----
|
|
|
|
const CENTRE: Point = Point::new(200.0, 150.0);
|
|
const RADIUS: f64 = 80.0;
|
|
|
|
/// What the fake tracer was asked.
|
|
#[derive(Debug, Default)]
|
|
struct Log {
|
|
snaps: Cell<usize>,
|
|
/// The `from` of every `trace`: the fastening points, with repeats.
|
|
froms: RefCell<Vec<Point>>,
|
|
searches: RefCell<Vec<EdgeSearch>>,
|
|
}
|
|
|
|
impl Log {
|
|
/// The distinct points traces started from.
|
|
fn starts(&self) -> usize {
|
|
let mut seen: Vec<Point> = Vec::new();
|
|
for &p in self.froms.borrow().iter() {
|
|
if !seen.iter().any(|q| q.distance(p) < 1e-6) {
|
|
seen.push(p);
|
|
}
|
|
}
|
|
seen.len()
|
|
}
|
|
|
|
fn clear(&self) {
|
|
self.snaps.set(0);
|
|
self.froms.borrow_mut().clear();
|
|
self.searches.borrow_mut().clear();
|
|
}
|
|
}
|
|
|
|
/// Edges lie on a circle of radius 80 round (200, 150): `snap` finds the nearest circle point within the width, `trace`
|
|
/// walks the shorter arc.
|
|
#[derive(Clone, Debug)]
|
|
struct Circle {
|
|
log: Rc<Log>,
|
|
}
|
|
|
|
fn on_circle(p: Point) -> bool {
|
|
((p - CENTRE).hypot() - RADIUS).abs() < 0.5
|
|
}
|
|
|
|
impl EdgeTracer for Circle {
|
|
fn snap(&mut self, at: Point, search: EdgeSearch) -> Option<Point> {
|
|
self.log.snaps.set(self.log.snaps.get() + 1);
|
|
self.log.searches.borrow_mut().push(search);
|
|
let d = at - CENTRE;
|
|
let len = d.hypot();
|
|
((len - RADIUS).abs() <= search.width && len > 0.0).then(|| CENTRE + d * (RADIUS / len))
|
|
}
|
|
|
|
fn trace(&mut self, from: Point, to: Point, _guide: &[Point], search: EdgeSearch) -> Vec<Point> {
|
|
self.log.froms.borrow_mut().push(from);
|
|
self.log.searches.borrow_mut().push(search);
|
|
if !on_circle(from) || !on_circle(to) {
|
|
return vec![from, to];
|
|
}
|
|
let angle = |p: Point| (p.y - CENTRE.y).atan2(p.x - CENTRE.x);
|
|
let mut delta = angle(to) - angle(from);
|
|
if delta > std::f64::consts::PI {
|
|
delta -= std::f64::consts::TAU;
|
|
} else if delta < -std::f64::consts::PI {
|
|
delta += std::f64::consts::TAU;
|
|
}
|
|
let n = ((delta.abs() * RADIUS / 2.0).ceil() as usize).max(1);
|
|
let mut points: Vec<Point> = (1..n).map(|k| CENTRE + circle_offset(angle(from) + delta * k as f64 / n as f64)).collect();
|
|
points.insert(0, from);
|
|
points.push(to);
|
|
points
|
|
}
|
|
}
|
|
|
|
fn circle_offset(angle: f64) -> Vec2 {
|
|
Vec2::new(angle.cos(), angle.sin()) * RADIUS
|
|
}
|
|
|
|
fn on(angle: f64) -> Point {
|
|
CENTRE + circle_offset(angle)
|
|
}
|
|
|
|
fn magnetic() -> (Rig<MagneticLassoTool<Circle>>, Rc<Log>) {
|
|
let log = Rc::new(Log::default());
|
|
let mut rig = rig("Magnetic Lasso", MagneticLassoTool::new(Circle { log: Rc::clone(&log) }), Fake::empty());
|
|
focus(&mut rig);
|
|
log.clear();
|
|
(rig, log)
|
|
}
|
|
|
|
fn pt(point: Point) -> (f64, f64) {
|
|
(point.x, point.y)
|
|
}
|
|
|
|
/// A hover to `point`.
|
|
fn glide(rig: &mut Rig<MagneticLassoTool<Circle>>, point: Point, mods: Mods) {
|
|
// The real pointer goes with the injected one, so the hover each pass reports is this point and not where the pointer was left.
|
|
let (ctx, id) = (rig.fixture().ctx().clone(), rig.canvas_id());
|
|
ToolHost::inject(&ctx, id, ToolInput::moved(at(pt(point))).mods(mods));
|
|
rig.fixture().frame(vec![pointer::moved(at(pt(point)))]);
|
|
}
|
|
|
|
/// The pointer moves along the circle from angle `from` to angle `to` in small samples, as a hand follows an edge.
|
|
fn glide_along(rig: &mut Rig<MagneticLassoTool<Circle>>, from: f64, to: f64) {
|
|
let samples = ((to - from).abs() / 0.05).ceil() as usize;
|
|
for k in 1..=samples {
|
|
glide(rig, on(from + (to - from) * k as f64 / samples as f64), NONE);
|
|
}
|
|
}
|
|
|
|
// Points fasten every `spacing` along the edge at frequencies 0, 57 and 100, and a long jump is walked in at most 256
|
|
// steps of `spacing / 2`.
|
|
#[trial]
|
|
fn magnetic_fastens_every_spacing_and_walks_jumps() {
|
|
let start = on(0.0);
|
|
let fastened = |frequency: f32| {
|
|
let (mut rig, log) = magnetic();
|
|
rig.tool_mut().tool().settings_mut().frequency = frequency;
|
|
click(&mut rig, pt(start), NONE);
|
|
// The pointer follows 2.5 rad (200 px of arc) of the circle.
|
|
glide_along(&mut rig, 0.0, 2.5);
|
|
log.starts()
|
|
};
|
|
let (slow, normal, fast) = (fastened(0.0), fastened(57.0), fastened(100.0));
|
|
assert!(slow < normal && normal < fast, "{slow} {normal} {fast}");
|
|
// 200 px at 47 px: the start and four fastened points.
|
|
assert!((4..=6).contains(&normal), "{normal}");
|
|
let (mut rig, log) = magnetic();
|
|
rig.tool_mut().tool().settings_mut().frequency = 100.0;
|
|
click(&mut rig, pt(start), NONE);
|
|
glide(&mut rig, Point::new(5000.0, 150.0), NONE);
|
|
assert_eq!(log.snaps.get(), 1 + 256, "the start, then 256 steps");
|
|
}
|
|
|
|
// `[` and `]` change the width by 1 within 1..=256 while an outline is open.
|
|
|
|
// With `pressure_width` on, a pen sample at pressure 0.5 halves the searched width (minus one); a mouse sample never
|
|
// narrows it.
|
|
|
|
// While the outline is open the tool is one accessible object with its point count (fastening points and the live trace).
|