Sketch trim: drag a path across curves to trim every piece it crosses (#3182)
`sketch.trim.path {points, dry_run?}` walks a polyline and, at each place it
crosses a curve trim may change, removes that piece exactly as `sketch.trim`
would there, in the order crossed and in one undo step. A piece already gone
is not trimmed again; projected geometry, infinite lines, offset outputs and
pieces trim refuses are passed over (reported in `skipped`). It returns each
trim's result and each removed piece as a polyline; `dry_run` reports them
without changing the design.
With Trim on, a press and drag in the viewport draws that path: the pieces it
would remove light up (a dry run of the command) and letting go runs it. A
click still trims the one piece under it.
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -613,6 +613,7 @@
|
||||
"cmd.sketch_spline_fit_point": "Fit Point Spline",
|
||||
"cmd.sketch_spun_profile": "Spun Profile",
|
||||
"cmd.sketch_toggle_driven": "Toggle Driven Dimension",
|
||||
"cmd.sketch_trim_path": "Trim Along Path",
|
||||
"cmd.solid_align": "Align",
|
||||
"cmd.solid_boundary_fill": "Boundary Fill",
|
||||
"cmd.solid_bounding_solid": "Bounding Solid",
|
||||
|
||||
@@ -613,6 +613,7 @@
|
||||
"cmd.sketch_spline_fit_point": "通過点スプライン",
|
||||
"cmd.sketch_spun_profile": "回転プロファイル",
|
||||
"cmd.sketch_toggle_driven": "従動寸法の切り替え",
|
||||
"cmd.sketch_trim_path": "パスに沿ってトリム",
|
||||
"cmd.solid_align": "整列",
|
||||
"cmd.solid_boundary_fill": "境界フィル",
|
||||
"cmd.solid_bounding_solid": "バウンディング ソリッド",
|
||||
|
||||
@@ -613,6 +613,7 @@
|
||||
"cmd.sketch_spline_fit_point": "拟合点样条曲线",
|
||||
"cmd.sketch_spun_profile": "旋转轮廓",
|
||||
"cmd.sketch_toggle_driven": "切换被驱动尺寸",
|
||||
"cmd.sketch_trim_path": "沿路径修剪",
|
||||
"cmd.solid_align": "对齐",
|
||||
"cmd.solid_boundary_fill": "边界填充",
|
||||
"cmd.solid_bounding_solid": "包围实体",
|
||||
|
||||
@@ -280,8 +280,13 @@ fn modify(sk: &mut Sketch, ci: usize, at: Vec2, remove: bool, points: Option<&[V
|
||||
}
|
||||
}
|
||||
let ids: Vec<String> = made.iter().filter_map(|c| sk.curves.get(*c).map(|c| c.id.clone())).collect();
|
||||
// The removed piece, for previews (`sketch.trim.path`).
|
||||
let removed: Vec<[f64; 2]> = gone
|
||||
.and_then(|k| intervals.get(k))
|
||||
.map(|(a, b, ..)| span(&segs, *a, *b).iter().flat_map(|s| s.polyline(1e-3)).map(|q| [q.x, q.y]).collect())
|
||||
.unwrap_or_default();
|
||||
sk.remove_curves(&[ci]);
|
||||
let unused: Vec<usize> = cut_pt.iter().map(|x| x.1).filter(|pi| !sk.curves.iter().any(|c| c.kind.uses(*pi))).collect();
|
||||
sk.remove_points(&unused);
|
||||
Ok(json!({"curves": ids}))
|
||||
Ok(json!({"curves": ids, "removed": removed}))
|
||||
}
|
||||
|
||||
@@ -59,6 +59,13 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.key("T")
|
||||
.enabled(in_sketch)
|
||||
.params(concat!("curve: id, at: [x,y] (the piece to remove: between the nearest intersections around it)", created_doc!())),
|
||||
CommandSpec::new("sketch.trim.path", "Trim Along Path", trim_path)
|
||||
.icon("trim")
|
||||
.enabled(in_sketch)
|
||||
.params(concat!(
|
||||
"points: [[x,y]…] (2…2000 positions: a path drawn across the sketch). Every piece the path crosses is removed as `sketch.trim` removes the piece at that crossing, in the order the path crosses them; a piece crossed again after it is gone is not trimmed twice; projected geometry, infinite lines, offset outputs and pieces trim refuses are passed over (why in `skipped`). dry_run?: bool (report without changing the design). One undo step → trimmed: [each trim's result], removed: [[[x,y]…]] (each removed piece as a polyline)",
|
||||
created_doc!()
|
||||
)),
|
||||
CommandSpec::new("sketch.extend", "Extend", extend)
|
||||
.at("SKETCH", "MODIFY")
|
||||
.icon("extend")
|
||||
@@ -343,65 +350,194 @@ fn trim(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let at = req_vec2(cmd, p, "at")?;
|
||||
let (out, info) = edit(s, p, cmd, false, |sk, doc| {
|
||||
let ci = curve_arg(sk, p, cmd)?;
|
||||
let id = sk.curves.get(ci).map(|c| c.id.clone()).unwrap_or_default();
|
||||
if sk.curves.get(ci).is_some_and(|c| c.infinite) {
|
||||
return Err(bad(cmd, "an infinite line has no ends to trim back to: make it a normal line first"));
|
||||
}
|
||||
if sk.curves.get(ci).is_some_and(|c| c.kind.is_freeform()) {
|
||||
let r = super::sketch_freeform::trim_or_break(sk, ci, at, true, cmd)?;
|
||||
doc.prune_model_params();
|
||||
return Ok(json!({"trimmed": id, "pieces": r["curves"]}));
|
||||
}
|
||||
let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?;
|
||||
let tq = sh.param(sh.project(at));
|
||||
let (cuts, full) = bracket(sk, ci, tq);
|
||||
if cuts.is_empty() {
|
||||
// Nothing crosses it: the whole curve goes.
|
||||
sk.remove_curves(&[ci]);
|
||||
doc.prune_model_params();
|
||||
return Ok(json!({"deleted": id}));
|
||||
}
|
||||
release_extent(sk, ci);
|
||||
let ts: Vec<f64> = cuts.iter().map(|c| c.0).collect();
|
||||
let (pieces, pts) = split_at(sk, ci, &ts)?;
|
||||
// The piece containing tq.
|
||||
let k = if full {
|
||||
let (a, b) = (ts[0], ts[1]);
|
||||
if tq > a && tq < b { 0 } else { 1 }
|
||||
} else {
|
||||
ts.iter().filter(|t| **t < tq).count()
|
||||
};
|
||||
for (pi, c) in pts.iter().zip(&cuts) {
|
||||
pin(sk, *pi, c.2)?;
|
||||
}
|
||||
let gone = pieces.get(k).copied().ok_or_else(|| bad(cmd, "piece"))?;
|
||||
let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();
|
||||
// The original curve keeps its id (and constraints): swap geometry into it if needed.
|
||||
let gone = match keep.first() {
|
||||
Some(&other) if gone == ci => {
|
||||
let ka = sk.curves.get(ci).map(|c| c.kind.clone());
|
||||
let kb = sk.curves.get(other).map(|c| c.kind.clone());
|
||||
if let (Some(ka), Some(kb)) = (ka, kb) {
|
||||
if let Some(c) = sk.curves.get_mut(ci) {
|
||||
c.kind = kb;
|
||||
}
|
||||
if let Some(c) = sk.curves.get_mut(other) {
|
||||
c.kind = ka;
|
||||
}
|
||||
}
|
||||
other
|
||||
}
|
||||
_ => gone,
|
||||
};
|
||||
let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();
|
||||
tie(sk, &keep)?;
|
||||
sk.remove_curves(&[gone]);
|
||||
let (out, _) = remove_piece(sk, ci, at, cmd)?;
|
||||
doc.prune_model_params();
|
||||
Ok(json!({"trimmed": id}))
|
||||
Ok(out)
|
||||
})?;
|
||||
Ok(json!({"result": out, "sketch": info}))
|
||||
}
|
||||
|
||||
/// Remove the piece of curve `ci` around `at`: between the nearest intersections on either
|
||||
/// side, or the whole curve when nothing crosses it. Returns what `sketch.trim` reports and the
|
||||
/// removed piece as a polyline.
|
||||
fn remove_piece(sk: &mut Sketch, ci: usize, at: Vec2, cmd: &str) -> Result<(Value, Vec<Vec2>)> {
|
||||
let id = sk.curves.get(ci).map(|c| c.id.clone()).unwrap_or_default();
|
||||
if sk.curves.get(ci).is_some_and(|c| c.infinite) {
|
||||
return Err(bad(cmd, "an infinite line has no ends to trim back to: make it a normal line first"));
|
||||
}
|
||||
if sk.curves.get(ci).is_some_and(|c| c.kind.is_freeform()) {
|
||||
let whole = sk.polyline(ci);
|
||||
let r = super::sketch_freeform::trim_or_break(sk, ci, at, true, cmd)?;
|
||||
let removed = match r.get("removed").and_then(Value::as_array) {
|
||||
Some(pts) => pts.iter().filter_map(|q| Some(Vec2::new(q.get(0)?.as_f64()?, q.get(1)?.as_f64()?))).collect(),
|
||||
None => whole,
|
||||
};
|
||||
return Ok((json!({"trimmed": id, "pieces": r["curves"]}), removed));
|
||||
}
|
||||
let sh = sk.shape(ci).ok_or_else(|| bad(cmd, "curve"))?;
|
||||
let tq = sh.param(sh.project(at));
|
||||
let (cuts, full) = bracket(sk, ci, tq);
|
||||
if cuts.is_empty() {
|
||||
// Nothing crosses it: the whole curve goes.
|
||||
let removed = sk.polyline(ci);
|
||||
sk.remove_curves(&[ci]);
|
||||
return Ok((json!({"deleted": id}), removed));
|
||||
}
|
||||
release_extent(sk, ci);
|
||||
let ts: Vec<f64> = cuts.iter().map(|c| c.0).collect();
|
||||
let (pieces, pts) = split_at(sk, ci, &ts)?;
|
||||
// The piece containing tq.
|
||||
let k = if full {
|
||||
let (a, b) = (ts[0], ts[1]);
|
||||
if tq > a && tq < b { 0 } else { 1 }
|
||||
} else {
|
||||
ts.iter().filter(|t| **t < tq).count()
|
||||
};
|
||||
for (pi, c) in pts.iter().zip(&cuts) {
|
||||
pin(sk, *pi, c.2)?;
|
||||
}
|
||||
let gone = pieces.get(k).copied().ok_or_else(|| bad(cmd, "piece"))?;
|
||||
let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();
|
||||
// The original curve keeps its id (and constraints): swap geometry into it if needed.
|
||||
let gone = match keep.first() {
|
||||
Some(&other) if gone == ci => {
|
||||
let ka = sk.curves.get(ci).map(|c| c.kind.clone());
|
||||
let kb = sk.curves.get(other).map(|c| c.kind.clone());
|
||||
if let (Some(ka), Some(kb)) = (ka, kb) {
|
||||
if let Some(c) = sk.curves.get_mut(ci) {
|
||||
c.kind = kb;
|
||||
}
|
||||
if let Some(c) = sk.curves.get_mut(other) {
|
||||
c.kind = ka;
|
||||
}
|
||||
}
|
||||
other
|
||||
}
|
||||
_ => gone,
|
||||
};
|
||||
let keep: Vec<usize> = pieces.iter().copied().filter(|x| *x != gone).collect();
|
||||
tie(sk, &keep)?;
|
||||
let removed = sk.polyline(gone);
|
||||
sk.remove_curves(&[gone]);
|
||||
Ok((json!({"trimmed": id}), removed))
|
||||
}
|
||||
|
||||
/// Most crossings one `sketch.trim.path` trims (each one splits a curve, so this also caps the
|
||||
/// work a hostile path can ask for).
|
||||
const MAX_PATH_TRIMS: usize = 500;
|
||||
/// Most positions in a trim path.
|
||||
const MAX_PATH_POINTS: usize = 2_000;
|
||||
|
||||
/// The first place along `path` after `after` (segment, parameter along it) where the path
|
||||
/// crosses a curve that a trim may change: (segment, parameter, curve, the crossing point). Crossings are found on the
|
||||
/// curves' display polylines; the trim projects them onto the exact curve.
|
||||
fn next_crossing(sk: &Sketch, path: &[Vec2], after: (usize, f64)) -> Option<(usize, f64, usize, Vec2)> {
|
||||
let bounds = |pts: &[Vec2]| {
|
||||
pts.iter().fold((Vec2::new(f64::INFINITY, f64::INFINITY), Vec2::new(f64::NEG_INFINITY, f64::NEG_INFINITY)), |(lo, hi), q| {
|
||||
(Vec2::new(lo.x.min(q.x), lo.y.min(q.y)), Vec2::new(hi.x.max(q.x), hi.y.max(q.y)))
|
||||
})
|
||||
};
|
||||
let trimmable: Vec<(usize, Vec<Vec2>, (Vec2, Vec2))> = (0..sk.curves.len())
|
||||
.filter(|ci| curve_ok(sk, *ci))
|
||||
.map(|ci| {
|
||||
let poly = sk.polyline(ci);
|
||||
let b = bounds(&poly);
|
||||
(ci, poly, b)
|
||||
})
|
||||
.collect();
|
||||
for (si, w) in path.windows(2).enumerate().skip(after.0) {
|
||||
let (a, b) = (w[0], w[1]);
|
||||
let from = if si == after.0 { after.1 } else { f64::NEG_INFINITY };
|
||||
let (lo, hi) = bounds(&[a, b]);
|
||||
let mut best: Option<(f64, usize, Vec2)> = None;
|
||||
for (ci, poly, (plo, phi)) in &trimmable {
|
||||
if plo.x > hi.x || plo.y > hi.y || phi.x < lo.x || phi.y < lo.y {
|
||||
continue;
|
||||
}
|
||||
for e in poly.windows(2) {
|
||||
let Some((t, q)) = seg_cross(a, b, e[0], e[1]) else { continue };
|
||||
if t > from + 1e-9 && best.is_none_or(|x| t < x.0) {
|
||||
best = Some((t, *ci, q));
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some((t, ci, q)) = best {
|
||||
return Some((si, t, ci, q));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Whether trim may change curve `ci` (what [`curve_arg`] accepts, and not an infinite line).
|
||||
fn curve_ok(sk: &Sketch, ci: usize) -> bool {
|
||||
let Some(c) = sk.curves.get(ci) else { return false };
|
||||
!c.infinite
|
||||
&& !sk.is_linked_curve(ci)
|
||||
&& !sk.freeform_offsets.iter().any(|offset| offset.output == c.id)
|
||||
&& !sk.offsets.iter().filter_map(|offset| offset.topology.as_ref()).any(|topology| topology.roles.iter().any(|role| role.output == c.id))
|
||||
}
|
||||
|
||||
/// Where segment `a`–`b` crosses segment `c`–`d`: the parameter along `a`–`b` and the point.
|
||||
fn seg_cross(a: Vec2, b: Vec2, c: Vec2, d: Vec2) -> Option<(f64, Vec2)> {
|
||||
let (r, s) = (b - a, d - c);
|
||||
let den = r.cross(s);
|
||||
if den.abs() <= 1e-15 * r.len2().max(s.len2()).max(1e-30) {
|
||||
return None;
|
||||
}
|
||||
let t = (c - a).cross(s) / den;
|
||||
let u = (c - a).cross(r) / den;
|
||||
((0.0..=1.0).contains(&t) && (0.0..=1.0).contains(&u)).then(|| (t, a + r * t))
|
||||
}
|
||||
|
||||
fn trim_path(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "sketch.trim.path";
|
||||
let path = vec2_list(cmd, p, "points", MAX_PATH_POINTS)?;
|
||||
if path.len() < 2 {
|
||||
return Err(bad(cmd, "`points` needs at least two positions"));
|
||||
}
|
||||
if bool_(p, "dry_run").unwrap_or(false) {
|
||||
let mut t = s.scratch();
|
||||
let mut q = p.clone();
|
||||
if let Some(o) = q.as_object_mut() {
|
||||
o.remove("dry_run");
|
||||
}
|
||||
let mut out = trim_path(&mut t, &q)?;
|
||||
out["dry_run"] = json!(true);
|
||||
return Ok(out);
|
||||
}
|
||||
let ((trimmed, removed, skipped), info) = edit(s, p, cmd, false, |sk, doc| {
|
||||
let mut trimmed: Vec<Value> = Vec::new();
|
||||
let mut removed: Vec<Value> = Vec::new();
|
||||
let mut skipped: Vec<String> = Vec::new();
|
||||
let mut after = (0, f64::NEG_INFINITY);
|
||||
for _ in 0..MAX_PATH_TRIMS {
|
||||
let Some((si, t, ci, q)) = next_crossing(sk, &path, after) else { break };
|
||||
after = (si, t);
|
||||
// A piece trim refuses (a closed spline crossed once) stays as it was.
|
||||
let before = sk.clone();
|
||||
match remove_piece(sk, ci, q, cmd) {
|
||||
Ok((out, gone)) => {
|
||||
trimmed.push(out);
|
||||
removed.push(json!(gone.iter().map(|v| [v.x, v.y]).collect::<Vec<_>>()));
|
||||
}
|
||||
Err(e) => {
|
||||
*sk = before;
|
||||
let why = e.to_string().replace(&format!("{cmd}: "), "");
|
||||
if !skipped.contains(&why) {
|
||||
skipped.push(why);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if trimmed.is_empty() {
|
||||
return Err(bad(cmd, skipped.first().cloned().unwrap_or_else(|| "the path crosses no curve that can be trimmed".into())));
|
||||
}
|
||||
doc.prune_model_params();
|
||||
Ok((trimmed, removed, skipped))
|
||||
})?;
|
||||
Ok(json!({"trimmed": trimmed, "removed": removed, "skipped": skipped, "sketch": info}))
|
||||
}
|
||||
|
||||
fn break_cmd(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "sketch.break";
|
||||
let points = if p.get("points").is_some() { Some(vec2_list(cmd, p, "points", 1000)?) } else { None };
|
||||
@@ -1884,3 +2020,7 @@ mod robust_tests;
|
||||
#[cfg(test)]
|
||||
#[path = "sketch_corner_tests.rs"]
|
||||
mod corner_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sketch_trim_path_tests.rs"]
|
||||
mod trim_path_tests;
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
//! `sketch.trim.path`: dragging across curves trims each piece the path crosses, as clicking it
|
||||
//! with `sketch.trim` would, in one undo step.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_geom::Vec2;
|
||||
use solidcraft_sketch::Shape;
|
||||
|
||||
use crate::Session;
|
||||
|
||||
fn run(s: &mut Session, id: &str, p: Value) -> Value {
|
||||
match s.execute(id, &p) {
|
||||
Ok(v) => v,
|
||||
Err(e) => panic!("{id} {p}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn ids(v: &Value) -> Vec<String> {
|
||||
v.as_array().map(|a| a.iter().filter_map(|x| x.as_str().map(str::to_string)).collect()).unwrap_or_default()
|
||||
}
|
||||
|
||||
fn sketch(s: &Session) -> solidcraft_sketch::Sketch {
|
||||
let id = s.active_sketch.unwrap();
|
||||
s.model.state().sketch(id).unwrap().sketch.clone()
|
||||
}
|
||||
|
||||
fn new_sketch() -> Session {
|
||||
let mut s = Session::default();
|
||||
run(&mut s, "sketch.create", json!({"plane": "XY"}));
|
||||
s
|
||||
}
|
||||
|
||||
fn line(s: &mut Session, points: Value) -> Vec<String> {
|
||||
ids(&run(s, "sketch.line", json!({"points": points}))["curves"])
|
||||
}
|
||||
|
||||
/// A 40 x 40 square with a step cut across its top right corner (as in the single trim's
|
||||
/// dimension test), the right side dimensioned.
|
||||
fn square_with_step() -> (Session, String, String) {
|
||||
let mut s = new_sketch();
|
||||
let sq = ids(&run(&mut s, "sketch.line", json!({"points": [[0, 0], [40, 0], [40, 40], [0, 40]], "closed": true, "infer": true}))["curves"]);
|
||||
let (right, top) = (sq[1].clone(), sq[2].clone());
|
||||
run(&mut s, "sketch.dimension", json!({"entities": [right]}));
|
||||
let step = ids(&run(&mut s, "sketch.line", json!({"points": [[23, 40], [23, 23], [40, 23]], "infer": true}))["curves"]);
|
||||
run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.start", step[0]), "b": top}));
|
||||
run(&mut s, "sketch.constraint.coincident", json!({"a": format!("{}.end", step[1]), "b": right}));
|
||||
(s, right, top)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_path_trims_what_clicking_each_crossed_piece_would() {
|
||||
// Clicks: the right side above the step, then the top side right of it.
|
||||
let (mut clicked, right, top) = square_with_step();
|
||||
run(&mut clicked, "sketch.trim", json!({"curve": right, "at": [40, 30]}));
|
||||
run(&mut clicked, "sketch.trim", json!({"curve": top, "at": [30, 40]}));
|
||||
|
||||
// One drag from outside the right side, across the corner, out through the top.
|
||||
let (mut dragged, ..) = square_with_step();
|
||||
let before = sketch(&dragged);
|
||||
let undo_before = dragged.undo.len();
|
||||
let out = run(&mut dragged, "sketch.trim.path", json!({"points": [[45, 30], [30, 30], [30, 45]]}));
|
||||
assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(2), "{out}");
|
||||
assert_eq!(out["removed"].as_array().map(Vec::len), Some(2), "{out}");
|
||||
assert_eq!(sketch(&dragged), sketch(&clicked), "the drag and the two clicks leave the same sketch");
|
||||
|
||||
// One undo step brings everything back.
|
||||
assert_eq!(dragged.undo.len(), undo_before + 1);
|
||||
run(&mut dragged, "edit.undo", json!({}));
|
||||
assert_eq!(sketch(&dragged), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_piece_crossed_twice_is_trimmed_once() {
|
||||
let mut s = new_sketch();
|
||||
line(&mut s, json!([[0, 0], [20, 0]]));
|
||||
line(&mut s, json!([[0, 10], [20, 10]]));
|
||||
let v = line(&mut s, json!([[10, -5], [10, 15]]))[0].clone();
|
||||
// A zigzag across the middle piece of the vertical line, three times.
|
||||
let out = run(&mut s, "sketch.trim.path", json!({"points": [[5, 3], [15, 4], [5, 5], [15, 6]]}));
|
||||
assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(1), "{out}");
|
||||
let removed = out["removed"][0].as_array().unwrap();
|
||||
let ends: Vec<Vec2> =
|
||||
[removed.first().unwrap(), removed.last().unwrap()].iter().map(|q| Vec2::new(q[0].as_f64().unwrap(), q[1].as_f64().unwrap())).collect();
|
||||
assert!(ends.iter().any(|q| q.dist(Vec2::new(10.0, 0.0)) < 1e-6) && ends.iter().any(|q| q.dist(Vec2::new(10.0, 10.0)) < 1e-6), "{ends:?}");
|
||||
// The two outer pieces of the vertical line stay, the original id on the lower one.
|
||||
let sk = sketch(&s);
|
||||
assert_eq!(sk.curves.len(), 4);
|
||||
let lower = sk.shape(sk.curve_index(&v).unwrap()).unwrap();
|
||||
assert!(matches!(lower, Shape::Line { a, b } if a.dist(Vec2::new(10.0, -5.0)) < 1e-6 && b.dist(Vec2::new(10.0, 0.0)) < 1e-6), "{lower:?}");
|
||||
}
|
||||
|
||||
/// A scene built twice: trimmed once along `path` and once by clicking `clicks` (curve index
|
||||
/// in the scene's curves, where) in turn; both must leave the same sketch.
|
||||
fn same_as_clicks(build: fn(&mut Session) -> Vec<String>, path: Value, clicks: &[(usize, [f64; 2])]) {
|
||||
let mut clicked = new_sketch();
|
||||
let curves = build(&mut clicked);
|
||||
for (k, at) in clicks {
|
||||
run(&mut clicked, "sketch.trim", json!({"curve": curves[*k], "at": at}));
|
||||
}
|
||||
let mut dragged = new_sketch();
|
||||
build(&mut dragged);
|
||||
let out = run(&mut dragged, "sketch.trim.path", json!({"points": path}));
|
||||
assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(clicks.len()), "{out}");
|
||||
assert!(out["removed"].as_array().unwrap().iter().all(|r| r.as_array().is_some_and(|r| r.len() >= 2)), "{out}");
|
||||
assert_eq!(sketch(&dragged), sketch(&clicked), "{path}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn circles_arcs_and_splines_trim_along_a_path() {
|
||||
// A circle across a line: the lower half goes, the rest is an arc.
|
||||
same_as_clicks(
|
||||
|s| {
|
||||
let c = ids(&run(s, "sketch.circle.center", json!({"center": [0, 0], "radius": 10}))["curves"]);
|
||||
[c, line(s, json!([[-20, 0], [20, 0]]))].concat()
|
||||
},
|
||||
json!([[0, -15], [0, -5]]),
|
||||
&[(0, [0.0, -10.0])],
|
||||
);
|
||||
// An arc cut by a line through its middle: the left part goes.
|
||||
same_as_clicks(
|
||||
|s| {
|
||||
let a = ids(&run(s, "sketch.arc.three_point", json!({"start": [-10, 0], "through": [0, 10], "end": [10, 0]}))["curves"]);
|
||||
[a, line(s, json!([[0, -5], [0, 15]]))].concat()
|
||||
},
|
||||
json!([[-10, 8], [-3, 8]]),
|
||||
&[(0, [-6.0, 8.0])],
|
||||
);
|
||||
// A spline over a line: its hump goes, then the line's piece under it.
|
||||
same_as_clicks(
|
||||
|s| {
|
||||
let sp =
|
||||
ids(&run(s, "sketch.spline.fit_point", json!({"points": [[-20, -20], [-10, 5], [10, 5], [20, -20]], "connect": false}))["curves"]);
|
||||
[sp, line(s, json!([[-30, 0], [30, 0]]))].concat()
|
||||
},
|
||||
json!([[0, 10], [0, -1]]),
|
||||
&[(0, [0.0, 10.0]), (1, [0.0, 0.0])],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dry_run_reports_the_pieces_without_changing_the_design() {
|
||||
let (mut s, ..) = square_with_step();
|
||||
let before = sketch(&s);
|
||||
let (undo, revision) = (s.undo.len(), s.revision);
|
||||
let path = json!([[45, 30], [30, 30], [30, 45]]);
|
||||
let dry = run(&mut s, "sketch.trim.path", json!({"points": path, "dry_run": true}));
|
||||
assert_eq!(dry["dry_run"], true);
|
||||
assert_eq!(sketch(&s), before);
|
||||
assert_eq!((s.undo.len(), s.revision), (undo, revision), "a dry run is no step");
|
||||
let real = run(&mut s, "sketch.trim.path", json!({"points": path}));
|
||||
assert_eq!(dry["removed"], real["removed"]);
|
||||
assert_eq!(dry["trimmed"], real["trimmed"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn curves_trim_cannot_change_are_passed_over() {
|
||||
let mut s = new_sketch();
|
||||
let inf = line(&mut s, json!([[0, -10], [0, 10]]))[0].clone();
|
||||
run(&mut s, "sketch.infinite", json!({"curves": [inf]}));
|
||||
let h = line(&mut s, json!([[-20, 0], [20, 0]]))[0].clone();
|
||||
// Crossing the infinite line leaves it alone; the horizontal line's right part goes.
|
||||
let out = run(&mut s, "sketch.trim.path", json!({"points": [[-5, 5], [10, 5], [10, -5]]}));
|
||||
assert_eq!(out["trimmed"].as_array().map(Vec::len), Some(1), "{out}");
|
||||
let sk = sketch(&s);
|
||||
assert!(sk.curves[sk.curve_index(&inf).unwrap()].infinite);
|
||||
let rest = sk.shape(sk.curve_index(&h).unwrap()).unwrap();
|
||||
assert!(matches!(rest, Shape::Line { a, b } if a.dist(Vec2::new(-20.0, 0.0)) < 1e-6 && b.dist(Vec2::new(0.0, 0.0)) < 1e-6), "{rest:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hostile_paths_fail_cleanly() {
|
||||
let mut s = new_sketch();
|
||||
line(&mut s, json!([[0, 0], [10, 0]]));
|
||||
let before = sketch(&s);
|
||||
let long: Vec<[f64; 2]> = (0..2_001).map(|i| [i as f64, 1.0]).collect();
|
||||
for p in [
|
||||
json!({}),
|
||||
json!({"points": []}),
|
||||
json!({"points": [[0, 1]]}),
|
||||
json!({"points": "x"}),
|
||||
json!({"points": [[0, 1], ["a", 2]]}),
|
||||
json!({"points": long}),
|
||||
json!({"points": [[50, 50], [60, 60]]}),
|
||||
json!({"points": [[1e308, -1e308], [-1e308, 1e308]]}),
|
||||
json!({"points": [[5, 1], [5, 1]]}),
|
||||
] {
|
||||
assert!(s.execute("sketch.trim.path", &p).is_err(), "{p}");
|
||||
assert_eq!(sketch(&s), before, "{p}");
|
||||
}
|
||||
// Outside a sketch.
|
||||
let mut none = Session::default();
|
||||
assert!(none.execute("sketch.trim.path", &json!({"points": [[0, -1], [0, 1]]})).is_err());
|
||||
}
|
||||
@@ -86,6 +86,78 @@ thread_local! {
|
||||
static ISO: RefCell<Vec<Vec<[Vec3; 2]>>> = const { RefCell::new(Vec::new()) };
|
||||
/// Center of Mass has just started: measure everything on the next frame.
|
||||
static DEFERRED: Cell<bool> = const { Cell::new(false) };
|
||||
/// A Trim drag: the pieces its path would remove (sketch polylines), and where the path's
|
||||
/// last point is on screen.
|
||||
static TRIM_REMOVED: RefCell<Vec<Vec<Vec2>>> = const { RefCell::new(Vec::new()) };
|
||||
static TRIM_LAST: Cell<Option<Pos2>> = const { Cell::new(None) };
|
||||
}
|
||||
|
||||
/// Screen distance the pointer moves before a Trim drag's path takes another point.
|
||||
const TRIM_STEP_PX: f32 = 4.0;
|
||||
|
||||
/// The sketch-plane position under screen position `pos`.
|
||||
fn on_sketch_plane(app: &SolveApp, proj: &Proj, pos: Pos2) -> Option<Vec2> {
|
||||
let st = app.session.world_state();
|
||||
let ss = st.sketch(active_sketch(app)?)?;
|
||||
let (o, d) = proj.ray(pos);
|
||||
ss.plane.intersect_ray(o, d).map(|w| ss.plane.to_local(w))
|
||||
}
|
||||
|
||||
/// A press and drag with Trim draws a path from `press`; true when it started one. Each piece
|
||||
/// the path crosses is trimmed when it is let go (`sketch.trim.path`).
|
||||
pub fn trim_drag_start(app: &mut SolveApp, proj: &Proj, press: Pos2) -> bool {
|
||||
let Some(q) = on_sketch_plane(app, proj, press) else { return false };
|
||||
let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim") else { return false };
|
||||
tool.pts = vec![(q, None)];
|
||||
TRIM_LAST.with(|c| c.set(Some(press)));
|
||||
TRIM_REMOVED.with(|r| r.borrow_mut().clear());
|
||||
true
|
||||
}
|
||||
|
||||
/// The Trim drag's path reaches `pos`: the pieces it would remove light up (a dry run of the
|
||||
/// command the release runs).
|
||||
pub fn trim_drag_to(app: &mut SolveApp, proj: &Proj, pos: Pos2) {
|
||||
if TRIM_LAST.with(Cell::get).is_some_and(|last| last.distance(pos) < TRIM_STEP_PX) {
|
||||
return;
|
||||
}
|
||||
let Some(q) = on_sketch_plane(app, proj, pos) else { return };
|
||||
let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim" && !t.pts.is_empty()) else { return };
|
||||
if tool.pts.len() >= TRIM_PATH_MAX {
|
||||
return;
|
||||
}
|
||||
tool.pts.push((q, None));
|
||||
TRIM_LAST.with(|c| c.set(Some(pos)));
|
||||
let points: Vec<[f64; 2]> = tool.pts.iter().map(|p| [p.0.x, p.0.y]).collect();
|
||||
let removed = app
|
||||
.session
|
||||
.execute("sketch.trim.path", &json!({"points": points, "dry_run": true}))
|
||||
.map(|v| {
|
||||
v["removed"]
|
||||
.as_array()
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|piece| piece.as_array().into_iter().flatten().filter_map(solidcraft_engine::params::vec2).collect())
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
TRIM_REMOVED.with(|r| *r.borrow_mut() = removed);
|
||||
}
|
||||
|
||||
/// Most points a Trim drag's path keeps (the command's limit).
|
||||
const TRIM_PATH_MAX: usize = 2_000;
|
||||
|
||||
/// The Trim drag is let go: trim every piece its path crossed, in one undo step. False when the
|
||||
/// path crossed nothing (the caller takes the release as a click).
|
||||
pub fn trim_drag_end(app: &mut SolveApp) -> bool {
|
||||
TRIM_LAST.with(|c| c.set(None));
|
||||
let crossed = TRIM_REMOVED.with(|r| !std::mem::take(&mut *r.borrow_mut()).is_empty());
|
||||
let Some(tool) = app.tool.as_mut().filter(|t| t.cmd == "sketch.trim") else { return false };
|
||||
let points: Vec<[f64; 2]> = std::mem::take(&mut tool.pts).iter().map(|p| [p.0.x, p.0.y]).collect();
|
||||
if !crossed || points.len() < 2 {
|
||||
return false;
|
||||
}
|
||||
let _ = app.run("sketch.trim.path", json!({"points": points}));
|
||||
true
|
||||
}
|
||||
|
||||
/// Commands registered on one panel that another panel also lists: the analyses (sketch
|
||||
@@ -528,7 +600,7 @@ pub fn hint(id: &str) -> Option<String> {
|
||||
"inspect.continuity" => "Continuity: click an edge for its numbers (the button again turns the colours off)",
|
||||
"canvas.insert" => "Canvas: click a plane or a planar face where the image's centre goes",
|
||||
"canvas.decal" => "Decal: click a planar face where the image's centre goes",
|
||||
"sketch.trim" => "Trim: click the piece of a curve to remove",
|
||||
"sketch.trim" => "Trim: click the piece of a curve to remove, or drag across the pieces to remove",
|
||||
"sketch.extend" => "Extend: click a curve near the end to extend",
|
||||
"sketch.break" => "Break: click a curve where it should split",
|
||||
"sketch.line.midpoint" => "Midpoint line: click the middle, then an end",
|
||||
@@ -1042,6 +1114,18 @@ pub fn preview(app: &SolveApp, t: &Tool, painter: &egui::Painter, proj: &Proj) {
|
||||
crate::tools::paint_sketch_path(&world, 0, painter, proj, Stroke::new(4.5, tk.error));
|
||||
}
|
||||
let stroke = Stroke::new(1.5, tk.rubber_band);
|
||||
// A Trim drag: the pieces it will remove, then the path drawn so far.
|
||||
if t.cmd == "sketch.trim" && !t.pts.is_empty() {
|
||||
TRIM_REMOVED.with(|r| {
|
||||
for piece in r.borrow().iter() {
|
||||
let line: Vec<Pos2> = piece.iter().filter_map(|p| to(*p)).collect();
|
||||
painter.add(egui::Shape::line(line, Stroke::new(4.0, tk.error.gamma_multiply(0.8))));
|
||||
}
|
||||
});
|
||||
let path: Vec<Pos2> = t.pts.iter().filter_map(|p| to(p.0)).collect();
|
||||
painter.add(egui::Shape::line(path, stroke));
|
||||
return;
|
||||
}
|
||||
if let Some((hp, snap)) = &t.hover
|
||||
&& let Some(sp) = to(*hp)
|
||||
{
|
||||
@@ -1320,3 +1404,7 @@ mod corner_ui_tests;
|
||||
#[cfg(test)]
|
||||
#[path = "sketch_continuity_tests.rs"]
|
||||
mod continuity_tests;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "sketch_trim_drag_ui_tests.rs"]
|
||||
mod trim_drag_ui_tests;
|
||||
|
||||
@@ -0,0 +1,151 @@
|
||||
//! Trim by dragging: with Trim on, a press and drag draws a path, the pieces it crosses light
|
||||
//! up, and letting go trims them all (`sketch.trim.path`) in one undo step. A click still trims
|
||||
//! the one piece under it.
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use solidcraft_engine::geom::Vec2;
|
||||
use solidcraft_engine::sketch::Shape;
|
||||
|
||||
use crate::scenario::Harness;
|
||||
|
||||
/// Two horizontal lines crossed by a vertical one, seen from the top, with Trim on. Returns the
|
||||
/// vertical line's id.
|
||||
fn ladder() -> (Harness, String) {
|
||||
let mut h = Harness::new();
|
||||
h.app.home.open = false;
|
||||
run(&mut h, "sketch.create", json!({"plane": "XY"}));
|
||||
run(&mut h, "sketch.line", json!({"points": [[0, 0], [20, 0]], "connect": false}));
|
||||
run(&mut h, "sketch.line", json!({"points": [[0, 10], [20, 10]], "connect": false}));
|
||||
let v = run(&mut h, "sketch.line", json!({"points": [[10, -5], [10, 15]], "connect": false}))["curves"][0].as_str().unwrap().to_string();
|
||||
h.call("ui.view", json!({"view": "top"}));
|
||||
h.app.cam.distance = 60.0;
|
||||
h.frames(3);
|
||||
h.call("ui.start", json!({"command": "sketch.trim"}));
|
||||
h.frames(2);
|
||||
(h, v)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dragging_across_pieces_trims_them_all_in_one_undo_step() {
|
||||
let (mut h, v) = ladder();
|
||||
let before = h.app.session.doc.to_json();
|
||||
let undo = h.app.session.undo.len();
|
||||
// A zigzag across the vertical line's middle piece, three times, then down across the
|
||||
// lower line's right half.
|
||||
let a = screen(&mut h, 5.0, 8.0);
|
||||
let b = screen(&mut h, 15.0, 7.0);
|
||||
let c = screen(&mut h, 5.0, 5.0);
|
||||
let d = screen(&mut h, 15.0, -3.0);
|
||||
let mut path = vec![a];
|
||||
path.extend(steps(a, b, 8));
|
||||
path.extend(steps(b, c, 8));
|
||||
path.extend(steps(c, d, 8));
|
||||
press_and_move(&mut h, &path);
|
||||
|
||||
// While dragging: nothing has changed yet, and the two pieces to go light up (the middle
|
||||
// piece once).
|
||||
assert!(h.app.viewport.trim_drag);
|
||||
assert_eq!(h.app.session.doc.to_json(), before, "a drag changes nothing before it is let go");
|
||||
assert_eq!(h.app.session.undo.len(), undo);
|
||||
let lit = super::TRIM_REMOVED.with(|r| r.borrow().clone());
|
||||
assert_eq!(lit.len(), 2, "{lit:?}");
|
||||
|
||||
release(&mut h, d);
|
||||
assert!(!h.app.viewport.trim_drag);
|
||||
assert!(super::TRIM_REMOVED.with(|r| r.borrow().is_empty()));
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
|
||||
// The vertical line keeps its ends; the lower line its left half.
|
||||
let sk = sketch(&h);
|
||||
let rest: Vec<Shape> = (0..sk.curves.len()).filter_map(|ci| sk.shape(ci)).collect();
|
||||
assert_eq!(rest.len(), 4, "{rest:?}");
|
||||
assert!(rest.iter().all(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3 && s.dist(Vec2::new(15.0, 0.0)) > 1e-3), "{rest:?}");
|
||||
let lower = sk.shape(sk.curve_index(&v).unwrap()).unwrap();
|
||||
assert!(matches!(lower, Shape::Line { a, b } if a.dist(Vec2::new(10.0, -5.0)) < 1e-6 && b.dist(Vec2::new(10.0, 0.0)) < 1e-6), "{lower:?}");
|
||||
// Trim stays on for the next piece.
|
||||
assert_eq!(h.app.tool.as_ref().map(|t| t.cmd), Some("sketch.trim"));
|
||||
|
||||
run(&mut h, "edit.undo", json!({}));
|
||||
assert_eq!(h.app.session.doc.to_json(), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_click_still_trims_one_piece_and_an_empty_drag_nothing() {
|
||||
let (mut h, v) = ladder();
|
||||
let undo = h.app.session.undo.len();
|
||||
// A drag that crosses nothing leaves the design alone.
|
||||
let a = screen(&mut h, 1.0, 3.0);
|
||||
let b = screen(&mut h, 8.0, 7.0);
|
||||
let mut path = vec![a];
|
||||
path.extend(steps(a, b, 6));
|
||||
press_and_move(&mut h, &path);
|
||||
release(&mut h, b);
|
||||
assert_eq!(h.app.session.undo.len(), undo);
|
||||
|
||||
// A click on the vertical line's middle piece trims just that piece.
|
||||
h.step(&json!({"click": {"sketch": [10, 5]}})).unwrap();
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1);
|
||||
let sk = sketch(&h);
|
||||
assert_eq!(sk.curves.len(), 4);
|
||||
assert!((0..sk.curves.len()).all(|ci| sk.shape(ci).is_some_and(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3)));
|
||||
assert!(sk.curve_index(&v).is_some());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_click_that_moves_along_a_piece_still_trims_it() {
|
||||
// A press that moves on the way (#2448) beside the vertical line's middle piece, crossing
|
||||
// nothing: the release is the click, and trims the piece under it.
|
||||
let (mut h, _) = ladder();
|
||||
let undo = h.app.session.undo.len();
|
||||
let a = screen(&mut h, 10.0, 3.0) + egui::vec2(3.0, 0.0);
|
||||
let b = screen(&mut h, 10.0, 7.0) + egui::vec2(3.0, 0.0);
|
||||
let mut path = vec![a];
|
||||
path.extend(steps(a, b, 6));
|
||||
press_and_move(&mut h, &path);
|
||||
release(&mut h, b);
|
||||
assert_eq!(h.app.session.undo.len(), undo + 1, "one trim");
|
||||
let sk = sketch(&h);
|
||||
assert_eq!(sk.curves.len(), 4);
|
||||
assert!((0..sk.curves.len()).all(|ci| sk.shape(ci).is_some_and(|s| s.dist(Vec2::new(10.0, 5.0)) > 1e-3)));
|
||||
}
|
||||
|
||||
fn run(h: &mut Harness, id: &str, p: Value) -> Value {
|
||||
match h.app.run(id, p.clone()) {
|
||||
Ok(v) => v,
|
||||
Err(e) => panic!("{id} {p}: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn sketch(h: &Harness) -> solidcraft_engine::sketch::Sketch {
|
||||
let sid = h.app.session.active_sketch.expect("sketch mode");
|
||||
h.app.session.world_state().sketch(sid).expect("the sketch").sketch.clone()
|
||||
}
|
||||
|
||||
fn screen(h: &mut Harness, x: f64, y: f64) -> egui::Pos2 {
|
||||
let [sx, sy] = h.at(&json!({"sketch": [x, y]})).expect("on screen");
|
||||
egui::pos2(sx as f32, sy as f32)
|
||||
}
|
||||
|
||||
fn steps(a: egui::Pos2, b: egui::Pos2, n: usize) -> Vec<egui::Pos2> {
|
||||
(1..=n).map(|i| a + (b - a) * (i as f32 / n as f32)).collect()
|
||||
}
|
||||
|
||||
/// Press at `path[0]` and move through the rest, one frame per event.
|
||||
fn press_and_move(h: &mut Harness, path: &[egui::Pos2]) {
|
||||
let Some(&a) = path.first() else { return };
|
||||
h.app.synthetic.push(egui::Event::PointerMoved(a));
|
||||
h.app.synthetic.push(egui::Event::PointerButton { pos: a, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
|
||||
h.app.synthetic.extend(path.iter().skip(1).map(|&p| egui::Event::PointerMoved(p)));
|
||||
play(h);
|
||||
}
|
||||
|
||||
fn release(h: &mut Harness, at: egui::Pos2) {
|
||||
h.app.synthetic.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
|
||||
play(h);
|
||||
}
|
||||
|
||||
fn play(h: &mut Harness) {
|
||||
while !h.app.synthetic.is_empty() {
|
||||
h.frame();
|
||||
}
|
||||
h.frames(2);
|
||||
}
|
||||
@@ -48,6 +48,8 @@ pub struct ViewportState {
|
||||
/// A tool's click moved on the way (#2448): egui takes a press that moves past its
|
||||
/// click distance, or is held past its click time, as a drag, so its release is the click.
|
||||
pub(crate) tool_click: bool,
|
||||
/// A Trim drag is drawing its path (`sketch_tools::trim_drag_*`).
|
||||
pub(crate) trim_drag: bool,
|
||||
/// Per-body boxes of one world state, held (not just its address, which a later state can
|
||||
/// reuse once the old one is freed, so stale boxes would come back).
|
||||
pick_bounds: std::sync::Mutex<Option<BodyBounds>>,
|
||||
@@ -2533,6 +2535,23 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
crate::tools::on_hover(app, &proj, p);
|
||||
}
|
||||
}
|
||||
// A Trim drag's path follows the pointer; letting go trims what it crossed. A path that
|
||||
// crossed nothing was a click that moved on the way (#2448): the release clicks.
|
||||
if app.viewport.trim_drag {
|
||||
let at = ui.input(|i| i.pointer.latest_pos()).filter(|p| rect.contains(*p));
|
||||
if resp.drag_stopped() || !ui.input(|i| i.pointer.primary_down()) {
|
||||
app.viewport.trim_drag = false;
|
||||
if !crate::sketch_tools::trim_drag_end(app)
|
||||
&& let Some(p) = at
|
||||
&& app.tool.is_some()
|
||||
{
|
||||
crate::tools::on_hover(app, &proj, p);
|
||||
crate::tools::on_click(app, &proj, p);
|
||||
}
|
||||
} else if let Some(p) = at {
|
||||
crate::sketch_tools::trim_drag_to(app, &proj, p);
|
||||
}
|
||||
}
|
||||
// Selection chords via resolve (add-only Shift is a preference; default both toggle).
|
||||
let held_mods = crate::tool_modifiers::Held::from_modifiers(mods);
|
||||
let (add, allow_toggle) = crate::tool_modifiers::selection_click(held_mods, app.preferences.selection_shift_add_only);
|
||||
@@ -2541,6 +2560,20 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
if app.tool.is_some() {
|
||||
crate::tools::on_hover(app, &proj, p);
|
||||
}
|
||||
// Trim also trims by press and drag across the pieces to remove (its own release handling,
|
||||
// so not a click that moved on the way below).
|
||||
if app.tool.as_ref().is_some_and(|t| t.cmd == "sketch.trim")
|
||||
&& !held
|
||||
&& primary_nav.is_none()
|
||||
&& mode.is_none()
|
||||
&& resp.drag_started_by(egui::PointerButton::Primary)
|
||||
&& let Some(a) = ui.input(|i| i.pointer.press_origin())
|
||||
{
|
||||
app.viewport.trim_drag = crate::sketch_tools::trim_drag_start(app, &proj, a);
|
||||
if app.viewport.trim_drag {
|
||||
crate::sketch_tools::trim_drag_to(app, &proj, p);
|
||||
}
|
||||
}
|
||||
// Rectangles, circles and polygons also draw by press, drag and release (#1630): the press
|
||||
// places the first point as a click there would, the release the second.
|
||||
let two_point_start = app.tool.as_ref().is_some_and(|t| matches!(t.kind, crate::tools::Kind::Draw(2)) && t.pts.is_empty());
|
||||
@@ -2553,7 +2586,13 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {
|
||||
{
|
||||
crate::tools::on_click(app, &proj, a);
|
||||
app.viewport.draw_drag = app.tool.as_ref().is_some_and(|t| t.pts.len() == 1).then_some(a);
|
||||
} else if app.tool.is_some() && !held && primary_nav.is_none() && mode.is_none() && resp.drag_started_by(egui::PointerButton::Primary) {
|
||||
} else if app.tool.is_some()
|
||||
&& !app.viewport.trim_drag
|
||||
&& !held
|
||||
&& primary_nav.is_none()
|
||||
&& mode.is_none()
|
||||
&& resp.drag_started_by(egui::PointerButton::Primary)
|
||||
{
|
||||
// Any other press of a tool that turns into a drag is a click that moved on the way
|
||||
// (#2448): its release clicks.
|
||||
app.viewport.tool_click = true;
|
||||
|
||||
@@ -30,7 +30,9 @@ Lines and polylines (L), rectangles (two-point R, three-point, centre), circles
|
||||
two-point, three-point, tangent), arcs (three-point, centre, tangent), polygons, slots, ellipses,
|
||||
fit-point and control-point splines, conics, points and text. **Construction** (X) turns curves
|
||||
into reference geometry that doesn't form profiles. Modify tools include trim (T), extend, break,
|
||||
fillet, chamfer, offset (O), mirror, patterns, move/copy and scale.
|
||||
fillet, chamfer, offset (O), mirror, patterns, move/copy and scale. With trim on, click a
|
||||
piece to remove it, or press and drag a path across several pieces: the ones it crosses light up
|
||||
and all go when you let go, in one undo step (`sketch.trim.path`).
|
||||
|
||||
The Sketch Palette's **Construction Geometries** option hides construction curves while you
|
||||
work. A hidden construction curve cannot be picked by a click or by a box. Nothing invisible
|
||||
|
||||
Reference in New Issue
Block a user