Compare commits

..
28 Commits
Author SHA1 Message Date
Tanish MankuandAldo Zarate d1d2e5788a Stack u1: #1555: tests for clicks made while moving in STRETCH, MOVE and TRIM
#1001 names STRETCH and TRIM; #1555's tests cover MOVE, idle picks,
window corners and CPOLYGON. These cases from #1059 check that a click
made while the mouse moves counts where the button went down in
STRETCH (pick and window), MOVE (pick, and a slow drag is a window),
TRIM, with no command running, with PICKDRAG off, at a click-click
window's second corner, and over overlapping objects with selection
cycling. #1059's fast-long-drag case is left out: under the press-first
model a quick release is a click however far the mouse went.

Co-authored-by: Aldo Zarate <azarate@azf.com.mx>
2026-11-19 15:25:16 -07:00
Tanish Mankuandaustin62jake fa4b6d136d Stack u1: #1555: a slow click on a grip makes it hot
#1555 acts on presses where the button goes down, but leaves grips (no
command running) to egui's click. egui calls a press held longer than
0.8 s a drag, and on a drawing that draws slowly an ordinary click lasts
that long, so the grip ignored it (#2813).

A press on a grip is now remembered and clicks the grip when the button
comes up within the press tolerance, however long it was held; a drag
from it still does nothing. #2853's slow-click tests come along: the
grip case fails without this change, the others pin press-first clicks
across slow frames.

Co-authored-by: austin62jake <340374338+austin62jake@users.noreply.github.com>
2026-11-19 15:25:16 -07:00
Tanish Manku 9787da7015 Stack u1: #1748: rustfmt the Right-Click Customization window's mode groups 2026-11-19 15:25:04 -07:00
Tanish Manku 6ff59c0ada Merge #3183: TRIM/EXTEND: Space enters an option at the mode, projection and edge prompts 2026-11-19 15:23:01 -07:00
Tanish Manku d49ea7e586 Stack u1: #1748: Default and Edit modes decide only with the time-sensitive right-click off
With #1748 a quick right-click between commands is Enter whenever the
time-sensitive right-click is on, and a longer click opens the shortcut
menu. Main's Right-Click Customization (#2371) still let Default and Edit
modes set to "Repeat last command" take every idle right-click, so a
longer click repeated the command instead of opening the menu.

As in AutoCAD, the modes now apply with the time-sensitive right-click
off, and the window greys them out with it on, as it does Command mode.
The Right-Click Customization tests set the option off where they test
the modes; a new test holds the button with both modes on repeat.
2026-11-19 15:22:58 -07:00
Tanish Manku 9a4347a08d Merge #1748: a quick right-click is Enter between commands too
# Conflicts:
#	contributors/people.toml
#	crates/ui-egui/src/canvas.rs
#	crates/ui-egui/src/context_menu.rs
#	crates/ui-egui/src/options.rs
#	docs/ui-parity.md
2026-11-19 15:21:49 -07:00
Tanish Manku 48a18c882b Merge #2070: show pickbox-only cursor at command object-selection prompts
# Conflicts:
#	crates/ui-egui/src/canvas.rs
2026-11-19 15:19:55 -07:00
Tanish Manku 1341b42127 Merge #1555: Canvas: clicks count when the button goes down, even while the mouse moves
# Conflicts:
#	crates/ui-egui/tests/it/main.rs
2026-11-19 15:19:39 -07:00
The old Dutch Guy 79784a62fe Merge branch 'main' into feat/pickbox-only-cursor 2026-11-18 18:03:45 +01:00
The old Dutch Guy 38888cd5d9 Merge branch 'main' into feat/pickbox-only-cursor 2026-11-18 11:28:53 +01:00
The old Dutch Guy 97e5c7ff37 Merge branch 'main' into feat/pickbox-only-cursor 2026-11-16 17:28:53 +01:00
The old Dutch Guy 54015120db fix(tests): restore missing closing brace in canvas tests 2026-11-16 17:17:10 +01:00
The old Dutch Guy 60b0f21edb feat(ui): show pickbox-only cursor at object selection prompts 2026-11-16 17:17:10 +01:00
filforce95andClaude Opus 5.5 60c4f0d439 docs: leave ui-parity.md to the maintainers
PRs no longer edit the progress docs (CLAUDE.md, Roadmap); the affected row is
named in the PR description instead.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 17:01:57 +01:00
filforce95andClaude Opus 5.5 a762140d4e Merge origin/main into feat/press-first-clicks-1001
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 11:06:47 +01:00
filforce95andClaude Opus 5.5 e7c3cf9223 Merge origin/main into feat/press-first-clicks-1001
main split canvas.rs into canvas/ modules and show() into helpers (#2187),
moved to egui 0.37 (#2119) and tightened Clippy (#2239). The press detector is
carried over to that structure: handle_presses replaces collect_prompt_clicks
(#835's release replay) and the egui drag-window block; selection cycling
(#1149) and PICKDRAG 0 (#1032) behave as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-29 22:08:52 +01:00
Sladrian PedrosoandClaude Opus 5.5 f8423bb44f Merge main into right-click-enter-between-commands
canvas.rs: main moved most of the canvas into canvas/ and documented
show(); the right-click change stays where it was, in show().
time_sensitive_right_click paints a frame after Escape before the next
quick click: with egui 0.37 the shortcut menu closes on the frame after.
people.toml and docs/ui-parity.md: both sides kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-28 11:14:58 -03:00
filforce95 0703ae91b4 Merge remote-tracking branch 'origin/main' into feat/press-first-clicks-1001
# Conflicts:
#	docs/ui-parity.md
2026-10-24 09:24:06 +02:00
filforce95andClaude Opus 5.5 d75e2a0ae0 test: press_first_clicks joins the ui-egui test binary (#1989)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 19:50:50 +02:00
filforce95 0c7b7ec469 Merge remote-tracking branch 'origin/main' into feat/press-first-clicks-1001 2026-10-23 19:45:42 +02:00
filforce95andClaude Opus 5.5 b5f6df8fec test(pickdrag): the second corner is set where the button goes down
With clicks counting on press (#1001), a press after the first corner
closes the window there even with PICKDRAG 0; letting go elsewhere after
a drag changes nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 18:31:43 +02:00
filforce95andClaude Opus 5.5 5fa1352d82 Merge main into feat/press-first-clicks-1001
Resolve the canvas conflicts with selection cycling (#1149) and the
two-click preference (#1032): cycling opens and picks on the press, and
with PICKDRAG off a drag no longer closes the window its press opened.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-23 18:23:59 +02:00
Sladrian PedrosoandClaude Opus 5.5 25714cac28 docs/ui-parity.md: with the time-sensitive right-click off, a right-click opens the command menu while a command runs
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 17:11:05 -03:00
Sladrian PedrosoandClaude Opus 5.5 8709920931 Document canvas::show, the drawing area for one frame
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 16:58:04 -03:00
Sladrian PedrosoandClaude Opus 5.5 77b9560729 contributors: add my real name for the About window credits
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 14:58:38 -03:00
Sladrian PedrosoandClaude Opus 5.5 80bbcb98ba A quick right-click is Enter between commands too: it runs the typed command or repeats the last one (fixes #1387)
With the time-sensitive right-click on (the default), a quick right-click
was Enter only while a command ran, and it sent a bare Enter even when
something was typed. Between commands every right-click opened the shortcut
menu, so typing `rec` and right-clicking opened the menu instead of starting
RECTANG, and at an empty prompt it didn't repeat the last command as AutoCAD
does.

A quick right-click now does what the Enter key does (cmdline::submit): it
enters what was typed (a command name, `@10,0`), ends the input of a running
command, and between commands repeats the last one. Held, it still opens the
command menu or the shortcut menu; a grip with options keeps its menu;
Shift/Ctrl+right-click is still the object snap menu; with the time-sensitive
right-click turned off, every right-click opens the menu. With nothing typed
and no command run yet, a quick click opens the shortcut menu (there is
nothing to enter).

time_sensitive_right_click now also checks that a quick click between
commands repeats LINE, a held one opens the menu with Repeat LINE and repeats
nothing, a typed `circle` starts CIRCLE and a typed `5,5` enters its centre;
these checks fail without the change. docs/ui-parity.md describes the new
behaviour.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 14:58:37 -03:00
filforce95andClaude Opus 5.5 023b833fd4 docs(ui-parity): a press on an object picks it; a drag from it opens no window (#1001)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 12:08:56 +02:00
filforce95andClaude Opus 5.5 06e53f3ee7 fix(canvas): clicks count when the button goes down, even while the mouse moves (fixes #1001, #1546)
Every click on the drawing used to be decided when the button came up: egui
calls a press that travels more than a few points a drag, so a click made
while the hand was still moving was lost (object picks, the second corner of a
click-click window) or taken where the hand had got to (points, #835).

Following the model agreed in #1001, a press now acts at once, where the button
went down: it places the point (snapped as the cursor would be there), picks
the object or sets a selection window's corner. Each press among a frame's
events counts, so a slow frame keeps all its clicks (#815). What the pointer
does while the button is held only decides whether the press becomes a drag:
once it leaves a 6-point tolerance a 0.25 s timer starts; a button still down
then is a drag and closes the window its press opened where it comes up, while
a button that comes up sooner was a click and the window waits for the next
press. Holding still never makes a drag.

The detector lives in canvas/press.rs. Grips with no command running, ZOOM
Realtime, the Dynamic Input options menu, model tiles and double-clicks keep
their release-based clicks.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 11:55:23 +02:00
35 changed files with 1230 additions and 2289 deletions
+5
View File
@@ -128,3 +128,8 @@ sync_github_name = true
[people.tyrel]
real_name = "Tyrel Haveman"
[people.Sladrian]
real_name = "Sladrian Pedroso"
display_name = "Sladrian Pedroso"
sync_github_name = false
+1 -11
View File
@@ -564,17 +564,7 @@ pub fn seg_param(s: &Segment, p: Vec2) -> f64 {
match s {
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
Segment::Arc { arc, ccw } => {
// A point just outside the sweep (on the arc within tolerance of an end) goes to the
// nearer end: a hair before the start is the start, not round the circle to the end.
let a = cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start);
let sweep = arc.sweep().max(1e-15);
let t = if a <= sweep {
a / sweep
} else if a - sweep < TAU - a {
1.0
} else {
0.0
};
let t = (cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15)).clamp(0.0, 1.0);
if *ccw { t } else { 1.0 - t }
}
}
-19
View File
@@ -601,25 +601,6 @@ fn measure_spline_by_its_own_parameter() {
assert!(pts.len() == 3 && [7.0, 4.0, 1.0].iter().all(|x| pts.iter().any(|p| near(*p, *x, 0.0))), "{pts:?}");
}
/// A pick a hair outside an arc's sweep beside its start is at its start, for an arc and for a
/// polyline's arc span alike: MEASURE runs from there (round the circle it was the far end).
#[test]
fn measure_from_a_pick_a_hair_before_an_arcs_start() {
let curves = [
("arc", json!({"center": [0, 0], "radius": 1, "start": 0, "end": 180})),
("pline", json!({"vertices": [{"p": [1, 0], "bulge": 1}, [-1, 0]]})),
];
for (cmd, args) in curves {
let mut s = Session::new();
let e = h(&s.execute(cmd, &args).unwrap());
s.execute("measure", &json!({"handle": e, "length": 1, "from": [1, -1e-13]})).unwrap();
let pts: Vec<Vec2> =
s.doc().unwrap().model.iter().filter_map(|e| if let EntityKind::Point(p) = &e.kind { Some(p.p.xy()) } else { None }).collect();
// From (1, 0), a point every radian.
assert!(pts.len() == 3 && [1.0f64, 2.0, 3.0].iter().all(|a| pts.iter().any(|p| near(*p, a.cos(), a.sin()))), "{cmd}: {pts:?}");
}
}
/// MEASURE counts every vertex in a polyline's parameter, coincident ones too (AutoCAD's polyline
/// parameter is the vertex index; the chain drops zero-length spans), and picks an ellipse's end
/// by the ellipse parameter like any other curve: AutoCAD 2024 runs both measured cases below from
+7 -20
View File
@@ -26,7 +26,7 @@ mod stretch;
mod transform;
mod trim;
use break_join::{BreakAtPointM, BreakM, run_break, run_breakat, run_join};
use break_join::{BreakM, run_break, run_breakat, run_join};
use explode::run_explode;
pub(crate) use explode::{explode_kind, explode_with};
use fillet::{FilletM, run_chamfer, run_fillet};
@@ -37,7 +37,7 @@ use select_then::{DisplaceM, Op, SelectThen};
use stretch::{StretchM, run_stretch};
pub(crate) use transform::{holds_ole_frame, ole_refusal, refuse_ole_frames, transform_entities};
use transform::{run_copy, run_erase, run_mirror, run_move, run_rotate, run_scale};
pub(crate) use trim::{CUT_ONCE, Edges, extend, json_pick_error, trim};
pub(crate) use trim::{Edges, extend, trim};
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -85,24 +85,14 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("trim", "Trim", trimextend::run_trim)
.menu(&["Modify", "Trim"])
.alias(&["tr"])
.params(concat!(
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; edges?: [hex] (default: every object; a polyline that is one of them, or every object in Standard mode, also cuts itself at its vertices and crossings), edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\" ",
"→ {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing). ",
"For handle+pick: handle is the object to trim; pick selects the portion of that object to remove ",
"(normally a point on it, away from a cutting intersection); edges are the cutting edges. The JSON default is standard mode."
))
.params(
"{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\", mode?: \"quick\"|\"standard\"} → {handles: the object (kept, reshaped) then the new pieces; none when it was erased} (pick) | {trimmed} (fence, crossing)",
)
.interactive(|_| Ok(Box::new(TrimM::new(false)))),
CommandSpec::new("extend", "Extend", trimextend::run_extend)
.menu(&["Modify", "Extend"])
.alias(&["ex"])
.params(concat!(
"{handle, pick: [x,y]} | {fence: [[x,y],...]} | {crossing: [[x,y],[x,y]]}; ",
"edges?: [hex], edgeMode?: \"extend\"|\"none\". ",
"For handle+pick: handle is the object to extend; pick points toward the boundary to extend to ",
"(normally a point on that boundary), selecting the nearer end of the object ",
"(of an open polyline, the end on the pick's side of its middle parameter); ",
"edges are the boundary edges, and the nearest forward intersection is used."
))
.params("{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\"}")
.interactive(|_| Ok(Box::new(TrimM::new(true)))),
CommandSpec::new("fillet", "Fillet", run_fillet)
.menu(&["Modify", "Fillet"])
@@ -124,10 +114,7 @@ pub fn specs() -> Vec<CommandSpec> {
.alias(&["br"])
.params("{handle, p1, p2} → {handles: the object (kept, reshaped) then the new pieces; none when nothing is left}")
.interactive(|_| Ok(Box::new(BreakM::default()))),
CommandSpec::new("breakatpoint", "Break At Point", run_breakat)
.menu(&["Modify", "Break At Point"])
.params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}")
.interactive(|_| Ok(Box::new(BreakAtPointM::default()))),
CommandSpec::new("breakatpoint", "Break At Point", run_breakat).menu(&["Modify", "Break At Point"]).params("{handle, at} → {handles: the object (kept, reshaped) then the new piece}"),
CommandSpec::new("join", "Join", run_join)
.menu(&["Modify", "Join"])
.alias(&["j"])
+34 -95
View File
@@ -4,6 +4,16 @@ use super::{
Value, Vec2, arc, bad, json, lwpoly, norm_angle, point_param, point_req, targets,
};
/// Gives a rebuilt arc piece its source centre Z, or a rebuilt polyline piece its source elevation.
fn with_z(mut k: EntityKind, z: f64) -> EntityKind {
match &mut k {
EntityKind::Arc(a) => a.center.z = z,
EntityKind::LwPolyline(p) => p.elevation = z,
_ => {}
}
k
}
/// Break `h` between two points (or at one point when p1 == p2).
pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Vec<Handle>> {
if crate::cmd::curves::is_locked(s, h) {
@@ -29,12 +39,12 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
}
EntityKind::Circle(c) => {
if p1.near(p2, 1e-12) {
return Err(EngineError::Other("Arc cannot be full 360 degrees".into()));
return Err(EngineError::Other("Arc cannot be full 360 degrees.".into()));
}
let a1 = c.center.xy().angle_to(p1);
let a2 = c.center.xy().angle_to(p2);
// AutoCAD removes the CCW portion from the first to the second point.
vec![arc(&Arc::new(c.center.xy(), c.radius, a2, a1))]
vec![with_z(arc(&Arc::new(c.center.xy(), c.radius, a2, a1)), c.center.z)]
}
EntityKind::Arc(a) => {
let ga = Arc::new(a.center.xy(), a.radius, a.start, a.end);
@@ -45,10 +55,10 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
}
let mut v = Vec::new();
if t1 > 1e-12 {
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)));
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)), a.center.z));
}
if t2 < ga.sweep() - 1e-12 {
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)));
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)), a.center.z));
}
v
}
@@ -71,32 +81,24 @@ pub(crate) fn break_entity(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Re
};
let (mut t1, mut t2) = (lp(p1), lp(p2));
if p.closed {
let (lo, hi) = if t1 <= t2 { (t1, t2) } else { (t2, t1) };
let tol = 1e-9 * (1.0 + total);
if hi - lo < tol {
// One point: the outline opens at its start vertex and splits at the point;
// at the start vertex itself it stays whole and closed.
if lo < tol || lo > total - tol {
return Ok(vec![h]);
}
vec![lwpoly(sub_polyline(&segs, 0.0, lo), false), lwpoly(sub_polyline(&segs, lo, total), false)]
} else {
// The stretch between the points that doesn't run through the start vertex
// goes, whichever point came first; what is left runs from the later point
// round through the start vertex to the earlier one.
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
vec![lwpoly(sub_polyline(&doubled, hi, lo + total), false)]
if (t1 - t2).abs() < 1e-9 {
return Err(EngineError::Other("Cannot break a closed polyline at a single point.".into()));
}
// Like a circle: the stretch from the first point to the second, along the
// vertices, goes; what is left runs from the second point round to the first.
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
let end = if t1 > t2 { t1 } else { t1 + total };
vec![with_z(lwpoly(sub_polyline(&doubled, t2, end), false), p.elevation)]
} else {
if t1 > t2 {
std::mem::swap(&mut t1, &mut t2);
}
let mut v = Vec::new();
if t1 > 1e-12 {
v.push(lwpoly(sub_polyline(&segs, 0.0, t1), false));
v.push(with_z(lwpoly(sub_polyline(&segs, 0.0, t1), false), p.elevation));
}
if t2 < total - 1e-12 {
v.push(lwpoly(sub_polyline(&segs, t2, total), false));
v.push(with_z(lwpoly(sub_polyline(&segs, t2, total), false), p.elevation));
}
v
}
@@ -213,41 +215,6 @@ pub(super) fn run_join(s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({ "handle": r.map(|h| h.hex()) }))
}
/// The object picked at `p` for BREAK and BREAKATPOINT ("*Invalid selection*" when there is none).
/// One on a locked layer is refused there, and the command asks for an object again, as AutoCAD
/// 2024 does; the pick doesn't fall through to an object under it.
fn pick_to_break(s: &mut Session, p: Vec2) -> Result<Option<Handle>> {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
match s.pick_object(&space, p, ap)? {
Some(h) if crate::cmd::curves::is_locked(s, h) => {
s.echo("The object is on a locked layer.");
Ok(None)
}
Some(h) => {
s.set_selection(vec![h]);
Ok(Some(h))
}
None => {
s.echo("*Invalid selection*");
Ok(None)
}
}
}
/// Break `h` from `p1` to `p2` and end the command. As in AutoCAD 2024, a break that can't be made
/// (a whole circle at one point: "Arc cannot be full 360 degrees") is reported and ends the
/// command too, leaving the object as it was.
fn break_and_end(s: &mut Session, h: Handle, p1: Vec2, p2: Vec2) -> Result<Step> {
match break_entity(s, h, p1, p2) {
Ok(_) => {}
Err(EngineError::Other(m)) => s.echo(m),
Err(e) => return Err(e),
}
s.set_selection(Vec::new());
Ok(Step::Done)
}
#[derive(Default)]
pub(super) struct BreakM {
obj: Option<(Handle, Vec2)>,
@@ -269,8 +236,14 @@ impl Interactive for BreakM {
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.obj, i) {
(None, Input::Point(p)) => {
if let Some(h) = pick_to_break(s, p)? {
self.obj = Some((h, p));
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
match s.pick_object(&space, p, ap)? {
Some(h) => {
self.obj = Some((h, p));
s.set_selection(vec![h]);
}
None => s.echo("*Invalid selection*"),
}
Ok(Step::Continue)
}
@@ -283,46 +256,12 @@ impl Interactive for BreakM {
self.first_point = false;
Ok(Step::Continue)
}
(Some((h, p1)), Input::Point(p2)) => break_and_end(s, h, p1, p2),
(Some(_), Input::Enter) => {
(Some((h, p1)), Input::Point(p2)) => {
break_entity(s, h, p1, p2)?;
s.set_selection(Vec::new());
Ok(Step::Done)
}
(None, Input::Enter) => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
}
/// BREAKATPOINT at the command line, with AutoCAD 2024's prompts: "Select object:", then "Specify
/// break point:"; the object is split there with no gap (the point projects onto it).
#[derive(Default)]
pub(super) struct BreakAtPointM {
obj: Option<Handle>,
}
impl Interactive for BreakAtPointM {
fn name(&self) -> &'static str {
"BREAKATPOINT"
}
fn prompt(&self, _s: &Session) -> Prompt {
match self.obj {
None => Prompt::new("Select object", Accept::POINT),
Some(_) => Prompt::new("Specify break point", Accept::POINT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.obj, i) {
(None, Input::Point(p)) => {
self.obj = pick_to_break(s, p)?;
Ok(Step::Continue)
}
(Some(h), Input::Point(p)) => break_and_end(s, h, p, p),
(Some(_), Input::Enter) => {
s.set_selection(Vec::new());
Ok(Step::Done)
}
(None, Input::Enter) => Ok(Step::Done),
(_, Input::Enter) => Ok(Step::Done),
_ => Ok(Step::Continue),
}
}
+4 -1
View File
@@ -323,13 +323,16 @@ impl Interactive for StretchM {
s.echo("Select objects to stretch by crossing-window or crossing-polygon...");
Ok(Step::Continue)
}
/// Returns the active interactive prompt for the current `STRETCH` phase.
fn prompt(&self, _s: &Session) -> Prompt {
if let (StretchPhase::Select, Some(m)) = (self.phase, &self.mode) {
return m.prompt();
}
match (self.phase, self.corner) {
(StretchPhase::Select, Some(c)) => Prompt::new("Specify opposite corner", Accept::POINT).corner(c),
(StretchPhase::Select, None) => Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT),
(StretchPhase::Select, None) => {
Prompt { picks_one: self.removing, ..Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT) }
}
(StretchPhase::Base, _) => Prompt::new("Specify base point", Accept::POINT).kw(&["Displacement"]).default("Displacement"),
(StretchPhase::Displacement, _) => Prompt::new("Specify displacement", Accept::POINT).default("0,0"),
(StretchPhase::Second, _) => Prompt::new("Specify second point or <use first point as displacement>", Accept::POINT).base_opt(self.base),
+36 -265
View File
@@ -1,5 +1,3 @@
use cadcraft_geom::Bounds2;
use super::{
Arc, EngineError, Entity, EntityKind, Handle, Line, PolyVertex, Polyline, Prim, Result, Segment, Session, TAU, Vec2, angle_in_sweep, arc,
ccw_sweep, intersect_ext, line, lwpoly, norm_angle,
@@ -93,62 +91,13 @@ fn prim_to_segments(p: &Prim) -> Vec<Segment> {
}
}
/// Explain the generic line failures for JSON handle+pick calls, and a line TRIM picked on its
/// only cuts ([`ON_THE_CUT`]). Other curves retain their own diagnostics: their nearest-parameter
/// rules do not prove that a pick is invalid.
pub(crate) fn json_pick_error(s: &Session, h: Handle, pick: Vec2, edges: Edges, extending: bool, error: EngineError) -> EngineError {
let generic = if extending { "Object does not intersect an edge." } else { "Object does not intersect a cutting edge." };
if !matches!(&error, EngineError::Other(message) if message == generic || (!extending && message == ON_THE_CUT)) {
return error;
}
let Ok(d) = s.doc() else { return error };
let Some(e) = d.entity(h) else { return error };
let EntityKind::Line(l) = &e.kind else { return error };
let Ok(cut) = edge_segments(s, edges, h) else { return error };
let ln = Line::new(l.a.xy(), l.b.xy());
let message = if extending {
// The selected end already failed. Check the opposite end with the same ray and
// forward-intersection rules before attributing the failure to the pick's end choice.
let (fixed, end) = if pick.dist(ln.b) < pick.dist(ln.a) { (ln.b, ln.a) } else { (ln.a, ln.b) };
let dir = (end - fixed).normalized();
let ray = Segment::Line(Line::new(end, end + dir * 1e8));
let opposite_hit = cut.iter().flat_map(|c| intersect_ext(&ray, c, false)).any(|x| (x - end).dot(dir) > 1e-9);
if opposite_hit {
"The `pick` point selects an end with no boundary ahead; choose `pick` toward the boundary to extend to."
} else {
"No usable boundary intersection was found for either end of the object to extend."
}
} else {
let pick_param = ln.param_of(pick).clamp(0.0, 1.0);
let has_cut = cut.iter().flat_map(|c| intersect_ext(&Segment::Line(ln), c, false)).any(|x| {
let t = ln.param_of(x);
t > 1e-9 && t < 1.0 - 1e-9
});
if !has_cut {
"No usable cutting-edge intersection in the interior of the object to trim."
} else if pick_param.is_nan() {
return error;
} else if !ln.at(pick_param).near(pick, 1e-9_f64.max(64.0 * f64::EPSILON * (1.0 + pick.len().max(ln.a.len()).max(ln.b.len())))) {
"The `pick` point is off the line and projects onto a cutting intersection; pick away from that intersection."
} else {
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection."
}
};
EngineError::Other(message.into())
}
/// Trim `h` at the piece containing `pick`. Returns the handles that replace it.
/// Trim `h` at the piece containing `pick`. Returns what it became: its pieces, `h` first
/// ([`replace_with_pieces`]).
pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Result<Vec<Handle>> {
if crate::cmd::curves::is_locked(s, h) {
return Err(EngineError::Other("The object is on a locked layer.".into()));
}
let e = s.doc()?.entity(h).map(|e| (**e).clone()).ok_or_else(|| EngineError::Other("no such object".into()))?;
let cut = edge_segments(s, edges, h)?;
// A polyline that is one of the edges (picked, or with every object in either mode) cuts
// itself too.
let itself = edges.only.is_none_or(|o| o.contains(&h));
let pieces: Vec<EntityKind> = match &e.kind {
EntityKind::Line(l) => {
let ln = Line::new(l.a.xy(), l.b.xy());
@@ -160,12 +109,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
.collect();
ts.sort_by(f64::total_cmp);
let tp = ln.param_of(pick).clamp(0.0, 1.0);
let found = ts.len();
ts.retain(|t| (t - tp).abs() * ln.len() > ON_CUT);
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(1.0, f64::min);
if lo == 0.0 && hi == 1.0 {
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -184,14 +131,11 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
let mut ts: Vec<f64> =
cut.iter().flat_map(|c| intersect_ext(&seg, c, false)).map(param).filter(|t| *t > 1e-9 && *t < sweep - 1e-9).collect();
ts.sort_by(f64::total_cmp);
// A pick off the arc is at the end it is nearer, round the circle.
let tp = crate::cmd::curves::seg_param(&seg, pick) * sweep;
let found = ts.len();
ts.retain(|t| (t - tp).abs() * ga.radius > ON_CUT);
let tp = param(pick).min(sweep);
let lo = ts.iter().copied().filter(|t| *t < tp).fold(0.0, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(sweep, f64::min);
if lo == 0.0 && hi == sweep {
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -207,16 +151,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
let mut angs: Vec<f64> = cut.iter().flat_map(|x| intersect_ext(&full, x, false)).map(|p| c.center.xy().angle_to(p)).collect();
angs.sort_by(f64::total_cmp);
angs.dedup_by(|a, b| (*a - *b).abs() < 1e-9);
let ap = c.center.xy().angle_to(pick);
let found = angs.len();
angs.retain(|a| {
let d = norm_angle(a - ap);
d.min(TAU - d) * c.radius > ON_CUT
});
if angs.len() < 2 {
let why = if found >= 2 { ON_THE_CUT } else { "Circle must intersect cutting edges at two or more points." };
return Err(EngineError::Other(why.into()));
return Err(EngineError::Other("Circle must intersect cutting edges at two or more points.".into()));
}
let ap = c.center.xy().angle_to(pick);
// The removed arc runs between the two intersections around the pick.
let n = angs.len();
let mut keep = None;
@@ -229,10 +167,7 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
}
keep.into_iter().collect()
}
EntityKind::LwPolyline(p) => match trim_polyline(p, &cut, pick, itself)? {
Some(pieces) => pieces,
None => return Ok(vec![h]),
},
EntityKind::LwPolyline(p) => trim_polyline(p, &cut, pick)?,
k => crate::cmd::modify2::trim_other(k, &cut, pick)?,
};
replace_with_pieces(s, h, pieces)
@@ -246,20 +181,19 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
/// in its middle keeps its handle on the piece from its start point, the piece to its end point is
/// new; a circle broken or trimmed becomes an arc with the circle's handle.)
///
/// Each piece keeps what the object had beyond its outline ([`inherit`]). Dimensions attached to
/// the object follow [`crate::assoc::follow_pieces`]. Its parametric constraints are removed: its
/// new shape no longer meets them, and solving them again would move the objects they tie it to.
/// Dimensions attached to the object follow [`crate::assoc::follow_pieces`]. Its parametric
/// constraints are removed: its new shape no longer meets them, and solving them again would move
/// the objects they tie it to.
pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<EntityKind>) -> Result<Vec<Handle>> {
let d = s.doc_mut()?;
if pieces.is_empty() {
let mut pieces = pieces.into_iter();
let Some(first) = pieces.next() else {
d.remove_entity(h);
return Ok(Vec::new());
}
};
let (Some(space), Some(old)) = (d.space_of(h), d.entity(h).cloned()) else {
return Err(EngineError::Other("no such object".into()));
};
let mut pieces = pieces.into_iter().map(|k| inherit(&old.kind, k));
let Some(first) = pieces.next() else { return Ok(Vec::new()) };
d.modify_entity(h, |e| e.kind = first)?;
let mut out = vec![h];
for kind in pieces {
@@ -279,31 +213,6 @@ pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<Entity
Ok(out)
}
/// `piece`, cut from `source`, with what it keeps of it as AutoCAD 2024's BREAK and TRIM leave
/// pieces: a line's Z along it, an arc's (or a circle's) centre Z, and a polyline's elevation,
/// constant width and linetype generation.
fn inherit(source: &EntityKind, mut piece: EntityKind) -> EntityKind {
match (source, &mut piece) {
(EntityKind::Line(s), EntityKind::Line(p)) => {
let ln = Line::new(s.a.xy(), s.b.xy());
if ln.len() > 0.0 {
let z = |t: f64| s.a.z + (s.b.z - s.a.z) * t;
p.a.z = z(ln.param_of(p.a.xy()));
p.b.z = z(ln.param_of(p.b.xy()));
}
}
(EntityKind::Arc(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
(EntityKind::Circle(s), EntityKind::Arc(p)) => p.center.z = s.center.z,
(EntityKind::LwPolyline(s), EntityKind::LwPolyline(p)) => {
p.elevation = s.elevation;
p.const_width = s.const_width;
p.plinegen = s.plinegen;
}
_ => {}
}
piece
}
/// Sub-polyline between length parameters `a` and `b` (open polylines).
pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex> {
let mut out: Vec<PolyVertex> = Vec::new();
@@ -336,128 +245,15 @@ pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex>
out
}
/// Two line segments of a polyline within this sine of parallel run on as one, straight on or
/// doubling back: the vertex between them doesn't cut it, and they don't cut each other. AutoCAD
/// 2024 cuts at a bend of 1e-8 and not at one of 8e-9, whatever the lengths.
const STRAIGHT: f64 = 1e-8;
/// Upper bounds on one trim's search for where a polyline crosses itself (hostile files): the pairs
/// of segments searched (those the piece picked can reach, times those near them) and the
/// crossings found. Past either the trim is refused, rather than made at some of its cuts.
const MAX_SELF_PAIRS: usize = 1 << 24;
const MAX_SELF_CROSSINGS: usize = 1 << 16;
/// How near a cut a pick is on it, along the object. AutoCAD 2024 trims nothing for a pick that
/// near one of a polyline's own cuts, and passes over a cut by another edge, the trim running on
/// across it, on lines, arcs and circles too. On open polylines from 1e-3 to 1e9 long it was within
/// 5e-7, and 5.1e-7 away trimmed at the cut (around a closed rectangle it reached a little further,
/// to 1e-6; on a line, further still, to 5e-4 on one 10 long).
const ON_CUT: f64 = 5e-7;
/// The refusal when every cut was passed over ([`ON_CUT`]): the object meets an edge, at the pick,
/// so Quick mode leaves it in place rather than erasing it as one no edge crosses.
const ON_THE_CUT: &str = "The pick is on the cut: nothing to trim.";
/// AutoCAD 2024's refusal to trim a closed polyline cut at one point only.
pub(crate) const CUT_ONCE: &str = "Curve must intersect cutting edges at least twice.";
/// Whether segments `a` and `b` of a polyline run on as one ([`STRAIGHT`]).
fn runs_on(a: &Segment, b: &Segment) -> bool {
let (Segment::Line(a), Segment::Line(b)) = (a, b) else { return false };
let (u, v) = (a.b - a.a, b.b - b.a);
u.cross(v).abs() < STRAIGHT * u.len() * v.len()
}
/// Where a polyline that is one of the cutting edges cuts itself around segment `k`, the one
/// picked, as lengths along it: at its vertices (every vertex of a closed one, its start included)
/// but those it runs straight on through ([`runs_on`]), and, on `k` and the segments it runs
/// straight on into, where another of its segments crosses them or a vertex of it (an end
/// included) touches them. The piece picked lies within those segments, so crossings elsewhere
/// don't bound it. AutoCAD 2024 trims a polyline that is one of the cutting edges at these.
fn self_cuts(segs: &[Segment], closed: bool, k: usize) -> Result<Vec<f64>> {
let n = segs.len();
let mut starts = Vec::with_capacity(n);
let mut acc = 0.0;
for s in segs {
starts.push(acc);
acc += s.len();
}
let before = |i: usize| {
if i > 0 {
Some(i - 1)
} else if closed {
n.checked_sub(1)
} else {
None
}
};
let after = |i: usize| {
if i + 1 < n {
Some(i + 1)
} else if closed {
Some(0)
} else {
None
}
};
// Whether the polyline runs straight on through the vertex segment `i` starts at.
let straight = |i: usize| matches!((before(i).and_then(|j| segs.get(j)), segs.get(i)), (Some(a), Some(b)) if runs_on(a, b));
let mut ts: Vec<f64> = (usize::from(!closed)..n).filter(|i| !straight(*i)).filter_map(|i| starts.get(i).copied()).collect();
let mut run = vec![k];
let mut i = k;
while let Some(j) = before(i).filter(|_| straight(i) && run.len() < n) {
run.push(j);
i = j;
}
let mut i = k;
while let Some(j) = after(i).filter(|j| straight(*j) && run.len() < n) {
run.push(j);
i = j;
}
let boxes: Vec<_> = segs.iter().map(Segment::bounds).collect();
let reach = run.iter().filter_map(|i| boxes.get(*i)).fold(Bounds2::EMPTY, |r, b| r.union(b));
let near: Vec<usize> = (0..n).filter(|j| boxes.get(*j).is_some_and(|b| b.intersects(&reach))).collect();
if run.len().saturating_mul(near.len()) > MAX_SELF_PAIRS {
return Err(EngineError::Other("Too many segments to trim the polyline where it crosses itself.".into()));
}
// A crossing, or a vertex of another segment touching this one, cuts it; so does a crossing
// where it runs straight on into the next. Two segments meeting at a vertex cut nothing more.
let cuts = |t: f64, i: usize| (t > 1e-9 && t < 1.0 - 1e-9) || (t <= 1e-9 && straight(i)) || (t >= 1.0 - 1e-9 && after(i).is_some_and(straight));
let vertices = ts.len();
for &i in &run {
let (Some(a), Some(box_a), Some(a0)) = (segs.get(i), boxes.get(i), starts.get(i)) else { continue };
for &j in &near {
let (Some(b), Some(box_b)) = (segs.get(j), boxes.get(j)) else { continue };
if j == i || runs_on(a, b) || !box_a.intersects(box_b) {
continue;
}
for x in intersect_ext(a, b, false) {
let t = param_on(a, x);
if cuts(t, i) {
ts.push(a0 + t * a.len());
if ts.len() - vertices > MAX_SELF_CROSSINGS {
return Err(EngineError::Other("Too many crossings to trim the polyline where it crosses itself.".into()));
}
}
}
}
}
Ok(ts)
}
/// Trim a polyline at the piece containing `pick`, between the cuts by `cut` and, when it is one
/// of the cutting edges (`itself`), by its own ([`self_cuts`]). `None`: the pick is on one of its
/// own cuts ([`ON_CUT`]), which trims nothing.
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itself: bool) -> Result<Option<Vec<EntityKind>>> {
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> Result<Vec<EntityKind>> {
let pl = Polyline { vertices: p.vertices.clone(), closed: p.closed };
let segs = pl.segments();
let total: f64 = segs.iter().map(Segment::len).sum();
let mut ts: Vec<f64> = Vec::new();
let mut acc = 0.0;
// The pick's length along the polyline and the segment it is on.
let (mut tp, mut k) = (0.0, 0);
let mut tp = 0.0;
let mut best = f64::INFINITY;
for (i, s) in segs.iter().enumerate() {
for s in &segs {
let len = s.len();
for x in cut.iter().flat_map(|c| intersect_ext(s, c, false)) {
ts.push(acc + param_on(s, x) * len);
@@ -466,34 +262,13 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itse
if c.dist(pick) < best {
best = c.dist(pick);
tp = acc + param_on(s, c) * len;
k = i;
}
acc += len;
}
let mut own = if itself { self_cuts(&segs, p.closed, k)? } else { Vec::new() };
// An open polyline's ends cut nothing; a closed one's start vertex cuts it like any other (a
// cut there is at 0 or at its length, which the pieces below take as one).
if !p.closed {
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
own.retain(|t| *t > 1e-9 && *t < total - 1e-9);
}
// How far apart two lengths along the polyline are, round its start too when it is closed.
let apart = |s: f64, t: f64| if p.closed { (s - t).abs().min(total - (s - t).abs()) } else { (s - t).abs() };
// A pick on one of its own cuts trims nothing; a cut by another edge there is passed over, and
// the piece runs on across it.
if own.iter().any(|t| apart(*t, tp) <= ON_CUT) {
return Ok(None);
}
let found = ts.len();
ts.retain(|t| apart(*t, tp) > ON_CUT);
let passed = ts.len() < found;
ts.extend(own);
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
ts.sort_by(f64::total_cmp);
if ts.is_empty() {
return Err(EngineError::Other(if passed { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
if p.closed && ts.first().is_some_and(|f| ts.iter().all(|t| apart(*f, *t) <= ON_CUT)) {
return Err(EngineError::Other(CUT_ONCE.into()));
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
}
let lo = ts.iter().copied().filter(|t| *t < tp).fold(f64::NEG_INFINITY, f64::max);
let hi = ts.iter().copied().filter(|t| *t > tp).fold(f64::INFINITY, f64::min);
@@ -508,31 +283,33 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2, itse
if hi.is_finite() { hi } else { ts.first().copied().unwrap_or(total) + total },
);
let doubled: Vec<Segment> = segs.iter().chain(segs.iter()).copied().collect();
let (a, b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
let (a, mut b) = if hi > total { (hi - total, lo) } else { (hi, lo + total) };
// A single cut leaves the whole outline, opened there.
if b <= a + 1e-9 {
b += total;
}
out.push(mk(sub_polyline(&doubled, a, b)));
} else {
// A piece whose ends meet (the polyline touched itself there) is closed, without its
// repeated vertex, as AutoCAD leaves it.
let piece = |mut vs: Vec<PolyVertex>| {
// Within rounding of the coordinates, however far from the origin, and no more.
let meets = vs.len() >= 4
&& matches!((vs.first(), vs.last()), (Some(a), Some(b)) if a.p.near(b.p, 64.0 * f64::EPSILON * (1.0 + a.p.len().max(b.p.len()))));
if meets {
vs.pop();
}
lwpoly(vs, meets)
};
if lo.is_finite() {
out.push(piece(sub_polyline(&segs, 0.0, lo)));
out.push(mk(sub_polyline(&segs, 0.0, lo)));
}
if hi.is_finite() {
out.push(piece(sub_polyline(&segs, hi, total)));
out.push(mk(sub_polyline(&segs, hi, total)));
}
}
Ok(Some(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect()))
Ok(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect())
}
pub(super) use crate::cmd::curves::seg_param as param_on;
pub(super) fn param_on(s: &Segment, p: Vec2) -> f64 {
match s {
Segment::Line(l) => l.param_of(p).clamp(0.0, 1.0),
Segment::Arc { arc, ccw } => {
let t = norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15);
let t = t.clamp(0.0, 1.0);
if *ccw { t } else { 1.0 - t }
}
}
}
/// A polyline arc segment on `ga`'s circle that ends at `end` after turning through `sweep`
/// (signed, positive counterclockwise), run on round the circle to the nearest boundary edge: the
@@ -595,13 +372,7 @@ pub(crate) fn extend(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Re
EntityKind::LwPolyline(p) if !p.closed && p.vertices.len() >= 2 => {
let mut vs = p.vertices.clone();
let n = vs.len();
// The pick's parameter: the segment it is nearest, plus how far along it. AutoCAD 2024
// extends the end on that side of the polyline's middle parameter, the last from the
// middle on, not the end nearer the pick. A repeated vertex counts as a segment, so
// these come from the vertices, not `Polyline::segments`, which skips it.
let spans: Vec<_> = vs.windows(2).filter_map(|w| Some((w.first()?.p, w.get(1)?.p, w.first()?.bulge))).collect();
let at = crate::cmd::curves::vertex_param_of(&spans, pick);
let from_end = 2.0 * at >= (n - 1) as f64;
let from_end = vs.last().is_some_and(|l| pick.dist(l.p) < vs.first().map(|f| pick.dist(f.p)).unwrap_or(f64::INFINITY));
let (i_end, i_prev) = if from_end { (n - 1, n - 2) } else { (0, 1) };
let end = vs.get(i_end).map(|v| v.p).unwrap_or_default();
let prev = vs.get(i_prev).map(|v| v.p).unwrap_or_default();
+8 -41
View File
@@ -10,7 +10,7 @@ use serde_json::{Value, json};
use super::curves::KW;
use super::helpers::{line, lwpoly, rect_vertices};
use super::modify::{CUT_ONCE, Edges, extend, json_pick_error, trim};
use super::modify::{Edges, extend, trim};
use super::{bad, point_param, points_param};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
@@ -32,10 +32,8 @@ fn proj_mode(s: &Session) -> i64 {
}
/// Whether a trim error says the object meets no cutting edge (a Quick-mode trim then erases it).
/// A closed polyline cut at one point meets one, and is left as it is.
fn misses_edges(e: &EngineError) -> bool {
let m = e.to_string();
m.contains("intersect") && m != CUT_ONCE
e.to_string().contains("intersect")
}
/// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
@@ -106,12 +104,7 @@ fn crossing(s: &mut Session, a: Vec2, b: Vec2, extending: bool, edges: Edges, qu
for w in pl.windows(2) {
let (Some(p), Some(q)) = (w.first(), w.get(1)) else { continue };
let seg = Line::new(*p, *q);
// Kept `tol` inside the segment: a vertex, where two segments meet, is a cut of a
// polyline that is one of its own edges, and a pick on a cut trims nothing.
let e = (tol / seg.len()).min(0.5);
let cands = [seg.at(e), seg.at(1.0 - e), seg.at(seg.param_of(a).clamp(e, 1.0 - e))]
.into_iter()
.chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
let cands = [*p, *q, seg.closest(a)].into_iter().chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
for c in cands.filter(|c| inside(*c)) {
if best.is_none_or(|b| c.dist(a) < b.dist(a)) {
best = Some(c);
@@ -181,6 +174,7 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
let cmd = if extending { "extend" } else { "trim" };
let only: Option<Vec<Handle>> =
p.get("edges").and_then(Value::as_array).map(|a| a.iter().filter_map(|v| v.as_str().and_then(Handle::parse_hex)).collect());
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
let quick = match p.get("mode") {
None | Some(Value::Null) => false,
Some(v) => match v.as_str().map(|m| m.trim().to_ascii_lowercase()).as_deref() {
@@ -189,7 +183,6 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
_ => return Err(bad(cmd, "`mode` must be \"quick\" or \"standard\"")),
},
};
let edges = Edges { only: only.as_deref(), implied: edge_mode_param(cmd, p)? };
let key = if extending { "extended" } else { "trimmed" };
if p.get("fence").is_some_and(|v| !v.is_null()) {
let pts = points_param(p, "fence")
@@ -205,19 +198,8 @@ fn run(s: &mut Session, p: &Value, extending: bool) -> Result<Value> {
return Ok(json!({ key: n }));
}
let h = super::targets(s, p)?.first().copied().ok_or_else(|| bad(cmd, "`handle` is required"))?;
let pick = point_param(p, "pick").ok_or_else(|| {
bad(
cmd,
if extending {
"`pick` ([x, y]) is required: point toward the boundary to extend to, selecting the nearer end"
} else {
"`pick` ([x, y]) is required: select the portion of the object to trim away"
},
)
})?;
// Diagnose only an existing single-pick JSON failure. Successful calls, Quick-mode
// erasure, fence/crossing and the interactive command keep their existing behavior.
let r = apply(s, h, pick, extending, edges, quick).map_err(|e| json_pick_error(s, h, pick, edges, extending, e))?;
let pick = point_param(p, "pick").ok_or_else(|| bad(cmd, "`pick` ([x, y]) is required"))?;
let r = apply(s, h, pick, extending, edges, quick)?;
if extending { Ok(Value::Null) } else { Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() })) }
}
@@ -239,8 +221,6 @@ enum Stage {
Edges(Vec<Handle>),
/// Fence points so far.
Fence(Vec<Vec2>),
/// Quick mode's two-point fence, started by a pick in empty space: its first point.
QuickFence(Vec2),
/// A crossing window: its first corner once picked.
Crossing(Option<Vec2>),
Mode,
@@ -377,7 +357,6 @@ impl Interactive for TrimM {
None => Prompt::new("Specify first fence point", Accept::POINT),
Some(l) => Prompt::new("Specify next fence point", Accept::POINT).kw(&["Undo"]).base(*l),
},
Stage::QuickFence(a) => Prompt::new("Specify next fence point", Accept::POINT).base(*a),
Stage::Crossing(None) => Prompt::new("Specify first corner", Accept::POINT),
Stage::Crossing(Some(_)) => Prompt::new("Specify opposite corner", Accept::POINT),
Stage::Mode => {
@@ -477,16 +456,6 @@ impl Interactive for TrimM {
}
Ok(Step::Continue)
}
Stage::QuickFence(a) => {
self.stage = Stage::Pick;
if let Input::Point(b) = i {
let r = self.step(s, |m, s| fence(s, &[a, b], extending, m.edges(quick, implied), quick).map(|_| ()));
if let Err(e) = r {
s.echo(e.to_string());
}
}
Ok(Step::Continue)
}
Stage::Crossing(first) => {
match (first, i) {
(None, Input::Point(p)) => self.stage = Stage::Crossing(Some(p)),
@@ -507,9 +476,8 @@ impl Interactive for TrimM {
let ap = s.pixel_size() * s.settings.pickbox.max(1.0) * 1.5;
let space = s.space();
let Some(h) = s.pick_object(&space, p, ap)? else {
// A pick in empty space starts a two-point fence in Quick mode (as in
// AutoCAD, #1594) and a crossing window in Standard mode.
self.stage = if quick { Stage::QuickFence(p) } else { Stage::Crossing(Some(p)) };
// A pick in empty space opens a crossing window there.
self.stage = Stage::Crossing(Some(p));
return Ok(Step::Continue);
};
let r = self.step(s, |m, s| apply(s, h, p, extending, m.edges(quick, implied), quick).map(|_| ()));
@@ -558,7 +526,6 @@ impl Interactive for TrimM {
.windows(2)
.filter_map(|w| Some(line(*w.first()?, *w.get(1)?)))
.collect(),
Stage::QuickFence(a) => vec![line(*a, c)],
Stage::Crossing(Some(a)) => vec![lwpoly(rect_vertices(*a, c), true)],
_ => Vec::new(),
}
@@ -1,6 +1,5 @@
//! BREAK on a closed polyline removes the stretch between the two points that doesn't run
//! through its start vertex, whichever point comes first, and leaves one open polyline from the
//! later point round to the earlier one (#1173; AutoCAD 2024, accoreconsole).
//! BREAK on a closed polyline removes the stretch from the first to the second point along the
//! vertex direction and leaves one open polyline (#1173).
use cadcraft_doc::{EntityKind, LwPolyline};
use cadcraft_engine::Session;
@@ -39,15 +38,14 @@ fn break_opens_a_closed_polyline_at_the_command_line() {
}
#[test]
fn break_json_on_a_closed_polyline_ignores_the_order_of_the_points() {
fn break_json_on_a_closed_polyline_follows_the_order_of_the_points() {
let mut s = Session::new();
let r = closed_rect(&mut s);
// Second point before the first along the vertices: the same stretch goes as with the points
// the other way round (measured with the first point after the second, and both ways on a
// 100 x 10 rectangle broken at (10, 0) and (10, 10), where the long stretch went).
// Second point before the first along the vertices: the long way round goes, the short
// stretch between them stays.
s.execute("break", &json!({ "handle": r["handle"], "p1": [100, 30], "p2": [50, 0] })).unwrap();
let ps = polys(&s);
assert_eq!(ps.len(), 1);
assert!(!ps[0].closed);
assert_eq!(pts(&ps[0]), vec![(100.0, 30.0), (100.0, 60.0), (0.0, 60.0), (0.0, 0.0), (50.0, 0.0)]);
assert_eq!(pts(&ps[0]), vec![(50.0, 0.0), (100.0, 0.0), (100.0, 30.0)]);
}
@@ -1,134 +0,0 @@
//! BREAKATPOINT and BREAK where the result is easy to get wrong, as AutoCAD 2024 runs them
//! (accoreconsole, `entget` of every object after the command, on these drawings):
//!
//! - BREAKATPOINT at either end of a line, or at the end vertex of an open polyline, leaves the
//! object whole;
//! - at an open polyline's middle vertex it splits it there, the original keeping the first part;
//! - BREAK of a closed polyline at two points of one side, either way round and on the side that
//! closes it too, opens it with its own handle;
//! - a circle trimmed or broken becomes an arc with its own handle.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// The model space objects in order: handle and kind.
fn objects(s: &Session) -> Vec<(Handle, EntityKind)> {
s.doc().unwrap().model.iter().map(|e| (e.handle, e.kind.clone())).collect()
}
/// A polyline's closed flag and vertices (rounded to 1e-9).
fn pts(k: &EntityKind) -> (bool, Vec<(f64, f64)>) {
let EntityKind::LwPolyline(p) = k else { panic!("not a polyline: {k:?}") };
let r = |v: f64| (v * 1e9).round() / 1e9;
(p.closed, p.vertices.iter().map(|v| (r(v.p.x), r(v.p.y))).collect())
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())
}
fn pline(s: &mut Session, vertices: Value, closed: bool) -> Handle {
handle(&s.execute("pline", &json!({ "vertices": vertices, "closed": closed })).unwrap())
}
fn run(s: &mut Session, script: &str) {
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
}
#[test]
fn breakatpoint_at_an_end_leaves_the_object_whole() {
for at in ["100,0", "0,0"] {
let mut s = Session::new();
let l = line(&mut s, [0.0, 0.0], [100.0, 0.0]);
run(&mut s, &format!("BREAKATPOINT {at} {at}\n"));
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{at}: {objs:?}");
let EntityKind::Line(k) = &objs[0].1 else { panic!("{objs:?}") };
assert!(objs[0].0 == l && (k.a.x, k.a.y, k.b.x, k.b.y) == (0.0, 0.0, 100.0, 0.0), "{at}: {objs:?}");
}
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [50, 0], [50, 30]]), false);
run(&mut s, "BREAKATPOINT 50,30 50,30\n");
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (p, (false, vec![(0.0, 0.0), (50.0, 0.0), (50.0, 30.0)])));
}
#[test]
fn breakatpoint_at_a_middle_vertex_splits_there_and_the_original_keeps_the_first_part() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [50, 0], [50, 30]]), false);
run(&mut s, "BREAKATPOINT 50,0 50,0\n");
let objs = objects(&s);
assert_eq!(objs.len(), 2, "{objs:?}");
let first = objs.iter().find(|o| o.0 == p).expect("the original stays");
let other = objs.iter().find(|o| o.0 != p).unwrap();
assert_eq!(pts(&first.1), (false, vec![(0.0, 0.0), (50.0, 0.0)]));
assert_eq!(pts(&other.1), (false, vec![(50.0, 0.0), (50.0, 30.0)]));
// One undo brings back the polyline as it was, under its handle, and nothing else.
s.undo().unwrap();
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (p, (false, vec![(0.0, 0.0), (50.0, 0.0), (50.0, 30.0)])));
}
#[test]
fn break_at_two_points_of_one_side_opens_a_closed_polyline_with_its_handle() {
let bottom = vec![(30.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0), (0.0, 0.0), (20.0, 0.0)];
// The side from (0, 10) back to the start vertex closes the rectangle.
let closing = vec![(0.0, 3.0), (0.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0), (0.0, 8.0)];
for (script, want) in [("BREAK 20,0 30,0\n", &bottom), ("BREAK 30,0 20,0\n", &bottom), ("BREAK 0,8 0,3\n", &closing)] {
let mut s = Session::new();
let r = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
run(&mut s, script);
let objs = objects(&s);
assert_eq!(objs.len(), 1, "{script}: {objs:?}");
assert_eq!((objs[0].0, pts(&objs[0].1)), (r, (false, want.clone())), "{script}");
// Undo closes it again.
s.undo().unwrap();
let objs = objects(&s);
let rect = vec![(0.0, 0.0), (100.0, 0.0), (100.0, 10.0), (0.0, 10.0)];
assert_eq!(objs.iter().map(|o| (o.0, pts(&o.1))).collect::<Vec<_>>(), vec![(r, (true, rect))], "{script}");
}
}
#[test]
fn a_circle_trimmed_or_broken_becomes_an_arc_with_its_handle() {
// Trimmed between the lines x = -5 and x = 5, picked at its top: the arc from 120 to 60
// degrees, round the bottom.
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
let l = line(&mut s, [-5.0, -20.0], [-5.0, 20.0]);
let m = line(&mut s, [5.0, -20.0], [5.0, 20.0]);
s.execute("trim", &json!({ "handle": c.hex(), "pick": [0, 10], "edges": [l.hex(), m.hex()] })).unwrap();
// The arc's handle, and whether it is AutoCAD's: radius 10 round (0, 0), from `start` to
// `end` degrees (to 1e-9 radians, 0 and 360 alike).
let arc_is = |s: &Session, start: f64, end: f64| {
let objs = objects(s);
let (h, k) = objs.iter().find(|o| matches!(o.1, EntityKind::Arc(_))).cloned().expect("an arc");
let EntityKind::Arc(a) = k else { panic!("not an arc") };
let same = |got: f64, want: f64| {
let d = (got - want.to_radians()).rem_euclid(std::f64::consts::TAU);
d < 1e-9 || std::f64::consts::TAU - d < 1e-9
};
let ok = (a.radius - 10.0).abs() < 1e-9 && a.center.x.abs() < 1e-9 && a.center.y.abs() < 1e-9 && same(a.start, start) && same(a.end, end);
(h, ok)
};
assert_eq!(arc_is(&s, 120.0, 60.0), (c, true));
// Broken from (10, 0) to (0, 10): the arc from 90 degrees round to 0.
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
run(&mut s, "BREAK 10,0 0,10\n");
assert_eq!(objects(&s).len(), 1);
assert_eq!(arc_is(&s, 90.0, 0.0), (c, true));
// Undo gives the circle back under its handle.
s.undo().unwrap();
let objs = objects(&s);
assert!(objs.len() == 1 && objs[0].0 == c && matches!(objs[0].1, EntityKind::Circle(_)), "{objs:?}");
}
@@ -1,647 +0,0 @@
//! BREAK on a closed polyline and TRIM of a polyline that is one of its own cutting edges, as
//! AutoCAD 2024 does them (measured with accoreconsole on these drawings):
//!
//! - BREAK between two points of a closed polyline removes the stretch between them that doesn't
//! run through its start vertex, whichever point comes first; BREAK or BREAKATPOINT at one point
//! splits it there into two open polylines, and at its start vertex leaves it closed.
//! - A polyline that is one of the cutting edges (picked, or with every object, in Standard or
//! Quick mode) is also cut at its own vertices, where it crosses itself and where a vertex of it
//! touches another of its segments. A piece whose ends meet there is left closed. A vertex
//! between two line segments in line (within 1e-8, straight on or doubling back) doesn't cut it.
//! - A pick within 5e-7 of one of the polyline's own cuts, whatever its size, trims nothing; a cut
//! by another edge that near the pick is passed over. An edge through a closed polyline's start
//! vertex cuts it there.
//!
//! Quick mode was measured in AutoCAD 2024 itself, picking on screen: its scripted TRIM runs
//! Standard mode only.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
type Vertex = (f64, f64, f64);
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
fn pline(s: &mut Session, vertices: Value, closed: bool) -> Handle {
handle(&s.execute("pline", &json!({ "vertices": vertices, "closed": closed })).unwrap())
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())
}
/// Every polyline in model space in order: its handle, closed flag and vertices with bulges.
fn polys(s: &Session) -> Vec<(Handle, bool, Vec<Vertex>)> {
s.doc()
.unwrap()
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::LwPolyline(p) => Some((e.handle, p.closed, p.vertices.iter().map(|v| (v.p.x, v.p.y, v.bulge)).collect())),
_ => None,
})
.collect()
}
fn same(got: &[Vertex], want: &[Vertex]) -> bool {
got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g.0 - w.0).abs() < 1e-9 && (g.1 - w.1).abs() < 1e-9 && (g.2 - w.2).abs() < 1e-9)
}
/// The polylines are `want` in order, (`kept`, closed, vertices): `kept` is whether it has the
/// handle `h`.
fn expect(s: &Session, h: Handle, want: &[(bool, bool, &[Vertex])]) {
let got = polys(s);
assert_eq!(got.len(), want.len(), "{got:?}");
for ((gh, gc, gv), (kept, closed, wv)) in got.iter().zip(want) {
assert_eq!((*gh == h, *gc), (*kept, *closed), "{got:?}");
assert!(same(gv, wv), "{gv:?} != {wv:?}");
}
}
fn run(s: &mut Session, script: &str) {
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
}
// ---------------- BREAK on a closed polyline ----------------
#[test]
fn break_removes_the_stretch_between_the_points_that_misses_the_start_vertex() {
// 100 x 10 rectangle broken at (10, 0) and (10, 10): the 190-unit stretch between them goes,
// the 20 units across the start vertex stay, with the points either way round.
for script in ["BREAK 10,0 10,10\n", "BREAK 10,10 10,0\n"] {
let mut s = Session::new();
let r = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
run(&mut s, script);
expect(&s, r, &[(true, false, &[(10.0, 10.0, 0.0), (0.0, 10.0, 0.0), (0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
}
#[test]
fn break_with_the_first_point_after_the_second_keeps_the_run_through_the_start() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], { "p": [40, 0], "bulge": 0.5 }, [60, 0], [60, 30], [0, 30]]), true);
run(&mut s, "BREAK 60,20 10,0\n");
expect(&s, p, &[(true, false, &[(60.0, 20.0, 0.0), (60.0, 30.0, 0.0), (0.0, 30.0, 0.0), (0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
const SQUARE: [[f64; 2]; 4] = [[250.0, 0.0], [270.0, 0.0], [270.0, 20.0], [250.0, 20.0]];
#[test]
fn break_at_one_point_splits_a_closed_polyline_in_two() {
let first: &[Vertex] = &[(250.0, 0.0, 0.0), (260.0, 0.0, 0.0)];
let second: &[Vertex] = &[(260.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0), (250.0, 20.0, 0.0), (250.0, 0.0, 0.0)];
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 260,0 260,0\n");
expect(&s, p, &[(true, false, first), (false, false, second)]);
// BREAKATPOINT does the same.
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
let r = s.execute("breakatpoint", &json!({ "handle": p.hex(), "at": [260, 0] })).unwrap();
assert_eq!(r["handles"].as_array().unwrap().len(), 2);
expect(&s, p, &[(true, false, first), (false, false, second)]);
}
#[test]
fn break_at_a_vertex_splits_there_and_at_the_start_vertex_changes_nothing() {
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 270,20 270,20\n");
expect(
&s,
p,
&[
(true, false, &[(250.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0)]),
(false, false, &[(270.0, 20.0, 0.0), (250.0, 20.0, 0.0), (250.0, 0.0, 0.0)]),
],
);
let mut s = Session::new();
let p = pline(&mut s, json!(SQUARE), true);
run(&mut s, "BREAK 250,0 250,0\n");
expect(&s, p, &[(true, true, &[(250.0, 0.0, 0.0), (270.0, 0.0, 0.0), (270.0, 20.0, 0.0), (250.0, 20.0, 0.0)])]);
}
// ---------------- TRIM of a polyline that cuts itself ----------------
/// A polyline with an arc, and vertical lines at x = 20 and x = 60 crossing it.
fn arc_polyline(s: &mut Session) -> (Handle, Handle, Handle) {
let p = pline(s, json!([[0, 0], { "p": [40, 0], "bulge": 0.4 }, [70, 0], [90, 30]]), false);
let b = line(s, [20.0, -10.0], [20.0, 40.0]);
let c = line(s, [60.0, -20.0], [60.0, 40.0]);
(p, b, c)
}
/// The piece from the x = 60 cut on the arc to the end, as measured.
const FROM_C: [Vertex; 3] = [(60.0, -5.417486860749438, 0.1330399827453447), (70.0, 0.0, 0.0), (90.0, 30.0, 0.0)];
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edges: Option<&[Handle]>) {
let mut p = json!({ "handle": h.hex(), "pick": pick });
if let Some(es) = edges {
p["edges"] = json!(es.iter().map(|e| e.hex()).collect::<Vec<_>>());
}
s.execute("trim", &p).unwrap();
}
#[test]
fn with_every_object_cutting_a_polyline_trims_to_its_own_vertex() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn edges_that_leave_the_polyline_out_cut_only_where_they_cross_it() {
let mut s = Session::new();
let (p, b, c) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], Some(&[b, c]));
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (20.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn a_polyline_that_is_its_only_edge_loses_the_whole_segment_picked() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [55.0, -6.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &[(70.0, 0.0, 0.0), (90.0, 30.0, 0.0)])]);
// The first segment: one piece left, the polyline itself.
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
trim(&mut s, p, [10.0, 0.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(40.0, 0.0, 0.4), (70.0, 0.0, 0.0), (90.0, 30.0, 0.0)])]);
}
#[test]
fn a_closed_polyline_that_is_its_only_edge_opens_without_the_segment_picked() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [40, 0], [40, 30], [0, 30]]), true);
trim(&mut s, p, [20.0, 0.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(40.0, 0.0, 0.0), (40.0, 30.0, 0.0), (0.0, 30.0, 0.0), (0.0, 0.0, 0.0)])]);
}
#[test]
fn a_polyline_crossing_itself_is_cut_at_the_crossing() {
let x = json!([[0, 0], [40, 20], [40, 0], [0, 20]]);
let mut s = Session::new();
let p = pline(&mut s, x.clone(), false);
trim(&mut s, p, [10.0, 5.0], Some(&[p]));
expect(&s, p, &[(true, false, &[(20.0, 10.0, 0.0), (40.0, 20.0, 0.0), (40.0, 0.0, 0.0), (0.0, 20.0, 0.0)])]);
// Every object (the polyline alone): cut between the crossing and the next vertex.
let mut s = Session::new();
let p = pline(&mut s, x, false);
trim(&mut s, p, [30.0, 15.0], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (20.0, 10.0, 0.0)]), (false, false, &[(40.0, 20.0, 0.0), (40.0, 0.0, 0.0), (0.0, 20.0, 0.0)])]);
}
#[test]
fn a_closed_polyline_at_survey_coordinates_trims_to_its_own_vertex() {
let mut s = Session::new();
let p = pline(
&mut s,
json!([[612345.678, 2398765.432], { "p": [612385.678, 2398765.432], "bulge": 0.4 }, [612415.678, 2398765.432], [612415.678, 2398795.432], [612345.678, 2398795.432]]),
true,
);
let b = line(&mut s, [612365.678, 2398755.432], [612365.678, 2398805.432]);
let c = line(&mut s, [612405.678, 2398745.432], [612405.678, 2398805.432]);
trim(&mut s, p, [612400.678, 2398759.432], Some(&[p, b, c]));
let got = polys(&s);
assert_eq!(got.len(), 1);
let (h, closed, vs) = &got[0];
assert!(*h == p && !closed);
let want: [Vertex; 6] = [
(612405.678, 2398760.014513139, 0.1330399827461127),
(612415.678, 2398765.432, 0.0),
(612415.678, 2398795.432, 0.0),
(612345.678, 2398795.432, 0.0),
(612345.678, 2398765.432, 0.0),
(612385.678, 2398765.432, 0.0),
];
// Survey coordinates: a micrometre on the points, the bulge to 1e-9.
assert_eq!(vs.len(), want.len());
for (g, w) in vs.iter().zip(&want) {
assert!((g.0 - w.0).abs() < 1e-6 && (g.1 - w.1).abs() < 1e-6 && (g.2 - w.2).abs() < 1e-9, "{g:?} != {w:?}");
}
}
#[test]
fn standard_mode_at_the_command_line_with_every_object_cuts_at_the_polyline_vertex() {
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
// Mode Standard, Enter: every object is a cutting edge.
run(&mut s, "TRIM O S\n\n55,-6\n\n");
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn a_polyline_picked_as_an_edge_in_quick_mode_cuts_itself_too() {
// Quick mode with the edges given (its cuTting edges option): picked is picked.
let mut s = Session::new();
let (p, _, c) = arc_polyline(&mut s);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [55, -6], "mode": "quick", "edges": [p.hex(), c.hex()] })).unwrap();
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
#[test]
fn quick_mode_with_every_object_cuts_a_polyline_at_its_own_vertex_too() {
// As Standard mode with every object: from the vertex at (40, 0), not from the line at x = 20.
let mut s = Session::new();
let (p, ..) = arc_polyline(&mut s);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [55, -6], "mode": "quick" })).unwrap();
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (40.0, 0.0, 0.0)]), (false, false, &FROM_C)]);
}
/// A rectangle, then an open polyline whose last vertex (6.9, 6.2) touches its second segment
/// inside the rectangle (reversed: whose first vertex does). The polyline's handle.
fn touching(s: &mut Session, reversed: bool) -> Handle {
pline(s, json!([[3.9, 3.8], [8.3, 3.8], [8.3, 6.9], [3.9, 6.9]]), true);
let mut v = vec![[2.3, 3.3], [5.3, 8.0], [8.5, 4.4], [8.8, 7.8], [6.9, 6.2]];
if reversed {
v.reverse();
}
pline(s, json!(v), false)
}
const RECT: [Vertex; 4] = [(3.9, 3.8, 0.0), (8.3, 3.8, 0.0), (8.3, 6.9, 0.0), (3.9, 6.9, 0.0)];
/// Where the second segment crosses the rectangle's top and right sides.
const TOP: Vertex = (6.277777777777777, 6.9, 0.0);
const RIGHT: Vertex = (8.3, 4.625, 0.0);
#[test]
fn a_polyline_is_cut_where_its_end_touches_it() {
let start: [Vertex; 3] = [(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), TOP];
let looped: [Vertex; 3] = [(6.9, 6.2, 0.0), (8.5, 4.4, 0.0), (8.8, 7.8, 0.0)];
// Picked above the touch, in the rectangle: cut from the top side to the touch. What is left
// after it ends where it starts, so it is closed. Quick mode as picked on screen, and Standard
// mode with every object at the command line.
let mut s = Session::new();
let p = touching(&mut s, false);
s.execute("trim", &json!({ "handle": p.hex(), "pick": [6.58, 6.56], "mode": "quick" })).unwrap();
expect(&s, p, &[(false, true, &RECT), (true, false, &start), (false, true, &looped)]);
let mut s = Session::new();
let p = touching(&mut s, false);
run(&mut s, "TRIM O S\n\n6.58,6.56\n\n");
expect(&s, p, &[(false, true, &RECT), (true, false, &start), (false, true, &looped)]);
// Below the touch: cut from the touch to the right side.
let mut s = Session::new();
let p = touching(&mut s, false);
trim(&mut s, p, [7.604, 5.408], None);
let end: [Vertex; 4] = [RIGHT, (8.5, 4.4, 0.0), (8.8, 7.8, 0.0), (6.9, 6.2, 0.0)];
expect(&s, p, &[(false, true, &RECT), (true, false, &[(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), (6.9, 6.2, 0.0)]), (false, false, &end)]);
// The first vertex touching: the closed loop is the piece that keeps the handle.
let mut s = Session::new();
let p = touching(&mut s, true);
trim(&mut s, p, [6.58, 6.56], None);
expect(
&s,
p,
&[
(false, true, &RECT),
(true, true, &[(6.9, 6.2, 0.0), (8.8, 7.8, 0.0), (8.5, 4.4, 0.0)]),
(false, false, &[TOP, (5.3, 8.0, 0.0), (2.3, 3.3, 0.0)]),
],
);
}
#[test]
fn a_closed_piece_keeps_its_arcs() {
let mut s = Session::new();
pline(&mut s, json!([[3.9, 3.8], [8.3, 3.8], [8.3, 6.9], [3.9, 6.9]]), true);
let p = pline(&mut s, json!([[2.3, 3.3], [5.3, 8.0], { "p": [8.5, 4.4], "bulge": 0.3 }, [8.8, 7.8], [6.9, 6.2]]), false);
trim(&mut s, p, [6.58, 6.56], None);
let looped: [Vertex; 3] = [(6.9, 6.2, 0.0), (8.5, 4.4, 0.3), (8.8, 7.8, 0.0)];
expect(&s, p, &[(false, true, &RECT), (true, false, &[(2.3, 3.3, 0.0), (5.3, 8.0, 0.0), TOP]), (false, true, &looped)]);
}
#[test]
fn a_pick_half_a_unit_from_a_vertex_1e9_out_trims_the_segment_it_is_on() {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [1e9, 0], [1e9, 10]]), false);
trim(&mut s, p, [1e9, 0.5], None);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (1e9, 0.0, 0.0)])]);
}
// ---------------- a pick on a cut ----------------
type Edge = ([f64; 2], [f64; 2]);
/// The polyline `v`, with lines `edges`, trimmed at `pick` with every object as an edge, or only
/// the lines when `only_lines`; the polyline's handle and whether the trim was made.
fn attempt(v: Value, closed: bool, edges: &[Edge], only_lines: bool, pick: [f64; 2]) -> (Session, Handle, bool) {
let mut s = Session::new();
let p = pline(&mut s, v, closed);
let ls: Vec<String> = edges.iter().map(|(a, b)| line(&mut s, *a, *b).hex()).collect();
let mut params = json!({ "handle": p.hex(), "pick": pick });
if only_lines {
params["edges"] = json!(ls);
}
let made = s.execute("trim", &params).is_ok();
(s, p, made)
}
/// [`attempt`] with at most one line, which must trim.
fn trimmed(v: Value, closed: bool, edge: Option<Edge>, only_line: bool, pick: [f64; 2]) -> (Session, Handle) {
let (s, p, made) = attempt(v, closed, edge.as_slice(), only_line, pick);
assert!(made, "{pick:?}");
(s, p)
}
/// A vertical line through x = `x`.
fn at(x: f64) -> Edge {
([x, -5.0], [x, 5.0])
}
#[test]
fn a_pick_on_a_cut_trims_nothing() {
// The vertex (10, 0) is the only cut. A pick whose nearest point is within 5e-7 of it, on it
// or off to the side, leaves the polyline as it was; one 6e-7 from it trims the segment it is
// on.
let v = || json!([[0, 0], [10, 0], [10, 10]]);
let whole: [Vertex; 3] = [(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0)];
for pick in [[10.0, 0.0], [10.0, 4e-7], [10.5, 4e-7], [9.99999999, 0.0]] {
let (s, p) = trimmed(v(), false, None, false, pick);
expect(&s, p, &[(true, false, &whole)]);
}
let (s, p) = trimmed(v(), false, None, false, [10.0, 6e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
let (s, p) = trimmed(v(), false, None, false, [9.9999994, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
#[test]
fn a_pick_on_a_cut_is_within_the_same_distance_at_any_size() {
// A polyline a thousandth across, and one 1e9 long with a line through its vertex: 1e-7 from
// the vertex is on the cut, 1e-6 off it.
let small = || json!([[0, 0], [0.001, 0], [0.001, 0.001]]);
let (s, p) = trimmed(small(), false, None, false, [0.001, 1e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (0.001, 0.0, 0.0), (0.001, 0.001, 0.0)])]);
let (s, p) = trimmed(small(), false, None, false, [0.001, 1e-6]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (0.001, 0.0, 0.0)])]);
let long = || json!([[0, 0], [10, 0], [10, 1e9]]);
let through = Some(([0.0, -10.0], [20.0, 10.0]));
let (s, p) = trimmed(long(), false, through, false, [10.0, 1e-7]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 1e9, 0.0)])]);
let (s, p) = trimmed(long(), false, through, false, [10.0, 1e-6]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0)])]);
}
#[test]
fn a_cut_by_another_edge_at_the_pick_is_passed_over() {
// A pick within 5e-7 of a cut by another edge runs the piece on across it, to the next cut
// either side; 6e-7 away the cut holds.
let flat = || json!([[0, 0], [10, 0]]);
let piece = |a: f64, b: f64| [(a, 0.0, 0.0), (b, 0.0, 0.0)];
for pick in [[3.0, 0.0], [3.0000004, 0.0]] {
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(7.0)], true, pick);
expect(&s, p, &[(true, false, &piece(7.0, 10.0))]);
}
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(7.0)], true, [3.0000006, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 3.0)), (false, false, &piece(7.0, 10.0))]);
// Lines at 3, 5 and 7: picked on 5, 3 to 7 goes; picked on 7, 5 to the end.
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(5.0), at(7.0)], true, [5.0, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 3.0)), (false, false, &piece(7.0, 10.0))]);
let (s, p, _) = attempt(flat(), false, &[at(3.0), at(5.0), at(7.0)], true, [7.0, 0.0]);
expect(&s, p, &[(true, false, &piece(0.0, 5.0))]);
// Every object an edge: on to the polyline's own vertex (10, 0).
let (s, p, _) = attempt(json!([[0, 0], [10, 0], [10, 10]]), false, &[at(5.0)], false, [5.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
// A closed rectangle cut at x = 30 and 70 top and bottom, picked on the bottom at 30: round
// its start vertex, from 30 on the top to 70 on the bottom.
let tall = |x: f64| ([x, -5.0], [x, 15.0]);
let (s, p, _) = attempt(json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true, &[tall(30.0), tall(70.0)], true, [30.0, 0.0]);
expect(&s, p, &[(true, false, &[(70.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (30.0, 10.0, 0.0)])]);
// One line only, picked on its cut or 4e-7 past it: no cut is left, and nothing is trimmed.
for pick in [[5.0, 0.0], [5.0000004, 0.0]] {
let (s, p, made) = attempt(json!([[0, 0], [10, 0], [10, 10]]), false, &[at(5.0)], true, pick);
assert!(!made);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
// In Quick mode too: the polyline meets the line, so it isn't erased as one no edge crosses.
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [10, 0]]), false);
line(&mut s, [5.0, -5.0], [5.0, 5.0]);
assert!(s.execute("trim", &json!({ "handle": p.hex(), "pick": [5, 0], "mode": "quick" })).is_err());
expect(&s, p, &[(true, false, &piece(0.0, 10.0))]);
}
#[test]
fn a_pick_on_a_vertex_an_edge_runs_through_trims_nothing() {
// The line's cut is found on the segments either side of the vertex, a rounding apart. Both
// are passed over, so no cut is left and the polyline stays as it was, not split there.
let cases = [
([[5.5, 1.1], [23.3, 7.7], [30.1, 29.9]], ([23.3, 7.7], [45.7, 2.3])),
([[5.5, 1.1], [23.3, 7.7], [30.1, 29.9]], ([2.0 * 23.3 - 45.7, 2.0 * 7.7 - 2.3], [45.7, 2.3])),
([[1.3, 2.7], [37.9, 11.3], [55.1, 48.7]], ([4.5, 43.5], [71.3, -20.9])),
];
for (v, edge) in cases {
let (s, p, made) = attempt(json!(v), false, &[edge], true, v[1]);
let whole: Vec<Vertex> = v.iter().map(|q| (q[0], q[1], 0.0)).collect();
assert!(!made);
expect(&s, p, &[(true, false, &whole)]);
}
}
#[test]
fn an_edge_through_a_closed_polylines_start_vertex_cuts_it_there() {
// The line cuts the rectangle at (0, 0) and at (10, 10) on its top. The pick takes the piece
// it is on, whichever vertex the rectangle starts at. 4e-7 from (0, 0) that cut is passed
// over, which leaves one, and the trim is refused.
let rect = || json!([[0, 0], [100, 0], [100, 10], [0, 10]]);
let edge = Some(([-5.0, -5.0], [15.0, 15.0]));
let left: [Vertex; 3] = [(10.0, 10.0, 0.0), (0.0, 10.0, 0.0), (0.0, 0.0, 0.0)];
let (s, p) = trimmed(rect(), true, edge, true, [50.0, 0.0]);
expect(&s, p, &[(true, false, &left)]);
let (s, p) = trimmed(json!([[50, 0], [100, 0], [100, 10], [0, 10], [0, 0]]), true, edge, true, [50.0, 10.0]);
expect(&s, p, &[(true, false, &left)]);
let (s, p) = trimmed(rect(), true, edge, true, [0.0, 5.0]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (10.0, 10.0, 0.0)])]);
let whole: [Vertex; 4] = [(0.0, 0.0, 0.0), (100.0, 0.0, 0.0), (100.0, 10.0, 0.0), (0.0, 10.0, 0.0)];
let (s, p, made) = attempt(rect(), true, edge.as_slice(), true, [0.0, 4e-7]);
assert!(!made);
expect(&s, p, &[(true, true, &whole)]);
// The rectangle alone, picked on its start vertex, and 4e-7 from it on its last segment.
for pick in [[0.0, 0.0], [0.0, 4e-7]] {
let (s, p) = trimmed(rect(), true, None, false, pick);
expect(&s, p, &[(true, true, &whole)]);
}
}
#[test]
fn a_closed_polyline_cut_at_one_point_is_left_as_it_was() {
// A line touching the rectangle only at its start vertex, and one crossing its bottom once and
// ending inside: AutoCAD refuses either trim, and Quick mode doesn't erase the rectangle.
for (a, b, pick) in [([-5.0, 5.0], [5.0, -5.0], [50.0, 0.0]), ([50.0, -5.0], [50.0, 5.0], [20.0, 0.0])] {
for mode in ["standard", "quick"] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [100, 0], [100, 10], [0, 10]]), true);
let l = line(&mut s, a, b);
let before = polys(&s);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": pick, "edges": [l.hex()], "mode": mode }));
assert!(r.is_err_and(|e| e.to_string() == "Curve must intersect cutting edges at least twice."), "{a:?} {mode}");
assert_eq!(polys(&s), before, "{a:?} {mode}");
}
}
}
// ---------------- where a polyline runs straight on ----------------
#[test]
fn a_vertex_the_polyline_runs_straight_on_through_doesnt_cut_it() {
// (5, 0) lies between two segments in line: the pick takes everything back to the cut before
// it, the start of the polyline or the closed polyline's start vertex.
let v = || json!([[0, 0], [5, 0], [10, 0], [10, 10]]);
let (s, p) = trimmed(v(), false, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
let (s, p) = trimmed(v(), true, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (0.0, 0.0, 0.0)])]);
// A crossing on the segment in line before the one picked bounds the piece, as does one on the
// segment in line after it, and one right at the vertex in line.
let (s, p) = trimmed(json!([[0, 0], [5, 0], [10, 0], [10, 10], [2, 10], [2, -5]]), false, None, false, [7.0, 0.0]);
expect(
&s,
p,
&[
(true, false, &[(0.0, 0.0, 0.0), (2.0, 0.0, 0.0)]),
(false, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (2.0, 10.0, 0.0), (2.0, -5.0, 0.0)]),
],
);
let (s, p) = trimmed(json!([[0, 0], [5, 0], [10, 0], [10, 10], [8, 10], [8, -5]]), false, None, false, [3.5, 0.0]);
expect(&s, p, &[(true, false, &[(8.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (8.0, 10.0, 0.0), (8.0, -5.0, 0.0)])]);
let at_vertex = || json!([[0, 0], [5, 0], [10, 0], [10, 10], [5, 10], [5, -5]]);
let rest: [Vertex; 4] = [(10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (5.0, 10.0, 0.0), (5.0, -5.0, 0.0)];
let (s, p) = trimmed(at_vertex(), false, None, false, [7.0, 0.0]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (5.0, 0.0, 0.0)]), (false, false, &rest)]);
let (s, p) = trimmed(at_vertex(), false, None, false, [3.0, 0.0]);
expect(&s, p, &[(true, false, &[(5.0, 0.0, 0.0), (10.0, 0.0, 0.0), (10.0, 10.0, 0.0), (5.0, 10.0, 0.0), (5.0, -5.0, 0.0)])]);
// Straight on, or doubling back over itself: no cut at all.
for (v, pick) in [(json!([[0, 0], [5, 0], [10, 0]]), [7.0, 0.0]), (json!([[0, 0], [10, 0], [5, 0]]), [2.0, 0.0])] {
let mut s = Session::new();
let p = pline(&mut s, v, false);
let before = polys(&s);
assert!(s.execute("trim", &json!({ "handle": p.hex(), "pick": pick })).is_err());
assert_eq!(polys(&s), before);
}
}
#[test]
fn a_bend_of_1e_8_cuts_a_polyline_and_a_smaller_one_doesnt() {
// The bend at (5, 0), as the sine of its angle, whatever the segments' lengths.
for (end, pick, cuts) in [
([10.0, 4e-8], [7.0, 0.0], false),
([10.0, 6e-8], [7.0, 0.0], true),
([5005.0, 1e-6], [700.0, 0.0], false),
([5005.0, 0.01], [700.0, 0.0], true),
] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [5, 0], end]), false);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": pick }));
assert_eq!((r.is_ok(), polys(&s)[0].2.len()), if cuts { (true, 2) } else { (false, 3) }, "{end:?}");
}
// Two arcs of one circle, or a line and an arc on from it, cut where they meet.
let q = 0.41421356237309503;
let (s, p) = trimmed(json!([{ "p": [0, 0], "bulge": -q }, { "p": [5, 5], "bulge": -q }, [10, 0]]), false, None, false, [8.5355339, 3.5355339]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, -q), (5.0, 5.0, 0.0)])]);
let (s, p) = trimmed(json!([[0, 0], { "p": [5, 0], "bulge": q }, [10, 5]]), false, None, false, [8.5355339, 1.4644661]);
expect(&s, p, &[(true, false, &[(0.0, 0.0, 0.0), (5.0, 0.0, 0.0)])]);
}
#[test]
fn a_polyline_of_thousands_of_segments_is_cut_where_it_crosses_itself() {
// 3,003 segments, the last crossing the first at (50, 0): the pick on the first takes it from
// there to the vertex (100, 0), as with a few segments.
let mut v = vec![json!([0, 0]), json!([100, 0]), json!([100, 20])];
v.extend((1..=3000).map(|i| json!([100.0 - f64::from(i) / 60.0, 20.0 + f64::from(i % 2)])));
v.push(json!([50, -10]));
let (s, p) = trimmed(json!(v), false, None, false, [75.0, 0.0]);
let got = polys(&s);
assert_eq!(got.len(), 2, "{:?}", got.iter().map(|g| g.2.len()).collect::<Vec<_>>());
assert!(got[0].0 == p && same(&got[0].2, &[(0.0, 0.0, 0.0), (50.0, 0.0, 0.0)]), "{:?}", got[0]);
assert_eq!((got[1].2.len(), got[1].2.first().copied()), (3003, Some((100.0, 0.0, 0.0))));
}
#[test]
fn a_polyline_too_long_to_search_for_its_own_crossings_is_left_as_it_was() {
// 4,100 segments in line: the run picked times those near it is past the bound searched. 300
// segments in line over the same stretch, back and forth, crossed by 300 more: 90,000
// crossings, past the bound kept. The trim is refused, and Quick mode doesn't erase the
// polyline as one no edge crosses.
let mut back_and_forth: Vec<[f64; 2]> = (0..=300).map(|i| [if i % 2 == 0 { 0.0 } else { 10.0 }, 0.0]).collect();
back_and_forth.extend((0..300).map(|i| [0.5 + f64::from(i) * 0.03, if i % 2 == 0 { 5.0 } else { -5.0 }]));
for (v, why) in [(json!((0..=4100).map(|i| [i, 0]).collect::<Vec<_>>()), "Too many segments"), (json!(back_and_forth), "Too many crossings")] {
let mut s = Session::new();
let p = pline(&mut s, v, false);
let before = polys(&s);
let r = s.execute("trim", &json!({ "handle": p.hex(), "pick": [0.2, 0], "mode": "quick" }));
assert!(r.is_err_and(|e| e.to_string().contains(why)), "{why}");
assert_eq!(polys(&s), before);
}
}
#[test]
fn a_piece_whose_ends_only_come_near_stays_open_far_from_the_origin() {
// 1e9 out, as survey coordinates in millimetres are: the piece left runs from the line's cut
// to the polyline's end, 0.58 away, and stays open.
let o = 1e9;
let mut s = Session::new();
let p = pline(&mut s, json!([[o + 2.3, 3.3], [o + 5.3, 8.0], [o + 8.5, 4.4], [o + 8.8, 7.8], [o + 7.4, 6.5]]), false);
line(&mut s, [o + 6.9, 5.0], [o + 6.9, 7.0]);
trim(&mut s, p, [o + 6.1, 7.1], None);
let got = polys(&s);
assert_eq!(got.len(), 2, "{got:?}");
let (h, closed, vs) = &got[1];
assert!(*h != p && !closed && vs.len() == 4, "{got:?}");
let last = vs[3];
assert!((last.0 - (o + 7.4)).abs() < 1e-6 && (last.1 - 6.5).abs() < 1e-6, "{last:?}");
}
#[test]
fn a_polyline_is_cut_where_a_vertex_of_it_touches_it() {
// The vertex (6, 6) lies on the first segment, which is cut there.
let v = json!([[0, 0], [10, 10], [12, 4], [6, 6], [4, 12]]);
let mut s = Session::new();
let p = pline(&mut s, v.clone(), false);
trim(&mut s, p, [3.0, 3.0], None);
expect(&s, p, &[(true, false, &[(6.0, 6.0, 0.0), (10.0, 10.0, 0.0), (12.0, 4.0, 0.0), (6.0, 6.0, 0.0), (4.0, 12.0, 0.0)])]);
let mut s = Session::new();
let p = pline(&mut s, v, false);
trim(&mut s, p, [8.0, 8.0], None);
expect(
&s,
p,
&[
(true, false, &[(0.0, 0.0, 0.0), (6.0, 6.0, 0.0)]),
(false, false, &[(10.0, 10.0, 0.0), (12.0, 4.0, 0.0), (6.0, 6.0, 0.0), (4.0, 12.0, 0.0)]),
],
);
}
#[test]
fn a_long_run_in_line_on_a_large_polyline_is_cut_where_it_is_crossed() {
// 1,000 segments in line along y = 0, then 20,002 more, the last crossing the run at x = 500.25:
// only the few segments near the run are searched, and the pick takes it from the crossing to
// the corner (1000, 0).
let mut v: Vec<Value> = (0..=1000).map(|i| json!([i, 0])).collect();
v.push(json!([1000, 200]));
v.extend((1..=20000).map(|i| json!([1000.0 - f64::from(i) * 499.75 / 20000.0, 200.0 + f64::from(i % 2)])));
v.push(json!([500.25, -10]));
let (s, p) = trimmed(json!(v), false, None, false, [999.5, 0.0]);
let got = polys(&s);
assert_eq!(got.len(), 2, "{:?}", got.iter().map(|g| g.2.len()).collect::<Vec<_>>());
assert!(got[0].0 == p && got[0].2.len() == 502 && got[0].2.last() == Some(&(500.25, 0.0, 0.0)), "{:?}", got[0].2.last());
assert_eq!((got[1].2.first().copied(), got[1].2.last().copied()), (Some((1000.0, 0.0, 0.0)), Some((500.25, -10.0, 0.0))));
}
#[test]
fn a_crossing_window_whose_nearest_point_is_a_vertex_trims_the_segment_it_ends() {
// The window's first corner is nearest the vertex (10, 0), a cut of the polyline: the segment
// before it goes, either way round the window, as in AutoCAD.
for (a, b) in [([10.5, -0.5], [8.0, 2.0]), ([8.0, 2.0], [10.5, -0.5])] {
let mut s = Session::new();
let p = pline(&mut s, json!([[0, 0], [10, 0], [10, 10]]), false);
s.execute("trim", &json!({ "crossing": [a, b], "mode": "standard" })).unwrap();
expect(&s, p, &[(true, false, &[(10.0, 0.0, 0.0), (10.0, 10.0, 0.0)])]);
}
}
@@ -1,128 +0,0 @@
//! BREAKATPOINT at the command line and from a script, with AutoCAD 2024's prompts ("Select
//! object:", then "Specify break point:"); BREAK and BREAKATPOINT end the command when a circle
//! can't be broken at one point, and refuse an object on a locked layer when it is picked. Measured
//! in AutoCAD 2024 (accoreconsole) on these drawings.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// The model space objects in order: handle and kind.
fn objects(s: &Session) -> Vec<(Handle, EntityKind)> {
s.doc().unwrap().model.iter().map(|e| (e.handle, e.kind.clone())).collect()
}
fn line_ends(k: &EntityKind) -> ((f64, f64), (f64, f64)) {
let EntityKind::Line(l) = k else { panic!("not a line: {k:?}") };
((l.a.x, l.a.y), (l.b.x, l.b.y))
}
#[test]
fn breakatpoint_asks_for_the_object_then_the_point_and_splits_the_line_there() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("BREAKATPOINT").unwrap();
assert!(s.prompt_text().ends_with("Select object:"), "{}", s.prompt_text());
s.cmdline("1002,0").unwrap();
assert!(s.prompt_text().ends_with("Specify break point:"), "{}", s.prompt_text());
// Off the line: the point projects onto it.
s.cmdline("1005,3").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1005.0, 0.0)));
assert_eq!(line_ends(&objs[1].1), ((1005.0, 0.0), (1010.0, 0.0)));
}
#[test]
fn breakatpoint_from_a_script_splits_an_arc_and_a_closed_polyline() {
let mut s = Session::new();
let a = handle(&s.execute("arc", &json!({ "center": [700, 0], "radius": 10, "start": 0, "end": 90 })).unwrap());
let p = handle(&s.execute("pline", &json!({ "vertices": [[250, 0], [270, 0], [270, 20], [250, 20]], "closed": true })).unwrap());
s.script("BREAKATPOINT 707.0710678,7.0710678 707.0710678,7.0710678\nBREAKATPOINT 260,0 260,0\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.iter().map(|o| o.0).take(2).collect::<Vec<_>>(), [a, p]);
let EntityKind::Arc(arc) = &objs[0].1 else { panic!("not an arc") };
assert!((arc.start - 0.0).abs() < 1e-9 && (arc.end.to_degrees() - 45.0).abs() < 1e-6, "{arc:?}");
let EntityKind::Arc(rest) = &objs[2].1 else { panic!("not an arc") };
assert!((rest.start.to_degrees() - 45.0).abs() < 1e-6 && (rest.end.to_degrees() - 90.0).abs() < 1e-9, "{rest:?}");
let pts = |k: &EntityKind| match k {
EntityKind::LwPolyline(l) => (l.closed, l.vertices.iter().map(|v| (v.p.x, v.p.y)).collect::<Vec<_>>()),
k => panic!("not a polyline: {k:?}"),
};
assert_eq!(pts(&objs[1].1), (false, vec![(250.0, 0.0), (260.0, 0.0)]));
assert_eq!(pts(&objs[3].1), (false, vec![(260.0, 0.0), (270.0, 0.0), (270.0, 20.0), (250.0, 20.0), (250.0, 0.0)]));
}
#[test]
fn breakatpoint_and_break_at_one_point_of_a_circle_report_it_and_end() {
for script in ["BREAKATPOINT 1300,10 1300,10\n", "BREAK 1300,10 1300,10\n"] {
let mut s = Session::new();
let c = handle(&s.execute("circle", &json!({ "center": [1300, 0], "radius": 10 })).unwrap());
s.script(script).unwrap();
assert!(s.running.is_none(), "{script}: {}", s.prompt_text());
assert!(s.log.iter().any(|l| l == "Arc cannot be full 360 degrees"), "{script}: {:?}", s.log);
let objs = objects(&s);
assert_eq!(objs.len(), 1);
assert!(objs[0].0 == c && matches!(objs[0].1, EntityKind::Circle(_)), "{objs:?}");
}
}
#[test]
fn enter_ends_breakatpoint_and_leaves_nothing_selected() {
let mut s = Session::new();
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
s.script("BREAKATPOINT\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
// Enter at the break point after picking: the line is not left selected.
s.script("BREAKATPOINT 5,0\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert!(s.selection().is_empty());
assert_eq!(objects(&s).len(), 1);
}
#[test]
fn an_object_on_a_locked_layer_is_refused_when_picked() {
let mut s = Session::new();
s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap();
s.execute("layer.set", &json!({ "name": "0", "locked": true })).unwrap();
for cmd in ["BREAKATPOINT", "BREAK"] {
s.cmdline(cmd).unwrap();
s.cmdline("5,0").unwrap();
assert!(s.prompt_text().ends_with("Select object:"), "{cmd}: {}", s.prompt_text());
assert!(s.log.iter().any(|l| l == "The object is on a locked layer."), "{cmd}: {:?}", s.log);
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{cmd}: {}", s.prompt_text());
}
assert_eq!(objects(&s).len(), 1);
}
#[test]
fn breakatpoint_from_lisp_with_a_bare_entity_name() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("(command \"_.BREAKATPOINT\" (entlast) '(1004.0 0.0))").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1004.0, 0.0)));
}
#[test]
fn breakatpoint_from_lisp_with_an_entity_and_point() {
let mut s = Session::new();
let l = handle(&s.execute("line", &json!({ "points": [[1000, 0], [1010, 0]] })).unwrap());
s.cmdline("(command \"_.BREAKATPOINT\" (list (entlast) '(1005.0 0.0)) '(1005.0 0.0))").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
let objs = objects(&s);
assert_eq!(objs.len(), 2);
assert_eq!(objs[0].0, l);
assert_eq!(line_ends(&objs[0].1), ((1000.0, 0.0), (1005.0, 0.0)));
}
@@ -1,187 +0,0 @@
//! Which end of an open polyline EXTEND runs on, as AutoCAD 2024 chooses it (measured with
//! accoreconsole on these drawings): the end on the pick's side of the polyline's middle parameter.
//! The pick's parameter is the segment it is nearest, counted from 0, plus how far along that
//! segment it is; from half the number of segments on, the last end extends, below it the first.
//! Neither the end vertex nearer the pick nor the length along the polyline decides.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
type Vertex = (f64, f64, f64);
fn handle(v: &Value) -> String {
v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_owned()
}
/// The open polyline `vertices` with lines `edges`, extended at `pick` to the lines; its vertices
/// with their bulges.
fn extended(vertices: &[Vertex], edges: &[([f64; 2], [f64; 2])], pick: [f64; 2]) -> Vec<Vertex> {
let mut s = Session::new();
let vs: Vec<Value> = vertices.iter().map(|(x, y, b)| json!({ "p": [x, y], "bulge": b })).collect();
let p = handle(&s.execute("pline", &json!({ "vertices": vs, "closed": false })).unwrap());
let es: Vec<String> = edges.iter().map(|(a, b)| handle(&s.execute("line", &json!({ "points": [a, b] })).unwrap())).collect();
s.execute("extend", &json!({ "handle": p, "pick": pick, "edges": es })).unwrap();
match &s.doc().unwrap().entity(Handle::parse_hex(&p).unwrap()).unwrap().kind {
EntityKind::LwPolyline(l) => l.vertices.iter().map(|v| (v.p.x, v.p.y, v.bulge)).collect(),
k => panic!("{k:?}"),
}
}
fn same(got: &[Vertex], want: &[Vertex]) -> bool {
got.len() == want.len() && got.iter().zip(want).all(|(g, w)| (g.0 - w.0).abs() < 1e-6 && (g.1 - w.1).abs() < 1e-6 && (g.2 - w.2).abs() < 1e-6)
}
/// Vertical lines through x = `xs`, from `y0` to `y1`.
fn at(xs: &[f64], y0: f64, y1: f64) -> Vec<([f64; 2], [f64; 2])> {
xs.iter().map(|x| ([*x, y0], [*x, y1])).collect()
}
fn flat(pts: &[(f64, f64)]) -> Vec<Vertex> {
pts.iter().map(|(x, y)| (*x, *y, 0.0)).collect()
}
#[test]
fn the_end_on_the_picks_side_of_the_middle_parameter_extends() {
// (name, vertices, edges, pick, the vertices AutoCAD leaves). Lines at both ends, so either
// end could extend.
let cases: Vec<(&str, Vec<Vertex>, Vec<([f64; 2], [f64; 2])>, [f64; 2], Vec<(f64, f64)>)> = vec![
// 1.2 of 3 segments: the first end, though the pick is on a vertex of the middle one.
(
"1.2 of 3",
flat(&[(0.0, 160.0), (10.0, 160.0), (10.0, 165.0), (20.0, 165.0)]),
at(&[-5.0, 25.0], 155.0, 170.0),
[10.0, 161.0],
vec![(-5.0, 160.0), (10.0, 160.0), (10.0, 165.0), (20.0, 165.0)],
),
// 0.8: the first end, though the last vertex is nearer the pick.
(
"0.8, last vertex nearer",
flat(&[(0.0, 220.0), (20.0, 220.0), (20.0, 230.0), (15.0, 221.0)]),
vec![([-5.0, 215.0], [-5.0, 235.0]), ([0.0, 210.0], [30.0, 210.0])],
[16.0, 220.0],
vec![(-5.0, 220.0), (20.0, 220.0), (20.0, 230.0), (15.0, 221.0)],
),
(
"0.2",
flat(&[(0.0, 240.0), (20.0, 240.0), (20.0, 250.0), (5.0, 241.0)]),
vec![([-5.0, 235.0], [-5.0, 255.0]), ([-10.0, 230.0], [30.0, 230.0])],
[4.0, 240.0],
vec![(-5.0, 240.0), (20.0, 240.0), (20.0, 250.0), (5.0, 241.0)],
),
(
"1.9",
flat(&[(0.0, 260.0), (2.0, 260.0), (2.0, 280.0), (4.0, 280.0)]),
at(&[-5.0, 10.0], 255.0, 285.0),
[2.0, 278.0],
vec![(0.0, 260.0), (2.0, 260.0), (2.0, 280.0), (10.0, 280.0)],
),
// 0.9: the first end, though 18 of the 22 units along is nearer the last.
(
"0.9, length nearer the last",
flat(&[(0.0, 300.0), (20.0, 300.0), (20.0, 301.0), (21.0, 301.0)]),
at(&[-5.0, 25.0], 295.0, 305.0),
[18.0, 300.0],
vec![(-5.0, 300.0), (20.0, 300.0), (20.0, 301.0), (21.0, 301.0)],
),
(
"1.1",
flat(&[(0.0, 320.0), (2.0, 320.0), (2.0, 340.0), (4.0, 340.0)]),
at(&[-5.0, 10.0], 315.0, 345.0),
[2.0, 322.0],
vec![(-5.0, 320.0), (2.0, 320.0), (2.0, 340.0), (4.0, 340.0)],
),
(
"1.25",
flat(&[(0.0, 400.0), (30.0, 400.0), (30.0, 420.0), (31.0, 420.0)]),
at(&[-5.0, 40.0], 395.0, 425.0),
[30.0, 405.0],
vec![(-5.0, 400.0), (30.0, 400.0), (30.0, 420.0), (31.0, 420.0)],
),
(
"1.75",
flat(&[(0.0, 440.0), (1.0, 440.0), (1.0, 460.0), (31.0, 460.0)]),
at(&[-5.0, 40.0], 435.0, 465.0),
[1.0, 455.0],
vec![(0.0, 440.0), (1.0, 440.0), (1.0, 460.0), (40.0, 460.0)],
),
("0.6 of 1", flat(&[(0.0, 480.0), (20.0, 480.0)]), at(&[-5.0, 25.0], 475.0, 485.0), [12.0, 480.0], vec![(0.0, 480.0), (25.0, 480.0)]),
// 1.8 of 4, the end of the segment picked: the first end.
(
"1.8 of 4",
flat(&[(0.0, 500.0), (10.0, 500.0), (10.0, 510.0), (20.0, 510.0), (20.0, 520.0)]),
vec![([-5.0, 495.0], [-5.0, 525.0]), ([15.0, 530.0], [25.0, 530.0])],
[10.0, 508.0],
vec![(-5.0, 500.0), (10.0, 500.0), (10.0, 510.0), (20.0, 510.0), (20.0, 520.0)],
),
(
"2.8 of 4",
flat(&[(0.0, 540.0), (10.0, 540.0), (10.0, 550.0), (20.0, 550.0), (20.0, 560.0)]),
vec![([-5.0, 535.0], [-5.0, 565.0]), ([15.0, 570.0], [25.0, 570.0])],
[18.0, 550.0],
vec![(0.0, 540.0), (10.0, 540.0), (10.0, 550.0), (20.0, 550.0), (20.0, 570.0)],
),
// Right on the middle parameter, 1.5 of 3: the last end.
(
"1.5 of 3",
flat(&[(0.0, 600.0), (10.0, 600.0), (10.0, 610.0), (20.0, 610.0)]),
at(&[-5.0, 25.0], 595.0, 615.0),
[10.0, 605.0],
vec![(0.0, 600.0), (10.0, 600.0), (10.0, 610.0), (25.0, 610.0)],
),
];
for (name, vertices, edges, pick, want) in cases {
let got = extended(&vertices, &edges, pick);
assert!(same(&got, &flat(&want)), "{name}: {got:?}");
}
}
#[test]
fn the_parameter_runs_along_an_arc_segment_too() {
// The middle segment an arc of bulge -18, swinging round to within 2 of the first vertex:
// picked 60% along it (1.6 of 3), 3.6 from the first vertex and 18.3 from the last, the last
// end extends.
let got = extended(
&[(0.0, 0.0, 0.0), (10.0, 0.0, -18.0), (10.0, 1.0, 0.0), (20.0, 1.0, 0.0)],
&at(&[-5.0, 25.0], -10.0, 10.0),
[1.804081304825758, 3.0714821777453793],
);
assert!(same(&got, &[(0.0, 0.0, 0.0), (10.0, 0.0, -18.0), (10.0, 1.0, 0.0), (25.0, 1.0, 0.0)]), "{got:?}");
// The end segment an arc of bulge -0.5: picked on it (1.6 of 2) the last end runs on round
// its circle to x = 14.3; the same polyline turned round, picked on its first segment (0.4),
// the first end does.
let got = extended(&[(0.0, 40.0, 0.0), (10.0, 40.0, -0.5), (14.0, 40.0, 0.0)], &at(&[14.3], 30.0, 50.0), [12.0, 41.0]);
assert!(same(&got, &[(0.0, 40.0, 0.0), (10.0, 40.0, -0.5776771824075506), (14.3, 39.47979589711327, 0.0)]), "{got:?}");
let got = extended(&[(0.0, 60.0, -0.5), (4.0, 60.0, 0.0), (14.0, 60.0, 0.0)], &at(&[-0.3], 50.0, 70.0), [2.0, 61.0]);
assert!(same(&got, &[(-0.3, 59.47979589711327, -0.5776771824075504), (4.0, 60.0, 0.0), (14.0, 60.0, 0.0)]), "{got:?}");
}
#[test]
fn a_repeated_vertex_counts_as_a_segment() {
// (10, 0) twice: three segments, the middle one of no length. Picked on (10, 0), the end of
// the first, 1.0 of 3: the first end extends (counting two segments it would be the last).
// Picked 1 up the last segment, 2.1 of 3: the last end.
let vs = flat(&[(0.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 10.0)]);
let edges = vec![([-5.0, -10.0], [-5.0, 10.0]), ([-10.0, 15.0], [20.0, 15.0])];
let got = extended(&vs, &edges, [10.0, 0.0]);
assert!(same(&got, &flat(&[(-5.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 10.0)])), "{got:?}");
let got = extended(&vs, &edges, [10.0, 1.0]);
assert!(same(&got, &flat(&[(0.0, 0.0), (10.0, 0.0), (10.0, 0.0), (10.0, 15.0)])), "{got:?}");
}
#[test]
fn a_pick_a_hair_outside_an_arc_end_counts_as_that_end() {
// A single semicircle from (1, 0) to (-1, 0). Picked 1e-13 outside its sweep at the first
// vertex, the pick is on the arc's start, not round the circle at its end: the first end runs
// on to x = 0, three quarters of the way round.
let b = 1.0 + 2f64.sqrt();
let got = extended(&[(1.0, 0.0, 1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], -2.0, -0.5), [1.0, -1e-13]);
assert!(same(&got, &[(0.0, -1.0, b), (-1.0, 0.0, 0.0)]), "{got:?}");
// A hair past its end is the last end.
let got = extended(&[(1.0, 0.0, 1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], -2.0, -0.5), [-1.0, -1e-13]);
assert!(same(&got, &[(1.0, 0.0, b), (0.0, -1.0, 0.0)]), "{got:?}");
// Turning clockwise, the arc's start angle is the polyline's last vertex: a hair outside it is
// the last end.
let got = extended(&[(1.0, 0.0, -1.0), (-1.0, 0.0, 0.0)], &at(&[0.0], 0.5, 2.0), [-1.0, 1e-13]);
assert!(same(&got, &[(1.0, 0.0, -b), (0.0, 1.0, 0.0)]), "{got:?}");
}
-8
View File
@@ -17,12 +17,9 @@ mod block_keep;
mod block_redefine;
mod blockreplace;
mod break_closed_polyline;
mod break_ends_and_closing_side;
mod break_join_locked_layers;
mod break_keeps_z;
mod break_trim_keep_handle;
mod break_trim_polyline_rules;
mod breakatpoint_command_line;
mod burst;
mod change_command;
mod chprop_command;
@@ -55,7 +52,6 @@ mod dynamic_block_data;
mod dynamic_grips;
mod explode_stretched;
mod extend_polyline_arc_end;
mod extend_polyline_end_choice;
mod fillet_chamfer;
mod fix_holds_grips;
mod followups_626;
@@ -174,11 +170,7 @@ mod text_left_justify;
mod tolerance;
mod transparent;
mod trim_closed_polyline;
mod trim_cut_at_the_pick;
mod trim_cut_where_an_arc_span_starts;
mod trim_extend_json_pick;
mod trim_extend_options;
mod trim_keeps_z_and_width;
mod undo_count;
mod undo_layout_tab;
mod viewport_clip;
@@ -123,13 +123,11 @@ fn undo_restores_the_closed_polyline() {
}
#[test]
fn a_single_cut_leaves_the_outline_as_it_was() {
// As AutoCAD 2024 does (measured with accoreconsole on a 100 x 10 rectangle cut once on its
// bottom): it refuses, "Curve must intersect cutting edges at least twice."
fn a_single_cut_still_opens_the_outline_there() {
let mut s = Session::new();
let p = handle(s.execute("pline", &json!({ "vertices": square(), "closed": true })).unwrap());
let cutter = handle(s.execute("line", &json!({ "points": [[2, -1], [2, 1]] })).unwrap());
let r = s.execute("trim", &json!({ "handle": p, "pick": [0, 2], "edges": [cutter] }));
assert!(r.is_err_and(|e| e.to_string() == "Curve must intersect cutting edges at least twice."));
assert_eq!(polys(&s), vec![(true, vec![(0.0, 0.0, 0.0), (4.0, 0.0, 0.0), (4.0, 4.0, 0.0), (0.0, 4.0, 0.0)])]);
s.execute("trim", &json!({ "handle": p, "pick": [0, 2], "edges": [cutter] })).unwrap();
let all = [(2.0, 0.0, 0.0), (4.0, 0.0, 0.0), (4.0, 4.0, 0.0), (0.0, 4.0, 0.0), (0.0, 0.0, 0.0), (2.0, 0.0, 0.0)];
assert_eq!(polys(&s), vec![(false, all.to_vec())]);
}
@@ -1,171 +0,0 @@
//! TRIM of a line, an arc or a circle picked on a cut, as AutoCAD 2024 does it (measured with
//! accoreconsole on these drawings): a cut within 5e-7 of the pick, along the object, is passed
//! over, and the piece runs on across it to the next cut either side. With no cut left, nothing is
//! trimmed.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{EntityKind, Handle};
use serde_json::{Value, json};
fn handle(v: &Value) -> Handle {
Handle::parse_hex(v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap()).unwrap()
}
/// Vertical lines through x = `xs`, from y = -15 to 15; their handles.
fn edges(s: &mut Session, xs: &[f64]) -> Vec<String> {
xs.iter().map(|x| handle(&s.execute("line", &json!({ "points": [[x, -15], [x, 15]] })).unwrap()).hex()).collect()
}
/// Every object but the edges: lines as their ends, arcs and circles as their angles in degrees.
fn shapes(s: &Session, edges: &[String]) -> Vec<(Handle, Vec<f64>)> {
let r = |v: f64| (v * 1e9).round() / 1e9;
s.doc()
.unwrap()
.model
.iter()
.filter(|e| !edges.contains(&e.handle.hex()))
.map(|e| {
let v = match &e.kind {
EntityKind::Line(l) => vec![l.a.x, l.a.y, l.b.x, l.b.y],
EntityKind::Arc(a) => vec![a.start.to_degrees(), a.end.to_degrees()],
EntityKind::Circle(_) => Vec::new(),
k => panic!("{k:?}"),
};
(e.handle, v.into_iter().map(r).collect())
})
.collect()
}
/// Trim `h` at `pick` with `edges`: whether the trim was made.
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edges: &[String]) -> bool {
s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "edges": edges })).is_ok()
}
/// A line from (0, 0) to (10, 0) with vertical lines through `xs`, trimmed at `pick`.
fn line_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("line", &json!({ "points": [[0, 0], [10, 0]] })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn a_line_picked_on_its_only_cut_is_left_as_it_was() {
for pick in [[5.0, 0.0], [5.0000004, 0.0], [4.9999996, 0.0]] {
let (made, got, h) = line_trimmed(&[5.0], pick);
assert!(!made, "{pick:?}");
assert_eq!(got, vec![(h, vec![0.0, 0.0, 10.0, 0.0])], "{pick:?}");
}
}
#[test]
fn a_line_picked_on_one_of_two_cuts_loses_the_pieces_both_sides() {
// Cuts at x = 3 and 7: on 3, 0 to 7 goes; 4e-7 past 7, 3 to the end; between them, 3 to 7.
let (_, got, h) = line_trimmed(&[3.0, 7.0], [3.0, 0.0]);
assert_eq!(got, vec![(h, vec![7.0, 0.0, 10.0, 0.0])]);
let (_, got, h) = line_trimmed(&[3.0, 7.0], [7.0000004, 0.0]);
assert_eq!(got, vec![(h, vec![0.0, 0.0, 3.0, 0.0])]);
let (_, got, h) = line_trimmed(&[3.0, 7.0], [5.0, 0.0]);
assert_eq!(got.len(), 2);
assert_eq!(got[0], (h, vec![0.0, 0.0, 3.0, 0.0]));
assert_eq!(got[1].1, vec![7.0, 0.0, 10.0, 0.0]);
}
/// An arc of radius 10 about the origin from 0 to 180 degrees, with vertical lines through `xs`,
/// trimmed at `pick`.
fn arc_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("arc", &json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 180 })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn an_arc_picked_on_its_only_cut_is_left_as_it_was() {
// The line x = 0 cuts it at 90 degrees: on the cut and 4e-7 along from it nothing is trimmed,
// 6e-7 along the arc from 90 to 180 goes.
for pick in [[0.0, 10.0], [-4e-7, 10.0]] {
let (made, got, h) = arc_trimmed(&[0.0], pick);
assert!(!made, "{pick:?}");
assert_eq!(got, vec![(h, vec![0.0, 180.0])], "{pick:?}");
}
let (_, got, h) = arc_trimmed(&[0.0], [-6e-7, 10.0]);
assert_eq!(got, vec![(h, vec![0.0, 90.0])]);
}
#[test]
fn an_arc_picked_on_its_last_cut_loses_the_rest() {
// Cuts at 60 and 120 degrees, picked on 120: from 60 to the end goes.
let (_, got, h) = arc_trimmed(&[5.0, -5.0], [-5.0, 75f64.sqrt()]);
assert_eq!(got, vec![(h, vec![0.0, 60.0])]);
}
/// A circle of radius 10 about the origin, with vertical lines through `xs`, trimmed at `pick`.
fn circle_trimmed(xs: &[f64], pick: [f64; 2]) -> (bool, Vec<(Handle, Vec<f64>)>, Handle) {
let mut s = Session::new();
let h = handle(&s.execute("circle", &json!({ "center": [0, 0], "radius": 10 })).unwrap());
let es = edges(&mut s, xs);
let made = trim(&mut s, h, pick, &es);
(made, shapes(&s, &es), h)
}
#[test]
fn a_circle_picked_on_a_cut_loses_the_arcs_both_sides() {
// Lines at x = 5 and -5 cut it at 60, 120, 240 and 300 degrees. Picked on 60, and 4e-7 along
// from it, the arc from 300 round to 120 goes; picked at 90, the arc from 60 to 120.
let y = 75f64.sqrt();
for pick in [[5.0, y], [4.9999998, y + 2e-7 * 5.0 / y]] {
let (_, got, h) = circle_trimmed(&[5.0, -5.0], pick);
assert_eq!(got, vec![(h, vec![120.0, 300.0])], "{pick:?}");
}
let (_, got, h) = circle_trimmed(&[5.0, -5.0], [0.0, 10.0]);
assert_eq!(got, vec![(h, vec![120.0, 60.0])]);
}
#[test]
fn a_circle_picked_on_one_of_two_cuts_is_left_as_it_was() {
// One line, cutting it at 60 and 300 degrees: picked on 60, one cut is left and the trim is
// refused.
let (made, got, h) = circle_trimmed(&[5.0], [5.0, 75f64.sqrt()]);
assert!(!made);
assert_eq!(got, vec![(h, Vec::new())]);
}
#[test]
fn quick_mode_leaves_an_object_picked_on_its_only_cut() {
// The line, the arc and the circle each meet the edges, at the pick, so Quick mode doesn't
// erase them as objects no edge crosses.
let y = 75f64.sqrt();
let cases = [
("line", json!({ "points": [[0, 0], [10, 0]] }), 5.0, [5.0, 0.0]),
("arc", json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 180 }), 0.0, [0.0, 10.0]),
("circle", json!({ "center": [0, 0], "radius": 10 }), 5.0, [5.0, y]),
];
for (cmd, shape, x, pick) in cases {
let mut s = Session::new();
let h = handle(&s.execute(cmd, &shape).unwrap());
let es = edges(&mut s, &[x]);
let r = s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "mode": "quick" }));
assert!(r.is_err(), "{cmd}");
assert!(s.doc().unwrap().entity(h).is_some(), "{cmd} was erased");
assert_eq!(shapes(&s, &es).len(), 1, "{cmd}");
}
}
#[test]
fn an_arc_picked_just_off_one_end_loses_the_piece_at_that_end() {
// From 0 to 90 degrees, cut at 45: picked just before its start the piece from 0 goes, just
// past its end the piece to 90.
let x = 10.0 * std::f64::consts::FRAC_PI_4.cos();
let trimmed = |pick: [f64; 2]| {
let mut s = Session::new();
let h = handle(&s.execute("arc", &json!({ "center": [0, 0], "radius": 10, "start": 0, "end": 90 })).unwrap());
let es = edges(&mut s, &[x]);
assert!(trim(&mut s, h, pick, &es));
shapes(&s, &es)
};
assert_eq!(trimmed([10.0, -0.01])[0].1, vec![45.0, 90.0]);
assert_eq!(trimmed([-0.01, 10.0])[0].1, vec![0.0, 45.0]);
}
@@ -1,42 +0,0 @@
//! TRIM on a polyline cut through the vertex where an arc span starts: the cut is at that vertex
//! only. Where the crossing came out a hair before the arc's start angle it was also put at the
//! arc's far end, round the circle, and TRIM took out the arc alone.
use cadcraft_engine::Session;
use cadcraft_engine::doc::EntityKind;
use serde_json::json;
fn handle(v: serde_json::Value) -> String {
v.get("handle").unwrap_or(&v["handles"][0]).as_str().unwrap().to_owned()
}
#[test]
fn the_cut_is_at_the_arc_spans_start_vertex_only() {
// (0, 0) to (10, 0), a semicircle round (15, 5) to (10, 10), then on to (0, 10). A line
// through (10, 0) running up to the left crosses the top span at x = 10 + 10 cot(angle);
// picked on the arc, the polyline goes from (10, 0) to there.
for k in 0..172 {
let th = (91.0 + f64::from(k) * 0.25).to_radians();
let d = [th.cos() * 30.0, th.sin() * 30.0];
let mut s = Session::new();
let p = handle(s.execute("pline", &json!({ "vertices": [[0, 0], { "p": [10, 0], "bulge": 1 }, [10, 10], [0, 10]] })).unwrap());
let e = handle(s.execute("line", &json!({ "points": [[10.0 - d[0], -d[1]], [10.0 + d[0], d[1]]] })).unwrap());
s.execute("trim", &json!({ "handle": p, "pick": [15, 5], "edges": [e] })).unwrap();
let pieces: Vec<Vec<(f64, f64)>> = s
.doc()
.unwrap()
.model
.iter()
.filter_map(|e| match &e.kind {
EntityKind::LwPolyline(l) => Some(l.vertices.iter().map(|v| (v.p.x, v.p.y)).collect()),
_ => None,
})
.collect();
let x = 10.0 + 10.0 / th.tan();
let near = |a: (f64, f64), b: (f64, f64)| (a.0 - b.0).abs() < 1e-6 && (a.1 - b.1).abs() < 1e-6;
let ok = pieces.len() == 2
&& pieces.iter().any(|v| v.len() == 2 && near(v[0], (0.0, 0.0)) && near(v[1], (10.0, 0.0)))
&& pieces.iter().any(|v| v.len() == 2 && near(v[0], (x, 10.0)) && near(v[1], (0.0, 10.0)));
assert!(ok, "{:.2} degrees: {pieces:?}", th.to_degrees());
}
}
@@ -1,177 +0,0 @@
//! JSON execute pick roles and diagnostic-only refusals (#2750).
use cadcraft_doc::{Common, EntityKind, Handle, Line, Space};
use cadcraft_engine::{Session, find_command};
use cadcraft_geom::Vec3;
use serde_json::{Value, json};
type TestResult<T = ()> = Result<T, Box<dyn std::error::Error>>;
fn fixture(end: f64, edge_x: f64) -> TestResult<(Session, Handle, Handle)> {
let mut s = Session::new();
let a = s.doc_mut()?.add(&Space::Model, Common::default(), EntityKind::Line(Line { a: Vec3::ZERO, b: Vec3::new(end, 0.0, 0.0) }))?;
let b = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(edge_x, -20.0, 0.0), b: Vec3::new(edge_x, 20.0, 0.0) }),
)?;
Ok((s, a, b))
}
fn assert_line(s: &Session, h: Handle, start: f64, end: f64) -> TestResult {
let e = s.doc()?.entity(h).ok_or("line missing")?;
let EntityKind::Line(l) = &e.kind else { return Err("expected line".into()) };
assert_eq!((l.a, l.b), (Vec3::new(start, 0.0, 0.0), Vec3::new(end, 0.0, 0.0)));
Ok(())
}
fn failure(s: &mut Session, cmd: &str, params: Value, message: &str) -> TestResult {
let before = s.doc()?.clone();
let selection = s.state()?.selection.clone();
let error = s.execute(cmd, &params).err().ok_or("expected refusal")?;
assert_eq!(error.to_string(), message);
assert_eq!(s.doc()?, &before, "a failed JSON call must leave the whole drawing unchanged");
assert_eq!(s.state()?.selection, selection);
Ok(())
}
#[test]
fn trim_execute_pick_selects_the_portion_to_remove() -> TestResult {
// Off-object picks that already succeed by projection remain accepted.
for (pick, start, end) in [([5, 0], 25.0, 50.0), ([40, 0], 0.0, 25.0), ([5, 3], 25.0, 50.0)] {
let (mut s, a, b) = fixture(50.0, 25.0)?;
let boundary = s.doc()?.entity(b).cloned().ok_or("boundary missing")?;
let result = s.execute("trim", &json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick}))?;
let handles = result["handles"].as_array().ok_or("expected handles")?;
assert_eq!(handles.len(), 1);
let h = handles.first().and_then(Value::as_str).and_then(Handle::parse_hex).ok_or("expected trimmed handle")?;
assert_eq!(h, a, "TRIM keeps the original handle on the surviving piece");
assert_line(&s, h, start, end)?;
assert_eq!(s.doc()?.entity(b), Some(&boundary));
}
Ok(())
}
#[test]
fn extend_execute_pick_selects_the_end_toward_the_boundary() -> TestResult {
for pick in [[25, 10], [25, -15], [19, 0], [40, 0]] {
let (mut s, a, b) = fixture(20.0, 25.0)?;
let boundary = s.doc()?.entity(b).cloned().ok_or("boundary missing")?;
let result = s.execute("extend", &json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick}))?;
assert_eq!(result, Value::Null);
assert_line(&s, a, 0.0, 25.0)?;
assert_eq!(s.doc()?.entity(b), Some(&boundary));
}
Ok(())
}
#[test]
fn trim_execute_distinguishes_picks_at_or_projecting_onto_a_cut_from_no_cut() -> TestResult {
let (mut s, a, b) = fixture(50.0, 25.0)?;
for (pick, message) in [
([25, 10], "The `pick` point is off the line and projects onto a cutting intersection; pick away from that intersection."),
([25, 0], "The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection."),
] {
failure(&mut s, "trim", json!({"handle": a.hex(), "edges": [b.hex()], "pick": pick, "mode": "standard"}), message)?;
}
let (mut s, a, b) = fixture(50.0, 75.0)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [5, 0]}),
"No usable cutting-edge intersection in the interior of the object to trim.",
)
}
#[test]
fn extend_execute_distinguishes_the_wrong_end_from_no_boundary_hit() -> TestResult {
let (mut s, a, b) = fixture(20.0, 25.0)?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [10, 0]}),
"The `pick` point selects an end with no boundary ahead; choose `pick` toward the boundary to extend to.",
)?;
s.doc_mut()?.modify_entity(b, |e| {
e.kind = EntityKind::Line(Line { a: Vec3::new(0.0, 20.0, 0.0), b: Vec3::new(25.0, 20.0, 0.0) });
})?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [25, 20]}),
"No usable boundary intersection was found for either end of the object to extend.",
)
}
#[test]
fn quick_erasure_and_unrelated_errors_keep_their_behavior() -> TestResult {
let (mut s, a, b) = fixture(50.0, 25.0)?;
// Quick mode leaves a line picked on its only cut in place (#2648), and the JSON form explains
// the refusal as Standard mode does.
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [25, 0], "mode": "quick"}),
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection.",
)?;
assert!(s.doc()?.entity(a).is_some());
assert!(s.doc()?.entity(b).is_some());
failure(&mut s, "trim", json!({"handle": "DEAD", "pick": [5, 0]}), "no such object")
}
#[test]
fn command_contracts_and_missing_pick_errors_explain_the_roles() -> TestResult {
let trim = find_command("trim").ok_or("trim not registered")?;
assert!(trim.params.contains("pick selects the portion of that object to remove"));
assert!(trim.params.contains("edges are the cutting edges"));
let extend = find_command("extend").ok_or("extend not registered")?;
assert!(extend.params.contains("pick points toward the boundary to extend to"));
assert!(extend.params.contains("selecting the nearer end"));
assert!(extend.params.contains("edges are the boundary edges"));
let (mut s, a, b) = fixture(20.0, 25.0)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()]}),
"invalid parameters for `trim`: `pick` ([x, y]) is required: select the portion of the object to trim away",
)?;
failure(
&mut s,
"extend",
json!({"handle": a.hex(), "edges": [b.hex()]}),
"invalid parameters for `extend`: `pick` ([x, y]) is required: point toward the boundary to extend to, selecting the nearer end",
)
}
#[test]
fn a_pick_on_the_line_far_from_the_origin_is_not_called_off_the_line() -> TestResult {
// Survey coordinates: rounding there is far above 1e-9 (the pick below is 3.7e-9 off the line
// after rounding), so a pick on the line still reads as on it.
let (x0, y0, k) = (123_456_789.1, 9_876_543.3, 33.3333);
let mut s = Session::new();
let a = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(x0, y0, 0.0), b: Vec3::new(x0 + 50.0, y0 + 30.0, 0.0) }),
)?;
let b = s.doc_mut()?.add(
&Space::Model,
Common::default(),
EntityKind::Line(Line { a: Vec3::new(x0 + k, y0 - 20.0, 0.0), b: Vec3::new(x0 + k, y0 + 50.0, 0.0) }),
)?;
failure(
&mut s,
"trim",
json!({"handle": a.hex(), "edges": [b.hex()], "pick": [x0 + k, y0 + k * 0.6]}),
"The `pick` point is at a cutting intersection; pick a portion of the object away from that intersection.",
)
}
#[test]
fn the_extend_contract_names_the_polyline_end_rule() -> TestResult {
// An open polyline extends the end on the pick's side of its middle parameter (#2693), not
// the nearer end.
let extend = find_command("extend").ok_or("extend not registered")?;
assert!(extend.params.contains("middle"), "{}", extend.params);
Ok(())
}
+2 -25
View File
@@ -112,33 +112,10 @@ fn crossing_window_trims_what_it_touches() {
s.script("TRIM C 4,-1 6,1\n\n").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(lines(&s), with_edges(&[((-5.0, 0.0), (0.0, 0.0)), ((-5.0, 2.0), (15.0, 2.0)), ((10.0, 0.0), (15.0, 0.0))]));
}
#[test]
fn a_pick_in_empty_space_starts_a_fence_in_quick_mode_and_a_window_in_standard_mode() {
// #1594: Quick mode's two-point fence trims what it crosses and returns to the first prompt.
for cmd in ["TRIM", "EXTEND"] {
let mut s = ladder();
s.cmdline(cmd).unwrap();
s.cmdline("4,-4").unwrap();
assert!(s.prompt_text().contains("Specify next fence point"), "{cmd}: {}", s.prompt_text());
}
// A pick in empty space opens a crossing window too.
let mut s = ladder();
s.script("TRIM 4,-4 6,1\n").unwrap();
assert!(s.prompt_text().contains("Select object to trim"), "{}", s.prompt_text());
s.cmdline("").unwrap();
s.script("TRIM 4,-4 6,1\n\n").unwrap();
assert_eq!(lines(&s), with_edges(&[((-5.0, 0.0), (0.0, 0.0)), ((-5.0, 2.0), (15.0, 2.0)), ((10.0, 0.0), (15.0, 0.0))]));
// EXTEND's fence extends both lines it crosses to the boundary at x = 10.
let mut s = session(&["10,-5 10,5", "0,0 4,0", "0,2 4,2"]);
s.script("EXTEND 3,-1 3,3\n").unwrap();
assert!(s.prompt_text().contains("Select object to extend"), "{}", s.prompt_text());
s.cmdline("").unwrap();
assert!(s.running.is_none(), "{}", s.prompt_text());
assert_eq!(lines(&s), vec![((0.0, 0.0), (10.0, 0.0)), ((0.0, 2.0), (10.0, 2.0)), ((10.0, -5.0), (10.0, 5.0))]);
// Standard mode keeps the crossing window.
let mut s = ladder();
s.script("TRIM O S\n\n4,-4\n").unwrap();
assert!(s.prompt_text().contains("Specify opposite corner"), "{}", s.prompt_text());
}
#[test]
@@ -1,102 +0,0 @@
//! TRIM keeps what the object has beyond its outline, as BREAK does: a line's Z, an arc's centre
//! Z (a circle trimmed into an arc), a polyline's elevation, and a polyline's constant width on
//! every piece. The Z cases and the width on BREAK were measured in AutoCAD 2024 (accoreconsole)
//! on these drawings.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Circle, Common, Entity, EntityKind, Handle, Line, LwPolyline};
use cadcraft_engine::geom::{PolyVertex, Vec2, Vec3};
use serde_json::json;
fn add(s: &mut Session, kind: EntityKind, thickness: f64) -> Handle {
let space = s.space();
let d = s.doc_mut().unwrap();
let handle = d.new_handle();
d.space_mut(&space).unwrap().push(Entity { handle, common: Common { thickness, ..Common::default() }, kind });
handle
}
fn line(s: &mut Session, a: [f64; 2], b: [f64; 2]) -> Handle {
let v = s.execute("line", &json!({ "points": [a, b] })).unwrap();
Handle::parse_hex(v["handles"][0].as_str().unwrap()).unwrap()
}
fn trim(s: &mut Session, h: Handle, pick: [f64; 2], edge: Handle) {
s.execute("trim", &json!({ "handle": h.hex(), "pick": pick, "edges": [edge.hex()] })).unwrap();
}
fn kind(s: &Session, h: Handle) -> EntityKind {
s.doc().unwrap().entity(h).unwrap().kind.clone()
}
fn polyline(vertices: &[(f64, f64, f64)], const_width: f64, elevation: f64, plinegen: bool) -> EntityKind {
let vertices = vertices.iter().map(|&(x, y, bulge)| PolyVertex { bulge, ..PolyVertex::new(Vec2::new(x, y)) }).collect();
EntityKind::LwPolyline(LwPolyline { vertices, closed: false, const_width, elevation, plinegen })
}
fn near(a: Vec3, b: Vec3, tol: f64) -> bool {
(a.x - b.x).abs() < tol && (a.y - b.y).abs() < tol && (a.z - b.z).abs() < tol
}
#[test]
fn trim_keeps_a_lines_z() {
let mut s = Session::new();
let a = add(&mut s, EntityKind::Line(Line { a: Vec3::new(0.5, 0.25, 0.007), b: Vec3::new(0.54, 0.25, 0.007) }), 0.0);
let b = line(&mut s, [0.52, 0.24], [0.52, 0.26]);
trim(&mut s, a, [0.53, 0.25], b);
let EntityKind::Line(l) = kind(&s, a) else { panic!("not a line") };
assert!(near(l.a, Vec3::new(0.5, 0.25, 0.007), 1e-12) && near(l.b, Vec3::new(0.52, 0.25, 0.007), 1e-12), "{l:?}");
}
#[test]
fn trim_keeps_the_centre_z_of_a_circle_made_an_arc() {
// At survey coordinates, with a thickness of 2.
let mut s = Session::new();
let c = add(&mut s, EntityKind::Circle(Circle { center: Vec3::new(612345.678, 2398765.432, 5.0), radius: 10.0 }), 2.0);
let b = line(&mut s, [612350.678, 2398745.432], [612350.678, 2398785.432]);
trim(&mut s, c, [612335.678, 2398765.432], b);
let e = s.doc().unwrap().entity(c).unwrap().clone();
let EntityKind::Arc(a) = &e.kind else { panic!("not an arc: {:?}", e.kind) };
assert!(near(a.center, Vec3::new(612345.678, 2398765.432, 5.0), 1e-9), "{a:?}");
assert!((a.start - 5.235987755978257).abs() < 1e-9 && (a.end - 1.047197551201328).abs() < 1e-9, "{a:?}");
assert_eq!(e.common.thickness, 2.0);
}
#[test]
fn trim_keeps_a_polylines_elevation() {
let mut s = Session::new();
let p = add(&mut s, polyline(&[(0.0, 0.0, 0.0), (20.0, 0.0, 0.4), (30.0, 15.0, 0.0), (5.0, 20.0, 0.0)], 0.0, 12.5, false), 1.0);
let b = line(&mut s, [10.0, -10.0], [10.0, 30.0]);
trim(&mut s, p, [5.0, 0.0], b);
let EntityKind::LwPolyline(l) = kind(&s, p) else { panic!("not a polyline") };
assert_eq!(l.elevation, 12.5);
let want = [(10.0, 0.0, 0.0), (20.0, 0.0, 0.4), (30.0, 15.0, 0.0), (5.0, 20.0, 0.0)];
assert_eq!(l.vertices.len(), want.len());
for (v, w) in l.vertices.iter().zip(want) {
assert!(near(Vec3::new(v.p.x, v.p.y, v.bulge), Vec3::new(w.0, w.1, w.2), 1e-12), "{v:?} != {w:?}");
}
}
#[test]
fn break_and_trim_keep_a_polylines_constant_width_on_every_piece() {
// Measured for BREAK: a width-2 polyline broken from (705, 0) to (735, 0) leaves two width-2
// pieces. TRIM leaves its pieces the same way. Linetype generation is the polyline's setting
// too, so the pieces keep it (not measured).
let shape = [(700.0, 0.0, 0.0), (720.0, 0.0, 0.0), (740.0, 0.0, 0.0)];
let mut s = Session::new();
let p = add(&mut s, polyline(&shape, 2.0, 0.0, true), 0.0);
let r = s.execute("break", &json!({ "handle": p.hex(), "p1": [705, 0], "p2": [735, 0] })).unwrap();
let mut s2 = Session::new();
let q = add(&mut s2, polyline(&shape, 2.0, 0.0, true), 0.0);
let k1 = line(&mut s2, [705.0, -5.0], [705.0, 5.0]);
let k2 = line(&mut s2, [735.0, -5.0], [735.0, 5.0]);
let t = s2.execute("trim", &json!({ "handle": q.hex(), "pick": [720, 0], "edges": [k1.hex(), k2.hex()] })).unwrap();
for (s, r) in [(&s, &r), (&s2, &t)] {
let hs = r["handles"].as_array().unwrap();
assert_eq!(hs.len(), 2);
for h in hs {
let EntityKind::LwPolyline(l) = kind(s, Handle::parse_hex(h.as_str().unwrap()).unwrap()) else { panic!("not a polyline") };
assert_eq!((l.const_width, l.plinegen), (2.0, true));
}
}
}
+207 -143
View File
@@ -20,6 +20,7 @@ mod grid;
mod grips;
mod list;
mod pick;
mod press;
mod viewport;
mod widgets;
@@ -164,7 +165,7 @@ pub struct CanvasState {
/// A GRIP edit was running last frame (its grips go cold when it ends).
grip_editing: bool,
/// The grip whose menu (Stretch, Add Vertex, Lengthen…) a right-click opened.
grip_menu: Option<(Handle, usize)>,
pub(crate) grip_menu: Option<(Handle, usize)>,
/// Dynamic block grips of the selection (cached), the one being dragged, and the list grip
/// whose choices are open (and whether it opened this frame).
pub(crate) dyn_grips: crate::dyngrips::Cache,
@@ -181,8 +182,8 @@ pub struct CanvasState {
hover_frozen: Vec<String>,
/// Constraint glyphs for the parametric overlay (cached per drawing revision).
pub param: crate::parametric::Cache,
/// A selection window opened by a press-and-drag, to close where the button is let go.
drag_window: bool,
/// The primary-button press being held, when it was acted on (see [`press`]).
press: Option<press::Press>,
/// The right-click that opened the shortcut menu held Shift or Ctrl: it is the object snap
/// menu ([`crate::context_menu`]).
pub snap_menu: bool,
@@ -513,13 +514,7 @@ fn paint_content_highlights(frame: &mut CanvasPaint<'_>, bg: Rgb, sel: &[Handle]
}
}
fn paint_pointer_overlay(
frame: &mut CanvasPaint<'_>,
paper_rect: Option<Rect>,
surround: Color32,
selecting: bool,
sheet: Option<cadcraft_render::Sheet>,
) {
fn paint_pointer_overlay(frame: &mut CanvasPaint<'_>, paper_rect: Option<Rect>, surround: Color32, sheet: Option<cadcraft_render::Sheet>) {
let app = &mut *frame.app;
let ui = &mut *frame.ui;
let painter = frame.painter;
@@ -563,7 +558,8 @@ fn paint_pointer_overlay(
// Use the painted sheet even in MSPACE, where the editing transform follows a
// model viewport. The whole cursor takes one colour from its centre.
let ink = paper_rect.map_or(t.crosshair, |paper| crate::theme::crosshair_color(if paper.contains(hp) { t.paper } else { surround }));
draw_crosshair(app, painter, rect, hp, selecting, ink);
let picking = app.session.picking_objects() && app.session.pending_window.is_none();
draw_crosshair(app, painter, rect, hp, picking, ink);
if app.canvas.cycle_badge && app.canvas.cycle.is_none() {
cycle_badge(painter, hp);
}
@@ -611,12 +607,12 @@ fn handle_double_click(app: &mut CadApp, ctx: DoubleClickContext<'_>) -> Option<
if !in_active {
app.canvas.hot_grips.clear();
app.session.pending_window = None;
app.canvas.drag_window = false;
app.canvas.press = None;
if app.run("mspace", serde_json::json!({"at": [pp.x, pp.y]})).is_err() && active_viewport.is_some() {
let _ = app.run("pspace", serde_json::json!({}));
}
app.session.pending_window = None;
app.canvas.drag_window = false;
app.canvas.press = None;
app.canvas.list = None;
return None;
}
@@ -657,43 +653,7 @@ fn update_canvas_cursor(
) -> (Option<Vec2>, Option<crate::dyninput::Frame>) {
let raw_world = hover.filter(|_| inside).map(|p| xf.to_world(p));
let dyn_frame = crate::cmdline::dyn_frame(app);
if let Some(w) = raw_world {
let mut eff = effective_point(app, w, xf, ui.ctx());
// A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps.
if let Some(f) = dyn_frame
&& let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f)
&& e.first_locked().is_some()
{
eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked());
app.canvas.snap = None;
app.canvas.track = None;
}
// Grip dimensional input: typed lengths and angles hold the grip and override snaps.
let grip_held = crate::grip_dyn::constrain(app, eff);
if let Some(q) = grip_held {
eff = q;
app.canvas.snap = None;
app.canvas.track = None;
}
app.canvas.cursor = Some(eff);
app.session.cursor = eff;
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
// Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins.
if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) {
override_cursor(app, w, xf);
}
// Typed grip dimensions win over snap overrides too.
if let Some(q) = grip_held {
app.canvas.cursor = Some(q);
app.session.cursor = q;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
} else {
app.canvas.cursor = None;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
track_cursor(app, raw_world, xf, ui.ctx(), dyn_frame);
(raw_world, dyn_frame)
}
@@ -743,48 +703,91 @@ fn update_hover(app: &mut CadApp, ui: &egui::Ui, inside: bool, hover_pos: Option
}
}
struct PromptClickContext<'a> {
struct PressContext {
rect: Rect,
xf: Xf,
inside: bool,
middle_down: bool,
primary_clicked: bool,
response: &'a egui::Response,
mods: egui::Modifiers,
}
fn collect_prompt_clicks(app: &mut CadApp, ui: &egui::Ui, context: PromptClickContext<'_>) -> bool {
// egui drops a click whose button comes up a few pixels from where it went down (a drag to it),
// and eframe hands a slow frame's clicks over together, which egui reports as one.
let point_prompt = app.session.current_prompt().is_some_and(|p| cadcraft_engine::pointmod::accepts(&p))
&& app.session.pending_window.is_none()
&& !app.session.realtime_zoom_active();
let pressed_primary = context.primary_clicked || (point_prompt && context.response.drag_stopped_by(egui::PointerButton::Primary));
if point_prompt && context.inside && pressed_primary && !context.middle_down && app.cmd.options.is_none() && app.cmd.buffer.is_empty() {
let releases: Vec<egui::Pos2> = ui.input(|i| {
i.events
.iter()
.filter_map(|e| match e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(*pos),
_ => None,
})
.collect()
});
// The last one is placed below, at the cursor, like any click.
if let Some((_, earlier)) = releases.split_last() {
for pos in earlier.iter().filter(|p| context.rect.contains(**p)) {
let w = effective_point(app, context.xf.to_world(*pos), &context.xf, ui.ctx());
let result = match app.canvas.snap {
Some(hit) => app.session.input_snapped(hit),
None => app.session.input(Input::Point(w)),
};
if let Err(e) = result {
app.session.echo(e.to_string());
/// Clicks count when the button goes down, where it went down, however fast the mouse moves
/// (#1001, #815): each press among this frame's events places its point, picks its object or sets a
/// selection window's corner at once. What the pointer does while the button is held only decides
/// whether the press becomes a drag ([`press`]): a drag closes the window its press opened where
/// the button comes up; after a click the window waits for the next press. A press on a grip
/// (idle) clicks the grip when the button comes up near it, however long it was held (#2813).
/// Presses while ZOOM Realtime runs are left to the clicks in [`show`]. Returns whether a press
/// handled here was released this frame (its click must not count again).
fn handle_presses(app: &mut CadApp, ui: &egui::Ui, context: &PressContext) -> bool {
let PressContext { rect, xf, inside, middle_down, mods } = *context;
let (steps, now, primary_down) = ui.input(|i| (press::steps(&i.events), i.time, i.pointer.primary_down()));
let mut click_used = false;
for step in steps {
match step {
press::Step::Down(pos, m) => {
app.canvas.press = None;
if !inside || !rect.contains(pos) || middle_down {
continue;
}
// A press on the Dynamic Input options menu is the menu's (picked on release);
// elsewhere it closes the menu and counts as usual.
if app.cmd.options.is_some() {
if app.cmd.option_at(pos).is_some() {
continue;
}
app.cmd.options = None;
}
// Selection cycling: the press picks a row of the open list, or opens the list over
// overlapping objects (#1149). Its release must not count again.
if cycle_click(app, &xf, Some(pos), Some(xf.to_world(pos)), m.shift) {
app.canvas.press = Some(press::Press::new(pos, false));
continue;
}
if press_takes(app, &xf, pos) {
let opened = press_at(app, &xf, ui.ctx(), pos, m);
app.canvas.press = Some(press::Press::new(pos, opened));
} else if !app.session.realtime_zoom_active() {
// A grip with no command running: clicked when the button comes up. egui
// calls a press held longer than 0.8 s a drag, and a slow drawing's frames
// can make an ordinary click that long (#2813).
app.canvas.press = Some(press::Press::on_grip(pos, m));
}
}
press::Step::Move(pos) => {
if let Some(p) = &mut app.canvas.press {
p.moved(pos, now);
}
}
press::Step::Up(pos) => {
let Some(mut p) = app.canvas.press.take() else { continue };
click_used = true;
if p.is_on_grip() {
if let Some((at, m)) = p.grip_click(pos) {
if let Some(g) = crate::dyngrips::at(app, &xf, Some(at)) {
crate::dyngrips::click(app, g);
} else if let Some(g) = grip_at(app, &xf, Some(at)) {
click_grip(app, g, m.shift);
}
}
continue;
}
// PICKDRAG off: a window takes two clicks, a drag doesn't close it (#1032).
if app.session.settings.pickdrag && p.released_as_drag(pos, now) && p.opened_window && app.session.pending_window.is_some() {
let end = xf.to_world(pos);
let done = if app.session.prompting() { app.session.input(Input::Point(end)) } else { app.session.idle_click(end, mods.shift) };
if let Err(e) = done {
app.session.echo(e.to_string());
}
}
}
}
}
pressed_primary
if !primary_down {
// The button came up where we didn't see it (outside the window, say).
app.canvas.press = None;
}
click_used
}
/// Whether a quick right-click cancels the running command instead of acting as Enter: it asks for
@@ -872,8 +875,21 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
return;
};
let pressed_primary =
collect_prompt_clicks(app, ui, PromptClickContext { rect, xf, inside, middle_down, primary_clicked: pressed_primary, response: &resp });
// Selection cycling's list closes when the prompt, the drawing or the view changes.
let key: CycleKey = (
app.session.running.as_ref().map(|r| r.id.clone()),
app.session.current_prompt().map(|p| p.message),
app.session.state().map_or(0, |st| st.uid),
app.session.state().map_or(0, |st| st.revision),
xf.center,
xf.scale,
);
if app.canvas.cycle_key.as_ref() != Some(&key) {
app.canvas.cycle = None;
app.canvas.hover_cycle = None;
app.canvas.cycle_key = Some(key);
}
let click_used = handle_presses(app, ui, &PressContext { rect, xf, inside, middle_down, mods });
let (raw_world, dyn_frame) = update_canvas_cursor(app, ui, &xf, inside, hover_pos);
@@ -893,26 +909,14 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
let idle_dbl = dbl_primary && app.session.running.is_none();
if idle_dbl {
app.session.pending_window = None;
app.canvas.drag_window = false;
app.canvas.press = None;
}
let pressed_primary = pressed_primary && !picked && !hatch_dialog && !idle_dbl;
let key: CycleKey = (
app.session.running.as_ref().map(|r| r.id.clone()),
app.session.current_prompt().map(|p| p.message),
app.session.state().map_or(0, |st| st.uid),
app.session.state().map_or(0, |st| st.revision),
xf.center,
xf.scale,
);
if app.canvas.cycle_key.as_ref() != Some(&key) {
app.canvas.cycle = None;
app.canvas.hover_cycle = None;
app.canvas.cycle_key = Some(key);
}
let cycled = pressed_primary && !middle_down && cycle_click(app, &xf, hover_pos, raw_world.filter(|_| inside), mods.shift);
// Clicks.
let cycled = pressed_primary && !click_used && !middle_down && cycle_click(app, &xf, hover_pos, raw_world.filter(|_| inside), mods.shift);
// Clicks the presses above left alone: on grips, and during ZOOM Realtime.
if inside
&& pressed_primary
&& !click_used
&& !middle_down
&& !cycled
&& let Some(p) = app.canvas.cursor
@@ -944,58 +948,31 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
app.session.echo(e.to_string());
}
}
// Press-and-drag selection window (PICKDRAG = 2; click-click still works): a drag
// that starts while objects are being selected opens a window where the button went down,
// and letting go closes it. Drags on grips and drags while drawing are left alone.
if !app.session.settings.pickdrag {
app.canvas.drag_window = false;
}
if app.session.settings.pickdrag
&& resp.drag_started_by(egui::PointerButton::Primary)
&& !middle_down
&& app.canvas.cycle.is_none()
&& app.session.pending_window.is_none()
&& let Some(origin) = ui.input(|i| i.pointer.press_origin())
&& rect.contains(origin)
&& grip_at(app, &xf, Some(origin)).is_none()
&& crate::dyngrips::at(app, &xf, Some(origin)).is_none()
{
app.canvas.drag_window = app.session.begin_window(xf.to_world(origin));
}
if app.canvas.drag_window && resp.drag_stopped_by(egui::PointerButton::Primary) {
app.canvas.drag_window = false;
if app.session.pending_window.is_some()
&& let Some(end) = ui.input(|i| i.pointer.interact_pos())
{
let end = xf.to_world(end);
let done = if app.session.prompting() { app.session.input(Input::Point(end)) } else { app.session.idle_click(end, mods.shift) };
if let Err(e) = done {
app.session.echo(e.to_string());
}
}
}
// Right-click acts as Enter while a command runs (the classic CAD default; held, it opens the
// command menu); otherwise it opens the shortcut menu (Repeat, Clipboard, …).
// Shift/Ctrl+right-click opens the object snap menu.
// A quick right-click is Enter (the classic CAD default): it enters what was typed, ends the
// input of a running command, and between commands repeats the last one. Held, it opens the
// command menu or the shortcut menu (Repeat, Clipboard, …). Shift/Ctrl+right-click opens the
// object snap menu.
let idle = !app.session.prompting();
if inside && pressed_secondary {
app.canvas.snap_menu = mods.shift || mods.ctrl;
}
if crate::context_menu::in_command(app, ui, inside, pressed_secondary) {
if right_click_cancels_placing(app) {
crate::cmdline::escape(app);
} else {
let _ = app.session.input(Input::Enter);
}
}
// Right-click on a grip with options (polyline vertex, line end…) opens the grip menu.
if inside && pressed_secondary && idle && !app.canvas.snap_menu {
app.canvas.grip_menu = grip_at(app, &xf, hover_pos).filter(|g| !grip_options(app, *g).is_empty());
}
let enter = crate::context_menu::in_command(app, ui, inside, pressed_secondary);
if enter {
if right_click_cancels_placing(app) {
crate::cmdline::escape(app);
} else {
// As the Enter key does: what was typed (`rec`, `@10,0`), or Enter when nothing was.
crate::cmdline::submit(app);
}
}
crate::dyngrips::menu(app, ui.ctx(), &xf);
if idle && !app.canvas.snap_menu && app.canvas.grip_menu.is_some() {
grip_menu(app, &resp);
} else if idle || app.canvas.snap_menu {
} else if (idle && !enter) || app.canvas.snap_menu {
crate::context_menu::show(app, &resp);
}
@@ -1021,6 +998,95 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
});
}
/// Put the cursor at `raw` (world, `None` off the canvas): snaps, ortho and polar, a locked
/// Dynamic Input value and typed grip dimensions applied (`app.canvas.cursor`, `.snap`, `.track`).
fn track_cursor(app: &mut CadApp, raw: Option<Vec2>, xf: &Xf, ctx: &egui::Context, dyn_frame: Option<crate::dyninput::Frame>) {
if let Some(w) = raw {
let mut eff = effective_point(app, w, xf, ctx);
// A locked Dynamic Input value (`40,` or `40<` typed) holds the cursor and overrides snaps.
if let Some(f) = dyn_frame
&& let Some(e) = crate::dyninput::parse(&app.cmd.buffer, &f)
&& e.first_locked().is_some()
{
eff = crate::dyninput::constrain(&e, &f, eff, app.cmd.second_locked());
app.canvas.snap = None;
app.canvas.track = None;
}
// Grip dimensional input: typed lengths and angles hold the grip and override snaps.
let grip_held = crate::grip_dyn::constrain(app, eff);
if let Some(q) = grip_held {
eff = q;
app.canvas.snap = None;
app.canvas.track = None;
}
app.canvas.cursor = Some(eff);
app.session.cursor = eff;
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
// Typed or menu snap overrides (END, NON…) and Tab cycling; a locked Dynamic Input value wins.
if dyn_frame.and_then(|f| crate::dyninput::parse(&app.cmd.buffer, &f)).is_none_or(|e| e.first_locked().is_none()) {
override_cursor(app, w, xf);
}
// Typed grip dimensions win over snap overrides too.
if let Some(q) = grip_held {
app.canvas.cursor = Some(q);
app.session.cursor = q;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
} else {
app.canvas.cursor = None;
app.canvas.snap = None;
app.session.cursor_deferred = None;
}
}
/// Whether the press at `pos` is acted on when the button goes down ([`press_at`]): at any prompt
/// and on the drawing with no command running. Grips (with no command running) and ZOOM Realtime
/// keep their clicks.
fn press_takes(app: &mut CadApp, xf: &Xf, pos: Pos2) -> bool {
if app.session.realtime_zoom_active() {
return false;
}
if app.session.prompting() {
return true;
}
crate::dyngrips::at(app, xf, Some(pos)).is_none() && grip_at(app, xf, Some(pos)).is_none()
}
/// Act on a press at `pos`: at a prompt the point goes in (snapped as the cursor would be there);
/// with no command running it picks the object there or sets a selection window's corner.
/// Returns whether the press opened a selection window.
fn press_at(app: &mut CadApp, xf: &Xf, ctx: &egui::Context, pos: Pos2, mods: egui::Modifiers) -> bool {
let had_window = app.session.pending_window.is_some();
let raw = xf.to_world(pos);
let dyn_frame = crate::cmdline::dyn_frame(app);
track_cursor(app, Some(raw), xf, ctx, dyn_frame);
let Some(p) = app.canvas.cursor else { return false };
if app.session.prompting() {
// Ctrl held while picking the point of a grip edit makes copies (the Copy option).
if mods.ctrl && app.session.running.as_ref().is_some_and(|r| r.id == "grip") {
let _ = app.session.input(Input::Keyword("Copy".into()));
}
// Clicking places the point; a value typed into the Dynamic Input boxes is used up.
if let Some(f) = dyn_frame
&& crate::dyninput::parse(&app.cmd.buffer, &f).is_some()
{
app.cmd.buffer.clear();
}
// Preserve a snap's viewport origin for DIST, and its deferred curve where needed.
let result = match app.canvas.snap {
Some(hit) => app.session.input_snapped(hit),
None => app.session.input(Input::Point(p)),
};
if let Err(e) = result {
app.session.echo(e.to_string());
}
} else if let Err(e) = app.session.idle_click(raw, mods.shift) {
app.session.echo(e.to_string());
}
!had_window && app.session.pending_window.is_some()
}
fn paint_canvas(frame: CanvasPaint<'_>) {
let CanvasPaint {
app,
@@ -1041,7 +1107,6 @@ fn paint_canvas(frame: CanvasPaint<'_>) {
raw_world,
} = frame;
let scale = xf.scale;
let selecting = app.session.previews_selection();
painter.rect_filled(rect, 0.0, t.canvas);
let t0 = crate::now_ms();
let mut views = vec![(xf_paper.world_bounds(), 1.0 / xf_paper.scale)];
@@ -1223,7 +1288,6 @@ fn paint_canvas(frame: CanvasPaint<'_>) {
},
paper_rect,
surround,
selecting,
sheet,
);
}
+21 -12
View File
@@ -212,28 +212,37 @@ pub(super) fn override_cursor(app: &mut CadApp, raw: Vec2, xf: &Xf) {
app.session.cursor_deferred = app.canvas.snap.and_then(|h| h.deferred);
}
/// Half the side of the pick box (`PICKBOX * 1.5` screen points), or `None` when `PICKBOX` is 0.
fn pickbox_half(pickbox: f64) -> Option<f32> {
let half = (pickbox * 1.5) as f32;
(half.is_finite() && half >= 1.0).then_some(half)
}
/// Draws the canvas cursor at `at`: the full crosshair with pickbox when idle, crosshair lines
/// only at point prompts, and the pickbox square alone at command object-selection prompts.
pub(super) fn draw_crosshair(app: &CadApp, p: &egui::Painter, rect: Rect, at: Pos2, pickbox: bool, ink: Color32) {
let st = Stroke::new(1.0, ink);
let len = (rect.height() * app.session.settings.cursorsize as f32 / 100.0).max(12.0);
let pb = if pickbox { pickbox_half(app.session.settings.pickbox) } else { None };
let picking_in_cmd = pickbox && app.session.current_prompt().is_some_and(|pr| pr.picks_objects());
let pb = if pickbox { pickbox_half(app.session.settings.pickbox).or(picking_in_cmd.then_some(1.5)) } else { None };
let gap = pb.unwrap_or(0.0);
// Along the isometric plane's axes in isometric drafting.
if app.session.settings.isodraft {
for a in cadcraft_engine::snap::iso::cursor_axes(&app.session.settings) {
let dir = vec2(a.cos() as f32, -(a.sin() as f32));
p.line_segment([at - dir * len, at - dir * gap], st);
p.line_segment([at + dir * gap, at + dir * len], st);
// At a command prompt that selects objects, AutoCAD shows only the pickbox square (no
// crosshair lines); when idle or once a selection window corner is picked, the crosshair
// lines are drawn.
if !picking_in_cmd {
// Along the isometric plane's axes in isometric drafting.
if app.session.settings.isodraft {
for a in cadcraft_engine::snap::iso::cursor_axes(&app.session.settings) {
let dir = vec2(a.cos() as f32, -(a.sin() as f32));
p.line_segment([at - dir * len, at - dir * gap], st);
p.line_segment([at + dir * gap, at + dir * len], st);
}
} else {
p.line_segment([pos2(at.x - len, at.y), pos2(at.x - gap, at.y)], st);
p.line_segment([pos2(at.x + gap, at.y), pos2(at.x + len, at.y)], st);
p.line_segment([pos2(at.x, at.y - len), pos2(at.x, at.y - gap)], st);
p.line_segment([pos2(at.x, at.y + gap), pos2(at.x, at.y + len)], st);
}
} else {
p.line_segment([pos2(at.x - len, at.y), pos2(at.x - gap, at.y)], st);
p.line_segment([pos2(at.x + gap, at.y), pos2(at.x + len, at.y)], st);
p.line_segment([pos2(at.x, at.y - len), pos2(at.x, at.y - gap)], st);
p.line_segment([pos2(at.x, at.y + gap), pos2(at.x, at.y + len)], st);
}
if let Some(pb) = pb {
p.rect_stroke(Rect::from_center_size(at, vec2(pb * 2.0, pb * 2.0)), 0.0, st, egui::StrokeKind::Middle);
+167
View File
@@ -0,0 +1,167 @@
//! Press-first clicks (#1001): a click on the canvas counts when the primary button goes down, at
//! the spot where it went down, however fast the mouse is moving. Where the pointer goes while the
//! button is held only decides whether the press also becomes a drag:
//!
//! - holding still, or staying within [`TOLERANCE`] of the press, never makes a drag;
//! - once the pointer leaves the tolerance a timer starts; a button still down [`DRAG_DELAY`]
//! later is a drag (a selection window the press opened closes where the button comes up);
//! - a button that comes up sooner was a click (the window waits for the next press).
//!
//! The timer starts on leaving the tolerance, not on the press: pressing, holding still and then
//! moving and letting go quickly is still a click, as in AutoCAD.
//!
//! A press on a grip with no command running ([`Press::on_grip`]) is the exception: the grip is
//! clicked when the button comes up within [`TOLERANCE`] of the press, however long it was held
//! (#2813), and a drag from it does nothing.
use egui::{Modifiers, Pos2};
/// How far (points) the pointer may wander from the press before the timer starts.
pub(crate) const TOLERANCE: f32 = 6.0;
/// How long (seconds) the button must stay down after the pointer left [`TOLERANCE`] for the
/// press to be a drag.
pub(crate) const DRAG_DELAY: f64 = 0.25;
/// A primary-button press being held.
#[derive(Clone, Copy, Debug)]
pub(crate) struct Press {
origin: Pos2,
/// When the pointer first went further than [`TOLERANCE`] from `origin` (seconds).
left_at: Option<f64>,
/// The press opened a selection window (set its first corner).
pub(crate) opened_window: bool,
/// The press went down on a grip with no command running, with these modifiers: it is a click
/// on the grip if the button comes up near it ([`Self::grip_click`]).
on_grip: Option<Modifiers>,
}
impl Press {
pub(crate) fn new(origin: Pos2, opened_window: bool) -> Self {
Self { origin, left_at: None, opened_window, on_grip: None }
}
/// A press on a grip with no command running, acted on when the button comes up.
pub(crate) fn on_grip(origin: Pos2, modifiers: Modifiers) -> Self {
Self { origin, left_at: None, opened_window: false, on_grip: Some(modifiers) }
}
/// For a press on a grip ([`Self::on_grip`]) whose button came up at `pos`: `Some` (where it
/// went down, the modifiers then) when that is a click on the grip, within [`TOLERANCE`] of the
/// press however long the button was held; `None` for a drag from it or a press elsewhere.
pub(crate) fn grip_click(&self, pos: Pos2) -> Option<(Pos2, Modifiers)> {
let modifiers = self.on_grip?;
(pos.distance(self.origin) <= TOLERANCE).then_some((self.origin, modifiers))
}
/// Whether the press went down on a grip ([`Self::on_grip`]).
pub(crate) fn is_on_grip(&self) -> bool {
self.on_grip.is_some()
}
/// The pointer is at `pos` at time `now`.
pub(crate) fn moved(&mut self, pos: Pos2, now: f64) {
if self.left_at.is_none() && pos.distance(self.origin) > TOLERANCE {
self.left_at = Some(now);
}
}
/// Whether the button coming up at `pos` at time `now` ends a drag rather than a click.
pub(crate) fn released_as_drag(&mut self, pos: Pos2, now: f64) -> bool {
self.moved(pos, now);
self.left_at.is_some_and(|t| now - t >= DRAG_DELAY)
}
}
/// A primary-button event of the frame, in order.
#[derive(Clone, Copy, Debug, PartialEq)]
pub(crate) enum Step {
Down(Pos2, Modifiers),
Move(Pos2),
Up(Pos2),
}
/// The primary-button presses, pointer moves and releases among a frame's events, in order. A slow
/// frame can hold several clicks; each press is its own step (#815).
pub(crate) fn steps(events: &[egui::Event]) -> Vec<Step> {
events
.iter()
.filter_map(|e| match *e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: true, modifiers } => Some(Step::Down(pos, modifiers)),
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, .. } => Some(Step::Up(pos)),
egui::Event::PointerMoved(pos) => Some(Step::Move(pos)),
_ => None,
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use egui::pos2;
#[test]
fn staying_within_the_tolerance_is_a_click_however_long_the_button_is_held() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(104.0, 103.0), 0.5);
assert!(!p.released_as_drag(pos2(105.0, 100.0), 5.0));
}
#[test]
fn letting_go_soon_after_leaving_the_tolerance_is_a_click() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(112.0, 100.0), 1.0);
assert!(!p.released_as_drag(pos2(130.0, 100.0), 1.0 + DRAG_DELAY / 2.0));
}
#[test]
fn holding_still_then_moving_and_letting_go_quickly_is_a_click() {
// The timer starts when the pointer leaves the tolerance, not when the button goes down.
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(101.0, 100.0), 2.0);
assert!(!p.released_as_drag(pos2(140.0, 100.0), 2.05));
}
#[test]
fn a_button_still_down_after_the_delay_is_a_drag() {
let mut p = Press::new(pos2(100.0, 100.0), true);
p.moved(pos2(110.0, 100.0), 1.0);
p.moved(pos2(200.0, 150.0), 1.1);
assert!(p.released_as_drag(pos2(250.0, 160.0), 1.0 + DRAG_DELAY));
}
#[test]
fn a_grip_press_is_a_click_where_it_went_down_only_when_let_go_near_it() {
let p = Press::on_grip(pos2(100.0, 100.0), Modifiers::SHIFT);
assert!(p.is_on_grip());
assert_eq!(p.grip_click(pos2(103.0, 104.0)), Some((pos2(100.0, 100.0), Modifiers::SHIFT)));
assert_eq!(p.grip_click(pos2(120.0, 100.0)), None, "a drag from the grip is no click");
let elsewhere = Press::new(pos2(100.0, 100.0), false);
assert!(!elsewhere.is_on_grip());
assert_eq!(elsewhere.grip_click(pos2(100.0, 100.0)), None);
}
#[test]
fn steps_keep_every_press_of_a_slow_frame_in_order() {
let at = |x| pos2(x, 10.0);
let button =
|x, pressed| egui::Event::PointerButton { pos: at(x), button: egui::PointerButton::Primary, pressed, modifiers: Modifiers::NONE };
let events = vec![
egui::Event::PointerMoved(at(1.0)),
button(1.0, true),
button(1.0, false),
egui::Event::PointerButton { pos: at(2.0), button: egui::PointerButton::Secondary, pressed: true, modifiers: Modifiers::NONE },
button(3.0, true),
button(3.0, false),
];
assert_eq!(
steps(&events),
vec![
Step::Move(at(1.0)),
Step::Down(at(1.0), Modifiers::NONE),
Step::Up(at(1.0)),
Step::Down(at(3.0), Modifiers::NONE),
Step::Up(at(3.0))
]
);
}
}
+60
View File
@@ -249,6 +249,66 @@ fn clicking_a_hot_grip_leaves_hidden_objects_out_of_the_stretch() {
assert_eq!(app.canvas.hot_grips, vec![(shown, 0)], "the hidden object's grip must leave the hot set");
}
/// Verifies that command object-selection prompts draw only the pickbox square while idle and
/// point prompts draw the crosshair lines.
#[test]
fn cursor_shows_pickbox_only_at_command_object_selection_prompts() {
let mut app = CadApp::new(cadcraft_engine::Session::new(), crate::Services::default());
let rect = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
let at = pos2(400.0, 300.0);
let paint = |app: &CadApp| {
let ctx = egui::Context::default();
let mut out = ctx.run_ui(egui::RawInput::default(), |ui| {
let painter = ui.painter_at(rect);
let picking = app.session.picking_objects() && app.session.pending_window.is_none();
draw_crosshair(app, &painter, rect, at, picking, Color32::WHITE);
});
out.textures_delta.clear();
let mut lines = 0usize;
let mut rects = 0usize;
for clipped in &out.shapes {
match &clipped.shape {
Shape::LineSegment { .. } => lines += 1,
Shape::Rect(r) if r.rect.center() == at => rects += 1,
_ => {}
}
}
(lines, rects)
};
// 1. Idle with PICKFIRST on: crosshair lines (4 segments) + pickbox square (1 rect).
assert_eq!(paint(&app), (4, 1), "idle with PICKFIRST on");
// 2. Idle with SELECTIONPREVIEW = 0: pickbox still drawn while PICKFIRST is on.
app.session.settings.selectionpreview = 0;
assert_eq!(paint(&app), (4, 1), "idle with SELECTIONPREVIEW = 0");
app.session.settings.selectionpreview = 3;
// 3. Command asking for points (LINE): crosshair lines only (4 segments, 0 rects).
app.session.cmdline("line").unwrap();
assert_eq!(paint(&app), (4, 0), "point prompt (LINE)");
app.session.cancel();
// 4. Command asking to select objects (ERASE): pickbox square only (0 segments, 1 rect).
app.session.cmdline("erase").unwrap();
assert_eq!(paint(&app), (0, 1), "object selection prompt (ERASE)");
// 5. Even when PICKBOX = 0, a command object-selection prompt keeps a minimal visible pickbox.
app.session.settings.pickbox = 0.0;
assert_eq!(paint(&app), (0, 1), "object selection prompt with PICKBOX = 0");
app.session.settings.pickbox = 3.0;
// 6. While picking the second corner of a selection window, the crosshair lines return.
app.session.pending_window = Some(cadcraft_engine::PendingWindow { corner: Vec2::ZERO, during_command: true });
assert_eq!(paint(&app), (4, 0), "selection window second corner");
app.session.pending_window = None;
app.session.cancel();
// 7. STRETCH's "Remove objects" prompt also draws the pickbox-only cursor.
app.session.cmdline("stretch r").unwrap();
assert_eq!(paint(&app), (0, 1), "STRETCH Remove objects prompt");
}
/// Makes the layer "Hidden" and, on Layout1, two viewports over the model: the first freezes
/// "Hidden", the second freezes nothing. The app is left in paper space.
fn viewports_freezing_hidden(app: &mut CadApp) -> (String, String) {
+26 -14
View File
@@ -1,6 +1,7 @@
//! The canvas's right-click menus, after AutoCAD's shortcut menus:
//!
//! - **No command running** ([`entries`]): Repeat the last command, Recent Commands, the
//! - **No command running** ([`entries`], opened by holding the button: a quick right-click is
//! Enter, which repeats the last command): Repeat the last command, Recent Commands, the
//! Clipboard and Isolate; with a selection the editing commands, Draw Order, Group, the edit
//! commands of the selected object type, Select Similar and Deselect All; then Undo/Redo,
//! Pan/Zoom, Quick Select, Find, Properties and Options.
@@ -10,8 +11,8 @@
//! Preferences ▸ Right-Click Customization sets how long, `rightClickDuration`). With that turned
//! off (`timeSensitiveRightClick`), Command mode says what a right-click does
//! (`rightClickCommand`: the menu, Enter, or the menu only when the prompt has options).
//! `rightClickDefault` and `rightClickEdit` can make a right-click with no command running
//! repeat the last command instead of opening the menu.
//! With it off, `rightClickDefault` and `rightClickEdit` can make a right-click with no command
//! running repeat the last command instead of opening the menu.
//! - **Shift/Ctrl+right-click** ([`snap_entries`]): the object snap menu. Its items type the point
//! modifiers and snap overrides (`_from`, `_endp`, `_non`…) at the current point prompt.
//!
@@ -387,13 +388,16 @@ pub fn groups_ui(ui: &mut egui::Ui, groups: &[Vec<Entry>], clicked: &mut Option<
pub fn show(app: &mut CadApp, resp: &egui::Response) {
let mut clicked = None;
let snap = app.canvas.snap_menu;
// Right-Click Customization: with nothing selected (Default mode) or a selection (Edit mode),
// a right-click may repeat the last command instead of opening the menu. With no last command
// yet, it opens the menu.
// Right-Click Customization: with the time-sensitive right-click off and nothing selected
// (Default mode) or a selection (Edit mode), a right-click may repeat the last command instead
// of opening the menu. With no last command yet, it opens the menu. With the time-sensitive
// right-click on, a quick click is already Enter ([`in_command`]) and a longer one is this
// menu, as in AutoCAD.
let o = &app.options;
let mode =
if o.right_click_default == o.right_click_edit || app.session.selection().is_empty() { o.right_click_default } else { o.right_click_edit };
if !snap
&& !o.time_sensitive_right_click
&& mode == crate::options::IdleClick::Repeat
&& let Some(last) = app.session.last_command.clone()
{
@@ -417,13 +421,15 @@ pub fn show(app: &mut CadApp, resp: &egui::Response) {
#[derive(Clone, Copy, Default)]
struct Press(f64, egui::Pos2);
/// The canvas's right button while a command runs (Shift/Ctrl+right-click is the snap menu's): a
/// quick click is Enter — returns `true` when the caller should send it — and a click held for
/// OPTIONS `rightClickDuration` opens the command menu ([`command_entries`]) at the pointer. With
/// the time-sensitive right-click turned off, `rightClickCommand` says whether a click opens the
/// menu or is Enter. Call it every frame
/// with whether the pointer is on the canvas and whether a right-click ended there; it also shows
/// the menu while it is open.
/// The canvas's right button (Shift/Ctrl+right-click is the snap menu's). With the time-sensitive
/// right-click on, a quick click is Enter — returns `true` when the caller should send it; between
/// commands that runs what was typed or repeats the last command — and while a command runs a
/// click held for OPTIONS `rightClickDuration` opens the command menu ([`command_entries`]) at the
/// pointer (between commands a held click is left to the caller's shortcut menu). With it turned
/// off, `rightClickCommand` says whether a click while a command runs opens the menu or is Enter,
/// and between commands the caller follows `rightClickDefault` and `rightClickEdit`. Call it every
/// frame with whether the pointer is on the canvas and whether a right-click ended there; it also
/// shows the menu while it is open.
pub fn in_command(app: &mut CadApp, ui: &egui::Ui, inside: bool, right_clicked: bool) -> bool {
let ctx = ui.ctx().clone();
let press_id = egui::Id::unique("cc_command_menu_press");
@@ -448,15 +454,21 @@ pub fn in_command(app: &mut CadApp, ui: &egui::Ui, inside: bool, right_clicked:
};
let hold = f64::from(o.right_click_hold_ms) / 1000.0;
let mut open = false;
let mut quick = false;
if released && let Some(Press(t0, p0)) = ctx.data_mut(|d| d.remove_temp::<Press>(press_id)) {
// A drag isn't a click; a click held long enough asks for the menu.
let still = pos.is_some_and(|p| p.distance(p0) <= 6.0);
let held = if timed { now - t0 >= hold } else { menu };
open = running && still && held;
quick = !held;
}
let enter = running && inside && right_clicked && !open && (timed || !menu);
if !running {
return false;
// Between commands a quick click is Enter too (as in AutoCAD): it runs the typed command,
// or repeats the last one; held, it opens the shortcut menu. A grip with options keeps
// its menu.
let something = !app.cmd.buffer.trim().is_empty() || app.session.last_command.is_some();
return timed && quick && inside && right_clicked && !app.canvas.snap_menu && app.canvas.grip_menu.is_none() && something;
}
let mut clicked = None;
let popup = egui::Popup::new(popup_id, ctx, egui::PopupAnchor::PointerFixed, ui.layer_id())
+8 -5
View File
@@ -16,9 +16,9 @@
//! | `SAVETIME` | minutes between automatic saves, 0–600 (0: off) |
//! | `SAVEFILEPATH` | the folder automatic saves go to |
//! | `ISAVEBAK` | 1: saving over a drawing keeps the previous file as `<name>.bak` (default); 0: no backup |
//! | `timeSensitiveRightClick` | while a command runs, a quick right-click is Enter and holding the button opens the shortcut menu (default); `false`: `rightClickCommand` decides |
//! | `timeSensitiveRightClick` | a quick right-click is Enter (between commands it runs what was typed, or repeats the last command) and holding the button opens the shortcut menu (default); `false`: `rightClickCommand` decides while a command runs, `rightClickDefault` and `rightClickEdit` between commands |
//! | `rightClickDuration` | how long the right button is held to open the menu while a command runs, 100–2000 ms (250) |
//! | `rightClickDefault`, `rightClickEdit` | a right-click with no command running and nothing (`Default`) or something (`Edit`) selected: `"menu"` (the shortcut menu, default) or `"repeat"` (the last command) |
//! | `rightClickDefault`, `rightClickEdit` | with the time-sensitive right-click off, a right-click with no command running and nothing (`Default`) or something (`Edit`) selected: `"menu"` (the shortcut menu, default) or `"repeat"` (the last command) |
//! | `rightClickCommand` | a right-click while a command runs, with the time-sensitive right-click off: `"menu"` (default), `"enter"`, or `"menuWithOptions"` (the menu when the prompt has options, else Enter) |
//! | `systemCursor` | keep the system cursor visible over the drawing area |
//! | `historyLines` | command-line history lines, 0–12 |
@@ -139,13 +139,16 @@ pub struct UiOptions {
pub snap_marker_size: f32,
/// The selection highlight colour; `None` keeps the theme's.
pub selection_color: Option<Color32>,
/// While a command runs: a quick right-click is Enter and a held one opens the shortcut menu
/// (AutoCAD's time-sensitive right-click). Off: [`Self::right_click_command`] decides.
/// A quick right-click is Enter and a held one opens the shortcut menu (AutoCAD's
/// time-sensitive right-click). Between commands that Enter runs what was typed, or repeats
/// the last command; with neither, the click opens the shortcut menu. Off:
/// [`Self::right_click_command`] decides while a command runs, and [`Self::right_click_default`]
/// and [`Self::right_click_edit`] between commands.
pub time_sensitive_right_click: bool,
/// How long the right button is held to open the menu while a command runs, in milliseconds.
pub right_click_hold_ms: u32,
/// A right-click with no command running and nothing selected (Default mode) or a selection
/// (Edit mode).
/// (Edit mode), with the time-sensitive right-click off.
pub right_click_default: IdleClick,
pub right_click_edit: IdleClick,
/// A right-click while a command runs, with the time-sensitive right-click off.
+26 -14
View File
@@ -615,23 +615,35 @@ fn right_click_window(o: &super::UiOptions, ctx: &egui::Context, open: &mut bool
ui.label(crate::tl!("milliseconds"));
});
hint(ui, crate::tl!("While a command runs, a quick click is Enter and a longer click opens the shortcut menu."));
hint(ui, crate::tl!("With no command running, a quick click repeats the last command or runs what was typed."));
});
ui.add_space(6.0);
for (title, note, key, current) in [
(crate::tl!("Default Mode"), crate::tl!("No objects selected and no command running:"), "rightClickDefault", o.right_click_default),
(crate::tl!("Edit Mode"), crate::tl!("Objects selected and no command running:"), "rightClickEdit", o.right_click_edit),
] {
heading(ui, title);
ui.group(|ui| {
ui.set_width(ui.available_width());
hint(ui, note);
for (choice, label) in [(IdleClick::Repeat, crate::tl!("Repeat last command")), (IdleClick::Menu, crate::tl!("Shortcut Menu"))] {
if ui.radio(current == choice, label).clicked() && current != choice {
changes.insert(key.into(), json!(choice.as_str()));
// Like Command mode, Default and Edit modes decide only with the time-sensitive
// right-click off: with it on, a quick click is Enter and a longer one the menu.
ui.add_enabled_ui(!o.time_sensitive_right_click, |ui| {
for (title, note, key, current) in [
(
crate::tl!("Default Mode"),
crate::tl!("No objects selected and no command running:"),
"rightClickDefault",
o.right_click_default,
),
(crate::tl!("Edit Mode"), crate::tl!("Objects selected and no command running:"), "rightClickEdit", o.right_click_edit),
] {
heading(ui, title);
ui.group(|ui| {
ui.set_width(ui.available_width());
hint(ui, note);
for (choice, label) in
[(IdleClick::Repeat, crate::tl!("Repeat last command")), (IdleClick::Menu, crate::tl!("Shortcut Menu"))]
{
if ui.radio(current == choice, label).clicked() && current != choice {
changes.insert(key.into(), json!(choice.as_str()));
}
}
}
});
}
});
}
});
ui.add_enabled_ui(!o.time_sensitive_right_click, |ui| {
heading(ui, crate::tl!("Command Mode"));
ui.group(|ui| {
+38
View File
@@ -240,4 +240,42 @@ fn time_sensitive_right_click() {
painted(&mut app, &ctx, Vec::new(), 3.1);
assert!(app.session.running.is_none(), "a quick right-click is Enter: {}", app.session.prompt_text());
assert_eq!(app.session.doc().unwrap().model.handles().len(), 1);
// Between commands a quick right-click is Enter too: it repeats LINE (it opened the shortcut
// menu instead).
painted(&mut app, &ctx, vec![quick(true)], 4.0);
painted(&mut app, &ctx, vec![quick(false)], 4.05);
let text = painted(&mut app, &ctx, Vec::new(), 4.1);
assert!(app.session.running.is_some(), "a quick right-click repeats LINE: {}", app.session.prompt_text());
assert!(!text.contains("Repeat LINE"), "no shortcut menu on a quick click:\n{text}");
app.session.input(cadcraft_engine::Input::Cancel).unwrap();
// Held, it opens the shortcut menu and repeats nothing.
painted(&mut app, &ctx, vec![quick(true)], 5.0);
painted(&mut app, &ctx, Vec::new(), 5.2);
painted(&mut app, &ctx, vec![quick(false)], 5.0 + context_menu::HOLD_SECS + 0.1);
let text = painted(&mut app, &ctx, Vec::new(), 5.5);
assert!(text.contains("Repeat LINE"), "Repeat LINE missing from the painted menu:\n{text}");
assert!(app.session.running.is_none(), "held, no repeat: {}", app.session.prompt_text());
// A quick click enters what was typed, as the Enter key does (#1387): a command name between
// commands (not a repeat of LINE)…
painted(
&mut app,
&ctx,
vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }],
5.6,
);
// The menu closes on the frame after Escape.
painted(&mut app, &ctx, Vec::new(), 5.7);
app.cmd.buffer = "circle".into();
painted(&mut app, &ctx, vec![quick(true)], 6.0);
painted(&mut app, &ctx, vec![quick(false)], 6.05);
painted(&mut app, &ctx, Vec::new(), 6.1);
assert!(app.session.prompt_text().contains("center point"), "the typed CIRCLE starts: {}", app.session.prompt_text());
// …and a point while a command runs.
app.cmd.buffer = "5,5".into();
painted(&mut app, &ctx, vec![quick(true)], 7.0);
painted(&mut app, &ctx, vec![quick(false)], 7.05);
painted(&mut app, &ctx, Vec::new(), 7.1);
assert!(app.session.prompt_text().contains("radius"), "the typed center is entered: {}", app.session.prompt_text());
}
+3
View File
@@ -21,6 +21,7 @@ mod instant_modals;
mod lisp_files;
mod measure_distance_snapping;
mod menubar_hover;
mod moving_clicks;
mod mspace_viewport_view;
mod named_viewports_dialog;
mod native_menu_text_keys;
@@ -29,6 +30,7 @@ mod options_dialog;
mod options_right_click;
mod parameters_rename;
mod pickdrag;
mod press_first_clicks;
mod properties_described;
mod properties_units;
mod rapid_clicks;
@@ -36,6 +38,7 @@ mod selection_cycling;
mod shared_controls;
mod shortcut_menus;
mod shortcuts_checked;
mod slow_clicks;
mod space_at_options;
mod status_bar_toggles;
mod style_dialogs;
+183
View File
@@ -0,0 +1,183 @@
//! A click made while the mouse moves counts where the button went down, in the commands #1001
//! names (STRETCH, MOVE, TRIM), with no command running, with PICKDRAG off, at a click-click
//! window's second corner and over overlapping objects (selection cycling).
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, EntityKind, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerMoved(pos));
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
fn lines(h: &Harness<'_, CadApp>) -> Vec<(Vec2, Vec2)> {
let st = h.state().session.state().unwrap();
st.doc
.space(&Space::Model)
.unwrap()
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some((l.a.xy(), l.b.xy())),
_ => None,
})
.collect()
}
/// A harness at 60 frames a second, with two lines to select: a horizontal one through (20, 50)
/// and (40, 50), and a vertical one at x = 80.
fn select_harness() -> Harness<'static, CadApp> {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Moving clicks", None);
session.execute("view.set", &json!({"center":[50,50],"height":100})).unwrap();
session.settings.osmode = 0;
session.execute("line", &json!({"points": [[20, 50], [40, 50]]})).unwrap();
session.execute("line", &json!({"points": [[80, 30], [80, 70]]})).unwrap();
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(5);
h
}
/// Press at `down`, move on (the hand is already going somewhere) and let go at `up`, `frames`
/// frames later.
fn press_moving(h: &mut Harness<'_, CadApp>, down: Vec2, up: Vec2, frames: usize) {
let (d, u) = (screen(h, down), screen(h, up));
button(h, d, true);
h.run_steps(1);
for i in 1..=frames {
let t = i as f32 / frames as f32;
h.event(Event::PointerMoved(d + (u - d) * t));
h.run_steps(1);
}
button(h, u, false);
h.run_steps(2);
}
fn handles(h: &Harness<'_, CadApp>) -> Vec<cadcraft_engine::doc::Handle> {
let st = h.state().session.state().unwrap();
st.doc.space(&Space::Model).unwrap().iter().map(|e| e.handle).collect()
}
/// #1001: in STRETCH (whose "Select objects" takes points), a click made while the mouse moves
/// picks the object where the button went down; on empty space it starts STRETCH's window.
#[test]
fn a_click_made_while_moving_selects_in_stretch() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().start("stretch");
h.run_steps(2);
// Down on the horizontal line, up a few units off it, a few frames later.
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[0]], "the line under the button is picked");
// Down on empty space while moving: the window starts where the button went down.
press_moving(&mut h, Vec2::new(70.0, 20.0), Vec2::new(72.0, 22.0), 4);
assert_eq!(h.state().session.current_prompt().unwrap().message, "Specify opposite corner");
let corner = screen(&h, Vec2::new(90.0, 80.0));
button(&mut h, corner, true);
h.run_steps(1);
button(&mut h, corner, false);
h.run_steps(2);
assert_eq!(h.state().session.selection(), vec![ids[0], ids[1]], "the window took the vertical line");
}
/// At a generic "Select objects" (MOVE), a moving click picks the object where the button went
/// down instead of closing a tiny window; a slow press-and-drag is still a window.
#[test]
fn a_click_made_while_moving_selects_in_move_and_a_slow_drag_is_a_window() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().start("move");
h.run_steps(2);
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[0]]);
assert!(h.state().session.pending_window.is_none());
// Half a second from (70, 20) to (90, 80): a window around the vertical line.
press_moving(&mut h, Vec2::new(70.0, 20.0), Vec2::new(90.0, 80.0), 30);
assert!(h.state().session.pending_window.is_none(), "closed where the drag ended");
assert_eq!(h.state().session.selection(), vec![ids[0], ids[1]]);
}
/// With no command running, the same moving click picks the object.
#[test]
fn a_click_made_while_moving_picks_with_no_command() {
let mut h = select_harness();
let ids = handles(&h);
press_moving(&mut h, Vec2::new(80.0, 40.0), Vec2::new(83.0, 41.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[1]]);
}
/// A click-click window already open: its second corner, clicked while moving, closes it where the
/// button went down instead of being lost to the drag egui saw.
#[test]
fn a_click_made_while_moving_closes_a_click_click_window() {
let mut h = select_harness();
let ids = handles(&h);
let corner = screen(&h, Vec2::new(70.0, 20.0));
button(&mut h, corner, true);
h.run_steps(1);
button(&mut h, corner, false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_some(), "the click on empty space opened a window");
press_moving(&mut h, Vec2::new(90.0, 80.0), Vec2::new(92.0, 82.0), 4);
assert!(h.state().session.pending_window.is_none(), "the moving click closed the window");
assert_eq!(h.state().session.selection(), vec![ids[1]], "the window took the vertical line");
}
/// With PICKDRAG 0 no drag opens a window, and a click made while moving still picks the object.
#[test]
fn a_click_made_while_moving_picks_with_pickdrag_off() {
let mut h = select_harness();
let ids = handles(&h);
h.state_mut().session.settings.pickdrag = false;
press_moving(&mut h, Vec2::new(80.0, 40.0), Vec2::new(83.0, 41.0), 4);
assert_eq!(h.state().session.selection(), vec![ids[1]]);
assert!(h.state().session.pending_window.is_none());
}
/// TRIM's "Select object to trim": a click made while moving trims the part the button went down
/// on.
#[test]
fn a_click_made_while_moving_trims_in_trim() {
let mut h = select_harness();
// A vertical cutting edge through the horizontal line, at x = 30.
h.state_mut().session.execute("line", &json!({"points": [[30, 40], [30, 60]]})).unwrap();
h.state_mut().start("trim");
h.run_steps(2);
press_moving(&mut h, Vec2::new(36.0, 50.0), Vec2::new(39.0, 56.0), 4);
let got = lines(&h);
assert!(
got.iter().any(|(a, b)| a.near(Vec2::new(20.0, 50.0), 1e-6) && b.near(Vec2::new(30.0, 50.0), 1e-6)),
"the right part of the horizontal line was trimmed: {got:?}"
);
}
/// With SELECTIONCYCLING 2, a click made while moving over overlapping objects opens selection
/// cycling's list, as a still click does, instead of picking one of them.
#[test]
fn a_click_made_while_moving_over_overlapping_objects_lists_them() {
let mut h = select_harness();
h.state_mut().session.execute("line", &json!({"points": [[20, 50], [60, 50]]})).unwrap();
h.state_mut().session.execute("setvar", &json!({ "name": "SELECTIONCYCLING", "value": 2 })).unwrap();
h.state_mut().session.set_selection(Vec::new());
h.run_steps(2);
press_moving(&mut h, Vec2::new(30.0, 50.0), Vec2::new(32.0, 54.0), 4);
assert_eq!(h.state().canvas.cycle_rows().len(), 2, "both lines are listed");
assert!(h.state().session.selection().is_empty(), "nothing is picked until a row is chosen");
}
+28 -5
View File
@@ -99,7 +99,7 @@ fn right_click_settings_are_checked_and_survive_a_restart() {
#[test]
fn an_idle_right_click_can_repeat_the_last_command() {
let mut a = app();
a.run("options", json!({"rightClickDefault": "repeat"})).unwrap();
a.run("options", json!({"timeSensitiveRightClick": false, "rightClickDefault": "repeat"})).unwrap();
a.cmdline("circle 0,0 5");
assert!(!a.session.prompting());
let ctx = egui::Context::default();
@@ -116,6 +116,22 @@ fn an_idle_right_click_can_repeat_the_last_command() {
assert!(text.contains("Erase"), "the shortcut menu opens:\n{text}");
}
/// With the time-sensitive right-click on (the default), Default and Edit modes don't decide, as
/// in AutoCAD: a quick click is Enter (#1387) and a longer one opens the shortcut menu, even with
/// both set to repeat the last command.
#[test]
fn the_time_sensitive_right_click_decides_between_commands_too() {
let mut a = app();
a.run("options", json!({"rightClickDefault": "repeat", "rightClickEdit": "repeat"})).unwrap();
a.cmdline("circle 0,0 5");
assert!(!a.session.prompting());
let ctx = egui::Context::default();
frame(&mut a, &ctx, Vec::new(), 0.0);
let text = right_click(&mut a, &ctx, 0.1, 0.4);
assert!(!a.session.prompting(), "a longer click repeats nothing: {}", a.session.prompt_text());
assert!(text.contains("Repeat CIRCLE"), "the shortcut menu opens:\n{text}");
}
#[test]
fn command_mode_and_click_duration_decide_enter_or_the_menu() {
let ctx = egui::Context::default();
@@ -182,6 +198,17 @@ fn the_customization_window_sets_every_mode() {
h.get_by_label("Longer click duration:");
shot(&mut h, "options-right-click.png");
// Default, Edit and Command modes apply once the time-sensitive right-click is off; with it
// on, Default mode's choice can't be made.
if let Some(n) = h.get_all_by_label("Repeat last command").next() {
n.click();
}
h.run_steps(3);
assert_eq!(h.state().options.right_click_default, IdleClick::Menu);
h.get_by_label("Turn on time-sensitive right-click").click();
h.run_steps(3);
assert!(!h.state().options.time_sensitive_right_click);
// Default mode's "Repeat last command" comes first, Edit mode's second.
if let Some(n) = h.get_all_by_label("Repeat last command").next() {
n.click();
@@ -190,10 +217,6 @@ fn the_customization_window_sets_every_mode() {
assert_eq!(h.state().options.right_click_default, IdleClick::Repeat);
assert_eq!(h.state().options.right_click_edit, IdleClick::Menu);
// Command mode applies once the time-sensitive right-click is off.
h.get_by_label("Turn on time-sensitive right-click").click();
h.run_steps(3);
assert!(!h.state().options.time_sensitive_right_click);
h.get_by_label("Shortcut Menu: enabled when command options are present").click();
h.run_steps(3);
assert_eq!(h.state().options.right_click_command, CommandClick::MenuWithOptions);
+5 -7
View File
@@ -83,13 +83,11 @@ fn drag_is_disabled_but_two_clicks_still_complete_the_window() {
button(&mut h, a, true);
button(&mut h, a, false);
assert!(h.state().session.pending_window.is_some());
// A held-button movement after the first click must not consume the second corner.
drag(&mut h, a, b);
assert!(h.state().session.pending_window.is_some());
assert!(h.state().session.selection().is_empty());
h.run_steps(30); // Separate deliberate clicks from egui's double-click interval.
button(&mut h, b, true);
button(&mut h, b, false);
// The second corner is where the button goes down (#1001): a drag on from there, let go
// elsewhere, changes nothing.
h.run_steps(30); // Separate deliberate clicks from the double-click interval.
let away = xf.to_screen(Vec2::new(30.0, 8.0));
drag(&mut h, b, away);
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
@@ -0,0 +1,189 @@
//! Press-first clicks (#1001): a click counts when the button goes down, where it went down, even
//! while the mouse is moving; holding the button after the pointer left a small tolerance makes a
//! drag. The harness runs at 60 frames a second and each queued event is one frame, so the number
//! of moves between press and release is how long the button was held.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, EntityKind, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_engine::prompt::Input;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
fn harness() -> Harness<'static, CadApp> {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Press first", None);
session.execute("view.set", &json!({"center":[50,50],"height":100})).unwrap();
session.settings.osmode = 0;
session.settings.snapmode = false;
session.settings.orthomode = false;
session.execute("line", &json!({"points": [[20, 20], [60, 20]]})).unwrap();
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(1.0 / 60.0).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(5);
h
}
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
/// Press at `at`, then move `dx` points to the right over `frames` frames and let go there.
fn moving_click(h: &mut Harness<'_, CadApp>, at: Pos2, dx: f32, frames: usize) {
h.event(Event::PointerMoved(at));
button(h, at, true);
for i in 1..=frames {
h.event(Event::PointerMoved(at + vec2(dx * i as f32 / frames as f32, 0.0)));
}
button(h, at + vec2(dx, 0.0), false);
h.run_steps(2);
}
/// A click that moves 15 points while the button is down, let go within two frames.
fn quick_moving_click(h: &mut Harness<'_, CadApp>, at: Vec2) {
let pos = screen(h, at);
moving_click(h, pos, 15.0, 2);
}
fn start(h: &mut Harness<'_, CadApp>, id: &str) {
h.state_mut().start(id);
h.run_steps(2);
assert_eq!(h.state().session.running.as_ref().map(|r| r.id.as_str()), Some(id));
}
fn enter(h: &mut Harness<'_, CadApp>) {
h.state_mut().session.input(Input::Enter).unwrap();
h.run_steps(2);
}
fn lines(h: &Harness<'_, CadApp>) -> Vec<(Vec2, Vec2)> {
let st = h.state().session.state().unwrap();
st.doc
.space(&Space::Model)
.unwrap()
.iter()
.filter_map(|e| match &e.kind {
EntityKind::Line(l) => Some((l.a.xy(), l.b.xy())),
_ => None,
})
.collect()
}
#[test]
fn move_takes_the_base_and_second_point_where_the_button_went_down() {
let mut h = harness();
start(&mut h, "move");
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
enter(&mut h);
// Base point and second point, both clicked on the move: 15 points is 1.5 drawing units here.
quick_moving_click(&mut h, Vec2::new(30.0, 40.0));
quick_moving_click(&mut h, Vec2::new(50.0, 40.0));
let got = lines(&h);
assert_eq!(got.len(), 1, "{got:?}");
assert!(got[0].0.near(Vec2::new(40.0, 20.0), 1e-3) && got[0].1.near(Vec2::new(80.0, 20.0), 1e-3), "moved by (20, 0): {got:?}");
}
#[test]
fn an_object_clicked_on_the_move_is_picked_with_no_command_running() {
let mut h = harness();
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
assert_eq!(h.state().session.selection().len(), 1);
assert!(h.state().session.pending_window.is_none());
}
#[test]
fn an_object_clicked_on_the_move_is_picked_at_select_objects() {
let mut h = harness();
start(&mut h, "erase");
quick_moving_click(&mut h, Vec2::new(40.0, 20.0));
enter(&mut h);
assert!(lines(&h).is_empty(), "the line was picked and erased");
}
#[test]
fn both_corners_of_a_click_click_window_count_while_the_mouse_moves() {
let mut h = harness();
// Lower left, then upper right: a window around the whole line.
quick_moving_click(&mut h, Vec2::new(10.0, 10.0));
assert!(h.state().session.pending_window.is_some(), "a quick click leaves the window open for the second corner");
quick_moving_click(&mut h, Vec2::new(70.0, 30.0));
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn holding_the_button_while_moving_drags_a_window() {
let mut h = harness();
// Half a second of dragging from lower left to upper right of the line.
let from = screen(&h, Vec2::new(10.0, 10.0));
let to = screen(&h, Vec2::new(70.0, 30.0));
h.event(Event::PointerMoved(from));
button(&mut h, from, true);
for i in 1..=30 {
h.event(Event::PointerMoved(from + (to - from) * (i as f32 / 30.0)));
}
button(&mut h, to, false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_none(), "letting go closes the dragged window");
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn holding_still_then_moving_and_letting_go_quickly_is_a_click() {
let mut h = harness();
let at = screen(&h, Vec2::new(10.0, 10.0));
h.event(Event::PointerMoved(at));
button(&mut h, at, true);
// Held in place for half a second: no drag yet.
h.run_steps(30);
h.event(Event::PointerMoved(at + vec2(40.0, 0.0)));
button(&mut h, at + vec2(40.0, 0.0), false);
h.run_steps(2);
assert!(h.state().session.pending_window.is_some(), "still waiting for the second corner");
}
#[test]
fn two_window_corners_clicked_within_one_frame_both_count() {
let mut h = harness();
let (a, b) = (screen(&h, Vec2::new(10.0, 10.0)), screen(&h, Vec2::new(70.0, 30.0)));
// A slow frame: both clicks arrive before the next one is drawn.
for pos in [a, b] {
h.input_mut().events.push(Event::PointerMoved(pos));
for pressed in [true, false] {
h.input_mut().events.push(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
}
h.run_steps(2);
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
#[test]
fn cpolygon_points_clicked_on_the_move_all_count() {
// #1546: a narrow crossing polygon over the line's right end (x 58.6–59.9, the line ends at
// 60), each point clicked while moving. Taken where the buttons came up (1.5 units further
// right) it would miss the line.
let mut h = harness();
start(&mut h, "erase");
h.state_mut().session.input(Input::Keyword("CP".into())).unwrap();
h.run_steps(2);
for p in [Vec2::new(58.6, 15.0), Vec2::new(59.9, 15.0), Vec2::new(59.9, 25.0), Vec2::new(58.6, 25.0)] {
quick_moving_click(&mut h, p);
}
enter(&mut h);
enter(&mut h);
assert!(lines(&h).is_empty(), "the polygon crossed the line and ERASE removed it");
}
+3 -2
View File
@@ -88,11 +88,12 @@ fn a_click_made_while_the_mouse_moves_still_places_the_point() {
let down = screen(&h, Vec2::new(40.0, 10.0));
button(&mut h, down, true);
h.run_steps(1);
// The hand is already on its way to the next point when the button comes up.
// The hand is already on its way to the next point when the button comes up; the point is
// where the button went down (#1001), not where the hand got to.
let up = down + vec2(12.0, 0.0);
button(&mut h, up, false);
h.run_steps(2);
let got = lines(&h);
assert_eq!(got.len(), 1, "{got:?}");
assert!(got[0].1.near(h.state().canvas.xf.unwrap().to_world(up), 1e-4), "{got:?}");
assert!(got[0].1.near(h.state().canvas.xf.unwrap().to_world(down), 1e-4), "{got:?}");
}
+159
View File
@@ -0,0 +1,159 @@
//! A click on an object selects it, however long the frames around it take (#2813).
//!
//! egui calls a press that lasts longer than `max_click_duration` (0.8 s) a drag, and it times the
//! press by frames. On a large drawing that draws slowly, an ordinary click can come down in one
//! frame and up in the next, more than 0.8 s later. The canvas took that "drag" for a press-and-drag
//! selection window that never left the click, a window of no size, and nothing was selected; when
//! no frame ran while the button was down, egui reported nothing at all.
use cadcraft_engine::Session;
use cadcraft_engine::doc::{Drawing, Handle, Space};
use cadcraft_engine::geom::Vec2;
use cadcraft_ui_egui::{CadApp, Services};
use egui::{Event, Modifiers, PointerButton, Pos2, vec2};
use egui_kittest::Harness;
use serde_json::json;
/// Seconds each harness step advances egui's clock: two steps between press and release make a
/// press longer than egui's 0.8 s click limit.
const STEP: f32 = 0.5;
/// A drawing with one line from (10, 10) to (30, 10), no object snaps, nothing selected; each frame
/// advances egui's clock by [`STEP`].
fn harness() -> (Harness<'static, CadApp>, Handle) {
harness_stepping(STEP)
}
/// [`harness`] with each frame advancing egui's clock by `step` seconds.
fn harness_stepping(step: f32) -> (Harness<'static, CadApp>, Handle) {
let mut session = Session::empty();
session.open_drawing(Drawing::new_imperial(), "Slow clicks", None);
session.execute("view.set", &json!({"center": [50, 50], "height": 100})).unwrap();
session.settings.osmode = 0;
session.execute("line", &json!({"points": [[10, 10], [30, 10]]})).unwrap();
let line = session.doc().unwrap().space(&Space::Model).unwrap().iter().next().unwrap().handle;
let mut app = CadApp::new(session, Services::default());
app.canvas.zoom_pending = false;
let mut h = Harness::builder().with_size(vec2(1600.0, 1000.0)).with_step_dt(step).build_ui_state(
|ui, app: &mut CadApp| {
app.logic(ui.ctx());
app.ui(ui);
},
app,
);
h.run_steps(3);
(h, line)
}
fn screen(h: &Harness<'_, CadApp>, p: Vec2) -> Pos2 {
h.state().canvas.xf.unwrap().to_screen(p)
}
fn button(h: &mut Harness<'_, CadApp>, pos: Pos2, pressed: bool) {
h.event(Event::PointerMoved(pos));
h.event(Event::PointerButton { pos, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE });
}
/// Press at `down`, let `frames` slow frames pass, release at `up`.
fn slow_click(h: &mut Harness<'_, CadApp>, down: Pos2, up: Pos2, frames: usize) {
button(h, down, true);
h.run_steps(frames);
button(h, up, false);
h.run_steps(2);
}
#[test]
fn a_click_spanning_slow_frames_selects_the_object() {
let (mut h, line) = harness();
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 2);
assert_eq!(h.state().session.selection(), vec![line]);
assert!(h.state().session.pending_window.is_none(), "no window is left open");
}
/// The slowest case: the frame the button went down in took a second, and the next frame already
/// has it up. No frame ran with the button down, so egui reports neither a click nor a drag.
#[test]
fn a_click_across_one_slow_frame_selects_the_object() {
let (mut h, line) = harness_stepping(1.0);
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 1);
assert_eq!(h.state().session.selection(), vec![line]);
}
/// A slow click on a grip of a selected object makes it hot, as a quick one does.
#[test]
fn a_slow_click_on_a_grip_starts_a_grip_edit() {
let (mut h, line) = harness();
h.state_mut().session.set_selection(vec![line]);
h.run_steps(2);
let grip = screen(&h, Vec2::new(30.0, 10.0));
slow_click(&mut h, grip, grip, 2);
assert_eq!(h.state().session.running.as_ref().map(|r| r.id.as_str()), Some("grip"));
}
/// The hand drifts a pixel or two while the button is down: still a click.
#[test]
fn a_slow_click_that_drifts_within_the_click_distance_selects_the_object() {
let (mut h, line) = harness();
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at + vec2(2.0, 1.0), 2);
assert_eq!(h.state().session.selection(), vec![line]);
}
/// In empty space a slow click does what a quick one does there: it starts a click-click window.
#[test]
fn a_slow_click_in_empty_space_starts_a_window_as_a_click_does() {
let (mut h, _) = harness();
let at = screen(&h, Vec2::new(20.0, 40.0));
slow_click(&mut h, at, at, 2);
assert!(h.state().session.selection().is_empty());
let corner = h.state().session.pending_window.map(|w| w.corner);
assert!(corner.is_some_and(|c| c.near(Vec2::new(20.0, 40.0), 0.5)), "{corner:?}");
}
/// A real press-and-drag still opens and closes a selection window, slow or not.
#[test]
fn a_press_and_drag_still_selects_by_window() {
let (mut h, line) = harness();
let (from, to) = (screen(&h, Vec2::new(5.0, 15.0)), screen(&h, Vec2::new(35.0, 5.0)));
button(&mut h, from, true);
h.run_steps(1);
h.event(Event::PointerMoved(from + (to - from) / 2.0));
h.run_steps(2);
button(&mut h, to, false);
h.run_steps(2);
assert_eq!(h.state().session.selection(), vec![line]);
assert!(h.state().session.pending_window.is_none());
}
/// While a command asks for objects, a slow click on one picks it.
#[test]
fn a_slow_click_picks_at_select_objects() {
let (mut h, line) = harness();
h.state_mut().start("erase");
h.run_steps(2);
let at = screen(&h, Vec2::new(20.0, 10.0));
slow_click(&mut h, at, at, 2);
h.state_mut().session.input(cadcraft_engine::Input::Enter).unwrap();
h.run_steps(2);
let d = h.state().session.doc().unwrap();
assert!(d.entity(line).is_none(), "the line was picked and erased");
}
/// At a point prompt, a click across one slow frame places one point. This already worked (a drag
/// that stops at a point prompt counts as a click, #815). The test keeps it so, and shows the click
/// isn't counted twice (CIRCLE would take the second as the radius).
#[test]
fn a_click_across_one_slow_frame_places_a_point() {
let (mut h, _) = harness_stepping(1.0);
h.state_mut().start("circle");
h.run_steps(1);
let prompt = |h: &Harness<'_, CadApp>| h.state().session.current_prompt().map(|p| p.message).unwrap_or_default();
let center_prompt = prompt(&h);
let at = screen(&h, Vec2::new(60.0, 60.0));
slow_click(&mut h, at, at, 1);
let next = prompt(&h);
assert_ne!(next, center_prompt, "the center was taken");
assert!(next.to_ascii_lowercase().starts_with("specify radius"), "{next}");
}