Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Insert Design: place reused links from their parent origin (#10813) (#10825)

Colin Faulkinghamb6aabb88ff91
diff --git a/crates/engine/src/cmd/component_link.rs b/crates/engine/src/cmd/component_link.rs
index ce7c781570..4523c6bf95 100644
--- a/crates/engine/src/cmd/component_link.rs
+++ b/crates/engine/src/cmd/component_link.rs
@@ -31,7 +31,8 @@ mod relink_tests;
pub static COMMANDS: &[CommandSpec] = &[
CommandSpec::new("component.insert_design", "Insert Design", insert_design).at("SOLID", "ASSEMBLE").icon("component").params(
"path: a .sc design → a new component linked to it, holding its solid bodies as placed in that design and a copy of its design properties; \
- name? (default: the design's name); parent?: component id or name (default: the active one); translate?: [x,y,z]; \
+ name? (default: the design's name); parent?: component id or name (default: the active one); \
+ translate?: [x,y,z] in mm from the destination parent's origin (default [0,0,0], also with reuse); \
reuse?: bool (default false): insert a free occurrence, reusing an existing link to the same file when available",
),
CommandSpec::new("component.update_links", "Update Links", update_links).icon("update").params(
@@ -506,8 +507,13 @@ fn insert_design(s: &mut Session, p: &Value) -> Result<Value> {
if p.get("reuse").and_then(Value::as_bool).unwrap_or(false) {
let existing = s.doc.links.iter().find(|(_, link)| absolute(&resolve(s.path.as_deref(), &link.path)) == file).map(|(id, _)| *id);
if let Some(component) = existing {
- let parent = p.get("parent").cloned().unwrap_or_else(|| json!(s.active_component));
- return super::component::copy_occurrence(s, &json!({"component": component, "parent": parent, "translate": translate}));
+ let parent = if p.get("parent").is_some() { component_key(s, p, "parent", cmd)? } else { s.active_component };
+ // Reuse the definition, not another placement's captured or pending move.
+ // Insert Design places from the parent origin whether the link is new or reused.
+ let mut transform = solidcraft_doc::IDENTITY;
+ transform[3] = [translate.x, translate.y, translate.z, 1.0];
+ let occurrence = s.doc_mut().add_occurrence(component, parent, transform)?;
+ return Ok(json!({"occurrence": occurrence, "component": component}));
}
}
let ((design_name, sf, faces, metadata, properties), read) = linked_bodies_read(&file, s.path.as_deref())?;
diff --git a/crates/engine/src/cmd/component_relink_tests.rs b/crates/engine/src/cmd/component_relink_tests.rs
index 4044b5b767..f214f20ab3 100644
--- a/crates/engine/src/cmd/component_relink_tests.rs
+++ b/crates/engine/src/cmd/component_relink_tests.rs
@@ -161,6 +161,90 @@ fn reused_design_insertion_is_free_even_before_a_link_exists() {
let _ = std::fs::remove_dir_all(dir);
}
+#[test]
+fn reused_design_insertion_uses_the_requested_position_and_survives_undo_and_reopen() {
+ let dir = folder("reuse-position");
+ let file = dir.join("part.sc");
+ part(&file, 30);
+ for first_reuses in [false, true] {
+ let mut s = Session::default();
+ let first = run(&mut s, "component.insert_design", json!({"path": file, "translate": [20, 0, 0], "reuse": first_reuses}));
+ let before = s.doc.to_json();
+ let undo = s.undo.len();
+ let second = run(&mut s, "component.insert_design", json!({"path": file, "translate": [40, 5, 7], "reuse": true}));
+ assert_eq!(first["component"], second["component"]);
+ assert_eq!(s.doc.links.len(), 1);
+ assert_eq!(s.doc.features.len(), 1);
+ assert_eq!(s.undo.len(), undo + 1);
+ let occurrence = second["occurrence"].as_u64().unwrap();
+ assert_linked_bounds(&mut s, occurrence, [40.0, 5.0, 7.0], [50.0, 25.0, 37.0]);
+ assert_linked_bounds(&mut s, first["occurrence"].as_u64().unwrap(), [20.0, 0.0, 0.0], [30.0, 20.0, 30.0]);
+ assert!(!s.doc.occurrences.iter().find(|o| o.id == occurrence).unwrap().grounded);
+ run(&mut s, "edit.undo", json!({}));
+ assert_eq!(s.doc.to_json(), before);
+ run(&mut s, "edit.redo", json!({}));
+ assert_linked_bounds(&mut s, occurrence, [40.0, 5.0, 7.0], [50.0, 25.0, 37.0]);
+ let assembly = dir.join("assembly.sc");
+ run(&mut s, "file.save", json!({"path": assembly}));
+ let mut cold = Session::default();
+ run(&mut cold, "doc.open", json!({"path": assembly}));
+ assert_linked_bounds(&mut cold, occurrence, [40.0, 5.0, 7.0], [50.0, 25.0, 37.0]);
+ let at_origin = run(&mut cold, "component.insert_design", json!({"path": file, "reuse": true}))["occurrence"].as_u64().unwrap();
+ assert_linked_bounds(&mut cold, at_origin, [0.0, 0.0, 0.0], [10.0, 20.0, 30.0]);
+ }
+ let _ = std::fs::remove_dir_all(dir);
+}
+
+fn assert_linked_bounds(s: &mut Session, occurrence: u64, min: [f64; 3], max: [f64; 3]) {
+ let p = run(s, "occurrence.properties", json!({"occurrence": occurrence}));
+ assert_eq!(p["body_count"], 1);
+ assert!((p["total"]["volume_mm3"].as_f64().unwrap() - 6000.0).abs() < 1e-6, "{p}");
+ for (key, expected) in [("min", min), ("max", max)] {
+ for (axis, expected) in expected.into_iter().enumerate() {
+ assert!((p["total"]["bbox"][key][axis].as_f64().unwrap() - expected).abs() < 1e-6, "{key}[{axis}] != {expected}: {p}");
+ }
+ }
+}
+
+#[test]
+fn reused_design_insertion_ignores_existing_moves_and_uses_the_destination_parent() {
+ let dir = folder("reuse-parent");
+ let file = dir.join("part.sc");
+ part(&file, 30);
+ for capture in [false, true] {
+ let mut s = Session::default();
+ let first = run(&mut s, "component.insert_design", json!({"path": file, "translate": [20, 0, 0]}));
+ run(
+ &mut s,
+ "occurrence.move",
+ json!({"occurrence": first["occurrence"], "translate": [0, 10, 0], "axis": [0, 0, 1], "angle": "90 deg", "capture": capture, "move_grounded": true}),
+ );
+ let original = s.doc.occurrences.clone();
+ let pending = s.pending_moves.clone();
+ let parent = run(&mut s, "component.create", json!({"name": "Parent", "activate": false}));
+ run(&mut s, "occurrence.move", json!({"occurrence": parent["occurrence"], "translate": [100, 0, 0], "axis": [0, 0, 1], "angle": "90 deg"}));
+ for explicit_parent in [true, false] {
+ let mut params = json!({"path": file, "translate": [40, 5, 7], "reuse": true});
+ if explicit_parent {
+ params["parent"] = json!("Parent");
+ } else {
+ run(&mut s, "component.activate", json!({"component": parent["component"]}));
+ }
+ let inserted = run(&mut s, "component.insert_design", params);
+ assert_eq!(inserted["component"], first["component"]);
+ assert_linked_bounds(&mut s, inserted["occurrence"].as_u64().unwrap(), [75.0, 40.0, 7.0], [95.0, 50.0, 37.0]);
+ assert_eq!(s.doc.occurrences.first(), original.first());
+ assert_eq!(s.pending_moves, pending);
+ }
+ let before = s.doc.to_json();
+ for parent in [json!("missing"), first["component"].clone()] {
+ assert!(s.execute("component.insert_design", &json!({"path": file, "parent": parent, "reuse": true})).is_err());
+ assert_eq!(s.doc.to_json(), before);
+ }
+ }
+ let _ = std::fs::remove_dir_all(dir);
+}
+
#[test]
fn linked_design_properties_update_density_without_geometry_and_keep_edited_cards() {
let dir = folder("properties-density");
diff --git a/docs/book/src/guide/assemblies.md b/docs/book/src/guide/assemblies.md
index ad046e7d5a..512d56bd68 100644
--- a/docs/book/src/guide/assemblies.md
+++ b/docs/book/src/guide/assemblies.md
@@ -394,6 +394,11 @@ off. A STEP or mesh file picked there is inserted as **Insert STEP** or **Insert
Mesh** would. The part's solid bodies come
in as they sit in that design, and they are kept in the assembly, so it opens even without the
part file. The link is stored relative to the assembly's folder once the assembly is saved.
+For scripts, `translate: [x,y,z]` places the design's origin in millimetres from the destination
+parent's origin (the active component unless `parent` is supplied). It defaults to `[0,0,0]`.
+With `reuse: true`, insertion reuses the existing linked component but uses the same coordinates;
+it does not inherit another occurrence's position or rotation. For example, inserts at
+`[20,0,0]` and `[40,0,0]` place the two origins at 20 and 40 mm, even when the second reuses the link.
After the part file changes, **Update Links** (`component.update_links`) reads it again.
An assembly that opens, or whose tab comes back to the front, does that by itself for the parts whose files
changed since it last read them, whether the part was saved in another tab, another window or by