diff --git a/crates/doc/src/document.rs b/crates/doc/src/document.rs index e41ceaeb1..160cc4b16 100644 --- a/crates/doc/src/document.rs +++ b/crates/doc/src/document.rs @@ -4173,6 +4173,11 @@ impl Document { analysis: solidcraft_sketch::Analysis, ) -> Result { self.apply_dimension_values(vals, sk)?; + // A text built anew since it was stored (an expression gave it other words) has other + // outline entities: the stored sketch is taken with this sketch's, so the points still + // pair up for the side checks and the walk below. + let paired = moved_from.and_then(|from| sk.stored_with_rebuilt_texts(from)); + let moved_from = paired.as_ref().or(moved_from); let was = |sk: &Sketch| moved_from.and_then(|from| sk.positions_in(from)); let offsets = !sk.offsets.is_empty() || !sk.freeform_offsets.is_empty(); // Offsets always require another solve after refresh. Only that last report is diff --git a/crates/engine/src/cmd/sketch_project_side_tests.rs b/crates/engine/src/cmd/sketch_project_side_tests.rs index 9b43f1a21..83295250a 100644 --- a/crates/engine/src/cmd/sketch_project_side_tests.rs +++ b/crates/engine/src/cmd/sketch_project_side_tests.rs @@ -86,6 +86,77 @@ fn a_distance_from_a_projected_line_keeps_its_side_when_the_source_moves_past() assert_p(&s, 15.0, "after an edit"); } +/// A label's sketch: three points brought in from sketch `A` (a 20 long vertical line whose start +/// the parameters `x` and `y` place, and its middle), a construction rectangle 5 wide on them +/// (its near side on the line's ends, its far side 5 from the middle) and a centred text on the +/// far side whose words the text parameter `Label` gives. Other words are other outlines: the text +/// is built anew in the evaluated sketch, so its entities are not the stored sketch's. Moved 280 +/// away afterwards (more than one jump can take: the solve walks there from the stored sketch), the +/// rectangle follows and keeps its side. +#[test] +fn a_label_follows_its_source_far_after_a_text_parameter_gave_it_other_words() { + let mut s = Session::default(); + run(&mut s, "parameters.add", json!({"name": "x", "expression": "100 mm"})); + run(&mut s, "parameters.add", json!({"name": "y", "expression": "200 mm"})); + run(&mut s, "parameters.add", json!({"name": "Label", "expression": "A1", "unit": "text"})); + run(&mut s, "sketch.create", json!({"plane": "XY", "name": "A"})); + run(&mut s, "sketch.line", json!({"points": [[100, 200], [100, 180]], "ids": ["rail"]})); + run(&mut s, "sketch.constraint.horizontal_vertical", json!({"line": "rail", "mode": "vertical"})); + run(&mut s, "sketch.dimension", json!({"entities": ["origin", "rail.start"], "type": "horizontal", "value": "x"})); + run(&mut s, "sketch.dimension", json!({"entities": ["origin", "rail.start"], "type": "vertical", "value": "y"})); + run(&mut s, "sketch.dimension", json!({"entities": ["rail"], "value": "20 mm"})); + run(&mut s, "sketch.point", json!({"point": [100, 190], "id": "mid"})); + run(&mut s, "sketch.constraint.midpoint", json!({"point": "mid", "line": "rail"})); + run(&mut s, "sketch.finish", json!({})); + run(&mut s, "sketch.create", json!({"plane": "XY", "name": "S"})); + let refs = ["rail.start", "rail.end", "mid"].map(|p| json!({"sketch": "A", "point": p})); + let r = run(&mut s, "sketch.project", json!({"refs": refs})); + let brought: Vec = (0..3).map(|i| r["links"][i]["points"][0].as_str().unwrap().to_string()).collect(); + let near = 100.0 - 5.0; + for (id, a, b) in [ + ("l1", [100.0, 200.0], [100.0, 180.0]), + ("l2", [near, 200.0], [near, 180.0]), + ("l3", [100.0, 200.0], [near, 200.0]), + ("l4", [100.0, 180.0], [near, 180.0]), + ] { + run(&mut s, "sketch.line", json!({"points": [a, b], "ids": [id], "construction": true, "connect": false})); + } + for (a, b) in [ + ("l1.start", brought[0].as_str()), + ("l1.end", &brought[1]), + ("l3.start", "l1.start"), + ("l3.end", "l2.start"), + ("l4.start", "l1.end"), + ("l4.end", "l2.end"), + ] { + run(&mut s, "sketch.constraint.coincident", json!({"a": a, "b": b})); + } + run(&mut s, "sketch.constraint.parallel", json!({"a": "l2", "b": "l1"})); + run(&mut s, "sketch.dimension", json!({"entities": [brought[2], "l2"], "type": "distance", "value": "5 mm"})); + run(&mut s, "sketch.constraint.perpendicular", json!({"a": "l3", "b": "l1"})); + run(&mut s, "sketch.constraint.perpendicular", json!({"a": "l4", "b": "l1"})); + run(&mut s, "sketch.text", json!({"text_expression": "Label + '-1'", "at": [0, 0], "height": 3, "align": "center", "path": "l2"})); + run(&mut s, "sketch.finish", json!({})); + let far_side = |s: &Session| { + let st = s.model.state(); + let sk = &st.sketch(s.doc.find_feature("S").unwrap().id).unwrap().sketch; + sk.point(sk.resolve_point("l2.start").unwrap()).unwrap() + }; + #[track_caller] + fn quiet(s: &Session, when: &str) { + let feature = s.model.result(s.doc.find_feature("S").unwrap().id).unwrap(); + assert_eq!((&feature.error, &feature.warning), (&None, &None), "{when}"); + } + quiet(&s, "drawn"); + run(&mut s, "parameters.change", json!({"name": "Label", "expression": "B2"})); + quiet(&s, "relabelled"); + for (x, y) in [(300.0, 400.0), (100.0, 200.0)] { + run(&mut s, "parameters.change", json!({"changes": {"x": format!("{x} mm"), "y": format!("{y} mm")}})); + quiet(&s, &format!("moved to ({x}, {y})")); + assert!(far_side(&s).dist(Vec2::new(x - 5.0, y)) < 1e-6, "({x}, {y}): {:?}", far_side(&s)); + } +} + /// The same from the other side: the point above the line, the source rising past it and /// coming back; and with the line brought in by Include 3D Geometry. #[test] diff --git a/crates/sketch/src/link.rs b/crates/sketch/src/link.rs index 54bedf484..0c3cd518e 100644 --- a/crates/sketch/src/link.rs +++ b/crates/sketch/src/link.rs @@ -1128,6 +1128,59 @@ impl Sketch { self.points.iter().zip(&was).any(|(p, w)| p.pos != *w).then_some(was) } + /// `stored` as this sketch has its entities, when they differ only by texts built anew + /// since (other words, from an expression, are other outlines with new points and curves): + /// those texts' entities as this sketch has them, every other point where `stored` has it, + /// every other circle and ellipse with its stored radius, arcs with their stored turn and + /// constraints with their stored values. Paired so entity by entity, a solve after the links + /// moved can walk from the stored state as it does when no text changed. `None` when the + /// two are the same entities or differ in anything else. + pub fn stored_with_rebuilt_texts(&self, stored: &Sketch) -> Option { + let texts: Vec<&str> = self.links.iter().filter(|l| matches!(l.source, LinkSource::Text { .. })).map(|l| l.id.as_str()).collect(); + let in_text = |link: &Option| link.as_deref().is_some_and(|l| texts.contains(&l)); + let same = self.points.len() == stored.points.len() + && self.curves.len() == stored.curves.len() + && self.points.iter().zip(&stored.points).all(|(p, q)| p.id == q.id) + && self.curves.iter().zip(&stored.curves).all(|(c, d)| c.id == d.id); + let ids = |sk: &Sketch| sk.links.iter().map(|l| l.id.clone()).collect::>(); + if same + || texts.is_empty() + || ids(self) != ids(stored) + || !self.points.iter().filter(|p| !in_text(&p.link)).map(|p| &p.id).eq(stored.points.iter().filter(|p| !in_text(&p.link)).map(|p| &p.id)) + || !self.curves.iter().filter(|c| !in_text(&c.link)).map(|c| &c.id).eq(stored.curves.iter().filter(|c| !in_text(&c.link)).map(|c| &c.id)) + || !self.constraints.iter().map(|c| &c.id).eq(stored.constraints.iter().map(|c| &c.id)) + { + return None; + } + let mut out = self.clone(); + let points: std::collections::BTreeMap<&str, Vec2> = + stored.points.iter().filter(|p| !in_text(&p.link)).map(|p| (p.id.as_str(), p.pos)).collect(); + for p in out.points.iter_mut().filter(|p| !in_text(&p.link)) { + if let Some(pos) = points.get(p.id.as_str()) { + p.pos = *pos; + } + } + let curves: std::collections::BTreeMap<&str, &Curve> = + stored.curves.iter().filter(|c| !in_text(&c.link)).map(|c| (c.id.as_str(), c)).collect(); + for c in out.curves.iter_mut().filter(|c| !in_text(&c.link)) { + let Some(d) = curves.get(c.id.as_str()) else { continue }; + match (&mut c.kind, &d.kind) { + (CurveKind::Circle { r, .. }, CurveKind::Circle { r: s, .. }) | (CurveKind::Ellipse { r, .. }, CurveKind::Ellipse { r: s, .. }) => { + *r = *s + } + (CurveKind::Conic { rho, .. }, CurveKind::Conic { rho: s, .. }) => *rho = *s, + _ => {} + } + c.reversed = d.reversed; + } + for (c, d) in out.constraints.iter_mut().zip(&stored.constraints) { + if let Some(v) = d.kind.value() { + c.kind.set_value(v); + } + } + Some(out) + } + fn drop_link_entities(&mut self, id: &str) { let curves = self.link_curves(id); let keep = self.links.clone();