Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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();
}