Equal with three or more curves selected makes them all equal (#4985) (#5139)

* claim: #4985

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Equal with three or more curves selected makes them all equal (#4985)

With more than two curves selected, Equal fell back to the pick tool and
applied nothing. sketch.constraint.equal also takes curves: [2..200],
each made equal to the first in one step (strict, so a conflict changes
nothing), and the toolbar sends a selection of three or more curves as
that list.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
DuBearte
2026-10-24 11:26:38 +00:00
committed by GitHub
parent c0da9fe861
commit 4612c5e6a9
4 changed files with 120 additions and 1 deletions
+36 -1
View File
@@ -141,7 +141,7 @@ pub static COMMANDS: &[CommandSpec] = &[
.at("SKETCH", "CONSTRAINTS")
.icon("c_equal")
.enabled(in_sketch)
.params("a, b: lines or circles/arcs"),
.params("a, b: lines or circles/arcs; or curves: [2 to 200 lines or circles/arcs], each made equal to the first, in one step"),
CommandSpec::new("sketch.constraint.parallel", "Parallel", c_parallel)
.at("SKETCH", "CONSTRAINTS")
.icon("c_parallel")
@@ -1925,8 +1925,43 @@ fn c_tangent(s: &mut Session, p: &Value) -> Result<Value> {
})
}
fn c_equal(s: &mut Session, p: &Value) -> Result<Value> {
if p.get("curves").is_some() {
return equal_curves(s, p);
}
constrain(s, p, "sketch.constraint.equal", |sk| two_curves(sk, p, "sketch.constraint.equal").map(|(a, b)| ConstraintKind::Equal { a, b }))
}
/// Equal over a list of curves (#4985): each one is made equal to the first, in one edit (one
/// undo step). A pair already made equal is not constrained twice. The solve moves as little as it
/// can, so a dimensioned curve keeps its size and the others take it, whatever the order.
fn equal_curves(s: &mut Session, p: &Value) -> Result<Value> {
let cmd = "sketch.constraint.equal";
let ids = string_list(p, "curves");
if !(2..=200).contains(&ids.len()) {
return Err(bad(cmd, "`curves` must list 2 to 200 lines or circles/arcs"));
}
let (out, info) = edit(s, p, cmd, true, |sk, _| {
let mut curves: Vec<usize> = Vec::with_capacity(ids.len());
for id in &ids {
let c = sk.curve_index(id).ok_or_else(|| bad(cmd, format!("unknown curve `{id}`")))?;
if curves.contains(&c) {
return Err(bad(cmd, format!("`{id}` is listed twice")));
}
curves.push(c);
}
let Some((&first, rest)) = curves.split_first() else { return Err(bad(cmd, "`curves` is empty")) };
let mut out = Vec::new();
for &c in rest {
let already =
sk.constraints.iter().any(|k| matches!(k.kind, ConstraintKind::Equal { a, b } if (a == first && b == c) || (a == c && b == first)));
if !already {
out.push(add_c(sk, ConstraintKind::Equal { a: first, b: c })?);
}
}
Ok(out)
})?;
Ok(json!({"constraints": out, "sketch": info}))
}
fn c_parallel(s: &mut Session, p: &Value) -> Result<Value> {
constrain(s, p, "sketch.constraint.parallel", |sk| {
two_curves_or_axes(sk, p, "sketch.constraint.parallel").map(|(a, b)| ConstraintKind::Parallel { a, b })
@@ -1058,3 +1058,52 @@ fn midpoint_pair_orientation_uses_the_text_box_and_respects_explicit_types() {
assert!((solidcraft_sketch::measure_dimension(&sk, &c.kind).unwrap() - expected).abs() < 1e-6);
}
}
/// Four circles, `c1` dimensioned to radius 5 (diameter 10).
fn four_circles() -> Session {
let mut s = new_sketch();
for (x, r) in [(0, 5), (20, 3), (40, 7), (60, 4)] {
run(&mut s, "sketch.circle.center", json!({"center": [x, 0], "radius": r}));
}
run(&mut s, "sketch.dimension", json!({"entities": ["c1"], "value": 10}));
s
}
fn radius_of(s: &Session, id: &str) -> f64 {
let sk = sketch(s);
sk.radius(sk.curve_index(id).unwrap()).unwrap()
}
#[test]
fn equal_over_a_list_of_curves_makes_them_all_equal_in_one_step() {
// #4985: whatever the order, the dimensioned circle keeps its size and the others take it.
for order in [["c1", "c2", "c3", "c4"], ["c4", "c3", "c2", "c1"]] {
let mut s = four_circles();
let r1 = radius_of(&s, "c1");
let undo = s.undo.len();
let out = run(&mut s, "sketch.constraint.equal", json!({"curves": order}));
assert_eq!(out["constraints"].as_array().unwrap().len(), 3, "{order:?}");
assert_eq!(s.undo.len(), undo + 1, "one undo step");
for id in ["c1", "c2", "c3", "c4"] {
assert!((radius_of(&s, id) - r1).abs() < 1e-6, "{order:?} {id}: {}", radius_of(&s, id));
}
// Applying it again adds nothing: those pairs are already equal.
let again = run(&mut s, "sketch.constraint.equal", json!({"curves": order}));
assert!(again["constraints"].as_array().unwrap().is_empty());
}
}
#[test]
fn equal_over_a_list_refuses_bad_lists_and_conflicts_without_changing_the_sketch() {
let mut s = four_circles();
let before = s.doc.to_json();
for bad in [json!({"curves": ["c1"]}), json!({"curves": ["c1", "c1"]}), json!({"curves": ["c1", "nope"]}), json!({"curves": vec!["c1"; 201]})] {
assert!(s.execute("sketch.constraint.equal", &bad).is_err(), "{bad}");
assert_eq!(s.doc.to_json(), before, "{bad}");
}
// Two circles dimensioned to different sizes can't be made equal: nothing changes.
run(&mut s, "sketch.dimension", json!({"entities": ["c2"], "value": 6}));
let before = s.doc.to_json();
assert!(s.execute("sketch.constraint.equal", &json!({"curves": ["c1", "c2", "c3"]})).is_err());
assert_eq!(s.doc.to_json(), before);
}
+2
View File
@@ -541,6 +541,8 @@ pub(crate) fn constraint_preselection(command: &str, selection: &[solidcraft_eng
match (command, selection) {
("sketch.constraint.fix", _) => selected_ids(false, 1).map(|ids| json!({"entities":ids})),
("sketch.constraint.polygon", _) => selected_ids(true, 3).map(|ids| json!({"lines":ids})),
// Three or more curves: all of them equal, in pick order (#4985). Two keep the `a, b` form.
("sketch.constraint.equal", _) if selection.len() >= 3 => selected_ids(true, 3).map(|ids| json!({"curves":ids})),
("sketch.constraint.curvature", [SketchCurve { id: a }, SketchCurve { id: b }]) if a != b => Some(json!({"a":a,"b":b})),
("sketch.constraint.horizontal_vertical", [SketchCurve { id }]) => Some(json!({"line":id})),
("sketch.constraint.horizontal_vertical", [SketchPoint { id: a }, SketchPoint { id: b }]) if a != b => Some(json!({"points":[a,b]})),
@@ -102,6 +102,39 @@ fn selected_circles_apply_constraints() {
}
}
/// #4985: Equal with three or more curves selected makes them all equal, in one undo step. With
/// one circle dimensioned, the others take its size.
#[test]
fn selected_circles_all_become_equal() {
let mut h = Harness::new();
h.run(&json!([
{"call":"engine.execute","params":{"command":"sketch.create","params":{"plane":"XY"}}},
{"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[0,0],"radius":5}}},
{"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[20,0],"radius":3}}},
{"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[40,0],"radius":7}}},
{"call":"engine.execute","params":{"command":"sketch.circle.center","params":{"center":[60,0],"radius":4}}},
{"call":"engine.execute","params":{"command":"sketch.dimension","params":{"entities":["c1"]}}}
]))
.unwrap();
let radius = |h: &Harness, id: &str| {
let sk = &h.app.session.model.state().sketches[0].sketch;
sk.radius(sk.curve_index(id).unwrap()).unwrap()
};
let r1 = radius(&h, "c1");
h.app.session.selection = ["c4", "c3", "c2", "c1"].iter().map(|id| Sel::SketchCurve { id: (*id).into() }).collect();
let undo = h.app.session.undo.len();
h.run(&json!([{"start":"sketch.constraint.equal"}])).unwrap();
assert!(!h.app.status.as_ref().is_some_and(|(_, _, error)| *error), "{:?}", h.app.status);
assert_eq!(h.app.session.undo.len(), undo + 1, "one undo step");
assert!(h.app.tool.is_none(), "applied at once, no pick tool");
assert!(h.app.session.selection.is_empty());
let sk = &h.app.session.model.state().sketches[0].sketch;
assert_eq!(sk.constraints.iter().filter(|c| matches!(c.kind, ConstraintKind::Equal { .. })).count(), 3);
for id in ["c1", "c2", "c3", "c4"] {
assert!((radius(&h, id) - r1).abs() < 1e-6, "{id}: {} vs the dimensioned {r1}", radius(&h, id));
}
}
#[test]
fn ambiguous_selection_preserves_tool_first_workflow() {
for selection in [