Compare commits

..
36 Commits
Author SHA1 Message Date
Tanish Manku 129dd86ef2 Stack d2: #2648: an arc's pick off its sweep goes through seg_param
#2648 sent an arc pick outside its sweep to the nearer end with its own copy of the rule that
#2693 put in curves::seg_param. TRIM of an arc now uses seg_param, so the rule is in one place.
No change in behaviour: an_arc_picked_just_off_one_end_loses_the_piece_at_that_end covers it.
2026-11-19 15:17:16 -07:00
Tanish Manku 451caaac32 Stack d2: #2759: EXTEND's params name the open-polyline end rule
#2693 extends the end of an open polyline on the pick's side of its middle parameter, not the
nearer end; the EXTEND params doc from #2759 said only "the nearer end".
2026-11-19 15:15:33 -07:00
Tanish Manku 0cd36ad172 Stack d2: #2759: a pick on a line far from the origin is on it
The JSON TRIM diagnostic told a pick on the line from one off it within an absolute 1e-9. At
survey coordinates rounding alone moves the pick further than that, so a pick on the line was
reported as off it. The tolerance is now rounding of the coordinates, at least 1e-9.
2026-11-19 15:15:20 -07:00
Tanish Manku 63347dbf12 Stack d2: #2759: explain a line TRIM picked on its only cut
#2648 refuses a line trim picked within 5e-7 of its only cut with its own message, and Quick mode
leaves the line in place. The JSON form now explains that refusal as it explains the generic one,
and the Quick-mode test expects the line kept, as #2648 measured in AutoCAD 2024.
2026-11-19 15:15:12 -07:00
Tanish Manku 05cfcaa249 Merge branch 'pr/2759' into stack/d2
# Conflicts:
#	crates/engine/src/cmd/modify.rs
#	crates/engine/src/cmd/modify/trim.rs
#	crates/engine/src/cmd/trimextend.rs
#	crates/engine/tests/it/main.rs
2026-11-19 14:47:50 -07:00
Tanish Manku 6ed36aa844 Merge branch 'pr/3183' into stack/d2 2026-11-19 14:47:09 -07:00
Tanish Manku cd4e04a0d1 Merge branch 'pr/2104' into stack/d2 2026-11-19 14:47:09 -07:00
Tanish Manku 76b13c7ed2 Merge branch 'pr/2693' into stack/d2
# Conflicts:
#	crates/engine/tests/it/main.rs
2026-11-19 14:47:08 -07:00
Tanish Manku 26819d3a68 Merge branch 'pr/2648' into stack/d2 2026-11-19 14:46:59 -07:00
Tanish Manku 777ebededb Merge branch 'pr/2550' into stack/d2 2026-11-19 14:46:59 -07:00
Tanish Manku 41368223db Merge branch 'pr/2548' into stack/d2 2026-11-19 14:46:59 -07:00
Zaxaerith 149ba217ef fix(engine): distinguish TRIM pick failures and unblock formatting 2026-11-15 16:23:24 +08:00
Zaxaerith 41c2a99a22 Merge upstream main into the TRIM and EXTEND pick fix
Keep the TRIM handle-return contract and clarify the projected cutting-intersection diagnostic.
2026-11-15 14:13:58 +08:00
Zaxaerith 96a9fa615c fix(engine): clarify JSON TRIM and EXTEND pick diagnostics (#2750) 2026-11-04 12:13:46 +08:00
2ez4gcxandClaude Opus 5.5 cf46d11e27 BREAK and BREAKATPOINT: test the measured ends, closing side and undo
Pins AutoCAD 2024's results (accoreconsole, entget of every object after
the command) for the cases that are easy to get wrong:

- 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.

Undo after each break restores the object under its handle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 20:37:26 +07:00
2ez4gcxandClaude Opus 5.5 1b7cf50fbe Arc points a hair outside the sweep take the nearer end
EXTEND, TRIM, BREAK, DIVIDE and MEASURE place a point on an arc segment by
its angle from the arc's start. A point the closest-point search accepts
just before the start (within the 1e-12 sweep tolerance) wrapped round to
nearly a full turn and was clamped to the far end:

