SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Reuse existing tabs when reopening saved designs (#2413) (#2414)
ChrisNo7556e23fe7ef
diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rsindex c42fb528e0..6cdcb929c1 100644--- a/crates/ui-egui/src/documents.rs+++ b/crates/ui-egui/src/documents.rs@@ -188,6 +188,49 @@ pub fn switch(app: &mut SolveApp, i: usize) {app.docs.active = i;}+/// Select an already-open saved design without reloading or framing it. Identity is derived+/// from the current session path so Save As immediately changes which file the tab owns.+pub(crate) fn reuse_path(app: &mut SolveApp, path: &str) -> Result<bool, String> {+ solidcraft_engine::io::vfs::check(path).map_err(|e| e.to_string())?;+ // Imports create unsaved designs, rather than owning their source file.+ if solidcraft_engine::io::is_step_path(path) || solidcraft_engine::io::is_mesh_path(path) {+ return Ok(false);+ }+ let matches = |s: &Session| s.path.as_deref().is_some_and(|p| same_path(p, path));+ let index = if matches(&app.session) {+ Some(app.docs.active)+ } else {+ app.docs.slots.iter().position(|s| s.as_ref().is_some_and(|s| matches(&s.session)))+ };+ let Some(index) = index else { return Ok(false) };+ if app.file_picker_busy() {+ return Err("finish choosing a file before switching designs".into());+ }+ switch(app, index);+ Ok(true)+}++fn same_path(a: &str, b: &str) -> bool {+ if a == b {+ return true;+ }+ #[cfg(not(target_arch = "wasm32"))]+ {+ // canonicalize resolves symlinks and Windows long names/case using the filesystem.+ // Never lowercase: Windows can also host case-sensitive directories.+ if let (Ok(a), Ok(b)) = (std::fs::canonicalize(a), std::fs::canonicalize(b)) {+ return a == b;+ }+ // A deleted file can still select its live editing session. Path equality also+ // accepts redundant separators and `.` without guessing how symlinks resolve `..`.+ if let (Ok(a), Ok(b)) = (std::path::absolute(a), std::path::absolute(b)) {+ return a == b;+ }+ }+ // Browser VFS keys are exact strings, independent of the host's path conventions.+ false+}+/// Open `session` in a new tab after the active one and switch to it (`fit`: frame its model).pub fn open_tab(app: &mut SolveApp, session: Session) -> Result<(), String> {if app.docs.slots.is_empty() {@@ -939,6 +982,104 @@ pub(crate) fn saved_for_close(app: &mut SolveApp) {#[cfg(test)]mod tests {+ #[test]+ fn reopening_saved_design_preserves_dirty_session_and_view() {+ let mut a = super::SolveApp::new(solidcraft_engine::Session::default(), Default::default());+ let path = std::env::temp_dir().join(format!("solidcraft-reopen-{}.solidcraft", std::process::id()));+ let path = path.to_string_lossy().into_owned();+ a.session.execute("file.save", &serde_json::json!({"path": path})).unwrap();+ a.session.execute("solid.box", &serde_json::json!({"length": 10, "width": 12, "height": 14})).unwrap();+ a.session.selection = vec![solidcraft_engine::Sel::Body { name: "Body1".into() }];+ a.cam.distance = 123.0;+ a.session.visibility.hidden_profiles = vec![7];+ let doc = a.session.doc.clone();+ let undo = a.session.undo.len();+ let cam = a.cam;+ a.open_path(&path);+ assert_eq!(a.docs.count(), 1);+ assert!(std::sync::Arc::ptr_eq(&doc, &a.session.doc));+ assert!(a.session.is_dirty());+ assert_eq!(a.session.undo.len(), undo);+ assert_eq!(a.cam, cam);+ assert_eq!(a.session.selection.len(), 1);+ assert_eq!(a.session.visibility.hidden_profiles, vec![7]);+ super::new_tab(&mut a);+ a.open_path(&path);+ assert_eq!(a.docs.count(), 2);+ assert_eq!(a.docs.active, 0);+ assert!(std::sync::Arc::ptr_eq(&doc, &a.session.doc));+ assert_eq!(a.cam, cam);+ assert_eq!(a.session.selection.len(), 1);+ assert_eq!(a.session.visibility.hidden_profiles, vec![7]);+ assert_eq!(a.session.undo.len(), undo);+ assert!(a.session.is_dirty());+ std::fs::remove_file(&path).unwrap();+ a.open_path(&path);+ assert_eq!(a.docs.count(), 2);+ assert!(std::sync::Arc::ptr_eq(&doc, &a.session.doc));+ }++ #[test]+ fn reuse_tracks_save_as_missing_files_and_full_capacity() {+ let mut a = app();+ a.session.path = Some("original.solidcraft".into());+ let original = a.session.doc.clone();+ // Save As updates the live path; lookup must not retain the old identity.+ a.session.path = Some("renamed.solidcraft".into());+ assert!(!reuse_path(&mut a, "original.solidcraft").unwrap());+ for _ in 1..MAX_OPEN {+ new_tab(&mut a);+ }+ assert_eq!(a.docs.count(), MAX_OPEN);+ assert!(reuse_path(&mut a, "renamed.solidcraft").unwrap());+ assert_eq!(a.docs.active, 0);+ assert!(std::sync::Arc::ptr_eq(&original, &a.session.doc));+ assert!(!reuse_path(&mut a, "elsewhere/renamed.solidcraft").unwrap());+ assert_eq!(a.docs.count(), MAX_OPEN);+ a.home.open = true;+ assert!(reuse_path(&mut a, "renamed.solidcraft").unwrap());+ assert!(!a.home.open);+ }++ #[test]+ fn reuse_does_not_claim_a_switch_while_a_picker_is_open() {+ let mut a = app();+ a.session.path = Some("picker.solidcraft".into());+ new_tab(&mut a);+ a.services.pick_open = Some(Box::new(|_| Box::pin(std::future::pending())));+ a.pick_open(|_, _| {});+ assert!(a.file_picker_busy());+ assert!(reuse_path(&mut a, "picker.solidcraft").is_err());+ assert_eq!(a.docs.active, 1);+ assert_eq!(a.docs.count(), 2);+ }++ #[test]+ fn saved_path_identity_uses_the_filesystem_without_folding_case() {+ let dir = std::env::temp_dir().join(format!("solidcraft-tab-paths-{}", std::process::id()));+ std::fs::create_dir_all(dir.join("other")).unwrap();+ let path = dir.join("design.solidcraft");+ std::fs::write(&path, b"identity test").unwrap();+ let text = |p: &std::path::Path| p.to_string_lossy().into_owned();+ assert!(same_path(&text(&path), &text(&dir.join("other/../design.solidcraft"))));+ assert!(!same_path(&text(&path), &text(&dir.join("other/design.solidcraft"))));+ #[cfg(windows)]+ assert!(same_path(&text(&path), &text(&dir.join("DESIGN.solidcraft"))));+ #[cfg(unix)]+ {+ let link = dir.join("alias.solidcraft");+ std::os::unix::fs::symlink(&path, &link).unwrap();+ assert!(same_path(&text(&path), &text(&link)));+ std::fs::write(dir.join("DESIGN.solidcraft"), b"distinct").unwrap();+ if std::fs::read(&path).unwrap() != b"distinct" {+ assert!(!same_path(&text(&path), &text(&dir.join("DESIGN.solidcraft"))));+ }+ }+ std::fs::remove_file(&path).unwrap();+ assert!(same_path(&text(&path), &text(&dir.join("./design.solidcraft"))));+ std::fs::remove_dir_all(dir).unwrap();+ }+use super::*;use crate::Services;use egui::Color32;diff --git a/crates/ui-egui/src/file_load.rs b/crates/ui-egui/src/file_load.rsindex 8dc8bc5b85..90f023b13c 100644--- a/crates/ui-egui/src/file_load.rs+++ b/crates/ui-egui/src/file_load.rs@@ -56,7 +56,7 @@ pub struct Request {impl Request {pub fn new(path: &str, kind: Kind) -> Self {- Request { path: path.into(), kind, reply: None, scope: None, options: Default::default() }+ Request { path: path.into(), kind, reply: None, scope: solidcraft_engine::io::vfs::current_scope(), options: Default::default() }}fn insert(&self) -> bool {self.kind == Kind::Insert@@ -222,6 +222,9 @@ pub fn begin(app: &mut SolveApp, path: &str, insert: bool) {/// Queue a file operation; on the web (no threads) it runs now.pub fn begin_request(app: &mut SolveApp, request: Request) -> Result<(), String> {+ if app.file_load.idle() && reuse_open(app, &request) {+ return Ok(());+ }#[cfg(target_arch = "wasm32")]{if staged_kind(&request) {@@ -284,6 +287,36 @@ pub(crate) fn queue(app: &mut SolveApp, request: Request) -> Result<(), String>Ok(())}+/// Answer each ordinary open separately, including queued requests for the same file.+/// Validate the caller's scope before looking at existing sessions or resolving paths.+fn reuse_open(app: &mut SolveApp, request: &Request) -> bool {+ if request.kind != Kind::Open {+ return false;+ }+ let reused = solidcraft_engine::io::vfs::scoped(request.scope.clone(), || {+ solidcraft_engine::io::vfs::check(&request.path).map_err(|e| e.to_string())?;+ // Let the command validate import-specific options, even for an existing tab.+ if !request.options.is_empty() {+ return Ok(false);+ }+ crate::documents::reuse_path(app, &request.path)+ });+ match reused {+ Ok(false) => false,+ Ok(true) => {+ let s = &app.session;+ request.answer(Ok(json!({"path": request.path, "features": s.doc.features.len(),+ "errors": s.model.results.iter().filter(|r| r.error.is_some()).count(), "name": s.doc.name})));+ true+ }+ Err(e) => {+ app.set_status(e.clone(), true);+ request.answer(Err(e));+ true+ }+ }+}+/// A control-channel (MCP) `doc.open` or STEP/mesh import runs like File > Open: off the window/// thread, answered when the file is in. Other requests come back to be handled now.pub fn control(app: &mut SolveApp, req: crate::control::ControlRequest) -> Option<crate::control::ControlRequest> {@@ -350,6 +383,9 @@ fn start(app: &mut SolveApp) {return;}let Some(request) = app.file_load.queued.pop_front() else { return };+ if reuse_open(app, &request) {+ return;+ }if matches!(request.kind, Kind::Open | Kind::Recover { .. })&& app.docs.count() >= crate::documents::MAX_OPEN&& !crate::documents::active_is_blank(app)@@ -846,6 +882,7 @@ pub fn tick(app: &mut SolveApp, ctx: &egui::Context) {app.set_status(language.format("ui.command_done", &[("command", language.label(crate::command_label(id)))]), false);request.answer(r);}+ Ok(_) if reuse_open(app, request) => {}Ok(made) if running.matches(&app.session) => {// Not meshed yet: framing it while it goes in must not mesh it here.app.open_meshing_next = true;@@ -1070,6 +1107,103 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {mod tests {use super::*;+ fn completed_open(app: &mut SolveApp, request: Request, session: Session) {+ let (tx, rx) = std::sync::mpsc::channel();+ tx.send(Ok(Made { session, result: json!({"loaded": true}), thumbnail: false })).unwrap();+ app.file_load.running = Some(Running {+ request,+ base: app.session.doc.clone(),+ base_revision: app.session.revision,+ before: Vec::new(),+ rx,+ phase: Arc::new(AtomicU8::new(0)),+ progress: Arc::new(Progress::default()),+ preview_rx: None,+ preview: None,+ partial_rx: None,+ built: None,+ staged: None,+ });+ }++ #[test]+ fn repeated_queued_opens_reply_once_and_keep_one_session() {+ let mut app = SolveApp::new(Session::default(), Default::default());+ let mut session = Session::default();+ session.path = Some("queued.solidcraft".into());+ let mut first = Request::new("queued.solidcraft", Kind::Open);+ let (tx, first_reply) = std::sync::mpsc::channel();+ first.reply = Some(tx);+ completed_open(&mut app, first, session);+ let mut replies = vec![first_reply];+ for _ in 0..3 {+ let mut request = Request::new("queued.solidcraft", Kind::Open);+ let (tx, rx) = std::sync::mpsc::channel();+ request.reply = Some(tx);+ replies.push(rx);+ begin_request(&mut app, request).unwrap();+ }+ let ctx = egui::Context::default();+ tick(&mut app, &ctx);+ let loaded = app.session.doc.clone();+ app.session.execute("solid.box", &json!({"length": 2, "width": 3, "height": 4})).unwrap();+ let dirty = app.session.doc.clone();+ assert!(!Arc::ptr_eq(&loaded, &dirty));+ for _ in 0..3 {+ tick(&mut app, &ctx);+ }+ assert!(app.file_load.idle());+ assert_eq!(app.docs.count(), 1);+ assert!(Arc::ptr_eq(&dirty, &app.session.doc));+ assert!(app.session.is_dirty());+ for rx in replies {+ assert_eq!(rx.try_recv().unwrap()["ok"], true);+ assert!(rx.try_recv().is_err());+ }+ }++ #[test]+ fn finished_open_reuses_existing_dirty_tab_and_scope_still_applies() {+ let mut app = SolveApp::new(Session::default(), Default::default());+ app.session.path = Some("existing.solidcraft".into());+ app.session.execute("solid.box", &json!({"length": 2, "width": 3, "height": 4})).unwrap();+ let dirty = app.session.doc.clone();+ let undo = app.session.undo.len();+ let camera = app.cam;+ crate::documents::new_tab(&mut app);+ let mut loaded = Session::default();+ loaded.path = Some("existing.solidcraft".into());+ let mut request = Request::new("existing.solidcraft", Kind::Open);+ let (tx, rx) = std::sync::mpsc::channel();+ request.reply = Some(tx);+ completed_open(&mut app, request, loaded);+ tick(&mut app, &egui::Context::default());+ assert_eq!(rx.try_recv().unwrap()["result"]["features"], 1);+ assert_eq!(app.docs.count(), 2);+ assert_eq!(app.docs.active, 0);+ assert!(Arc::ptr_eq(&dirty, &app.session.doc));+ assert_eq!(app.session.undo.len(), undo);+ assert_eq!(app.cam, camera);+ assert!(app.session.is_dirty());++ let mut denied = Request::new("existing.solidcraft", Kind::Open);+ denied.scope = Some(Default::default());+ let (tx, rx) = std::sync::mpsc::channel();+ denied.reply = Some(tx);+ begin_request(&mut app, denied).unwrap();+ assert_eq!(rx.try_recv().unwrap()["ok"], false);+ assert!(rx.try_recv().is_err());+ assert!(app.file_load.idle());+ assert!(Arc::ptr_eq(&dirty, &app.session.doc));+ // ui.file dispatch carries its scope on the calling thread; preserve it in the queue.+ solidcraft_engine::io::vfs::scoped(Some(Default::default()), || {+ begin(&mut app, "existing.solidcraft", false);+ });+ assert!(app.status.as_ref().is_some_and(|s| s.2 && s.0.contains("outside the folders")));+ assert!(!reuse_open(&mut app, &Request::new("existing.solidcraft", Kind::Insert)));+ assert!(!reuse_open(&mut app, &Request::new("existing.solidcraft", Kind::Recover { id: "test".into(), dir: None })));+ }+#[test]fn drawing_insert_and_drop_reuse_the_active_sketch_or_create_xy() {let mut h = crate::scenario::Harness::new();diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex d38a677896..209a840b7f 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -1507,6 +1507,14 @@ impl SolveApp {}pub fn open_path(&mut self, path: &str) {+ match documents::reuse_path(self, path) {+ Ok(true) => return,+ Err(e) => {+ self.set_status(e, true);+ return;+ }+ Ok(false) => {}+ }self.home.open = false;documents::prepare_open(self);if let Ok(r) = self.run("doc.open", json!({ "path": path })) {diff --git a/crates/ui-egui/tests/scenarios.rs b/crates/ui-egui/tests/scenarios.rsindex c1637528b2..95e7c18e94 100644--- a/crates/ui-egui/tests/scenarios.rs+++ b/crates/ui-egui/tests/scenarios.rs@@ -154,7 +154,7 @@ fn home_tab_and_file_recent_open_designs() {{"click":{"handle":"tab:home"}},{"click":{"handle":"home:recent:0"}},{"until":{"file_busy":false}},- {"expect":{"home":false,"bodies":1,"documents":2}},+ {"expect":{"home":false,"bodies":1,"documents":1}},{"click":{"handle":"appbar:folder"}},{"widget":"Open Recent"}]))@@ -162,7 +162,7 @@ fn home_tab_and_file_recent_open_designs() {h.run(&json!([{"widget":path},{"until":{"file_busy":false}},- {"expect":{"home":false,"bodies":1,"documents":3}}+ {"expect":{"home":false,"bodies":1,"documents":1}}])).unwrap();}