SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Web: open tabs share settings changes, so one tab no longer undoes another's (#8644) (#8832)
austin62jake9b97e06f7128
diff --git a/apps/solidcraft-web/Cargo.toml b/apps/solidcraft-web/Cargo.tomlindex 2339990a38..03eccbe8ff 100644--- a/apps/solidcraft-web/Cargo.toml+++ b/apps/solidcraft-web/Cargo.toml@@ -34,7 +34,7 @@ serde_json = { workspace = true }web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "Location", "Navigator", "StorageManager","FileSystemHandle", "FileSystemDirectoryHandle", "FileSystemFileHandle", "FileSystemGetFileOptions", "FileSystemWritableFileStream",- "WritableStream", "File", "FileList", "Blob", "BlobPropertyBag", "Url", "HtmlAnchorElement", "HtmlInputElement", "Storage",+ "WritableStream", "File", "FileList", "Blob", "BlobPropertyBag", "Url", "HtmlAnchorElement", "HtmlInputElement", "Storage", "StorageEvent","IdbFactory", "IdbDatabase", "IdbObjectStore", "IdbOpenDbRequest", "IdbRequest", "IdbTransaction", "IdbTransactionMode","Headers", "ReadableStream", "ReadableStreamDefaultReader","BeforeUnloadEvent", "Event", "EventTarget", "KeyboardEvent", "Response", "FormData", "RequestInit", "MediaQueryList", "Gamepad", "Performance",diff --git a/apps/solidcraft-web/src/main.rs b/apps/solidcraft-web/src/main.rsindex 403898f5fc..08443ca6a2 100644--- a/apps/solidcraft-web/src/main.rs+++ b/apps/solidcraft-web/src/main.rs@@ -119,6 +119,43 @@ fn closes_design(key: &str, command: bool, shift: bool, alt: bool, design_shown:design_shown && command && !shift && !alt && key.eq_ignore_ascii_case("w")}+/// The settings a tab last wrote to the browser's storage, or loaded from another tab (#8644).+/// Every open tab of the app shares that storage, and eframe saves each tab's whole copy every+/// 30 s and when the page loses focus, so a tab still holding old settings put them back over a+/// change made in another. A change is now written in the frame it is made, and the other tabs+/// load it ([`settings_written`]).+#[cfg(any(target_arch = "wasm32", test))]+#[derive(Default, Debug)]+struct PrefsWriter {+ written: Option<String>,+}++#[cfg(any(target_arch = "wasm32", test))]+impl PrefsWriter {+ /// `prefs` if they are not the settings written or loaded last (they count as written from+ /// now on).+ fn take(&mut self, prefs: String) -> Option<String> {+ if self.written.as_deref() == Some(prefs.as_str()) {+ return None;+ }+ self.written = Some(prefs.clone());+ Some(prefs)+ }++ /// The settings the tab holds after loading another tab's: the tab doesn't write them back.+ fn loaded(&mut self, prefs: String) {+ self.written = Some(prefs);+ }+}++/// The settings another tab wrote, from a `storage` event (the browser sends one to every other+/// tab of the page when one tab writes). Other keys, and settings taken away (clearing the site's+/// data), leave this tab's settings as they are.+#[cfg(any(target_arch = "wasm32", test))]+fn settings_written(key: Option<&str>, value: Option<String>) -> Option<String> {+ value.filter(|_| key == Some(solidcraft_ui_egui::prefs::STORAGE_KEY))+}+#[cfg(target_arch = "wasm32")]mod web {use std::rc::Rc;@@ -217,6 +254,24 @@ mod web {on_key.forget();}+ /// Settings another tab wrote, waiting for this tab's next frame (#8644).+ type PrefsInbox = Rc<std::cell::Cell<Option<String>>>;++ /// Settings another tab of the app writes go to `inbox`, and this tab draws a frame, which+ /// loads them.+ fn hear_settings_from_other_tabs(window: &web_sys::Window, ctx: &egui::Context, inbox: PrefsInbox) {+ let ctx = ctx.clone();+ let on_storage = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::StorageEvent)>::new(move |e: web_sys::StorageEvent| {+ if let Some(prefs) = crate::settings_written(e.key().as_deref(), e.new_value()) {+ inbox.set(Some(prefs));+ ctx.request_repaint();+ }+ });+ let _ = window.add_event_listener_with_callback("storage", on_storage.as_ref().unchecked_ref());+ // The listener lives as long as the page.+ on_storage.forget();+ }+const JAPANESE_FONT_PATH: &str = "./fonts/BIZUDPGothic-Regular.ttf";type FontLoadResult = Rc<std::cell::RefCell<Option<Result<Vec<u8>, String>>>>;@@ -246,9 +301,48 @@ mod web {font_language: String,space_mouse: SpaceMouse,wheel_gestures: solidcraft_ui_egui::WebWheelGestures,+ /// The settings this tab wrote or loaded last, and those another tab wrote since (#8644).+ prefs_writer: crate::PrefsWriter,+ other_tab_prefs: PrefsInbox,}impl Shell {+ /// The settings as they are kept between visits: with the user's own language, not a+ /// session-only English fallback.+ fn persisted_prefs(&mut self) -> String {+ let saved = self.font.persisted_language(&self.app.preferences.language).to_owned();+ let live = std::mem::replace(&mut self.app.preferences.language, saved);+ let prefs = self.app.prefs();+ self.app.preferences.language = live;+ prefs+ }++ /// A settings change goes to the browser's storage in the frame it is made, and from+ /// there to the other open tabs (#8644). Input is what changes settings, so a frame+ /// without any is skipped; eframe's own save still catches anything else.+ fn store_prefs(&mut self, ctx: &egui::Context) {+ if !self.launch.persists() || ctx.input(|i| i.events.is_empty()) {+ return;+ }+ let prefs = self.persisted_prefs();+ let Some(prefs) = self.prefs_writer.take(prefs) else { return };+ let stored =+ web_sys::window().and_then(|w| w.local_storage().ok().flatten()).map(|s| s.set_item(solidcraft_ui_egui::prefs::STORAGE_KEY, &prefs));+ if !matches!(stored, Some(Ok(()))) {+ log::warn!("settings: the browser's storage did not take them; they are saved again later");+ self.prefs_writer = crate::PrefsWriter::default();+ }+ }++ /// Settings another tab wrote replace this tab's, so this tab's own saves keep them+ /// instead of putting its older copy back (#8644).+ fn load_other_tabs_prefs(&mut self) {+ let Some(prefs) = self.other_tab_prefs.take() else { return };+ self.app.load_prefs(&prefs);+ let held = self.persisted_prefs();+ self.prefs_writer.loaded(held);+ }+/// Files from the computer, writes to store, messages and the autosave.fn files_tick(&mut self, ctx: &egui::Context) {if !self.launch.persists() {@@ -647,6 +741,8 @@ mod web {impl eframe::App for Shell {fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {+ // First: a language another tab chose fetches its font this frame.+ self.load_other_tabs_prefs();self.tick_font(ctx);self.app.logic(ctx);self.api.poll();@@ -689,6 +785,7 @@ mod web {self.recovery_prompt(&ctx);}self.watch_text_for_font(&ctx);+ self.store_prefs(&ctx);}fn persist_egui_memory(&self) -> bool {self.launch.persists()@@ -697,11 +794,8 @@ mod web {if !self.launch.persists() {return;}- // Persist the user's own language, not a session-only English fallback.- let saved = self.font.persisted_language(&self.app.preferences.language).to_owned();- let live = std::mem::replace(&mut self.app.preferences.language, saved);- storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, self.app.prefs());- self.app.preferences.language = live;+ let prefs = self.persisted_prefs();+ storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, prefs);}}@@ -822,6 +916,12 @@ mod web {let (sender, receiver) = std::sync::mpsc::channel();let mut app = SolveApp::new(Session::default(), services).with_control(receiver);app.embedded = launch.embed;+ // Listening before reading: settings another tab writes from now on are+ // newer than those read here.+ let other_tab_prefs = PrefsInbox::default();+ if launch.persists() {+ hear_settings_from_other_tabs(&window, &cc.egui_ctx, other_tab_prefs.clone());+ }if launch.persists() && let Some(p) = cc.storage.and_then(|s| solidcraft_ui_egui::prefs::stored(|k| s.get_string(k))) {app.load_prefs(&p);}@@ -865,6 +965,8 @@ mod web {font_language,space_mouse: SpaceMouse::default(),wheel_gestures: solidcraft_ui_egui::WebWheelGestures::default(),+ prefs_writer: crate::PrefsWriter::default(),+ other_tab_prefs,}))}),)@@ -1001,4 +1103,28 @@ mod tests {assert!(!closes_design("w", false, false, false, true));assert!(!closes_design("s", true, false, false, true));}++ /// A tab writes its settings when they change, and not again while they stay the same; the+ /// settings it loaded from another tab aren't written back (#8644).+ #[test]+ fn changed_settings_are_written_once_and_loaded_ones_not_at_all() {+ let mut writer = PrefsWriter::default();+ assert_eq!(writer.take(r#"{"a":1}"#.into()).as_deref(), Some(r#"{"a":1}"#), "the first settings are written");+ assert_eq!(writer.take(r#"{"a":1}"#.into()), None, "the same settings are not written again");+ assert_eq!(writer.take(r#"{"a":2}"#.into()).as_deref(), Some(r#"{"a":2}"#), "a change is written at once");+ writer.loaded(r#"{"a":3}"#.into());+ assert_eq!(writer.take(r#"{"a":3}"#.into()), None, "settings from another tab are not written back");+ assert_eq!(writer.take(r#"{"a":4}"#.into()).as_deref(), Some(r#"{"a":4}"#), "this tab's next change is written");+ }++ /// Only the settings another tab wrote are loaded: not other keys, and not settings taken+ /// away by clearing the site's data (#8644).+ #[test]+ fn only_settings_another_tab_wrote_are_loaded() {+ let key = solidcraft_ui_egui::prefs::STORAGE_KEY;+ assert_eq!(settings_written(Some(key), Some("{}".into())).as_deref(), Some("{}"));+ assert_eq!(settings_written(Some("solidcraft.webgl"), Some("1".into())), None);+ assert_eq!(settings_written(Some(key), None), None, "removed settings leave this tab's");+ assert_eq!(settings_written(None, None), None, "clearing all storage leaves this tab's settings");+ }}diff --git a/crates/ui-egui/src/prefs.rs b/crates/ui-egui/src/prefs.rsindex 25665accfb..a0f5d73dc1 100644--- a/crates/ui-egui/src/prefs.rs+++ b/crates/ui-egui/src/prefs.rs@@ -5069,6 +5069,30 @@ mod tests {assert_eq!(app.preferences.ui_font, "");}+ /// The web app's open tabs share their settings (#8644): a running tab loads what another+ /// tab wrote over settings of its own. Everything it had changed is replaced, a pin or a+ /// shortcut the other tab doesn't have included, so both tabs then save the same settings.+ #[test]+ fn settings_loaded_over_changed_ones_replace_them_all() {+ let new_app = || crate::SolveApp::new(solidcraft_engine::Session::default(), crate::Services::default());+ let mut writer = new_app();+ writer.sbox.toggle_pin("sketch.line");+ writer.ui.dark = !writer.ui.dark;+ writer.keymap.custom.insert("view.fit".into(), vec!["Shift+F".into()]);+ let mut reader = new_app();+ reader.sbox.toggle_pin("feature.extrude");+ reader.keymap.custom.insert("view.home".into(), vec!["H".into()]);+ reader.toolbar_custom.panels.insert(format!("{}/SOLID/CREATE", crate::toolbar_custom::WORKSPACE), vec!["feature.extrude".into()]);+ reader.tree.collapsed.insert("Bodies".into());+ reader.home.recent.push("part.solidcraft".into());+ reader.preferences.ui_scale = 1.5;+ reader.load_prefs(&writer.prefs());+ assert_eq!(reader.sbox.pinned, ["sketch.line"], "the other tab's pins, not this tab's");+ assert!(!reader.keymap.custom.contains_key("view.home"));+ assert_eq!(reader.ui.dark, writer.ui.dark);+ assert_eq!(reader.prefs(), writer.prefs(), "both tabs save the same settings");+ }+/// Bodies folders (#4217): Several bodies only by default, also in preferences saved before it/// existed. Each value is saved and read back; `ui.prefs` refuses anything else and changes/// nothing, and saved preferences read such a value as the default and keep the rest. The