From dfa9afd39f30190532513652aac8da2438abb4b2 Mon Sep 17 00:00:00 2001 From: phanoob Date: Wed, 28 Oct 2026 12:13:15 +0000 Subject: [PATCH] Sketch: leaving a sketch opened inside a component gives the active component back (#8127) (#8157) Double-clicking a sketch row inside a component (an inserted fastener's sketch) activates that component so the sketch is edited in its placement. Finish and Cancel only closed the sketch, so the component stayed active and every other body stayed faded. Edit Sketch now remembers the component and placement active before it activated the sketch's own (also when sketch.edit activates the component of a face-attached sketch), and leaving the sketch makes that one active again, as Finish already puts the history marker back. A component activated while the sketch is open stays active. Co-authored-by: Phanoob Co-authored-by: Claude Opus 5.5 --- crates/ui-egui/src/browser.rs | 5 +- crates/ui-egui/src/documents.rs | 3 ++ crates/ui-egui/src/lib.rs | 51 +++++++++++++++++++ .../ui-egui/src/sketch_attachment_ui_tests.rs | 1 + crates/ui-egui/src/sketch_edit_tests.rs | 45 ++++++++++++++++ 5 files changed, 101 insertions(+), 4 deletions(-) diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs index c9d4eafed..e794ea88f 100644 --- a/crates/ui-egui/src/browser.rs +++ b/crates/ui-egui/src/browser.rs @@ -2478,10 +2478,7 @@ fn entry_row( } if r.double && folder == "sketches" { if let Ok(id) = e.key.parse() { - if let Some(path) = path { - let _ = app.run("component.activate", json!({"component": comp,"occurrence":path.last(),"path":path})); - } - app.edit_sketch(id); + app.edit_sketch_in(id, path.map(|path| (comp, path))); } } else if r.clicked { let shift = ui.input(|i| i.modifiers.shift); diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs index c6ba36de0..449af1df4 100644 --- a/crates/ui-egui/src/documents.rs +++ b/crates/ui-egui/src/documents.rs @@ -27,6 +27,7 @@ pub struct DocSlot { pre_sketch_marker: Option>, pub(crate) pending_feature_edit: Option, pre_sketch_cam: Option, + pre_sketch_component: Option, view: DocView, occurrence_move: Option, agent_chat: crate::agent_chat::AgentChat, @@ -55,6 +56,7 @@ impl DocSlot { pre_sketch_marker: None, pending_feature_edit: None, pre_sketch_cam: None, + pre_sketch_component: None, view: DocView::default(), occurrence_move: None, agent_chat: Default::default(), @@ -148,6 +150,7 @@ fn swap_in(app: &mut SolveApp, mut slot: DocSlot) -> DocSlot { pre_sketch_marker: std::mem::replace(&mut app.pre_sketch_marker, slot.pre_sketch_marker), pending_feature_edit: std::mem::replace(&mut app.pending_feature_edit, slot.pending_feature_edit), pre_sketch_cam: std::mem::replace(&mut app.pre_sketch_cam, slot.pre_sketch_cam), + pre_sketch_component: std::mem::replace(&mut app.pre_sketch_component, slot.pre_sketch_component), view: take_view(app), occurrence_move: std::mem::replace(&mut app.tree.occurrence_move, slot.occurrence_move), agent_chat: slot.agent_chat, diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs index fcc89588a..c1775c199 100644 --- a/crates/ui-egui/src/lib.rs +++ b/crates/ui-egui/src/lib.rs @@ -430,6 +430,16 @@ pub struct PreSketchView { pub facing: Camera, } +/// The active component (and placement) before a sketch opened inside another one (#8127), and +/// the component the sketch opened in. +#[derive(Clone, Debug, PartialEq)] +pub struct PreSketchComponent { + pub sketch: u64, + pub component: u64, + pub path: Option>, + pub opened_in: u64, +} + pub struct SolveApp { /// Compact browser embed: retain model panels and joint controls without application chrome. pub embedded: bool, @@ -447,6 +457,9 @@ pub struct SolveApp { /// The views around opening the open sketch. Leaving it goes back to the earlier one as the /// "When a sketch ends" preference says (#7038). pub pre_sketch_cam: Option, + /// The component active before Edit Sketch activated the one the sketch is in (#8127); + /// leaving the sketch makes it active again. + pub pre_sketch_component: Option, pub services: Services, file_picker: Option, /// A slicer started alone and waited for before the file is sent (Send to Slicer). @@ -665,6 +678,7 @@ impl SolveApp { now: 0.0, pre_sketch_marker: None, pre_sketch_cam: None, + pre_sketch_component: None, services, file_picker: None, slicer_wait: None, @@ -1642,9 +1656,22 @@ impl SolveApp { /// it, and remember the marker so Finish Sketch puts it back. Editing the sketch that is already open does nothing; editing another one /// finishes the current sketch first, so edit sessions never nest. pub fn edit_sketch(&mut self, id: u64) { + self.edit_sketch_in(id, None); + } + + /// Edit a sketch as [`SolveApp::edit_sketch`] does, in one placement of its component (a + /// sketch row inside a component in the browser): that component is active while the sketch + /// is open, and the one active before comes back when the sketch ends (#8127). + pub fn edit_sketch_in(&mut self, id: u64, placement: Option<(u64, &[u64])>) { + let activate = |app: &mut Self| { + if let Some((component, path)) = placement { + let _ = app.run("component.activate", json!({"component": component, "occurrence": path.last(), "path": path})); + } + }; if let solidcraft_engine::doc::FaceAttachmentStatus::Lost { message, .. } = self.session.placed_document().sketch_face_attachment(id, &self.session.model) { + activate(self); browser::redefine_sketch(self, id); self.set_status(message, true); return; @@ -1655,19 +1682,39 @@ impl SolveApp { let Some(idx) = self.session.doc.feature_index(id) else { return }; let marker = self.finish_sketch_for_edit(); let before = self.settled_cam(); + let context = (self.session.active_component, self.session.active_occurrence_path.clone()); self.tool = None; self.dialog = None; + activate(self); let rolled = self.session.doc.marker != Some(idx + 1) && self.run("timeline.roll_to", json!({ "position": idx + 1 })).is_ok(); if self.run("sketch.edit", json!({ "sketch": id })).is_err() { if rolled || marker != self.session.doc.marker { self.restore_marker(marker); } + self.restore_component(context.0, context.1); return; } self.pre_sketch_marker = (rolled || marker != self.session.doc.marker).then_some(marker); + // `sketch.edit` itself activates the component a face-attached sketch was drawn in. + let opened_in = self.session.active_component; + let moved = (opened_in, &self.session.active_occurrence_path) != (context.0, &context.1); + self.pre_sketch_component = moved.then_some(PreSketchComponent { sketch: id, component: context.0, path: context.1, opened_in }); self.look_at_opened_sketch(before); } + /// Make a component active again, in the placement it was active in. + fn restore_component(&mut self, component: u64, path: Option>) { + if (self.session.active_component, &self.session.active_occurrence_path) == (component, &path) { + return; + } + let mut p = json!({ "component": component }); + if let Some(path) = path { + p["occurrence"] = json!(path.last()); + p["path"] = json!(path); + } + let _ = self.run("component.activate", p); + } + /// Turn the view to face the sketch just opened, and remember the view from `before` it and /// the one facing it for when the sketch ends (#7038). pub(crate) fn look_at_opened_sketch(&mut self, before: Camera) { @@ -1721,6 +1768,10 @@ impl SolveApp { if let Some(marker) = self.pre_sketch_marker.take() { self.restore_marker(marker); } + // Unless another component was activated meanwhile: that one stays. + if let Some(pre) = self.pre_sketch_component.take().filter(|pre| Some(pre.sketch) == open && pre.opened_in == self.session.active_component) { + self.restore_component(pre.component, pre.path); + } // Only the views saved when this sketch opened: one opened another way saved none. if let Some(view) = self.pre_sketch_cam.take().filter(|v| Some(v.sketch) == open) && let Some(to) = self.preferences.sketch_exit_view.view_after(view.before, view.facing, self.settled_cam()) diff --git a/crates/ui-egui/src/sketch_attachment_ui_tests.rs b/crates/ui-egui/src/sketch_attachment_ui_tests.rs index 7fa8ed395..46f4472ec 100644 --- a/crates/ui-egui/src/sketch_attachment_ui_tests.rs +++ b/crates/ui-egui/src/sketch_attachment_ui_tests.rs @@ -229,6 +229,7 @@ fn actual_nested_second_placement_face_pick_keeps_target_and_author_paths() { assert_eq!(h.app.session.active_component, child_component); assert_eq!(h.app.session.active_occurrence_path.as_ref(), Some(&path)); h.app.finish_sketch(); + assert_eq!((h.app.session.active_component, h.app.session.active_occurrence_path.as_ref()), (0, None), "the design is active again (#8127)"); assert_eq!(h.app.session.doc.feature(sketch).unwrap().kind, kind); let file = h.dir.join("nested-face.solidcraft"); h.app.run("file.save", json!({"path":file})).unwrap(); diff --git a/crates/ui-egui/src/sketch_edit_tests.rs b/crates/ui-egui/src/sketch_edit_tests.rs index 8c7fe7731..882ee39ec 100644 --- a/crates/ui-egui/src/sketch_edit_tests.rs +++ b/crates/ui-egui/src/sketch_edit_tests.rs @@ -367,3 +367,48 @@ mod exit_view_preference { assert_eq!(SketchExitView::UnlessRotated.view_after(before, facing, turned), None); } } + +/// #8127: a sketch inside an inserted fastener, opened from its row in the browser, activates the +/// fastener's component while it is open; Finish and Cancel make the design active again, so the +/// other bodies are no longer drawn faded. Editing it with the fastener already active leaves the +/// fastener active, and so does activating another component while the sketch is open. +#[test] +fn a_sketch_opened_inside_a_component_gives_the_active_component_back() { + let mut app = sample_app(); + let bolt = app.run("parts.insert", serde_json::json!({"family": "socket_head_cap_screw", "size": "M6", "point": [0, 0, 0]})).unwrap(); + let comp = bolt["component"].as_u64().unwrap(); + let path = app.session.doc.first_path(comp); + let sketch = app.session.doc.features.iter().find(|f| f.component == comp && matches!(f.kind, FeatureKind::Sketch { .. })).map(|f| f.id).unwrap(); + let marker = app.session.doc.marker; + for leave in [SolveApp::finish_sketch as fn(&mut SolveApp), SolveApp::cancel_sketch] { + app.edit_sketch_in(sketch, Some((comp, &path))); + assert_eq!( + (app.session.active_sketch, app.session.active_component), + (Some(sketch), comp), + "the fastener is active while its sketch is open" + ); + leave(&mut app); + assert_eq!((app.session.active_sketch, app.session.active_component), (None, 0), "the design is active again"); + assert_eq!(app.session.active_occurrence_path, None); + assert_eq!(app.session.doc.marker, marker); + } + // Switching to a sketch of the design from the fastener's leaves nothing of the fastener active. + app.edit_sketch_in(sketch, Some((comp, &path))); + app.edit_sketch(first_sketch(&app)); + assert_eq!(app.session.active_component, 0); + app.finish_sketch(); + assert_eq!(app.session.active_component, 0); + // The fastener was active already: it stays active. + app.run("component.activate", serde_json::json!({"component": comp})).unwrap(); + app.edit_sketch_in(sketch, Some((comp, &path))); + app.finish_sketch(); + assert_eq!(app.session.active_component, comp); + // Another component activated while the sketch is open stays active. + app.run("component.activate", serde_json::json!({"component": 0})).unwrap(); + let washer = app.run("parts.insert", serde_json::json!({"family": "washer", "size": "M6", "point": [20, 0, 0]})).unwrap(); + let washer = washer["component"].as_u64().unwrap(); + app.edit_sketch_in(sketch, Some((comp, &path))); + app.run("component.activate", serde_json::json!({"component": washer})).unwrap(); + app.finish_sketch(); + assert_eq!(app.session.active_component, washer, "the component activated meanwhile stays active"); +}