SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Timeline marker, undo and redo compute off the window thread (#1675)
phanoobd5640b5efbd9
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rsindex c75ba9991b..d714352cb3 100644--- a/crates/engine/src/lib.rs+++ b/crates/engine/src/lib.rs@@ -156,6 +156,16 @@ pub struct Snapshot {pub pending_moves: std::collections::BTreeMap<u64, solidcraft_doc::Mat>,}+/// A copy of a session that evaluates commands ahead of it ([`Session::ahead`]).+pub struct Ahead(Session);++impl Ahead {+ /// Run `commands` (their results stay in the shared evaluation cache).+ pub fn evaluate(self, commands: &[(String, Value)]) -> Result<()> {+ self.0.preview_in_place(commands).map(|_| ())+ }+}+/// What some commands would make, evaluated on a scratch copy of a session/// ([`Session::preview`]). The session itself is not changed.#[derive(Clone, Debug)]@@ -887,6 +897,17 @@ impl Session {self.scratch().preview_in_place(commands).map(|(after, replies)| Preview { before: visible(self), after: visible(&after), replies })}+ /// Run `commands` on a [`Session::scratch`] copy that keeps the undo and redo stacks: what+ /// they evaluate lands in the evaluation cache the copy shares with this session, so running+ /// them here afterwards finds it there. For a front end that computes a command which may+ /// take a while (undo, the history marker moved) off its window thread first.+ pub fn ahead(&self) -> Ahead {+ let mut copy = self.scratch();+ copy.undo.clone_from(&self.undo);+ copy.redo.clone_from(&self.redo);+ Ahead(copy)+ }+fn preview_in_place(mut self, commands: &[(String, Value)]) -> Result<(Self, Vec<Value>)> {if commands.is_empty() {return Err(EngineError::Other("nothing to preview".into()));diff --git a/crates/ui-egui/src/deferred.rs b/crates/ui-egui/src/deferred.rsnew file mode 100644index 0000000000..382e957e87--- /dev/null+++ b/crates/ui-egui/src/deferred.rs@@ -0,0 +1,123 @@+//! Commands that recompute the history, computed off the window thread as OK is (#1201): the+//! history marker dragged or clicked, a feature suppressed, reordered or deleted from the+//! timeline, undo and redo, the marker put back after a sketch. On a part with a slow feature+//! after the marker (a line of text cut into a block), each of these ran that feature's boolean+//! on the window thread, and the window froze until it was done.+//!+//! The command is evaluated on a copy of the session ([`solidcraft_engine::Session::ahead`]),+//! which leaves what it computes in the evaluation cache the session shares. Done within the+//! app's wait ([`crate::dialogs::APPLY_AT_ONCE`]), the command just runs; otherwise the window+//! goes on, saying it computes, and the command runs for real once the evaluation is in, finding+//! its features in the cache. Commands asked for meanwhile wait their turn; a marker moved again+//! replaces the move still waiting, so a drag computes where it ends rather than every slot it+//! crossed.++use serde_json::Value;++use crate::SolveApp;++/// A command computing off the window thread.+pub struct Deferred {+ done: std::sync::mpsc::Receiver<()>,+ /// When it started (ms).+ pub(crate) started: f64,+ command: (String, Value),+ /// The design's revision it was computed for: a design changed meanwhile computes it again.+ revision: u64,+}++impl Deferred {+ fn finished(&self) -> bool {+ !matches!(self.done.try_recv(), Err(std::sync::mpsc::TryRecvError::Empty))+ }+}++/// Commands a later one of the same kind replaces while they wait: where the marker ends is all+/// that counts.+fn replaced_by_a_later_one(id: &str) -> bool {+ id == "timeline.roll_to"+}++impl SolveApp {+ /// Run a command that may recompute much of the history, off the window thread when it takes+ /// a while (see the module notes). `Ok(Null)` when it is left computing or waiting its turn:+ /// its outcome then shows as any command's does (an error in the status line).+ pub fn run_heavy(&mut self, id: &str, params: Value) -> Result<Value, String> {+ if self.deferred.is_some() {+ if replaced_by_a_later_one(id) && self.deferred_queue.last().is_some_and(|(q, _)| q == id) {+ self.deferred_queue.pop();+ }+ self.deferred_queue.push((id.to_string(), params));+ return Ok(Value::Null);+ }+ match self.begin_deferred(id, ¶ms) {+ Some(job) => {+ self.deferred = Some(job);+ Ok(Value::Null)+ }+ None => self.run(id, params),+ }+ }++ /// Since when a command has been computing off the window thread (ms), if one is.+ pub fn computing_since(&self) -> Option<f64> {+ self.deferred.as_ref().map(|d| d.started)+ }++ /// Each frame: a command whose evaluation is in runs, then the next one waiting starts.+ pub(crate) fn poll_deferred(&mut self, ctx: &egui::Context) {+ if let Some(job) = &self.deferred {+ if !job.finished() {+ ctx.request_repaint_after(std::time::Duration::from_millis(100));+ return;+ }+ if let Some(job) = self.deferred.take() {+ let (id, params) = job.command;+ let superseded = replaced_by_a_later_one(&id) && self.deferred_queue.first().is_some_and(|(q, _)| *q == id);+ if job.revision != self.session.revision {+ // The design changed meanwhile: computed again for the design as it is now.+ let _ = self.run_heavy(&id, params);+ } else if !superseded {+ let _ = self.run(&id, params);+ }+ }+ }+ if self.deferred.is_none() && !self.deferred_queue.is_empty() {+ let (id, params) = self.deferred_queue.remove(0);+ let _ = self.run_heavy(&id, params);+ }+ }++ /// Start evaluating a command ahead. `None` when it should just run: not asked for+ /// ([`SolveApp::apply_off_thread`]), a file operation in progress, no threads (the web), or+ /// done within the wait.+ #[cfg(not(target_arch = "wasm32"))]+ fn begin_deferred(&self, id: &str, params: &Value) -> Option<Deferred> {+ let wait = self.apply_off_thread?;+ if self.file_load.busy() || self.file_picker.is_some() {+ return None;+ }+ let ahead = self.session.ahead();+ let command = (id.to_string(), params.clone());+ let commands = vec![command.clone()];+ let (tx, rx) = std::sync::mpsc::channel();+ std::thread::Builder::new()+ .name("history".into())+ .spawn(move || {+ let _ = ahead.evaluate(&commands);+ let _ = tx.send(());+ })+ .ok()?;+ match rx.recv_timeout(wait) {+ Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {+ Some(Deferred { done: rx, started: crate::now_ms(), command, revision: self.session.revision })+ }+ _ => None,+ }+ }++ #[cfg(target_arch = "wasm32")]+ fn begin_deferred(&self, _id: &str, _params: &Value) -> Option<Deferred> {+ None+ }+}diff --git a/crates/ui-egui/src/history_off_thread_tests.rs b/crates/ui-egui/src/history_off_thread_tests.rsnew file mode 100644index 0000000000..99f98a7736--- /dev/null+++ b/crates/ui-egui/src/history_off_thread_tests.rs@@ -0,0 +1,100 @@+//! Commands that recompute the history off the window thread (`deferred`): the marker moved,+//! undo, each computed beside the window and run once in; a marker moved again while one move+//! computes replaces the move still waiting.++use std::time::Duration;++use serde_json::json;++use crate::scenario::Harness;++/// A 60 × 20 × 10 block, a 10 × 10 × 5 boss on it, and a 4 mm hole through the boss, the+/// marker at the end. Every command computes off the window thread (no wait at all).+fn block_boss_hole() -> Harness {+ let mut h = Harness::new();+ h.app.home.open = false;+ for (id, p) in [+ ("solid.box", json!({"length": 60, "width": 20, "height": 10})),+ ("solid.box", json!({"corner": [5, 5, 10], "length": 10, "width": 10, "height": 5, "operation": "join"})),+ ("solid.cylinder", json!({"base": [10, 10, -1], "axis": [0, 0, 1], "radius": 2, "height": 20, "operation": "cut"})),+ ] {+ h.app.run(id, p).unwrap();+ }+ h.app.apply_off_thread = Some(Duration::ZERO);+ h+}++/// Frames until nothing computes or waits (a few seconds at most).+fn until_settled(h: &mut Harness) {+ for _ in 0..500 {+ if h.app.deferred.is_none() && h.app.deferred_queue.is_empty() {+ break;+ }+ h.frames(1);+ std::thread::sleep(Duration::from_millis(10));+ }+ h.frames(1);+}++fn marker(h: &Harness) -> Option<usize> {+ h.app.session.doc.marker+}++#[test]+fn the_marker_moved_computes_off_the_window_thread_then_moves() {+ let mut h = block_boss_hole();+ h.app.run_heavy("timeline.roll_to", json!({"position": 1})).unwrap();+ assert!(h.app.computing_since().is_some(), "computing");+ assert_eq!(marker(&h), None, "the design is as it was while it computes");+ until_settled(&mut h);+ assert_eq!(marker(&h), Some(1));+ h.step(&json!({"expect": {"volume": 12000}})).unwrap();+ // And back to the end, the boss and the hole recomputed (or found in the cache).+ h.app.run_heavy("timeline.roll_to", json!({})).unwrap();+ until_settled(&mut h);+ assert_eq!(marker(&h), None);+ let hole = std::f64::consts::PI * 4.0 * 15.0;+ let v = h.app.run("inspect.measure", json!({})).unwrap()["total"]["volume_mm3"].as_f64().unwrap();+ assert!((v - (12500.0 - hole)).abs() < 1.0, "{v}");+}++#[test]+fn a_marker_moved_again_replaces_the_move_still_waiting() {+ let mut h = block_boss_hole();+ h.app.run_heavy("timeline.roll_to", json!({"position": 1})).unwrap();+ assert!(h.app.computing_since().is_some());+ // A drag: two more slots while the first computes. Only the last one waits.+ h.app.run_heavy("timeline.roll_to", json!({"position": 2})).unwrap();+ h.app.run_heavy("timeline.roll_to", json!({"position": 3})).unwrap();+ assert_eq!(h.app.deferred_queue.len(), 1, "{:?}", h.app.deferred_queue);+ until_settled(&mut h);+ assert_eq!(marker(&h), None, "where the drag ended: the end of the history");+}++#[test]+fn undo_computes_off_the_window_thread() {+ let mut h = block_boss_hole();+ let features = h.app.session.doc.features.len();+ h.app.start("edit.undo");+ assert!(h.app.computing_since().is_some(), "undo computing");+ assert_eq!(h.app.session.doc.features.len(), features, "nothing undone yet");+ until_settled(&mut h);+ assert_eq!(h.app.session.doc.features.len(), features - 1, "the hole undone");+ h.step(&json!({"expect": {"volume": 12500}})).unwrap();+ h.app.start("edit.redo");+ until_settled(&mut h);+ assert_eq!(h.app.session.doc.features.len(), features, "and redone");+}++#[test]+fn a_design_changed_while_a_move_computes_is_computed_again() {+ let mut h = block_boss_hole();+ h.app.run_heavy("timeline.roll_to", json!({"position": 2})).unwrap();+ assert!(h.app.computing_since().is_some());+ // Something else changes the design meanwhile (a command that just runs).+ h.app.run("solid.box", json!({"corner": [40, 5, 10], "length": 5, "width": 5, "height": 5, "operation": "join"})).unwrap();+ let revision = h.app.session.revision;+ until_settled(&mut h);+ assert!(h.app.session.revision > revision, "the move ran after the change");+ assert_eq!(marker(&h), Some(2));+}diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 8e5a2a439b..60aec6bf26 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -20,6 +20,7 @@ mod colour_vision_tests;pub mod context_menu;pub mod control;pub mod crash_ui;+pub mod deferred;pub mod delete;pub mod design_properties;pub mod dialogs;@@ -97,6 +98,8 @@ mod expression_complete;mod extrude_edit_tests;mod file_load;mod file_picker;+#[cfg(test)]+mod history_off_thread_tests;pub use file_picker::FilePickerFuture;#[cfg(test)]mod blend_arrow_tests;@@ -321,6 +324,10 @@ pub struct SolveApp {pub preview: preview::PreviewState,/// OK pressed on a feature that takes a while: its evaluation runs off the window thread.pub applying: Option<dialogs::Applying>,+ /// A command recomputing the history (the marker moved, undo) computing off the window+ /// thread, and those asked for meanwhile ([`deferred`]).+ pub deferred: Option<deferred::Deferred>,+ pub deferred_queue: Vec<(String, Value)>,/// How long OK waits for a feature before computing it off the window thread, saying so;/// `None`: it waits as long as it takes (headless use, tests). The desktop app sets it.pub apply_off_thread: Option<std::time::Duration>,@@ -435,6 +442,8 @@ impl SolveApp {slicer_menu: dialogs_save_mesh::SlicerMenu::default(),preview: preview::PreviewState::default(),applying: None,+ deferred: None,+ deferred_queue: Vec::new(),apply_off_thread: None,last_command: None,esc_handled: false,@@ -843,6 +852,11 @@ impl SolveApp {self.dialog = Some(d);return;}+ // Undo and redo can recompute much of the history: off the window thread when slow.+ if matches!(id, "edit.undo" | "edit.redo") {+ let _ = self.run_heavy(id, json!({}));+ return;+ }let _ = self.run(id, json!({}));}@@ -928,7 +942,9 @@ impl SolveApp {}fn restore_marker(&mut self, marker: Option<usize>) {- let _ = self.run("timeline.roll_to", marker.map(|m| json!({ "position": m })).unwrap_or_else(|| json!({})));+ // Rolling forward past the features after the sketch recomputes them (an edited sketch+ // under a text cut): off the window thread when it takes a while.+ let _ = self.run_heavy("timeline.roll_to", marker.map(|m| json!({ "position": m })).unwrap_or_else(|| json!({})));}/// Everything shown as selected: the selection plus the open dialog's inputs.@@ -1320,6 +1336,7 @@ impl SolveApp {fn cad_ui(&mut self, ui: &mut egui::Ui, report_input: &mut Option<issue_report::CadInput>) {scenario::clear_handles();+ self.poll_deferred(ui.ctx());toolbar::app_bar(self, ui);issue_report::CadInput::block(self, ui, report_input);file_load::show(self, ui.ctx());diff --git a/crates/ui-egui/src/timeline.rs b/crates/ui-egui/src/timeline.rsindex 4e7fccd269..867f4d8363 100644--- a/crates/ui-egui/src/timeline.rs+++ b/crates/ui-egui/src/timeline.rs@@ -81,7 +81,7 @@ pub(crate) fn delete_features(app: &mut SolveApp, ids: Vec<u64>) {}}if with.is_empty() && fail.is_empty() {- let _ = app.run("timeline.delete", json!({ "features": ids }));+ let _ = app.run_heavy("timeline.delete", json!({ "features": ids }));} else {app.dialog = Some(crate::dialogs::Dialog::confirm_delete_many(ids, with.into_iter().collect(), fail.into_iter().collect()));}@@ -192,7 +192,7 @@ pub fn timeline(app: &mut SolveApp, ui: &mut egui::Ui) {Some(k) if k < n => json!({"position": k}),_ => json!({}),};- let _ = app.run("timeline.roll_to", pos);+ let _ = app.run_heavy("timeline.roll_to", pos);}x += 24.0;}@@ -341,11 +341,11 @@ pub fn timeline(app: &mut SolveApp, ui: &mut egui::Ui) {ui.close();}if ui.button(if *suppressed { "Unsuppress Features" } else { "Suppress Features" }).clicked() {- let _ = app.run("timeline.suppress", json!({"feature": id}));+ let _ = app.run_heavy("timeline.suppress", json!({"feature": id}));ui.close();}if ui.button(crate::i18n::tr_label("Roll History Marker Here")).clicked() {- let _ = app.run("timeline.roll_to", json!({ "feature": id }));+ let _ = app.run_heavy("timeline.roll_to", json!({ "feature": id }));ui.close();}if ui.button(crate::i18n::tr_label("Find in Browser")).clicked() {@@ -398,14 +398,14 @@ pub fn timeline(app: &mut SolveApp, ui: &mut egui::Ui) {let slot = slot_at(&xs, end, pp.x);match dg {Drag::Marker => {- let _ = app.run("timeline.roll_to", if slot >= n { json!({}) } else { json!({ "position": slot }) });+ let _ = app.run_heavy("timeline.roll_to", if slot >= n { json!({}) } else { json!({ "position": slot }) });}Drag::Feature(id) => {let from = app.session.doc.feature_index(id).unwrap_or(0);// Dropping after itself means the slot shifts by one.let to = if slot > from { slot - 1 } else { slot };if to != from {- let _ = app.run("timeline.reorder", json!({ "feature": id, "position": to }));+ let _ = app.run_heavy("timeline.reorder", json!({ "feature": id, "position": to }));}}}diff --git a/crates/ui-egui/src/timeline_left.rs b/crates/ui-egui/src/timeline_left.rsindex 51e1f09a3a..3f88b81ac6 100644--- a/crates/ui-egui/src/timeline_left.rs+++ b/crates/ui-egui/src/timeline_left.rs@@ -117,7 +117,7 @@ fn timeline_transport(app: &mut SolveApp, ui: &mut egui::Ui) {Some(position) if position < n => json!({"position": position}),_ => json!({}),};- let _ = app.run("timeline.roll_to", params);+ let _ = app.run_heavy("timeline.roll_to", params);}}});@@ -794,11 +794,11 @@ fn vertical_features(app: &mut SolveApp, ui: &mut egui::Ui) {ui.close();}if ui.button(if *suppressed { "Unsuppress Feature" } else { "Suppress Feature" }).clicked() {- let _ = app.run("timeline.suppress", json!({"feature": id}));+ let _ = app.run_heavy("timeline.suppress", json!({"feature": id}));ui.close();}if ui.button("Roll Back Here").clicked() {- let _ = app.run("timeline.roll_to", json!({"feature": id}));+ let _ = app.run_heavy("timeline.roll_to", json!({"feature": id}));ui.close();}ui.separator();@@ -875,7 +875,7 @@ fn vertical_features(app: &mut SolveApp, ui: &mut egui::Ui) {{match active {Drag::Marker => {- let _ = app.run("timeline.roll_to", if slot.position >= n { json!({}) } else { json!({"position": slot.position}) });+ let _ = app.run_heavy("timeline.roll_to", if slot.position >= n { json!({}) } else { json!({"position": slot.position}) });}Drag::Items(items) => {let panel_left = ui.min_rect().left();diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rsindex 95eb6fdaea..e5d72eeafc 100644--- a/crates/ui-egui/src/viewport.rs+++ b/crates/ui-egui/src/viewport.rs@@ -2591,6 +2591,19 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui) {crate::select_other::show(app, ui.ctx());axis_view(app, ui, rect);nav_bar(app, ui, rect);+ // A command recomputing the history off the window thread (the marker moved, undo): the+ // window goes on, and says so above the status chip.+ if let Some(since) = app.computing_since() {+ let seconds = ((crate::now_ms() - since) / 1000.0).floor().max(0.0);+ let text = crate::i18n::format("dialog.computing", &[("seconds", &format!("{seconds:.0}"))]);+ let pos = pos2(rect.left() + 12.0, rect.bottom() - 76.0);+ let galley = painter.layout_no_wrap(text, FontId::proportional(12.5), t.text);+ let r = Rect::from_min_size(pos, galley.size() + vec2(34.0, 8.0));+ painter.rect_filled(r, 4.0, t.overlay);+ egui::Spinner::new().size(12.0).paint_at(ui, Rect::from_center_size(pos2(r.left() + 13.0, r.center().y), vec2(12.0, 12.0)));+ painter.galley(pos + vec2(26.0, 4.0), galley, t.text);+ ui.ctx().request_repaint_after(std::time::Duration::from_millis(100));+ }// Status chip.if let Some((msg, at, err)) = app.status.clone() {if crate::now_ms() - at < 6000.0 {