- EXTEND on a polyline picked there extended the wrong end;
- TRIM put a second cut at the far end of an arc span when a cutting edge
  ran through the vertex where the span starts (63 of 400 angles through
  that vertex on main), and took out the arc alone;
- DIVIDE and MEASURE ran from the wrong end.

`curves::seg_param` now sends an angle outside the sweep to the nearer end.
TRIM's `param_on` is that function, and EXTEND takes its pick parameter from
`curves::vertex_param_of`, the walk DIVIDE uses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 14:15:56 +07:00
2ez4gcxandClaude Opus 5.5 f6a97d273f EXTEND: a polyline extends the end on the pick's side of its middle
Measured in AutoCAD 2024 (accoreconsole): EXTEND on an open polyline
extends the end on the pick's side of the polyline's middle parameter,
not the end vertex nearer the pick. The pick's parameter is the segment
it is nearest, counted from 0, plus how far along it; from half the
number of segments on, the last end extends. (0,220) (20,220) (20,230)
(15,221) picked at (16,220) is 0.8 of 3, so the first end extends,
though the last vertex is 1.4 from the pick.

A repeated vertex counts as a segment, so the parameter is computed
over the vertex pairs rather than Polyline::segments.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 12:20:28 +07:00
2ez4gcxandClaude Opus 5.5 1415bb7fe1 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's measured pass-over rule: a cut by another edge at the
pick is passed over; a pick on the polyline's own cut trims nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 00:05:33 +07:00
2ez4gcxandClaude Opus 5.5 f370a5580e TRIM: lines, arcs and circles pass over a cut at the pick
Measured in AutoCAD 2024 (accoreconsole). A line, an arc or a circle
picked within 5e-7 of a cut by another edge runs the trim on across
that cut, as a polyline does: a line cut at x = 3 and 7 and picked on
3 loses 0 to 7; a circle cut at 60, 120, 240 and 300 degrees and
picked on 60 loses the arc from 300 round to 120. With no cut left,
nothing is trimmed, and Quick mode leaves the object in place, as it
meets an edge.

An arc picked just off its start is now trimmed at its start: the pick
was taken as being at the arc's end, round the circle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 23:23:59 +07:00
2ez4gcxandClaude Opus 5.5 3a9b653b51 TRIM: a cut by another edge at the pick is passed over
Measured in AutoCAD 2024 (accoreconsole): a pick within 5e-7 of a cut
by another edge doesn't leave the polyline as it is. AutoCAD runs the
piece on across that cut to the next one either side: with lines at
x = 3 and 7, a pick on 3 removes 0 to 7; with lines at 3, 5 and 7, a
pick on 5 removes 3 to 7. A pick that near one of the polyline's own
cuts (a vertex, where it is one of its own edges) still trims nothing.

When every cut is passed over, the refusal doesn't say "intersect", so
Quick mode doesn't erase the polyline as one no edge crosses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 23:19:42 +07:00
2ez4gcxandClaude Opus 5.5 b1fa96a690 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's measured TRIM rules: a pick on a cut trims nothing,
vertices in line don't cut, an edge through a closed polyline's start
vertex cuts it, and a closed polyline cut once is refused.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 22:31:53 +07:00
2ez4gcxandClaude Opus 5.5 061ecd1cd6 TRIM: a pick on a cut trims nothing; vertices in line don't cut
Measured in AutoCAD 2024 (accoreconsole) and followed here:

- A pick within 5e-7 of a cut along the polyline trims nothing, at any
  size; this replaces picking a side by cut index.
