SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Settings: saved to disk as soon as they change, not only when the app closes normally (#8275) (#9711)
PaddleStrokeb8eb8d262c36
diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rsindex 3d18f9e936..39f9e6d0a1 100644--- a/apps/solidcraft/src/main.rs+++ b/apps/solidcraft/src/main.rs@@ -99,6 +99,86 @@ struct App {nav_bridge: nav_bridge::NavBridge,/// Where the next file dialog opens: it follows the open design (#7756).dialog_folder: DialogFolder,+ /// Settings go to `app.ron` in the frame they change (#8275).+ prefs_writer: PrefsWriter,+}++/// Settings written to the settings file soon after they change (#8275). eframe saves them+/// only every 30 s and when the window closes normally, so a change was lost whenever the app+/// did not get that far: ended from the Task Manager, stopped by a sign-out or shutdown, or+/// crashed or hung in the graphics driver on the way out.+///+/// Some settings change continuously (a panel's width while its edge is dragged), so the file+/// is written at most once per [`PrefsWriter::INTERVAL`], and a change made in between is written+/// when that interval ends.+#[derive(Default)]+struct PrefsWriter {+ /// The settings written (or read at start) last.+ written: Option<String>,+ /// The previous frame had input that can change settings: what it changed shows in this+ /// frame's settings.+ input_before: bool,+ /// When the settings were last written by this writer.+ last_write: Option<std::time::Instant>,+ /// A change waits until then to be written.+ pending_until: Option<std::time::Instant>,+}++impl PrefsWriter {+ /// The least time between two writes of the settings file.+ const INTERVAL: std::time::Duration = std::time::Duration::from_secs(1);++ /// The settings as they were read at start: they are on disk already.+ fn read(prefs: String) -> Self {+ Self { written: Some(prefs), ..Self::default() }+ }++ /// Whether this frame's settings are worth comparing: input that can change them came in this+ /// frame or the one before, or a waiting change's time has come. Pointer motion alone isn't+ /// such input; eframe's own save still catches anything else.+ fn due(&mut self, input: bool, now: std::time::Instant) -> bool {+ let due = input || self.input_before || self.pending_until.is_some_and(|at| now >= at);+ self.input_before = input;+ due+ }++ /// Write `prefs` and flush them to disk if they differ from the settings written last and the+ /// last write is at least [`Self::INTERVAL`] old. Returns how long a change waits otherwise:+ /// the caller asks for a frame then, so an idle app still writes it.+ fn store(&mut self, storage: &mut dyn eframe::Storage, prefs: String, now: std::time::Instant) -> Option<std::time::Duration> {+ if self.written.as_deref() == Some(prefs.as_str()) {+ self.pending_until = None;+ return None;+ }+ if let Some(wait) = self.last_write.map(|at| Self::INTERVAL.saturating_sub(now.saturating_duration_since(at))).filter(|w| !w.is_zero()) {+ self.pending_until = Some(now + wait);+ return Some(wait);+ }+ storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, prefs.clone());+ storage.flush();+ self.written = Some(prefs);+ self.last_write = Some(now);+ self.pending_until = None;+ None+ }+}++/// Input that can change a setting: a click, a key, typed or pasted text, a wheel or a pinch.+/// Pointer motion, which comes every frame while the mouse moves, cannot by itself.+fn changes_settings(event: &egui::Event) -> bool {+ matches!(+ event,+ egui::Event::PointerButton { .. }+ | egui::Event::Key { .. }+ | egui::Event::Text(_)+ | egui::Event::Paste(_)+ | egui::Event::Cut+ | egui::Event::Ime(_)+ | egui::Event::MouseWheel { .. }+ | egui::Event::Zoom(_)+ | egui::Event::Rotate(_)+ | egui::Event::AccessKitActionRequest(_)+ )}impl eframe::App for App {@@ -186,11 +266,21 @@ impl eframe::App for App {solidcraft_ui_egui::space_mouse::buttons_hook(&mut self.solve, ctx, self.space_mouse.buttons(), raw);self.solve.raw_input_hook(raw);}- fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {+ fn ui(&mut self, ui: &mut egui::Ui, frame: &mut eframe::Frame) {content_ui(&mut self.solve, ui);+ // After the frame's UI, so a setting changed in it (Preferences' OK) is written now.+ let now = std::time::Instant::now();+ if self.prefs_writer.due(ui.input(|i| i.events.iter().any(changes_settings)), now)+ && let Some(storage) = frame.storage_mut()+ && let Some(wait) = self.prefs_writer.store(storage, self.solve.prefs(), now)+ {+ ui.ctx().request_repaint_after(wait);+ }}fn save(&mut self, storage: &mut dyn eframe::Storage) {- storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, self.solve.prefs());+ let prefs = self.solve.prefs();+ storage.set_string(solidcraft_ui_egui::prefs::STORAGE_KEY, prefs.clone());+ self.prefs_writer.written = Some(prefs);}fn on_exit(&mut self) {// The agent chat's agent and everything it started end with the app.@@ -1122,6 +1212,8 @@ fn main() -> eframe::Result {mark("app created");solidcraft_engine::crash::phase("first frame");Ok(Box::new(App {+ // Before `app` moves: the settings as read, already on disk.+ prefs_writer: PrefsWriter::read(app.prefs()),solve: app,starting,frames: 0,@@ -1315,6 +1407,132 @@ mod backend_tests {}}+#[cfg(test)]+mod prefs_writer_tests {+ use super::PrefsWriter;+ use solidcraft_ui_egui::prefs::{NavigatorStyle, STORAGE_KEY};+ use std::collections::HashMap;+ use std::time::{Duration, Instant};++ /// eframe's settings file: what was flushed to disk is what the next start reads.+ #[derive(Default)]+ struct Disk {+ pending: HashMap<String, String>,+ flushed: HashMap<String, String>,+ flushes: usize,+ }++ impl eframe::Storage for Disk {+ fn get_string(&self, key: &str) -> Option<String> {+ self.pending.get(key).cloned()+ }+ fn set_string(&mut self, key: &str, value: String) {+ self.pending.insert(key.into(), value);+ }+ fn remove_string(&mut self, key: &str) {+ self.pending.remove(key);+ }+ fn flush(&mut self) {+ self.flushed = self.pending.clone();+ self.flushes += 1;+ }+ }++ fn new_app() -> solidcraft_ui_egui::SolveApp {+ solidcraft_ui_egui::SolveApp::new(solidcraft_engine::Session::default(), solidcraft_ui_egui::Services::default())+ }++ /// #8275: Preferences' View navigator and Display quality, changed and confirmed, are on disk+ /// in that frame, so the next start has them even when this one never closes normally (ended+ /// from the Task Manager, a sign-out, a hang or crash in the graphics driver on the way out).+ #[test]+ fn changed_settings_reach_the_disk_in_the_frame_they_change() {+ let mut app = new_app();+ let mut disk = Disk::default();+ let mut writer = PrefsWriter::read(app.prefs());+ let now = Instant::now();+ assert_eq!(writer.store(&mut disk, app.prefs(), now), None);+ assert_eq!(disk.flushes, 0, "the settings read at start are not written again");+ app.preferences.navigator_style = NavigatorStyle::Cube;+ app.preferences.display_quality = "fine".into();+ assert!(writer.due(true, now), "a frame with input is checked");+ assert_eq!(writer.store(&mut disk, app.prefs(), now), None);+ assert_eq!(disk.flushes, 1, "flushed at once, not left for eframe's next save");+ assert_eq!(writer.store(&mut disk, app.prefs(), now + Duration::from_secs(5)), None);+ assert_eq!(disk.flushes, 1, "unchanged settings are not written again");++ // The next start reads them.+ let mut next = new_app();+ let stored = solidcraft_ui_egui::prefs::stored(|k| disk.flushed.get(k).cloned()).expect("settings on disk");+ next.load_prefs(&stored);+ assert_eq!(next.preferences.navigator_style, NavigatorStyle::Cube);+ assert_eq!(next.preferences.display_quality, "fine");+ assert!(disk.flushed.contains_key(STORAGE_KEY));+ }++ /// A frame without input is checked only right after one with input (whose clicks the UI+ /// handled in that frame); after that, idle frames cost nothing. Pointer motion, which comes+ /// every frame while the mouse moves, doesn't count as input.+ #[test]+ fn frames_are_checked_with_input_and_once_after_it() {+ let now = Instant::now();+ let mut writer = PrefsWriter::default();+ assert!(!writer.due(false, now));+ assert!(writer.due(true, now));+ assert!(writer.due(false, now), "the frame after input");+ assert!(!writer.due(false, now));++ let click = egui::Event::PointerButton {+ pos: egui::Pos2::ZERO,+ button: egui::PointerButton::Primary,+ pressed: false,+ modifiers: egui::Modifiers::NONE,+ };+ assert!(super::changes_settings(&click));+ assert!(super::changes_settings(&egui::Event::Text("5".into())));+ assert!(!super::changes_settings(&egui::Event::PointerMoved(egui::Pos2::ZERO)));+ assert!(!super::changes_settings(&egui::Event::MouseMoved(egui::Vec2::X)));+ }++ /// A setting that changes in every frame (a panel's width while its edge is dragged) doesn't+ /// write the file in every frame: at most once a second, and the last change is on disk at+ /// most a second after it was made, with a frame asked for then so an idle app writes it.+ #[test]+ fn a_continuous_change_is_written_once_a_second_and_its_end_soon_after() {+ let mut app = new_app();+ let mut disk = Disk::default();+ let mut writer = PrefsWriter::read(app.prefs());+ let start = Instant::now();+ let frame = Duration::from_millis(16);+ let mut asked = None;+ // 1.5 s of dragging at 60 frames a second, with input in every frame.+ for n in 0..94u32 {+ let now = start + frame * n;+ app.preferences.browser_width = 200.0 + n as f32;+ assert!(writer.due(true, now));+ asked = writer.store(&mut disk, app.prefs(), now);+ }+ assert_eq!(disk.flushes, 2, "the first change at once, then one a second later");+ let wait = asked.expect("the last width waits, and a frame is asked for when it can be written");+ assert!(wait <= PrefsWriter::INTERVAL);++ // The drag ends: no more input. Frames before the wait is over don't even look.+ let end = start + frame * 93;+ assert!(writer.due(false, end + frame), "the frame right after input");+ assert!(!writer.due(false, end + frame * 2), "an idle frame before the wait is over");+ // The frame asked for writes the last width.+ let then = end + wait;+ assert!(writer.due(false, then));+ assert_eq!(writer.store(&mut disk, app.prefs(), then), None);+ assert_eq!(disk.flushes, 3);+ let mut next = new_app();+ let stored = solidcraft_ui_egui::prefs::stored(|k| disk.flushed.get(k).cloned()).expect("settings on disk");+ next.load_prefs(&stored);+ assert_eq!(next.preferences.browser_width, 293.0, "the width the drag ended at");+ assert!(!writer.due(false, then + frame), "nothing waits any more");+ }+}+#[cfg(test)]mod dialog_folder_tests {use super::DialogFolder;