SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
feat(align): add Components mode to Align for occurrence placement (#7224)
Charlie5a0abb871068
diff --git a/assets/locales/pending/align-components.json b/assets/locales/pending/align-components.jsonnew file mode 100644index 0000000000..34b8aba5e7--- /dev/null+++ b/assets/locales/pending/align-components.json@@ -0,0 +1,32 @@+{+ "ar": {+ "cmd.occurrence_align": "محاذاة النسخة",+ "select components first": "حدد المكوّنات أولًا",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "هذا المكوّن داخل تجميع فرعي موضوع أكثر من مرة: محاذاته تحرّكه في كل موضع."+ },+ "en": {+ "cmd.occurrence_align": "Align Occurrence",+ "select components first": "select components first",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "This component is inside a subassembly placed more than once: aligning it moves it in every placement."+ },+ "he": {+ "cmd.occurrence_align": "יישור מופע",+ "select components first": "יש לבחור רכיבים תחילה",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "רכיב זה נמצא בתוך תת-הרכבה שהוצבה יותר מפעם אחת: יישורו יזיז אותו בכל הצבה."+ },+ "ja": {+ "cmd.occurrence_align": "オカレンスを整列",+ "select components first": "コンポーネントを先に選択してください",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "このコンポーネントは複数配置されたサブアセンブリ内にあります。整列すると、すべての配置で移動します。"+ },+ "vi": {+ "cmd.occurrence_align": "Căn chỉnh bản thể",+ "select components first": "hãy chọn các thành phần trước",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "Thành phần này nằm trong một cụm lắp phụ được đặt nhiều lần: căn chỉnh nó sẽ làm nó di chuyển ở mọi vị trí đặt."+ },+ "zh": {+ "cmd.occurrence_align": "对齐实例",+ "select components first": "请先选择组件",+ "This component is inside a subassembly placed more than once: aligning it moves it in every placement.": "此组件位于多次放置的子装配体中:对齐它会使其在每个放置位置中都移动。"+ }+}diff --git a/crates/engine/src/cmd/component.rs b/crates/engine/src/cmd/component.rsindex 04145baa81..ce2b3f31fb 100644--- a/crates/engine/src/cmd/component.rs+++ b/crates/engine/src/cmd/component.rs@@ -11,13 +11,17 @@ use solidcraft_geom::Vec3;use super::CommandSpec;use crate::params::{bad, bool_, str_, string_list, vec3};-use crate::schema::component::{EditInPlaceParams, EditInPlaceResult, FinishEditParams, FinishEditResult};+use crate::schema::component::{+ EditInPlaceParams, EditInPlaceResult, FinishEditParams, FinishEditResult, OccurrenceAlignParams, OccurrenceAlignResult,+};use crate::schema::{TypedContract, output_schema_for};use crate::{Result, Session};const EDIT_IN_PLACE_CONTRACT: TypedContract<EditInPlaceParams> = TypedContract::new();const FINISH_EDIT_CONTRACT: TypedContract<FinishEditParams> = TypedContract::new();+#[path = "component_align.rs"]+mod align;#[path = "component_drag.rs"]mod drag;#[path = "component_matrix.rs"]@@ -110,6 +114,16 @@ pub static COMMANDS: &[CommandSpec] = &[point - at (with any chain of joints it is in that is joined to nothing grounded) and captures its position; other pending \moves stay pending. Shared definitions move in all placements. Grounded parts and parts joints hold to something fixed are refused (joint.reach moves those)",),+ CommandSpec::new("occurrence.align", "Align Occurrence", crate::checked!("occurrence.align", align::align))+ .icon("align")+ .contract(&ALIGN_CONTRACT)+ .output(output_schema_for::<OccurrenceAlignResult>)+ .params(+ "occurrence?, occurrences?, path?, paths?: placements to move together; from | from_face | from_plane; to | to_face | to_plane; \+ flip?: bool; capture?: bool (default true); move_grounded?: bool (default false). Moves only the chosen occurrence placements in \+ world coordinates without changing shared component geometry; a placement inside a component placed more than once moves in \+ every placement of it, and the reply's `shared` lists those paths",+ ),CommandSpec::new("occurrence.ground", "Ground", ground).icon("ground").params("occurrence; grounded?: bool (default toggles)"),CommandSpec::new("occurrence.reparent", "Move to Component", reparent::reparent).icon("move").params("occurrence; path?: exact placement; parent: component id or name (0 or \"root\" for the design); parent_path?: the parent's \@@ -120,6 +134,8 @@ pub static COMMANDS: &[CommandSpec] = &[CommandSpec::new("component.revert_position", "Revert Position", revert).at("SOLID", "POSITION").icon("revert").noundo().params("occurrences?: [ids] (default all); drops selected pending occurrence moves"),];+const ALIGN_CONTRACT: TypedContract<OccurrenceAlignParams> = TypedContract::new();+fn key(v: Option<&Value>) -> Option<String> {match v {Some(Value::Number(n)) => Some(n.to_string()),diff --git a/crates/engine/src/cmd/component_align.rs b/crates/engine/src/cmd/component_align.rsnew file mode 100644index 0000000000..b8371b6db6--- /dev/null+++ b/crates/engine/src/cmd/component_align.rs@@ -0,0 +1,244 @@+//! Aligning component occurrences (`occurrence.align`): moves only the chosen occurrence+//! placements in world coordinates using the same `from` / `to` / `flip` rules as `solid.align`,+//! without modifying shared component geometry across other instances.++use serde_json::{Value, json};+use solidcraft_doc::{IDENTITY, mat_inverse, mat_mul, rigid};+use solidcraft_geom::Vec3;++use super::{occurrence, occurrence_path, valid_position};+use crate::params::{bad, vec3};+use crate::{Result, Session};++const MAX_ALIGNED: usize = 64;++fn opt_bool(p: &Value, key: &str, default: bool, cmd: &str) -> Result<bool> {+ match p.get(key) {+ None => Ok(default),+ Some(Value::Bool(b)) => Ok(*b),+ _ => Err(bad(cmd, format!("`{key}` must be a boolean"))),+ }+}++fn parse_path(v: &Value, key: &str, cmd: &str) -> Result<Vec<u64>> {+ v.as_array()+ .filter(|a| !a.is_empty() && a.len() <= 64)+ .and_then(|a| a.iter().map(Value::as_u64).collect::<Option<Vec<_>>>())+ .ok_or_else(|| bad(cmd, format!("`{key}` must list 1..64 occurrence ids")))+}++fn resolve_paths(s: &Session, p: &Value, cmd: &str) -> Result<Vec<Vec<u64>>> {+ let raw: Vec<Vec<u64>> = if let Some(v) = p.get("paths") {+ if ["occurrences", "occurrence", "path"].into_iter().any(|k| p.get(k).is_some()) {+ return Err(bad(cmd, "give `paths`, `occurrences`, or `occurrence`/`path`, not more than one"));+ }+ let items = v+ .as_array()+ .filter(|a| !a.is_empty() && a.len() <= MAX_ALIGNED)+ .ok_or_else(|| bad(cmd, format!("`paths` must list 1..{MAX_ALIGNED} occurrence paths")))?;+ let mut out = Vec::with_capacity(items.len());+ for item in items {+ let path = parse_path(item, "paths", cmd)?;+ s.occurrence_placement(&path).map_err(|e| bad(cmd, e.to_string()))?;+ out.push(path);+ }+ out+ } else if let Some(v) = p.get("occurrences") {+ if p.get("occurrence").is_some() || p.get("path").is_some() {+ return Err(bad(cmd, "give `occurrences` or `occurrence`/`path`, not both"));+ }+ let items: Vec<&Value> = match v {+ Value::Number(_) | Value::String(_) => vec![v],+ Value::Array(a) if !a.is_empty() && a.len() <= MAX_ALIGNED => a.iter().collect(),+ _ => return Err(bad(cmd, format!("`occurrences` must be an occurrence id/name or a list of 1..{MAX_ALIGNED} ids/names"))),+ };+ let mut out = Vec::with_capacity(items.len());+ for item in items {+ let q = json!({ "occurrence": item });+ let id = occurrence(s, &q, cmd)?;+ out.push(occurrence_path(s, &json!({}), id, cmd)?);+ }+ out+ } else if p.get("occurrence").is_some() {+ let id = occurrence(s, p, cmd)?;+ vec![occurrence_path(s, p, id, cmd)?]+ } else if let Some(v) = p.get("path") {+ let path = parse_path(v, "path", cmd)?;+ s.occurrence_placement(&path).map_err(|e| bad(cmd, e.to_string()))?;+ vec![path]+ } else {+ return Err(bad(cmd, "give `occurrence`, `occurrences`, `path` or `paths`"));+ };++ let mut deduped: Vec<Vec<u64>> = Vec::with_capacity(raw.len());+ for path in raw {+ if !deduped.contains(&path) {+ deduped.push(path);+ }+ }++ // If both an ancestor placement and a placement under it were selected, moving the ancestor+ // already carries the descendant along; skip the descendant so it moves once. Only a path+ // prefix means "under it": another placement of the same component does not carry it.+ let all = deduped.clone();+ deduped.retain(|cand| !all.iter().any(|other| other.len() < cand.len() && cand.starts_with(other)));++ // Two distinct paths ending in the same nested occurrence id share one definition transform.+ for (i, a) in deduped.iter().enumerate() {+ if deduped[..i].iter().any(|b| b.last() == a.last()) {+ return Err(bad(cmd, "cannot align two placements of the same shared child occurrence at once; align their parent occurrences instead"));+ }+ }+ Ok(deduped)+}++fn world_pick(+ s: &Session,+ p: &Value,+ pk: &str,+ fk: &str,+ plane: &Option<solidcraft_doc::PlaneRef>,+ vals: &std::collections::BTreeMap<String, solidcraft_doc::expr::Value>,+ cmd: &str,+) -> Result<(Vec3, Option<Vec3>)> {+ if let Some(pl_ref) = plane {+ if p.get(pk).is_some() || p.get(fk).is_some() {+ return Err(bad(cmd, format!("give `{pk}_plane` or `{pk}`/`{fk}`, not both")));+ }+ let world = s.world_state();+ let pl = s.placed_document().resolve_plane_in(vals, pl_ref, 0, Some(&*world)).map_err(|e| bad(cmd, e.to_string()))?;+ return Ok((pl.origin, Some(pl.normal())));+ }+ if let Some(fv) = p.get(fk) {+ if p.get(pk).is_some() {+ return Err(bad(cmd, format!("give `{pk}` or `{fk}`, not both")));+ }+ let fp = vec3(fv).ok_or_else(|| bad(cmd, format!("`{fk}` must be [x, y, z]")))?;+ let n = super::super::face::face_normal_world(s, fp).ok_or_else(|| bad(cmd, format!("`{fk}` must be on a planar face")))?;+ return Ok((fp, Some(n)));+ }+ if p.get(pk).and_then(Value::as_str).is_some_and(|o| o.eq_ignore_ascii_case("origin")) {+ return Ok((Vec3::ZERO, None));+ }+ if let Some(o) = p.get(pk).and_then(Value::as_object)+ && (o.contains_key("at") || o.contains_key("snap"))+ {+ let at = o.get("at").and_then(vec3).ok_or_else(|| bad(cmd, format!("`{pk}.at` must be [x, y, z]")))?;+ let kind = match o.get("snap") {+ None => "vertex",+ Some(Value::String(k)) if matches!(k.as_str(), "vertex" | "edge_mid" | "face_center" | "circle_center") => k.as_str(),+ _ => return Err(bad(cmd, format!("`{pk}.snap` must be vertex, edge_mid, face_center or circle_center"))),+ };+ return super::super::features_more::snap_point(s, kind, at)+ .map(|q| (q, None))+ .ok_or_else(|| bad(cmd, format!("no {kind} to snap to near `{pk}`")));+ }+ p.get(pk)+ .and_then(vec3)+ .map(|v| (v, None))+ .ok_or_else(|| bad(cmd, format!("give `{pk}`, `{fk}` or `{pk}_plane` ([x, y, z], \"origin\", or a plane)")))+}++pub(super) fn align(s: &mut Session, p: &Value) -> Result<Value> {+ let cmd = "occurrence.align";+ let paths = resolve_paths(s, p, cmd)?;+ let flip = opt_bool(p, "flip", false, cmd)?;+ let capture = opt_bool(p, "capture", true, cmd)?;+ let move_grounded = opt_bool(p, "move_grounded", false, cmd)?;++ for path in &paths {+ let Some(&id) = path.last() else {+ return Err(bad(cmd, "occurrence path is empty"));+ };+ let o = s.doc.occurrences.iter().find(|o| o.id == id).ok_or_else(|| bad(cmd, "no occurrence"))?;+ if o.grounded && !move_grounded {+ return Err(bad(+ cmd,+ format!("{} is grounded: unground it first (occurrence.ground; a design's first part is grounded when it is made)", o.name),+ ));+ }+ if let Some(mut group) = s.held_by_rigid_group(id) {+ for _ in 0..64 {+ match s.doc.occurrence_of(group).and_then(|occ| s.held_by_rigid_group(occ.id)) {+ Some(up) => group = up,+ None => break,+ }+ }+ let name = s.doc.components.iter().find(|c| c.id == group).map(|c| c.name.clone()).unwrap_or_default();+ return Err(bad(cmd, format!("{} is held in {name} by a rigid group: move {name}, or Unlock Contents (component.unlock) first", o.name)));+ }+ }++ let plane = |key: &str| -> Result<Option<solidcraft_doc::PlaneRef>> {+ p.get(key).map(|v| super::super::features::plane_param(s, Some(v), cmd)).transpose()+ };+ let (from_plane, to_plane) = (plane("from_plane")?, plane("to_plane")?);+ let (vals, _) = s.doc.param_values();+ let (from, from_normal) = world_pick(s, p, "from", "from_face", &from_plane, &vals, cmd)?;+ let (to, to_normal) = world_pick(s, p, "to", "to_face", &to_plane, &vals, cmd)?;++ let (mut axis, mut ang) = (Vec3::Z, 0.0);+ if let (Some(a), Some(b)) = (from_normal.and_then(Vec3::normalized), to_normal.and_then(Vec3::normalized)) {+ let want = if flip { b } else { b * -1.0 };+ let cross = a.cross(want);+ let theta = cross.len().atan2(a.dot(want));+ if theta.abs() > 1e-12 {+ axis = cross.normalized().unwrap_or_else(|| a.any_perp());+ ang = theta;+ }+ }+ let d = match (&to_plane, to_normal.and_then(Vec3::normalized)) {+ (Some(_), Some(n)) => n * (to - from).dot(n),+ _ => to - from,+ };+ if !(d.is_finite() && from.is_finite() && axis.is_finite() && ang.is_finite()) {+ return Err(bad(cmd, "non-finite alignment transform"));+ }+ let world_move = rigid(d, from, axis, ang);++ // Compute every new local placement from the current placements before mutating anything.+ let mut updates = Vec::with_capacity(paths.len());+ for path in &paths {+ let placement = s.occurrence_placement(path).map_err(|e| bad(cmd, e.to_string()))?;+ let inverse = mat_inverse(&placement.parent_world).ok_or_else(|| bad(cmd, "parent frame is singular"))?;+ let local_delta = mat_mul(&mat_mul(&inverse, &world_move), &placement.parent_world);+ let next = mat_mul(&local_delta, &placement.local);+ if !valid_position(&next) {+ return Err(bad(cmd, "alignment transform exceeds supported numeric range"));+ }+ updates.push((placement.occurrence, next));+ }++ let moved: Vec<u64> = updates.iter().map(|(id, _)| *id).collect();+ // Placements inside a component placed more than once move in every placement of it: the+ // command still runs (as occurrence.move does), and says so for the dialog's warning.+ let shared: Vec<&Vec<u64>> = paths.iter().filter(|path| s.occurrence_shared(path)).collect();+ if capture {+ if world_move != IDENTITY || updates.iter().any(|(id, _)| s.pending_moves.contains_key(id)) {+ for (id, next) in updates {+ s.pending_moves.remove(&id);+ if let Some(x) = s.doc_mut().occurrences.iter_mut().find(|x| x.id == id) {+ x.transform = next;+ }+ }+ }+ } else {+ for (id, next) in updates {+ s.pending_moves.insert(id, next);+ }+ s.revision += 1;+ }++ let mut reply = json!({+ "occurrences": moved,+ "paths": paths,+ "world_transform": world_move,+ "pending": !capture,+ });+ if !shared.is_empty()+ && let Some(o) = reply.as_object_mut()+ {+ o.insert("shared".into(), json!(shared));+ }+ Ok(reply)+}diff --git a/crates/engine/src/cmd/features_more.rs b/crates/engine/src/cmd/features_more.rsindex 6b5f1404b5..77b80fe35e 100644--- a/crates/engine/src/cmd/features_more.rs+++ b/crates/engine/src/cmd/features_more.rs@@ -506,7 +506,7 @@ mod tests;/// A snap point near `at` on the model: the nearest vertex, edge midpoint, planar face's centre/// or circular edge's centre (the end of a cylindrical face).-pub(super) fn snap_point(s: &Session, kind: &str, at: Vec3) -> Option<Vec3> {+pub(crate) fn snap_point(s: &Session, kind: &str, at: Vec3) -> Option<Vec3> {let st = s.world_state();let near = |pts: Vec<Vec3>| pts.into_iter().min_by(|a, b| a.dist(at).total_cmp(&b.dist(at)));match kind {diff --git a/crates/engine/src/cmd/occurrence_tests.rs b/crates/engine/src/cmd/occurrence_tests.rsindex 702d8c9b5f..42503da4c9 100644--- a/crates/engine/src/cmd/occurrence_tests.rs+++ b/crates/engine/src/cmd/occurrence_tests.rs@@ -1507,3 +1507,134 @@ fn a_pattern_of_another_components_body_follows_its_own_component_when_moved() {fresh.evaluate(&s.doc);assert_eq!(boxes(&s.model.state()), boxes(&fresh.state()), "the kept model against a fresh evaluation");}++#[test]+fn occurrence_align_moves_only_selected_instance_including_90_degree_face_mate() {+ let mut s = Session::default();+ let c = run(&mut s, "component.create", json!({"name": "Extrusion"}));+ let (comp, first) = (c["component"].as_u64().unwrap(), c["occurrence"].as_u64().unwrap());+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 60, "body_name": "Beam"}));+ run(&mut s, "component.activate", json!({"component": "root"}));+ let second = run(&mut s, "occurrence.copy", json!({"component": comp, "translate": [40, 0, 0]}))["occurrence"].as_u64().unwrap();++ // Activate the second instance (the user's exact workflow) and align its bottom face (-Z at+ // [45, 5, 0]) onto the first instance's +X side face ([10, 5, 30]): instance 2 turns 90 deg+ // to extend along +X, while instance 1 remains untouched.+ run(&mut s, "component.activate", json!({"component": comp, "occurrence": second, "path": [second]}));+ let features_before = s.doc.features.len();+ run(+ &mut s,+ "occurrence.align",+ json!({+ "occurrence": second,+ "path": [second],+ "from_face": [45, 5, 0],+ "to_face": [10, 5, 30]+ }),+ );+ assert_eq!(s.doc.features.len(), features_before, "aligning an occurrence must not add a body feature to the shared component");++ let st = s.world_state();+ let b1 = st.body("Beam").unwrap().mesh().bounds();+ assert!((b1.min.x - 0.0).abs() < 1e-5 && (b1.max.x - 10.0).abs() < 1e-5, "{b1:?}");+ assert!((b1.min.y - 0.0).abs() < 1e-5 && (b1.max.y - 10.0).abs() < 1e-5, "{b1:?}");+ assert!((b1.min.z - 0.0).abs() < 1e-5 && (b1.max.z - 60.0).abs() < 1e-5, "{b1:?}");++ let b2 = st.body("Beam (Extrusion:2)").unwrap().mesh().bounds();+ assert!((b2.min.x - 10.0).abs() < 1e-5 && (b2.max.x - 70.0).abs() < 1e-5, "{b2:?}");+ assert!((b2.min.y - 0.0).abs() < 1e-5 && (b2.max.y - 10.0).abs() < 1e-5, "{b2:?}");+ assert!((b2.min.z - 25.0).abs() < 1e-5 && (b2.max.z - 35.0).abs() < 1e-5, "{b2:?}");++ // Grounded first part refuses without move_grounded, leaving both placements untouched.+ let doc_before = s.doc.clone();+ let err = s.execute("occurrence.align", &json!({"occurrence": first, "from": [0, 0, 0], "to": [5, 0, 0]})).unwrap_err().to_string();+ assert!(err.contains("grounded"), "{err}");+ assert_eq!(s.doc, doc_before);+}++#[test]+fn occurrence_align_supports_snaps_planes_flip_nested_paths_and_pending_capture() {+ let mut s = Session::default();+ let (_, parent) = created(&mut s, "Frame");+ run(&mut s, "occurrence.move", json!({"occurrence": parent, "axis": [0, 0, 1], "angle": "90 deg"}));+ let (_, child) = created(&mut s, "Bracket");+ run(&mut s, "solid.box", json!({"length": 10, "width": 20, "height": 4, "corner": [5, 5, 10], "body_name": "Plate"}));+ run(&mut s, "component.activate", json!({"component": "root"}));++ // Align the child under a 90-deg rotated parent onto XY plane along plane normal only (capture: false).+ let before = s.world_state().body("Plate").unwrap().mesh().bounds();+ run(+ &mut s,+ "occurrence.align",+ json!({+ "paths": [[parent, child]],+ "from_face": [before.center().x, before.center().y, 10.0],+ "to_plane": "XY",+ "capture": false+ }),+ );+ let moved = s.world_state().body("Plate").unwrap().mesh().bounds();+ assert!((moved.min.z - 0.0).abs() < 1e-5 && (moved.max.z - 4.0).abs() < 1e-5, "{moved:?}");+ assert!((moved.center().x - before.center().x).abs() < 1e-5 && (moved.center().y - before.center().y).abs() < 1e-5, "{moved:?}");++ // Revert drops the pending alignment; re-align with capture: true and vertex snap to origin.+ run(&mut s, "component.revert_position", json!({}));+ assert!((s.world_state().body("Plate").unwrap().mesh().bounds().min.z - 10.0).abs() < 1e-5);++ run(+ &mut s,+ "occurrence.align",+ json!({+ "occurrence": child,+ "path": [parent, child],+ "from": {"snap": "vertex", "at": [before.min.x, before.min.y, before.min.z]},+ "to": "origin"+ }),+ );+ let at_origin = s.world_state().body("Plate").unwrap().mesh().bounds();+ assert!(at_origin.min.dist(solidcraft_geom::Vec3::ZERO) < 1e-5, "{at_origin:?}");++ // Hostile / invalid parameters never panic.+ for bad_params in [+ json!({}),+ json!({"occurrence": 999999, "from": [0, 0, 0], "to": [1, 0, 0]}),+ json!({"paths": [], "from": [0, 0, 0], "to": [1, 0, 0]}),+ json!({"occurrence": child, "path": [parent, child], "from": [1e12, 0, 0], "to": [0, 0, 0]}),+ json!({"occurrence": child, "path": [parent, child], "from": {"snap": "bogus", "at": [0, 0, 0]}, "to": [0, 0, 0]}),+ json!({"occurrence": child, "path": [parent, child], "from_plane": "XY", "from": [0, 0, 0], "to": [0, 0, 1]}),+ ] {+ assert!(s.execute("occurrence.align", &bad_params).is_err(), "{bad_params}");+ }+}++#[test]+fn occurrence_align_keeps_every_pick_and_reports_shared_definitions() {+ // Frame holds Bracket and is placed twice (A and B). Aligning [A, Bracket] together with B+ // must move both picks: B is another placement of Frame, not an ancestor of [A, Bracket].+ let mut s = Session::default();+ let (frame, a) = created(&mut s, "Frame");+ let (_, bracket) = created(&mut s, "Bracket");+ run(&mut s, "solid.box", json!({"length": 10, "width": 10, "height": 4, "body_name": "Plate"}));+ run(&mut s, "component.activate", json!({"component": "root"}));+ let b = run(&mut s, "occurrence.copy", json!({"component": frame, "translate": [0, 50, 0]}))["occurrence"].as_u64().unwrap();+ let origin = |s: &Session, path: &[u64]| solidcraft_doc::apply_point(&s.occurrence_placement(path).unwrap().world, solidcraft_geom::Vec3::ZERO);+ let (a0, ab0, b0, bb0) = (origin(&s, &[a]), origin(&s, &[a, bracket]), origin(&s, &[b]), origin(&s, &[b, bracket]));++ assert!(!s.occurrence_shared(&[a]) && !s.occurrence_shared(&[b]), "top-level placements are their own");+ assert!(s.occurrence_shared(&[a, bracket]) && s.occurrence_shared(&[b, bracket]), "Bracket's placement lives in Frame, placed twice");++ let r = run(&mut s, "occurrence.align", json!({"paths": [[a, bracket], [b]], "from": [0, 0, 0], "to": [5, 0, 0]}));+ assert_eq!(r["paths"], json!([[a, bracket], [b]]), "{r}");+ assert_eq!(r["shared"], json!([[a, bracket]]), "{r}");++ let shift = solidcraft_geom::Vec3::new(5.0, 0.0, 0.0);+ assert!(origin(&s, &[a]).dist(a0) < 1e-9, "A itself stays");+ assert!(origin(&s, &[a, bracket]).dist(ab0 + shift) < 1e-9, "the picked Bracket moves");+ assert!(origin(&s, &[b]).dist(b0 + shift) < 1e-9, "B moves");+ // B's Bracket moves with B and, sharing Frame's definition, with the other pick too.+ assert!(origin(&s, &[b, bracket]).dist(bb0 + shift + shift) < 1e-9);++ // A top-level-only alignment reports nothing shared.+ let r = run(&mut s, "occurrence.align", json!({"paths": [[b]], "from": [0, 0, 0], "to": [1, 0, 0]}));+ assert!(r.get("shared").is_none(), "{r}");+}diff --git a/crates/engine/src/occurrences.rs b/crates/engine/src/occurrences.rsindex 987a2c0e8d..ec6a34d1b1 100644--- a/crates/engine/src/occurrences.rs+++ b/crates/engine/src/occurrences.rs@@ -326,6 +326,20 @@ impl Session {})}+ /// Is the leaf of `path` placed inside a component that has more than one placement? Its+ /// transform lives in that shared definition, so moving it moves it in every placement.+ /// Top-level placements and unknown ids are never shared.+ pub fn occurrence_shared(&self, path: &[u64]) -> bool {+ let Some((_, ancestors)) = path.split_last() else { return false };+ ancestors.iter().take(64).any(|id| {+ self.doc+ .occurrences+ .iter()+ .find(|o| o.id == *id)+ .is_some_and(|a| self.doc.occurrences.iter().filter(|o| o.component == a.component).nth(1).is_some())+ })+ }+/// Children are definitions shared by every placement of the parent component.pub fn occurrence_children(&self, path: &[u64]) -> Result<Vec<OccurrencePlacement>> {let component = if path.is_empty() { 0 } else { self.occurrence_placement(path)?.component };diff --git a/crates/engine/src/schema/component.rs b/crates/engine/src/schema/component.rsindex 8129a0fac7..ef918bb65e 100644--- a/crates/engine/src/schema/component.rs+++ b/crates/engine/src/schema/component.rs@@ -1,9 +1,14 @@//! Contracts and result types for the commands in `cmd/component.rs`.-use schemars::JsonSchema;-use serde::{Deserialize, Serialize};+use std::borrow::Cow;-use super::types::{IdOrName, present};+use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};+use serde::de::Error as _;+use serde::{Deserialize, Deserializer, Serialize};+use serde_json::{Value, json};++use super::types::{IdOrName, Point3, PointExpr3, not_blank_pattern, present};+use crate::params;/// Edit a linked component's design in place. In the app window: open the design it links in a/// tab of its own, with the rest of the assembly drawn faded around it as the placement `path`@@ -60,6 +65,290 @@ pub struct FinishEditResult {pub param_warnings: Vec<String>,}+/// One exact occurrence placement path (`1..=64` occurrence ids, root-first).+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct OccurrencePath(pub Vec<u64>);++impl<'de> Deserialize<'de> for OccurrencePath {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let v = Value::deserialize(d)?;+ v.as_array()+ .filter(|a| !a.is_empty() && a.len() <= 64)+ .and_then(|a| a.iter().map(Value::as_u64).collect::<Option<Vec<_>>>())+ .map(OccurrencePath)+ .ok_or_else(|| D::Error::custom("must list 1..64 occurrence ids"))+ }+}++impl JsonSchema for OccurrencePath {+ fn schema_name() -> Cow<'static, str> {+ "OccurrencePath".into()+ }+ fn json_schema(_: &mut SchemaGenerator) -> Schema {+ json_schema!({+ "description": "An exact placement path: 1 to 64 occurrence ids from the root down.",+ "type": "array",+ "items": {"type": "integer", "minimum": 0, "maximum": u64::MAX},+ "minItems": 1,+ "maxItems": 64+ })+ }+}++/// A list of `1..=64` exact occurrence placement paths.+#[derive(Clone, Debug, PartialEq, Eq)]+pub struct OccurrencePaths(pub Vec<Vec<u64>>);++impl<'de> Deserialize<'de> for OccurrencePaths {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let v = Value::deserialize(d)?;+ let items = v.as_array().filter(|a| !a.is_empty() && a.len() <= 64).ok_or_else(|| D::Error::custom("must list 1..64 occurrence paths"))?;+ items+ .iter()+ .map(|item| OccurrencePath::deserialize(item).map(|p| p.0).map_err(D::Error::custom))+ .collect::<Result<Vec<_>, _>>()+ .map(OccurrencePaths)+ }+}++impl JsonSchema for OccurrencePaths {+ fn schema_name() -> Cow<'static, str> {+ "OccurrencePaths".into()+ }+ fn json_schema(generator: &mut SchemaGenerator) -> Schema {+ let path = generator.subschema_for::<OccurrencePath>();+ json_schema!({+ "description": "1 to 64 exact occurrence placement paths.",+ "type": "array",+ "items": path,+ "minItems": 1,+ "maxItems": 64+ })+ }+}++/// One occurrence or a list of `1..=64` occurrences, each by id or name.+#[derive(Clone, Debug, PartialEq)]+pub struct OccurrenceList(pub Vec<String>);++impl<'de> Deserialize<'de> for OccurrenceList {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let fail = || D::Error::custom("must be an occurrence id/name or a list of 1..64 ids/names");+ match Value::deserialize(d)? {+ v @ (Value::Number(_) | Value::String(_)) => IdOrName::deserialize(v).map(|x| OccurrenceList(vec![x.0])).map_err(|_| fail()),+ Value::Array(a) if !a.is_empty() && a.len() <= 64 => {+ a.into_iter().map(|v| IdOrName::deserialize(v).ok().map(|x| x.0)).collect::<Option<Vec<_>>>().map(OccurrenceList).ok_or_else(fail)+ }+ _ => Err(fail()),+ }+ }+}++impl JsonSchema for OccurrenceList {+ fn schema_name() -> Cow<'static, str> {+ "OccurrenceList".into()+ }+ fn json_schema(generator: &mut SchemaGenerator) -> Schema {+ let item = generator.subschema_for::<IdOrName>();+ json_schema!({+ "description": "An occurrence id/name, or 1 to 64 occurrence ids/names.",+ "anyOf": [+ item.clone(),+ {"type": "array", "items": item, "minItems": 1, "maxItems": 64}+ ]+ })+ }+}++const SNAPS: [&str; 4] = ["vertex", "edge_mid", "face_center", "circle_center"];++/// An alignment point: `[x, y, z]`, `"origin"`, or `{snap?: vertex|edge_mid|face_center|circle_center, at: [x, y, z]}`.+#[derive(Clone, Debug, PartialEq)]+pub struct AlignPickParam(pub Value);++impl<'de> Deserialize<'de> for AlignPickParam {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let v = Value::deserialize(d)?;+ if v.as_str().is_some_and(|s| s.eq_ignore_ascii_case("origin")) {+ return Ok(AlignPickParam(v));+ }+ if let Some(o) = v.as_object()+ && (o.contains_key("at") || o.contains_key("snap"))+ {+ if o.get("at").and_then(params::vec3).is_none() {+ return Err(D::Error::custom("`.at` must be [x, y, z]"));+ }+ if let Some(snap) = o.get("snap") {+ let Some(s) = snap.as_str() else {+ return Err(D::Error::custom("`.snap` must be vertex, edge_mid, face_center or circle_center"));+ };+ if !SNAPS.contains(&s) {+ return Err(D::Error::custom("`.snap` must be vertex, edge_mid, face_center or circle_center"));+ }+ }+ return Ok(AlignPickParam(v));+ }+ if params::vec3(&v).is_some() {+ return Ok(AlignPickParam(v));+ }+ Err(D::Error::custom("must be [x, y, z], \"origin\", or {snap, at: [x, y, z]}"))+ }+}++impl JsonSchema for AlignPickParam {+ fn schema_name() -> Cow<'static, str> {+ "AlignPick".into()+ }+ fn json_schema(generator: &mut SchemaGenerator) -> Schema {+ let point = generator.subschema_for::<Point3>();+ json_schema!({+ "description": "A world point [x, y, z], \"origin\", or a snap point {\"snap\": \"vertex\"|\"edge_mid\"|\"face_center\"|\"circle_center\", \"at\": [x, y, z]}.",+ "anyOf": [+ point.clone(),+ {"type": "string", "pattern": "^[Oo][Rr][Ii][Gg][Ii][Nn]$"},+ {+ "type": "object",+ "properties": {+ "snap": {"type": "string", "enum": SNAPS},+ "at": point+ },+ "required": ["at"]+ }+ ]+ })+ }+}++/// A plane parameter as `features::plane_param` reads it: `"XY" | "XZ" | "YZ"`, a construction+/// plane name or feature id, or `{origin?, normal}` / `{origin?, x_dir, y_dir}`.+#[derive(Clone, Debug, PartialEq)]+pub struct AlignPlaneParam(pub Value);++impl<'de> Deserialize<'de> for AlignPlaneParam {+ fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {+ let v = Value::deserialize(d)?;+ match &v {+ Value::String(s) if !s.trim().is_empty() && s.len() <= 4096 => Ok(AlignPlaneParam(v)),+ Value::Number(n) if n.as_u64().is_some() => Ok(AlignPlaneParam(v)),+ Value::Object(o) => {+ if let Some(origin) = o.get("origin") {+ PointExpr3::deserialize(origin).map_err(|_| D::Error::custom("plane `origin` must be [x, y, z]"))?;+ }+ let has_xy = o.get("x_dir").and_then(params::vec3).is_some() && o.get("y_dir").and_then(params::vec3).is_some();+ let has_n = o.get("normal").and_then(params::vec3).is_some();+ if has_xy || has_n { Ok(AlignPlaneParam(v)) } else { Err(D::Error::custom("plane needs x_dir and y_dir, or normal")) }+ }+ _ => Err(D::Error::custom("must be XY, XZ, YZ, a construction plane name or id, or {origin, normal}")),+ }+ }+}++impl JsonSchema for AlignPlaneParam {+ fn schema_name() -> Cow<'static, str> {+ "AlignPlane".into()+ }+ fn json_schema(generator: &mut SchemaGenerator) -> Schema {+ let point = generator.subschema_for::<Point3>();+ let expr_point = generator.subschema_for::<PointExpr3>();+ json_schema!({+ "description": "XY, XZ, YZ, a construction plane name or feature id, or an explicit plane {origin?, normal} / {origin?, x_dir, y_dir}.",+ "anyOf": [+ {"type": "string", "minLength": 1, "maxLength": 4096, "pattern": not_blank_pattern()},+ {"type": "integer", "minimum": 0, "maximum": u64::MAX},+ json!({+ "type": "object",+ "properties": {"origin": expr_point.clone(), "normal": point.clone()},+ "required": ["normal"]+ }),+ json!({+ "type": "object",+ "properties": {"origin": expr_point, "x_dir": point.clone(), "y_dir": point},+ "required": ["x_dir", "y_dir"]+ })+ ]+ })+ }+}++/// Align one or more component occurrence placements in world coordinates without modifying+/// shared component geometry.+#[derive(Debug, Deserialize, JsonSchema)]+#[schemars(deny_unknown_fields)]+pub struct OccurrenceAlignParams {+ /// A single occurrence to align, by id or name (optionally disambiguated by `path`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "IdOrName")]+ pub occurrence: Option<IdOrName>,+ /// One or more occurrences to align together, by id or name.+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "OccurrenceList")]+ pub occurrences: Option<OccurrenceList>,+ /// Exact placement path `[occ_id, ...]` of a single occurrence.+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "OccurrencePath")]+ pub path: Option<OccurrencePath>,+ /// Exact placement paths `[[occ_id, ...], ...]` of one or more occurrences to align together.+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "OccurrencePaths")]+ pub paths: Option<OccurrencePaths>,+ /// Source point (`[x, y, z]`, `"origin"`, or `{snap, at}`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "AlignPickParam")]+ pub from: Option<AlignPickParam>,+ /// Point on a planar source face in world coordinates (turns to meet `to_face` or `to_plane`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "Point3")]+ pub from_face: Option<Point3>,+ /// Source plane (`XY`, `XZ`, `YZ`, a construction plane, or `{origin, normal}`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "AlignPlaneParam")]+ pub from_plane: Option<AlignPlaneParam>,+ /// Destination point (`[x, y, z]`, `"origin"`, or `{snap, at}`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "AlignPickParam")]+ pub to: Option<AlignPickParam>,+ /// Point on a planar destination face in world coordinates.+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "Point3")]+ pub to_face: Option<Point3>,+ /// Destination plane (`XY`, `XZ`, `YZ`, a construction plane, or `{origin, normal}`).+ #[serde(default, deserialize_with = "present")]+ #[schemars(with = "AlignPlaneParam")]+ pub to_plane: Option<AlignPlaneParam>,+ /// Flip face/plane normal alignment so normals point the same way instead of meeting opposite.+ #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub flip: Option<bool>,+ /// Capture the aligned position immediately (default: `true`); `false` leaves it pending.+ #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub capture: Option<bool>,+ /// Allow aligning a grounded occurrence while keeping it grounded (default: `false`).+ #[serde(default, deserialize_with = "present", skip_serializing_if = "Option::is_none")]+ #[schemars(with = "bool")]+ pub move_grounded: Option<bool>,+}++/// Result of `occurrence.align`.+#[derive(Debug, Serialize, JsonSchema)]+pub struct OccurrenceAlignResult {+ /// Occurrence ids whose placements were updated, in order.+ pub occurrences: Vec<u64>,+ /// Exact placement paths aligned, in order.+ pub paths: Vec<Vec<u64>>,+ /// World-space rigid transform applied (column-major 4×4 matrix).+ pub world_transform: [[f64; 4]; 4],+ /// True when `capture: false` kept the aligned positions as pending moves.+ pub pending: bool,+ /// Aligned paths that sit inside a component placed more than once: they moved in every+ /// placement of it. Left out when there are none.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub shared: Vec<Vec<u64>>,+ /// In the warn parameter-check mode: what the call's parameters got wrong.+ #[serde(default, skip_serializing_if = "Vec::is_empty")]+ pub param_warnings: Vec<String>,+}+#[cfg(test)]#[path = "component_tests.rs"]mod tests;diff --git a/crates/engine/src/schema/component_tests.rs b/crates/engine/src/schema/component_tests.rsindex 08ae137a86..0ef2d01713 100644--- a/crates/engine/src/schema/component_tests.rs+++ b/crates/engine/src/schema/component_tests.rs@@ -1,16 +1,34 @@use std::sync::Arc;-use serde_json::json;+use serde_json::{Value, json};-use super::{EditInPlaceParams, FinishEditParams};+use super::{EditInPlaceParams, FinishEditParams, OccurrenceAlignParams, OccurrenceAlignResult};use crate::Session;-use crate::schema::input_schema_for;-use crate::schema::tests::assert_keys;+use crate::schema::tests::{assert_keys, conforms};+use crate::schema::{ParamCheck, input_schema_for, output_schema_for};#[test]fn schemas_and_the_key_check_agree() {assert_keys(input_schema_for::<EditInPlaceParams>(), &["component", "path"]);assert_keys(input_schema_for::<FinishEditParams>(), &[]);+ assert_keys(+ input_schema_for::<OccurrenceAlignParams>(),+ &[+ "capture",+ "flip",+ "from",+ "from_face",+ "from_plane",+ "move_grounded",+ "occurrence",+ "occurrences",+ "path",+ "paths",+ "to",+ "to_face",+ "to_plane",+ ],+ );}#[test]@@ -32,3 +50,30 @@ fn finishing_an_edit_outside_the_window_changes_nothing() {assert!(r.as_object().is_some_and(serde_json::Map::is_empty), "{r}");assert!(Arc::ptr_eq(&doc, &s.doc) && s.undo.len() == undo);}++#[test]+fn replies_match_the_output_schema() {+ let schema = output_schema_for::<OccurrenceAlignResult>();+ let schema = schema.as_value();+ let required: Vec<&str> = schema.get("required").and_then(Value::as_array).into_iter().flatten().filter_map(Value::as_str).collect();+ assert!(!required.contains(&"param_warnings"));+ assert!(!required.contains(&"shared"), "`shared` is left out when nothing shared moved");++ let mut s = Session::default();+ let comp = s.execute("component.create", &json!({"name": "Extrusion"})).unwrap_or_else(|e| panic!("{e}"));+ let comp_id = comp["component"].as_u64().unwrap_or(0);+ s.execute("solid.box", &json!({"length": 10, "width": 10, "height": 40})).unwrap_or_else(|e| panic!("{e}"));+ s.execute("component.activate", &json!({"component": "root"})).unwrap_or_else(|e| panic!("{e}"));+ let copy = s.execute("occurrence.copy", &json!({"component": comp_id, "translate": [30, 0, 0]})).unwrap_or_else(|e| panic!("{e}"));+ let second = copy["occurrence"].as_u64().unwrap_or(0);++ s.param_check = ParamCheck::Warn;+ let r1 = s.execute("occurrence.align", &json!({"occurrence": second, "from": [30, 0, 0], "to": [10, 0, 0]})).unwrap_or_else(|e| panic!("{e}"));+ assert!(conforms(schema, schema, &r1), "{r1} doesn't match {schema}");++ let r2 = s+ .execute("occurrence.align", &json!({"paths": [[second]], "from": [10, 0, 0], "to": [20, 0, 0], "unknown_extra": 1}))+ .unwrap_or_else(|e| panic!("{e}"));+ assert!(r2.get("param_warnings").is_some(), "{r2}");+ assert!(conforms(schema, schema, &r2), "{r2} doesn't match {schema}");+}diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rsindex e5be74595f..fe2a4acc45 100644--- a/crates/ui-egui/src/browser.rs+++ b/crates/ui-egui/src/browser.rs@@ -271,7 +271,7 @@ enum Take {/// ([`pick_from_browser`]). Returns false when that input does not take bodies, so the click/// keeps its ordinary meaning. A Shift range only adds; a group or component toggles.fn offer_bodies(app: &mut SolveApp, names: &[String], take: Take) -> bool {- if !dialog_takes_body(app) {+ if !dialog_takes_body(app) || app.dialog.as_ref().is_some_and(|d| d.takes_components()) {return false;}let world = app.session.world_state();@@ -1502,16 +1502,22 @@ fn occurrence_rows_inner(if r.eye {let _ = app.run("browser.visibility", json!({"visible": app.session.occurrence_hidden(path), "paths": [path]}));}+ let takes_components = app.dialog.as_ref().is_some_and(|d| d.takes_components());let params = json!({"component": placement.component, "occurrence": placement.occurrence, "path": path});if r.radio {let _ = app.run("component.activate", params);- } else if r.double && !app.session.doc.parts.contains_key(&placement.component) {+ } else if r.double && !takes_components && !app.session.doc.parts.contains_key(&placement.component) {crate::edit_in_place::double_click_component(app, params);}- if r.double && app.session.doc.parts.contains_key(&placement.component) {+ if r.double && !takes_components && app.session.doc.parts.contains_key(&placement.component) {crate::dialogs_part_size::open(app, placement.component);}- if r.clicked && !r.double {+ if r.clicked && takes_components {+ if let Some(mut d) = app.dialog.take() {+ d.pick(&app.session, Sel::Occurrence { path: path.to_vec() });+ app.dialog = Some(d);+ }+ } else if r.clicked && !r.double {let names = app.session.occurrence_bodies(path, true).unwrap_or_default();if !offer_bodies(app, &names, Take::Toggle) {click_select(app, ui, key.clone(), Some(Sel::Occurrence { path: path.to_vec() }));@@ -2013,11 +2019,18 @@ fn dialog_takes_body(app: &SolveApp) -> bool {/// Browser picks go only into compatible active dialog inputs. Outside a dialog, planes and/// axes become the selection; body rows use the ordinary Ctrl/Shift-aware selection path.fn pick_from_browser(app: &mut SolveApp, x: Sel) {- if let Sel::Body { .. } = &x+ if let Sel::Body { name } = &x&& dialog_takes_body(app)&& let Some(mut d) = app.dialog.take(){- d.pick(&app.session, x);+ let pick = if d.takes_components() {+ crate::dialogs::occurrence_path_of_body(&app.session, name).map(|path| Sel::Occurrence { path })+ } else {+ Some(x)+ };+ if let Some(pick) = pick {+ d.pick(&app.session, pick);+ }app.dialog = Some(d);return;}@@ -2915,7 +2928,13 @@ pub fn needs_capture(app: &SolveApp, what: &str) -> bool {!app.session.pending_moves.is_empty()&& !matches!(what,- "component.capture_position" | "component.revert_position" | "occurrence.move" | "occurrence.drag" | "edit.undo" | "edit.redo"+ "component.capture_position"+ | "component.revert_position"+ | "occurrence.move"+ | "occurrence.align"+ | "occurrence.drag"+ | "edit.undo"+ | "edit.redo")&& app.tree.capture_prompt.is_none()}diff --git a/crates/ui-egui/src/browser_card_tests.rs b/crates/ui-egui/src/browser_card_tests.rsindex 39bcd43bd5..2bf76a96c5 100644--- a/crates/ui-egui/src/browser_card_tests.rs+++ b/crates/ui-egui/src/browser_card_tests.rs@@ -481,3 +481,31 @@ fn mesh_and_solid_body_rows_have_different_icons_and_tooltips() {assert_ne!(icon.master, crate::icon_svg::resolve("body").master);assert_eq!(icon.accent, crate::icon_svg::accent_index("mesh"));}++#[test]+fn browser_occurrence_clicks_fill_align_components_input() {+ let mut h = Harness::new();+ let comp = h.app.run("component.create", json!({"name": "Extrusion", "grounded": false})).unwrap()["component"].as_u64().unwrap();+ h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 40, "body_name": "Beam"})).unwrap();+ h.app.run("component.activate", json!({"component": "root"})).unwrap();+ let second = h.app.run("occurrence.copy", json!({"component": comp, "translate": [30, 0, 0]})).unwrap()["occurrence"].as_u64().unwrap();++ h.app.start("solid.align");+ {+ let d = h.app.dialog.as_mut().unwrap();+ d.kind = crate::dialogs::Kind::Align { flip: false, components: true };+ d.inputs[0].label = "Components";+ d.active = 0;+ }+ h.settle();++ let handle = format!("row:occurrence:{second}");+ h.step(&json!({"click": {"handle": &handle}})).unwrap();+ let d = h.app.dialog.as_ref().unwrap();+ assert_eq!(d.inputs[0].items, vec![Sel::Occurrence { path: vec![second] }]);+ assert!(h.app.session.selection.is_empty(), "dialog picks do not change global selection");++ // Clicking the same occurrence row again toggles it off in the multi-select Components input.+ h.step(&json!({"click": {"handle": &handle}})).unwrap();+ assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());+}diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rsindex c7246c166d..4737b92c1b 100644--- a/crates/ui-egui/src/dialogs.rs+++ b/crates/ui-egui/src/dialogs.rs@@ -268,9 +268,10 @@ crate::dialog_descriptor::dialog_descriptors! {cells: Vec<(Vec3, String, bool)>,of: Vec<Sel>,},- /// Move bodies so a face or point meets another.+ /// Move bodies or component occurrences so a face or point meets another.Align {flip: bool,+ components: bool,},/// Remove bodies from here on in the timeline.Remove,@@ -844,14 +845,17 @@ impl Dialog {"solid.boundary_fill" => {Dialog::new(Kind::BoundaryFill { operation: 0, cells: Vec::new(), of: Vec::new() }, vec![SelInput::new("Tools", BODIES, true)])}- "solid.align" => Dialog::new(- Kind::Align { flip: false },- vec![- SelInput::new("Bodies", BODIES, true),- SelInput::new("From", FACES | EDGES | selection::VERTICES | PLANES | selection::ORIGIN, false),- SelInput::new("To", FACES | EDGES | selection::VERTICES | PLANES | selection::ORIGIN, false),- ],- ),+ "solid.align" => {+ let components = s.selection.iter().any(|x| matches!(x, Sel::Occurrence { .. }));+ Dialog::new(+ Kind::Align { flip: false, components },+ vec![+ SelInput::new(if components { "Components" } else { "Bodies" }, BODIES, true),+ SelInput::new("From", FACES | EDGES | selection::VERTICES | PLANES | selection::ORIGIN, false),+ SelInput::new("To", FACES | EDGES | selection::VERTICES | PLANES | selection::ORIGIN, false),+ ],+ )+ }"solid.remove" => Dialog::new(Kind::Remove, vec![SelInput::new("Bodies", BODIES, true)]),"solid.pattern.path" => Dialog::new(Kind::PathPattern { count: "4".into(), spacing: length_default(s, "20") },@@ -1045,6 +1049,24 @@ impl Dialog {// text it edits, not its path.)let preselection: &[Sel] = if matches!(d.kind, Kind::Text(_)) { &[] } else { &s.selection };for sel in preselection {+ if matches!(d.kind, Kind::Align { components: true, .. }) {+ let occ = match sel {+ Sel::Occurrence { path } if !path.is_empty() => Some(Sel::Occurrence { path: path.clone() }),+ Sel::Body { name } => occurrence_path_of_body(s, name).map(|path| Sel::Occurrence { path }),+ Sel::Face { body, .. } | Sel::Edge { body, .. } | Sel::Vertex { body, .. } => {+ occurrence_path_of_body(s, body).map(|path| Sel::Occurrence { path })+ }+ _ => None,+ };+ if let Some(occ) = occ {+ if let Some(inp) = d.inputs.first_mut()+ && !inp.items.contains(&occ)+ {+ inp.items.push(occ);+ }+ continue;+ }+ }let as_body = match sel {Sel::Face { body, .. } | Sel::Edge { body, .. } | Sel::Vertex { body, .. } => Some(Sel::Body { name: body.to_string() }),_ => None,@@ -1330,6 +1352,11 @@ impl Dialog {&& (matches!(self.kind, Kind::Move { .. }) || (matches!(self.kind, Kind::Construct { .. }) && inp.accept & selection::VERTICES != 0))}+ /// Does the active input pick component occurrences rather than bodies?+ pub(crate) fn takes_components(&self) -> bool {+ matches!(self.kind, Kind::Align { components: true, .. }) && self.active == 0+ }+/// Everything the inputs hold (for highlighting).pub fn items(&self) -> Vec<Sel> {self.inputs.iter().flat_map(|i| i.items.iter().cloned()).collect()@@ -1422,6 +1449,12 @@ impl Dialog {return Some(target);}let inp = self.active_input()?;+ if self.takes_components() {+ return match h {+ Hit::Face { body, .. } => occurrence_path_of_body(s, body).map(|path| Sel::Occurrence { path }),+ _ => None,+ };+ }// Features are also picked on the canvas: a face stands for the feature that made it.if inp.accept == selection::FEATURES {return match h {@@ -1609,6 +1642,7 @@ impl Dialog {self.profile_selection_changed = true;}let measure = matches!(self.kind, Kind::Measure { .. });+ let takes_components = self.takes_components();let is_fillet = matches!(self.kind, Kind::Fillet { .. }) && self.active == 0;let chain = matches!(self.kind, Kind::Fillet { chain: true, .. });if is_fillet && !add {@@ -1619,6 +1653,19 @@ impl Dialog {inp.items.clear();}for x in sels {+ if takes_components {+ let occ = match x {+ Sel::Occurrence { path } if !path.is_empty() => Some(Sel::Occurrence { path }),+ Sel::Body { name } => occurrence_path_of_body(s, &name).map(|path| Sel::Occurrence { path }),+ _ => None,+ };+ if let Some(occ) = occ+ && !inp.items.contains(&occ)+ {+ inp.items.push(occ);+ }+ continue;+ }let x = if measure { crate::viewport::measurement_selection(s, &x) } else { x };if !fits(inp.accept, &x) {continue;@@ -2153,6 +2200,8 @@ fn hint(inp: &SelInput) -> &'static str {"click sketch curves"} else if a & (selection::POINTS | selection::SKETCH_POINTS) != 0 {"click sketch points"+ } else if inp.label == "Components" {+ "click components"} else if a & BODIES != 0 {"click bodies"} else {@@ -2248,6 +2297,22 @@ fn object_type_row(d: &mut Dialog, ui: &mut egui::Ui) {}}+fn align_object_type_row(d: &mut Dialog, ui: &mut egui::Ui) {+ let Kind::Align { components, .. } = &mut d.kind else { return };+ let Some(inp) = d.inputs.first_mut() else { return };+ let cur = usize::from(*components);+ let mut ty = cur;+ choice_row(ui, "Object Type", "align_obj", &mut ty, &["Bodies", "Components"]);+ if ty != cur {+ *components = ty == 1;+ inp.label = if *components { "Components" } else { "Bodies" };+ let back = std::mem::take(&mut d.other_objects);+ d.other_objects = std::mem::replace(&mut inp.items, back);+ d.active = 0;+ d.error = None;+ }+}+/// Rows above the selection inputs: the pattern type and object type, the Hole placement (one/// face point, or sketch points).fn placement_row(d: &mut Dialog, ui: &mut egui::Ui, app: &SolveApp) {@@ -2256,6 +2321,10 @@ fn placement_row(d: &mut Dialog, ui: &mut egui::Ui, app: &SolveApp) {object_type_row(d, ui);return;}+ if matches!(d.kind, Kind::Align { .. }) {+ align_object_type_row(d, ui);+ return;+ }if matches!(d.kind, Kind::Move { .. }) {crate::dialogs_move::type_row(app, d, ui);return;@@ -2320,6 +2389,65 @@ fn placement_row(d: &mut Dialog, ui: &mut egui::Ui, app: &SolveApp) {}}+/// The placement a click on a placed component's world body picks (`None` for root-component+/// bodies): the one directly under the active component, as the browser shows it. With the design+/// active a part inside a subassembly picks the subassembly; with the subassembly (or the part)+/// active it picks the part. A body outside the active component picks its top-level placement.+pub(crate) fn occurrence_path_of_body(s: &Session, body: &str) -> Option<Vec<u64>> {+ let st = s.world_state();+ let b = st.body(body)?;+ if s.doc.model_body_component(b) == 0 {+ return None;+ }+ let model = s.model.state();+ let (_, _, _, path, _) = s.placed_document().body_frames_with_source(&model).into_iter().find(|(world, ..)| world == body)?;+ let depth = pick_depth(s, &path);+ let path: Vec<u64> = path.into_iter().take(depth).collect();+ (!path.is_empty()).then_some(path)+}++/// How many ids of a body's full placement `path` a component pick keeps (see+/// [`occurrence_path_of_body`]).+fn pick_depth(s: &Session, path: &[u64]) -> usize {+ let context = match &s.active_occurrence_path {+ Some(active) => Some(active.len()),+ // An active component without an exact placement: the placement of it on this path.+ None if s.active_component != 0 => {+ path.iter().position(|id| s.doc.occurrences.iter().any(|o| o.id == *id && o.component == s.active_component)).map(|i| i + 1)+ }+ None => Some(0),+ };+ match context {+ Some(n) if s.active_occurrence_path.as_deref().is_none_or(|active| path.starts_with(active)) => (n + 1).min(path.len()),+ _ => 1,+ }+}++/// The note Align shows when a picked component sits inside a subassembly placed more than once.+const ALIGN_SHARED_WARNING: &str = "This component is inside a subassembly placed more than once: aligning it moves it in every placement.";++/// Does aligning these Components picks move a placement shared by several subassembly copies?+fn align_moves_shared(s: &Session, items: &[Sel]) -> bool {+ occurrence_paths(s, items).iter().any(|path| s.occurrence_shared(path))+}++fn occurrence_paths(s: &Session, items: &[Sel]) -> Vec<Vec<u64>> {+ let mut out = Vec::new();+ for item in items {+ let path = match item {+ Sel::Occurrence { path } if !path.is_empty() => Some(path.clone()),+ Sel::Body { name } => occurrence_path_of_body(s, name),+ _ => None,+ };+ if let Some(p) = path+ && !out.contains(&p)+ {+ out.push(p);+ }+ }+ out+}+/// A picked item as its chip shows it. A round edge or face says what it stands for in `inp`:/// its axis in an axis input, a circle's centre in a point input. An origin plane goes by/// the name the preferences give it.@@ -2340,6 +2468,7 @@ pub(crate) fn selection_label(s: &Session, names: crate::prefs::OriginPlaneNames// A point of the model: a vertex, or the centre a round edge stands for.Sel::Vertex { body, .. } if !body.is_empty() => format!("{body} · point"),Sel::Feature { id } => s.doc.feature(*id).map(|f| f.name.clone()).unwrap_or_else(|| format!("Feature {id}")),+ Sel::Occurrence { path } => s.occurrence_placement(path).map(|p| p.name).unwrap_or_else(|_| "Component".into()),Sel::Vertex { body, point } if body.is_empty() => {let state = s.world_state();let p = s.active_sketch.and_then(|id| state.sketch(id)).map(|sk| sk.plane.to_local(*point)).unwrap_or_default();@@ -4313,11 +4442,19 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, Sneed(0, "faces")?;("face.delete", json!({"faces": face_points(0)}))}- Kind::Align { flip } => {- need(0, "bodies")?;+ Kind::Align { flip, components } => {+ need(0, if *components { "components" } else { "bodies" })?;need(1, "what to move from")?;need(2, "where to move it to")?;- let mut p = json!({"bodies": sels(d, 0).body_names(), "flip": flip});+ let mut p = if *components {+ let paths = occurrence_paths(s, sels(d, 0));+ if paths.is_empty() {+ return Err("select components first".into());+ }+ json!({"paths": paths, "flip": flip})+ } else {+ json!({"bodies": sels(d, 0).body_names(), "flip": flip})+ };for (i, key) in [(1, "from"), (2, "to")] {let snap = d.extra.get(&format!("{key}_snap")).and_then(Value::as_str).unwrap_or("picked");match (sels(d, i).first(), snap) {@@ -4335,7 +4472,7 @@ fn dialog_commands(app: &SolveApp, d: &Dialog) -> Result<Vec<(String, Value)>, S_ => return Err("pick faces, edges, vertices or planes".into()),}}- ("solid.align", p)+ (if *components { "occurrence.align" } else { "solid.align" }, p)}Kind::Remove => {need(0, "bodies")?;diff --git a/crates/ui-egui/src/dialogs_all_tests.rs b/crates/ui-egui/src/dialogs_all_tests.rsindex 9edb12c54d..69f4c3ebba 100644--- a/crates/ui-egui/src/dialogs_all_tests.rs+++ b/crates/ui-egui/src/dialogs_all_tests.rs@@ -398,7 +398,53 @@ form_case!(web, "solid.web", ["Direction", "Thickness", "Depth"]);form_case!(emboss, "solid.emboss", ["Depth", "Type"]);form_case!(replace_face, "solid.replace_face", []);form_case!(boundary_fill, "solid.boundary_fill", ["Cells", "Operation"]);-form_case!(align, "solid.align", ["From Snap", "To Snap"]);+form_case!(align, "solid.align", ["Object Type", "From Snap", "To Snap"]);++#[test]+fn align_components_mode_switches_and_aligns_only_selected_instance() {+ let mut h = Harness::new();+ let comp = h.app.run("component.create", json!({"name": "Extrusion"})).unwrap()["component"].as_u64().unwrap();+ h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 60, "body_name": "Beam"})).unwrap();+ h.app.run("component.activate", json!({"component": "root"})).unwrap();+ let second = h.app.run("occurrence.copy", json!({"component": comp, "translate": [40, 0, 0]})).unwrap()["occurrence"].as_u64().unwrap();++ // Preselecting an occurrence opens Align in Components mode and advances to From.+ let picked = vec![Sel::Occurrence { path: vec![second] }];+ h.app.session.selection = picked.clone();+ h.app.start("solid.align");+ h.frames(4);+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].label, "Components");+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].items, picked);+ assert_eq!(h.app.dialog.as_ref().unwrap().active, 1);++ // Switching Object Type to Bodies and back restores the preselected occurrence.+ mirror_object_type(&mut h, "Bodies");+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].label, "Bodies");+ assert!(h.app.dialog.as_ref().unwrap().inputs[0].items.is_empty());+ mirror_object_type(&mut h, "Components");+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].label, "Components");+ assert_eq!(h.app.dialog.as_ref().unwrap().inputs[0].items, picked);++ let from = face_sel(&h.app.session, Vec3::new(45.0, 5.0, 0.0)).unwrap();+ let to = face_sel(&h.app.session, Vec3::new(10.0, 5.0, 30.0)).unwrap();+ {+ let d = h.app.dialog.as_mut().unwrap();+ d.inputs[1].items = vec![from];+ d.inputs[2].items = vec![to];+ }+ let commands = apply_commands(&h.app, h.app.dialog.as_ref().unwrap()).unwrap();+ assert_eq!(commands[0].0, "occurrence.align");+ assert_eq!(commands[0].1["paths"], json!([[second]]));+ for (command, params) in commands {+ h.app.run(&command, params).unwrap();+ }++ let st = h.app.session.world_state();+ let b1 = st.body("Beam").unwrap().mesh().bounds();+ assert!((b1.min.x - 0.0).abs() < 1e-5 && (b1.max.x - 10.0).abs() < 1e-5, "{b1:?}");+ let b2 = st.body("Beam (Extrusion:2)").unwrap().mesh().bounds();+ assert!((b2.min.x - 10.0).abs() < 1e-5 && (b2.max.x - 70.0).abs() < 1e-5, "{b2:?}");+}form_case!(remove, "solid.remove", []);form_case!(path_pattern, "solid.pattern.path", ["Type", "Object Type", "Quantity", "Spacing"]);form_case!(pipe, "solid.pipe", ["Diameter", "Wall", "Operation"]);@@ -1061,3 +1107,35 @@ fn every_selection_field_label_is_translated() {}assert!(missing.is_empty(), "selection fields without a message: {missing:#?}");}++#[test]+fn align_components_picks_the_placement_under_the_active_component_and_warns_when_shared() {+ let mut h = Harness::new();+ let made = h.app.run("component.create", json!({"name": "Frame", "grounded": false})).unwrap();+ let (frame, a) = (made["component"].as_u64().unwrap(), made["occurrence"].as_u64().unwrap());+ let bracket = h.app.run("component.create", json!({"name": "Bracket", "grounded": false})).unwrap()["occurrence"].as_u64().unwrap();+ h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 4, "body_name": "Plate"})).unwrap();+ h.app.run("component.activate", json!({"component": "root"})).unwrap();+ let plate = h.app.session.world_state().bodies.first().map(|b| b.name.clone()).unwrap();++ // With the design active, a click on the part inside Frame picks the Frame placement.+ assert_eq!(occurrence_path_of_body(&h.app.session, &plate), Some(vec![a]));+ // With that Frame placement active, the same click picks the part inside it.+ h.app.run("component.activate", json!({"component": frame, "occurrence": a, "path": [a]})).unwrap();+ assert_eq!(occurrence_path_of_body(&h.app.session, &plate), Some(vec![a, bracket]));+ assert!(!align_moves_shared(&h.app.session, &[Sel::Occurrence { path: vec![a, bracket] }]), "Frame is placed once");++ // Once Frame is placed twice, the part's placement inside it is shared: the dialog says so.+ h.app.run("component.activate", json!({"component": "root"})).unwrap();+ h.app.run("occurrence.copy", json!({"component": frame, "translate": [0, 50, 0]})).unwrap();+ assert!(align_moves_shared(&h.app.session, &[Sel::Occurrence { path: vec![a, bracket] }]));+ assert!(!align_moves_shared(&h.app.session, &[Sel::Occurrence { path: vec![a] }]), "a top-level placement is its own");++ h.app.session.selection = vec![Sel::Occurrence { path: vec![a] }];+ h.app.start("solid.align");+ h.frames(4);+ assert!(h.widget(ALIGN_SHARED_WARNING).is_none(), "no warning for a top-level pick");+ h.app.dialog.as_mut().unwrap().inputs[0].items = vec![Sel::Occurrence { path: vec![a, bracket] }];+ h.frames(4);+ assert!(h.widget(ALIGN_SHARED_WARNING).is_some(), "the shared pick is called out");+}diff --git a/crates/ui-egui/src/dialogs_assembly.rs b/crates/ui-egui/src/dialogs_assembly.rsindex 91d9df3cf3..8e35dd277c 100644--- a/crates/ui-egui/src/dialogs_assembly.rs+++ b/crates/ui-egui/src/dialogs_assembly.rs@@ -83,6 +83,7 @@ const MOVES: &[&str] = &["joint.rack_pinion","joint.screw","joint.cam",+ "occurrence.align","parts.insert","parts.fastener",];diff --git a/crates/ui-egui/src/dialogs_dense.rs b/crates/ui-egui/src/dialogs_dense.rsindex 744121ae15..793933d790 100644--- a/crates/ui-egui/src/dialogs_dense.rs+++ b/crates/ui-egui/src/dialogs_dense.rs@@ -731,7 +731,7 @@ fn additional_rows(app: &mut SolveApp, d: &mut Dialog, ui: &mut egui::Ui) -> boo});ui.add(egui::Label::new(crate::i18n::tr("ui.emboss_wrap_note")).wrap());}- Kind::Align { flip } => {+ Kind::Align { flip, components } => {// Where on the picked face or edge to snap: as picked (a face turns to meet// the other, an edge at its middle), its centre, or a round one's centre.for (label, key) in [("From Snap", "from_snap"), ("To Snap", "to_snap")] {@@ -740,6 +740,12 @@ fn additional_rows(app: &mut SolveApp, d: &mut Dialog, ui: &mut egui::Ui) -> boo});}ui_kit::options(ui, "feature_options", &mut [("Flip", flip)]);+ // A part inside a subassembly placed more than once sits where that shared+ // definition says: aligning it moves it in every placement.+ if *components && align_moves_shared(&app.session, d.inputs.first().map_or(&[], |i| i.items.as_slice())) {+ let t = Tokens::get();+ ui.add(egui::Label::new(RichText::new(tr(ALIGN_SHARED_WARNING)).color(t.warning).size(t.font_small)).wrap());+ }}Kind::BoundaryFill { operation, cells, .. } => {form_row(ui, "Cells", |_| {});diff --git a/crates/ui-egui/src/preselect_tests.rs b/crates/ui-egui/src/preselect_tests.rsindex de6423aac4..87cbe13570 100644--- a/crates/ui-egui/src/preselect_tests.rs+++ b/crates/ui-egui/src/preselect_tests.rs@@ -1901,6 +1901,32 @@ fn align_accepts_a_plane_click() {assert_eq!(p["to"], json!("origin"));}+#[test]+fn align_components_input_picks_occurrence_from_viewport_body_and_skips_root_body() {+ let mut app = app_with(json!([]));+ app.run("solid.box", json!({"length": 10, "width": 10, "height": 10, "body_name": "RootBody"})).unwrap();+ let comp = app.run("component.create", json!({"name": "Extrusion", "grounded": false})).unwrap()["component"].as_u64().unwrap();+ app.run("solid.box", json!({"length": 10, "width": 10, "height": 40, "corner": [20, 0, 0], "body_name": "Beam"})).unwrap();+ app.run("component.activate", json!({"component": "root"})).unwrap();+ let second = app.run("occurrence.copy", json!({"component": comp, "translate": [30, 0, 0]})).unwrap()["occurrence"].as_u64().unwrap();++ let mut d = start(&mut app, vec![], "solid.align");+ d.kind = Kind::Align { flip: false, components: true };+ d.inputs[0].label = "Components";+ d.active = 0;++ // Root-component bodies are not components.+ let root_hit = crate::viewport::Hit::Face { body: "RootBody".into(), index: 0, point: Vec3::new(5.0, 5.0, 10.0) };+ assert_eq!(d.candidate(&app.session, &root_hit), None);++ // Clicking the second instance's body picks its exact occurrence path.+ let inst_hit = crate::viewport::Hit::Face { body: "Beam (Extrusion:2)".into(), index: 0, point: Vec3::new(55.0, 5.0, 20.0) };+ let cand = d.candidate(&app.session, &inst_hit);+ assert_eq!(cand, Some(Sel::Occurrence { path: vec![second] }));+ d.pick(&app.session, cand.unwrap());+ assert_eq!(d.inputs[0].items, vec![Sel::Occurrence { path: vec![second] }]);+}+#[test]fn surface_dialogs_make_their_commands() {// A planar patch of a sketch's rectangle, then thickened; Edit Feature brings both back.