- An edge through a closed polyline's start vertex cuts it there.
- A closed polyline cut at one point is refused ("Curve must intersect
  cutting edges at least twice."); Quick mode leaves it in place.
- A vertex between two line segments within 1e-8 of parallel, straight
  on or doubling back, is not a cut.
- Crossing picks stay just inside a segment, off its vertices.

A polyline's own crossings are searched only on the segment picked and
those it runs straight on into, against the segments near them; past
2^24 pairs or 65,536 crossings the trim is refused instead of being made
at some of its cuts.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 22:31:38 +07:00
ZachAR3 7619133bd6 docs: leave geometry-parity.md unchanged in this PR (#1594) 2026-11-02 16:07:30 +01:00
ZachAR3 596b9fe2ca Merge remote-tracking branch 'origin/main' into extend-trim-quick-fence
# Conflicts:
#	crates/engine/src/cmd/trimextend.rs
#	docs/geometry-parity.md
2026-11-02 15:37:54 +01:00
2ez4gcxandClaude Opus 5.5 c039fee2df Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's index-based choice of the piece next to a picked cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:15:52 +07:00
2ez4gcxandClaude Opus 5.5 9c2b8a2589 TRIM: a pick on a cut takes the piece next to that cut, by index
The split point was moved 2 x 4 ULP off a cut the pick was on. When two
cuts are closer than that (1e9 out, a segment a few ULP long) it moved
past the other cut too, and the long segment before was trimmed instead
of the short one picked. The cut the pick is on (the nearest within
rounding) now bounds the piece directly: with the next cut when the pick
is at its segment's start, with the previous one otherwise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 18:15:46 +07:00
2ez4gcxandClaude Opus 5.5 189b1810f4 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's fix keeping a pick inside a segment on its side of a cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:22:30 +07:00
2ez4gcxandClaude Opus 5.5 45d84f1090 TRIM: only a pick on a cut picks a side of it
A pick within 1e-9 of the polyline's length from a cut was moved across
it. On a long polyline that window is wide: 10000 long, a pick inside a
segment a millionth long was moved before the cut ahead of it, and
1e9 long, a pick half a unit up the second segment was moved onto the
first, so the wrong segment was trimmed. Only a pick on a cut within
rounding (4 ULP of the length) now picks a side of it; any other pick
splits the cuts where it is.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:22:24 +07:00
2ez4gcxandClaude Opus 5.5 0f645f1275 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's fixes for a pick on a vertex and for closing pieces.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:46:31 +07:00
2ez4gcxandClaude Opus 5.5 e35dfe6533 TRIM: a pick on a vertex keeps the polyline; close only meeting ends
A pick exactly on a cut (a vertex, now that a polyline cuts itself at
each) found no piece on either side, and the whole polyline was erased.
It now takes the piece of the segment it was found on: the one before a
vertex the segment ends at, the one after a vertex it starts at.

A piece was closed when its ends were within 1e-9 of the coordinates'
size: about one unit 1e9 from the origin, so ends 0.58 apart closed. It
is now rounding error only, 64 ULP of the larger coordinate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:46:23 +07:00
2ez4gcxandClaude Opus 5.5 179e946a70 Merge fix/break-trim-geometry into feat/breakatpoint-command-line
Brings #2548's touch points and Quick-mode self-cuts for TRIM of a
polyline into this stacked branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 11:11:49 +07:00
2ez4gcxandClaude Opus 5.5 a70223e25f TRIM: a polyline cuts itself where it touches itself, in Quick mode too
A polyline that is one of the cutting edges was cut at its vertices and
where two of its segments cross, not where a vertex of it (an end
included) touches another of its segments. Trimmed there, a polyline
whose end returns onto its own segment lost the stretch past the touch
too. In Quick mode with every object it didn't cut itself at all.

As AutoCAD 2024 does (Standard mode by accoreconsole; Quick mode in
AutoCAD itself, picking on screen):
- a vertex touching another segment of the same polyline cuts that
  segment, in Standard and in Quick mode;
- a piece whose two ends meet is left closed, without the repeated
  vertex, its arcs kept.

Edges::quick is gone: nothing reads it any more.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 11:11:31 +07:00
2ez4gcxandClaude Opus 5.5 032a5dc3c7 feat(modify): BREAKATPOINT at the command line, as AutoCAD does
BREAKATPOINT gets AutoCAD 2024's prompts ("Select object:", then
"Specify break point:") and splits the object there; before, it only
had its JSON form, so typing it, a script or the menu failed. BREAK
and BREAKATPOINT now end the command when the break can't be made
("Arc cannot be full 360 degrees", no full stop, as measured), refuse
an object on a locked layer when it is picked, and leave nothing
selected after Enter.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 18:19:01 +07:00
2ez4gcxandClaude Opus 5.5 4c875d949e fix(modify): BREAK and TRIM on closed and self-cutting polylines, keeping Z
BREAK on a closed polyline removes the stretch between the two points
that doesn't run through the start vertex, whichever point comes first;
at one point (or BREAKATPOINT) it splits the polyline in two, and at the
start vertex leaves it closed. In Standard mode, or when picked as an
edge, a polyline that is one of the cutting edges is also cut at its own
vertices and crossings. Pieces keep a line's Z, an arc's centre Z and a
polyline's elevation, constant width and linetype generation, for TRIM
as for BREAK. All measured in AutoCAD 2024 except Quick mode's implicit
edges, which keep leaving the polyline out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-31 17:12:08 +07:00
ZachAR3 683dd0bfec TRIM and EXTEND: test Quick-mode EXTEND through its fence (#1594)
The empty-space fence test now drives EXTEND through the second fence
point and checks the extended lines, not only the prompt.
2026-10-25 02:09:31 +01:00
ZachAR3 61483802a1 TRIM and EXTEND: a pick in empty space starts a fence in Quick mode (fixes #1594)
In Quick mode AutoCAD reads two picks in empty space as a crossing
fence: everything the fence crosses is trimmed or extended, without
choosing the Fence option first. CADCraft opened a crossing window
there. A pick in empty space now starts that two-point fence in Quick
mode; the next point applies it and the command asks for the next
object again. Standard mode keeps the crossing window.
2026-10-25 00:19:11 +02:00
35 changed files with 2290 additions and 1231 deletions
-5
View File
@@ -128,8 +128,3 @@ sync_github_name = true
[people.tyrel]
real_name = "Tyrel Haveman"
[people.Sladrian]
real_name = "Sladrian Pedroso"
display_name = "Sladrian Pedroso"
sync_github_name = false
+11 -1
View File
@@ -564,7 +564,17 @@ 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 } => {
let t = (cadcraft_geom::norm_angle(arc.center.angle_to(p) - arc.start) / arc.sweep().max(1e-15)).clamp(0.0, 1.0);
// 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
};
if *ccw { t } else { 1.0 - t }
}
}
+19
View File
@@ -601,6 +601,25 @@ 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
+20 -7
View File
@@ -26,7 +26,7 @@ mod stretch;
mod transform;
mod trim;
use break_join::{BreakM, run_break, run_breakat, run_join};
use break_join::{BreakAtPointM, 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::{Edges, extend, trim};
pub(crate) use trim::{CUT_ONCE, Edges, extend, json_pick_error, trim};
pub fn specs() -> Vec<CommandSpec> {
vec![
@@ -85,14 +85,24 @@ pub fn specs() -> Vec<CommandSpec> {
CommandSpec::new("trim", "Trim", trimextend::run_trim)
.menu(&["Modify", "Trim"])
.alias(&["tr"])
.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)",
)
.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."
))
.interactive(|_| Ok(Box::new(TrimM::new(false)))),
CommandSpec::new("extend", "Extend", trimextend::run_extend)
.menu(&["Modify", "Extend"])
.alias(&["ex"])
.params("{handle, pick: [x,y] | fence: [[x,y],...] | crossing: [[x,y],[x,y]], edges?: [hex], edgeMode?: \"extend\"|\"none\"}")
.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."
))
.interactive(|_| Ok(Box::new(TrimM::new(true)))),
CommandSpec::new("fillet", "Fillet", run_fillet)
.menu(&["Modify", "Fillet"])
@@ -114,7 +124,10 @@ 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}"),
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("join", "Join", run_join)
.menu(&["Modify", "Join"])
.alias(&["j"])
+95 -34
View File
@@ -4,16 +4,6 @@ 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) {
@@ -39,12 +29,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![with_z(arc(&Arc::new(c.center.xy(), c.radius, a2, a1)), c.center.z)]
vec![arc(&Arc::new(c.center.xy(), c.radius, a2, a1))]
}
EntityKind::Arc(a) => {
let ga = Arc::new(a.center.xy(), a.radius, a.start, a.end);
@@ -55,10 +45,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(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)), a.center.z));
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start, ga.start + t1)));
}
if t2 < ga.sweep() - 1e-12 {
v.push(with_z(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)), a.center.z));
v.push(arc(&Arc::new(ga.center, ga.radius, ga.start + t2, ga.end)));
}
v
}
@@ -81,24 +71,32 @@ 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 {
if (t1 - t2).abs() < 1e-9 {
return Err(EngineError::Other("Cannot break a closed polyline at a single point.".into()));
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)]
}
// 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(with_z(lwpoly(sub_polyline(&segs, 0.0, t1), false), p.elevation));
v.push(lwpoly(sub_polyline(&segs, 0.0, t1), false));
}
if t2 < total - 1e-12 {
v.push(with_z(lwpoly(sub_polyline(&segs, t2, total), false), p.elevation));
v.push(lwpoly(sub_polyline(&segs, t2, total), false));
}
v
}
@@ -215,6 +213,41 @@ 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)>,
@@ -236,14 +269,8 @@ impl Interactive for BreakM {
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.obj, i) {
(None, Input::Point(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*"),
if let Some(h) = pick_to_break(s, p)? {
self.obj = Some((h, p));
}
Ok(Step::Continue)
}
@@ -256,12 +283,46 @@ impl Interactive for BreakM {
self.first_point = false;
Ok(Step::Continue)
}
(Some((h, p1)), Input::Point(p2)) => {
break_entity(s, h, p1, p2)?;
(Some((h, p1)), Input::Point(p2)) => break_and_end(s, h, p1, p2),
(Some(_), Input::Enter) => {
s.set_selection(Vec::new());
Ok(Step::Done)
}
(_, Input::Enter) => 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),
_ => Ok(Step::Continue),
}
}
+1 -4
View File
@@ -323,16 +323,13 @@ 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 { picks_one: self.removing, ..Prompt::new(if self.removing { "Remove objects" } else { "Select objects" }, Accept::POINT) }
}
(StretchPhase::Select, None) => 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),
+266 -37
View File
@@ -1,3 +1,5 @@
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,
@@ -91,13 +93,62 @@ 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());
@@ -109,10 +160,12 @@ 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("Object does not intersect a cutting edge.".into()));
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -131,11 +184,14 @@ 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);
let tp = param(pick).min(sweep);
// 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 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("Object does not intersect a cutting edge.".into()));
return Err(EngineError::Other(if ts.len() < found { ON_THE_CUT } else { "Object does not intersect a cutting edge." }.into()));
}
let mut v = Vec::new();
if lo > 0.0 {
@@ -151,10 +207,16 @@ 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);
if angs.len() < 2 {
return Err(EngineError::Other("Circle must intersect cutting edges at two or more points.".into()));
}
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()));
}
// The removed arc runs between the two intersections around the pick.
let n = angs.len();
let mut keep = None;
@@ -167,7 +229,10 @@ pub(crate) fn trim(s: &mut Session, h: Handle, pick: Vec2, edges: Edges) -> Resu
}
keep.into_iter().collect()
}
EntityKind::LwPolyline(p) => trim_polyline(p, &cut, pick)?,
EntityKind::LwPolyline(p) => match trim_polyline(p, &cut, pick, itself)? {
Some(pieces) => pieces,
None => return Ok(vec![h]),
},
k => crate::cmd::modify2::trim_other(k, &cut, pick)?,
};
replace_with_pieces(s, h, pieces)
@@ -181,19 +246,20 @@ 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.)
///
/// 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.
/// 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.
pub(super) fn replace_with_pieces(s: &mut Session, h: Handle, pieces: Vec<EntityKind>) -> Result<Vec<Handle>> {
let d = s.doc_mut()?;
let mut pieces = pieces.into_iter();
let Some(first) = pieces.next() else {
if pieces.is_empty() {
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 {
@@ -213,6 +279,31 @@ 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();
@@ -245,15 +336,128 @@ pub(super) fn sub_polyline(segs: &[Segment], a: f64, b: f64) -> Vec<PolyVertex>
out
}
fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> Result<Vec<EntityKind>> {
/// 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>>> {
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;
let mut tp = 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 best = f64::INFINITY;
for s in &segs {
for (i, s) in segs.iter().enumerate() {
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);
@@ -262,13 +466,34 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> R
if c.dist(pick) < best {
best = c.dist(pick);
tp = acc + param_on(s, c) * len;
k = i;
}
acc += len;
}
ts.retain(|t| *t > 1e-9 && *t < total - 1e-9);
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.sort_by(f64::total_cmp);
if ts.is_empty() {
return Err(EngineError::Other("Object does not intersect a cutting edge.".into()));
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()));
}
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);
@@ -283,33 +508,31 @@ fn trim_polyline(p: &cadcraft_doc::LwPolyline, cut: &[Segment], pick: Vec2) -> R
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, 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;
}
let (a, b) = if hi > total { (hi - total, lo) } else { (hi, lo + 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(mk(sub_polyline(&segs, 0.0, lo)));
out.push(piece(sub_polyline(&segs, 0.0, lo)));
}
if hi.is_finite() {
out.push(mk(sub_polyline(&segs, hi, total)));
out.push(piece(sub_polyline(&segs, hi, total)));
}
}
Ok(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect())
Ok(Some(out.into_iter().filter(|k| matches!(k, EntityKind::LwPolyline(l) if l.vertices.len() >= 2)).collect()))
}
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 }
}
}
}
pub(super) use crate::cmd::curves::seg_param as param_on;
/// 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
@@ -372,7 +595,13 @@ 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();
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));
// 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 (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();
+41 -8
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::{Edges, extend, trim};
use super::modify::{CUT_ONCE, Edges, extend, json_pick_error, trim};
use super::{bad, point_param, points_param};
use crate::{Accept, EngineError, Input, Interactive, Prompt, Result, Session, Step};
@@ -32,8 +32,10 @@ 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 {
e.to_string().contains("intersect")
let m = e.to_string();
m.contains("intersect") && m != CUT_ONCE
}
/// Trim or extend `h` at `at`. A Quick-mode (`quick`) trim of an object no cutting edge crosses
@@ -104,7 +106,12 @@ 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);
let cands = [*p, *q, seg.closest(a)].into_iter().chain(sides.iter().filter_map(|sd| line_line(sd, &seg)));
// 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)));
for c in cands.filter(|c| inside(*c)) {
if best.is_none_or(|b| c.dist(a) < b.dist(a)) {
best = Some(c);
@@ -174,7 +181,6 @@ 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() {
@@ -183,6 +189,7 @@ 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")
@@ -198,8 +205,19 @@ 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, "`pick` ([x, y]) is required"))?;
let r = apply(s, h, pick, extending, edges, quick)?;
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))?;
if extending { Ok(Value::Null) } else { Ok(json!({ "handles": r.iter().map(|h| h.hex()).collect::<Vec<_>>() })) }
}
@@ -221,6 +239,8 @@ 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,
@@ -357,6 +377,7 @@ 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 => {
@@ -456,6 +477,16 @@ 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)),
@@ -476,8 +507,9 @@ 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 opens a crossing window there.
self.stage = Stage::Crossing(Some(p));
// 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)) };
return Ok(Step::Continue);
};
let r = self.step(s, |m, s| apply(s, h, p, extending, m.edges(quick, implied), quick).map(|_| ()));
@@ -526,6 +558,7 @@ 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,5 +1,6 @@
//! 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).
//! 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).
use cadcraft_doc::{EntityKind, LwPolyline};
use cadcraft_engine::Session;
@@ -38,14 +39,15 @@ fn break_opens_a_closed_polyline_at_the_command_line() {
}
#[test]
fn break_json_on_a_closed_polyline_follows_the_order_of_the_points() {
fn break_json_on_a_closed_polyline_ignores_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 long way round goes, the short
// stretch between them stays.
// 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).
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![(50.0, 0.0), (100.0, 0.0), (100.0, 30.0)]);
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)]);
}
@@ -0,0 +1,134 @@
//! 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:?}");
}
@@ -0,0 +1,647 @@
//! 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)])]);
}
}
@@ -0,0 +1,128 @@
//! 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)));
}
@@ -0,0 +1,187 @@
//! 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,9 +17,12 @@ 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;
@@ -52,6 +55,7 @@ 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;
@@ -170,7 +174,11 @@ 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,11 +123,13 @@ fn undo_restores_the_closed_polyline() {
}
#[test]
fn a_single_cut_still_opens_the_outline_there() {
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."
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());
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())]);
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)])]);
}
@@ -0,0 +1,171 @@
//! 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]);
}
@@ -0,0 +1,42 @@
//! 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());
}
}
@@ -0,0 +1,177 @@
//! 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(())
}
+25 -2
View File
@@ -112,10 +112,33 @@ 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))]));
// A pick in empty space opens a crossing window too.
}
#[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());
}
let mut s = ladder();
s.script("TRIM 4,-4 6,1\n\n").unwrap();
s.script("TRIM 4,-4 6,1\n").unwrap();
assert!(s.prompt_text().contains("Select object to trim"), "{}", s.prompt_text());
s.cmdline("").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]
@@ -0,0 +1,102 @@
//! 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));
}
}
}
+143 -207
View File
@@ -20,7 +20,6 @@ mod grid;
mod grips;
mod list;
mod pick;
mod press;
mod viewport;
mod widgets;
@@ -165,7 +164,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.
pub(crate) grip_menu: Option<(Handle, usize)>,
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,
@@ -182,8 +181,8 @@ pub struct CanvasState {
hover_frozen: Vec<String>,
/// Constraint glyphs for the parametric overlay (cached per drawing revision).
pub param: crate::parametric::Cache,
/// The primary-button press being held, when it was acted on (see [`press`]).
press: Option<press::Press>,
/// A selection window opened by a press-and-drag, to close where the button is let go.
drag_window: bool,
/// 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,
@@ -514,7 +513,13 @@ fn paint_content_highlights(frame: &mut CanvasPaint<'_>, bg: Rgb, sel: &[Handle]
}
}
fn paint_pointer_overlay(frame: &mut CanvasPaint<'_>, paper_rect: Option<Rect>, surround: Color32, sheet: Option<cadcraft_render::Sheet>) {
fn paint_pointer_overlay(
frame: &mut CanvasPaint<'_>,
paper_rect: Option<Rect>,
surround: Color32,
selecting: bool,
sheet: Option<cadcraft_render::Sheet>,
) {
let app = &mut *frame.app;
let ui = &mut *frame.ui;
let painter = frame.painter;
@@ -558,8 +563,7 @@ fn paint_pointer_overlay(frame: &mut CanvasPaint<'_>, paper_rect: Option<Rect>,
// 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 }));
let picking = app.session.picking_objects() && app.session.pending_window.is_none();
draw_crosshair(app, painter, rect, hp, picking, ink);
draw_crosshair(app, painter, rect, hp, selecting, ink);
if app.canvas.cycle_badge && app.canvas.cycle.is_none() {
cycle_badge(painter, hp);
}
@@ -607,12 +611,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.press = None;
app.canvas.drag_window = false;
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.press = None;
app.canvas.drag_window = false;
app.canvas.list = None;
return None;
}
@@ -653,7 +657,43 @@ 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);
track_cursor(app, raw_world, xf, ui.ctx(), dyn_frame);
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;
}
(raw_world, dyn_frame)
}
@@ -703,91 +743,48 @@ fn update_hover(app: &mut CadApp, ui: &egui::Ui, inside: bool, hover_pos: Option
}
}
struct PressContext {
struct PromptClickContext<'a> {
rect: Rect,
xf: Xf,
inside: bool,
middle_down: bool,
mods: egui::Modifiers,
primary_clicked: bool,
response: &'a egui::Response,
}
/// 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());
}
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());
}
}
}
}
if !primary_down {
// The button came up where we didn't see it (outside the window, say).
app.canvas.press = None;
}
click_used
pressed_primary
}
/// Whether a quick right-click cancels the running command instead of acting as Enter: it asks for
@@ -875,21 +872,8 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
return;
};
// 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 pressed_primary =
collect_prompt_clicks(app, ui, PromptClickContext { rect, xf, inside, middle_down, primary_clicked: pressed_primary, response: &resp });
let (raw_world, dyn_frame) = update_canvas_cursor(app, ui, &xf, inside, hover_pos);
@@ -909,14 +893,26 @@ 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.press = None;
app.canvas.drag_window = false;
}
let pressed_primary = pressed_primary && !picked && !hatch_dialog && !idle_dbl;
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.
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.
if inside
&& pressed_primary
&& !click_used
&& !middle_down
&& !cycled
&& let Some(p) = app.canvas.cursor
@@ -948,31 +944,58 @@ pub fn show(app: &mut CadApp, ui: &mut egui::Ui) {
app.session.echo(e.to_string());
}
}
// 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.
// 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.
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 && !enter) || app.canvas.snap_menu {
} else if idle || app.canvas.snap_menu {
crate::context_menu::show(app, &resp);
}
@@ -998,95 +1021,6 @@ 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,
@@ -1107,6 +1041,7 @@ 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)];
@@ -1288,6 +1223,7 @@ fn paint_canvas(frame: CanvasPaint<'_>) {
},
paper_rect,
surround,
selecting,
sheet,
);
}
+12 -21
View File
@@ -212,37 +212,28 @@ 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 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 pb = if pickbox { pickbox_half(app.session.settings.pickbox) } else { None };
let gap = pb.unwrap_or(0.0);
// 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);
// 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);
}
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
@@ -1,167 +0,0 @@
//! 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,66 +249,6 @@ 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) {
+14 -26
View File
@@ -1,7 +1,6 @@
//! The canvas's right-click menus, after AutoCAD's shortcut menus:
//!
//! - **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
//! - **No command running** ([`entries`]): 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.
@@ -11,8 +10,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).
//! With it off, `rightClickDefault` and `rightClickEdit` can make a right-click with no command
//! running repeat the last command instead of opening the menu.
//! `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.
//!
@@ -388,16 +387,13 @@ 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 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.
// 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.
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()
{
@@ -421,15 +417,13 @@ pub fn show(app: &mut CadApp, resp: &egui::Response) {
#[derive(Clone, Copy, Default)]
struct Press(f64, egui::Pos2);
/// 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.
/// 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.
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");
@@ -454,21 +448,15 @@ 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 {
// 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;
return false;
}
let mut clicked = None;
let popup = egui::Popup::new(popup_id, ctx, egui::PopupAnchor::PointerFixed, ui.layer_id())
+5 -8
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` | 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 |
//! | `timeSensitiveRightClick` | while a command runs, a quick right-click is Enter and holding the button opens the shortcut menu (default); `false`: `rightClickCommand` decides |
//! | `rightClickDuration` | how long the right button is held to open the menu while a command runs, 100–2000 ms (250) |
//! | `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) |
//! | `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) |
//! | `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,16 +139,13 @@ pub struct UiOptions {
pub snap_marker_size: f32,
/// The selection highlight colour; `None` keeps the theme's.
pub selection_color: Option<Color32>,
/// 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.
/// 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.
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), with the time-sensitive right-click off.
/// (Edit mode).
pub right_click_default: IdleClick,
pub right_click_edit: IdleClick,
/// A right-click while a command runs, with the time-sensitive right-click off.
+14 -26
View File
@@ -615,35 +615,23 @@ 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);
// 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()));
}
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,42 +240,4 @@ 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,7 +21,6 @@ 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;
@@ -30,7 +29,6 @@ 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;
@@ -38,7 +36,6 @@ 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
@@ -1,183 +0,0 @@
//! 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");
}
+5 -28
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!({"timeSensitiveRightClick": false, "rightClickDefault": "repeat"})).unwrap();
a.run("options", json!({"rightClickDefault": "repeat"})).unwrap();
a.cmdline("circle 0,0 5");
assert!(!a.session.prompting());
let ctx = egui::Context::default();
@@ -116,22 +116,6 @@ 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();
@@ -198,17 +182,6 @@ 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();
@@ -217,6 +190,10 @@ 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);
+7 -5
View File
@@ -83,11 +83,13 @@ 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());
// 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);
// 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);
assert!(h.state().session.pending_window.is_none());
assert_eq!(h.state().session.selection().len(), 1);
}
@@ -1,189 +0,0 @@
//! 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");
}
+2 -3
View File
@@ -88,12 +88,11 @@ 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 point is
// where the button went down (#1001), not where the hand got to.
// The hand is already on its way to the next point when the button comes up.
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(down), 1e-4), "{got:?}");
assert!(got[0].1.near(h.state().canvas.xf.unwrap().to_world(up), 1e-4), "{got:?}");
}
-159
View File
@@ -1,159 +0,0 @@
//! 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}");
}