SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Report a bug: take the screenshot once the preview is done instead of giving up (#7171) (#7173)
semmelrinde95515ed2bfdb
diff --git a/crates/ui-egui/src/issue_report.rs b/crates/ui-egui/src/issue_report.rsindex 887cdb37ee..a8fbf276df 100644--- a/crates/ui-egui/src/issue_report.rs+++ b/crates/ui-egui/src/issue_report.rs@@ -104,9 +104,27 @@ impl Drop for CadInput {pub struct ReportState {pub draft: Option<Draft>,pending: Option<Pending>,+ /// A screenshot waiting for the preview being computed (#7171).+ waiting: Option<Waiting>,+ /// What was typed while a capture hid the report, for the form once it is back.+ held: Vec<egui::Event>,+ /// The report's field that had focus when a capture hid it.+ refocus: Option<egui::Id>,cad_focus: Option<egui::Id>,}+/// How long a screenshot waits for a preview being computed before it shows it unfinished.+const PREVIEW_WAIT_MS: f64 = 10_000.0;+/// Keystrokes kept while a capture hides the report.+const MAX_HELD: usize = 4096;++struct Waiting {+ deadline: f64,+ /// [`context_signature`] when it began: the preview it waits for belongs to the report+ /// unless the design, the dialog or the selection changed meanwhile.+ context: u64,+}+pub struct Draft {pub title: String,title_prefix: String,@@ -273,16 +291,29 @@ impl std::fmt::Write for Fingerprint {}}-fn source_signature(app: &SolveApp, dialog: Option<&dialogs::Dialog>) -> u64 {+/// What a report's context is drawn from: the design, the dialog and the selection.+fn context_signature(app: &SolveApp, dialog: Option<&dialogs::Dialog>) -> u64 {let mut h = Fingerprint(std::collections::hash_map::DefaultHasher::new());app.session.revision.hash(&mut h.0);app.docs.active.hash(&mut h.0);app.docs.count().hash(&mut h.0);app.session.doc.name.hash(&mut h.0);+ // What the dialog makes, not its state: a preview error it shows (a sketch fillet's) is often+ // what is being reported.+ if let Some(d) = dialog {+ let _ = write!(&mut h, "{:?}{:?}{:?}", d.kind, d.inputs, d.extra);+ }+ let _ = write!(&mut h, "{:?}", app.session.selection);+ h.0.finish()+}++/// [`context_signature`] and the preview shown with it.+fn source_signature(app: &SolveApp, dialog: Option<&dialogs::Dialog>) -> u64 {+ let mut h = Fingerprint(std::collections::hash_map::DefaultHasher::new());+ context_signature(app, dialog).hash(&mut h.0);app.preview.key.hash(&mut h.0);app.preview.error.hash(&mut h.0);app.preview.busy.hash(&mut h.0);- let _ = write!(&mut h, "{:?}{:?}", dialog, app.session.selection);h.0.finish()}@@ -577,14 +608,24 @@ pub fn begin(app: &mut SolveApp, ctx: &egui::Context, dialog: Option<&dialogs::D}fn cancel_capture(app: &mut SolveApp) {+ app.issue_report.waiting = None;if let Some(pending) = app.issue_report.pending.take() {app.queued_shots.retain(|(token, ..)| *token != pending.token);}}fn capture(app: &mut SolveApp, ctx: &egui::Context, dialog: Option<&dialogs::Dialog>) {+ capture_unless_busy(app, ctx, dialog, true);+}++/// Take a screenshot for the report; `wait`: while the preview is being computed, wait for it+/// with the report open ([`tick`] takes it once it is done, #7171).+fn capture_unless_busy(app: &mut SolveApp, ctx: &egui::Context, dialog: Option<&dialogs::Dialog>, wait: bool) {cancel_capture(app);let current_source = source_signature(app, dialog);+ let context = context_signature(app, dialog);+ let full = app.queued_shots.len() >= 16;+ let busy = app.preview.busy;let Some(draft) = app.issue_report.draft.as_mut() else { return };draft.image = None;draft.texture = None;@@ -594,16 +635,39 @@ fn capture(app: &mut SolveApp, ctx: &egui::Context, dialog: Option<&dialogs::Dia.into();return;}- if app.preview.busy || app.queued_shots.len() >= 16 {+ if wait && (busy || full) {+ draft.note = "Waiting for the preview to finish to take the screenshot…".into();+ app.issue_report.waiting = Some(Waiting { deadline: crate::now_ms() + PREVIEW_WAIT_MS, context });+ ctx.request_repaint();+ return;+ }+ if full {draft.note = "Screenshot unavailable while the preview is updating. Reopen the report after it settles, or continue with text.".into();return;}+ if busy {+ draft.note = "The preview is still being computed: the screenshot shows it unfinished.".into();+ let line = format!(+ "\nThe preview was still being computed {:.0} s after the report opened; the screenshot shows it unfinished.\n",+ PREVIEW_WAIT_MS / 1000.0+ );+ if !draft.body.contains(line.trim()) {+ draft.body.push_str(&line);+ truncate(&mut draft.body, MAX_BODY);+ }+ }+ // The form hides for the capture: give its focused field back after it.+ if draft.focus_requested {+ app.issue_report.refocus = ctx.memory(|m| m.focused());+ }let Some(token) = app.shot_token.checked_add(1) else {draft.note = "Screenshot request limit reached; restart the app to capture another frame.".into();return;};app.shot_token = token;- draft.note = "Capturing the current app view locally…".into();+ if !busy {+ draft.note = "Capturing the current app view locally…".into();+ }let now = crate::now_ms();app.issue_report.pending = Some(Pending {token,@@ -621,7 +685,71 @@ pub(crate) fn pending(app: &SolveApp) -> bool {app.issue_report.pending.is_some()}+/// While a capture hides the report, what is typed waits for the form to come back, which gets+/// its focused field back: a screenshot taken once the preview is done can hide the form while+/// its user types (#7171).+pub(crate) fn hold_input(app: &mut SolveApp, raw: &mut egui::RawInput) {+ let state = &mut app.issue_report;+ if state.draft.is_none() {+ state.held.clear();+ } else if state.pending.is_some() {+ let mut kept = Vec::with_capacity(raw.events.len());+ for event in raw.events.drain(..) {+ if typing(&event) {+ if state.held.len() < MAX_HELD {+ state.held.push(event);+ }+ } else {+ kept.push(event);+ }+ }+ raw.events = kept;+ } else if !state.held.is_empty() {+ let mut events = std::mem::take(&mut state.held);+ events.append(&mut raw.events);+ raw.events = events;+ }+}++/// What [`hold_input`] keeps for the form.+fn typing(event: &egui::Event) -> bool {+ matches!(+ event,+ egui::Event::Text(_) | egui::Event::Key { .. } | egui::Event::Paste(_) | egui::Event::Copy | egui::Event::Cut | egui::Event::Ime(_)+ )+}+pub(crate) fn tick(app: &mut SolveApp, ctx: &egui::Context) {+ if let Some(waiting) = &app.issue_report.waiting {+ let settled = !app.preview.busy && app.queued_shots.len() < 16;+ let (late, context) = (crate::now_ms() >= waiting.deadline, waiting.context);+ if settled || late {+ app.issue_report.waiting = None;+ let dialog = app.dialog.clone();+ // The preview the report waited for is what it shows now.+ let source = source_signature(app, dialog.as_ref());+ if context_signature(app, dialog.as_ref()) == context+ && let Some(draft) = app.issue_report.draft.as_mut()+ {+ draft.source_signature = source;+ }+ capture_unless_busy(app, ctx, dialog.as_ref(), false);+ // The capture hides the form before it is drawn this frame: what was typed in it+ // waits with what comes while it is hidden.+ if pending(app) {+ let state = &mut app.issue_report;+ ctx.input(|i| {+ for event in i.events.iter().filter(|e| typing(e)) {+ if state.held.len() < MAX_HELD {+ state.held.push(event.clone());+ }+ }+ });+ }+ } else {+ ctx.request_repaint_after(std::time::Duration::from_millis(50));+ }+ }let problem = app.issue_report.pending.as_ref().and_then(|p| {if signature(app, app.dialog.as_ref()) != p.signature || p.window != ctx.content_rect() || p.pixels_per_point != ctx.pixels_per_point() {Some("The model, inputs or view changed during capture. Retake the current view.")@@ -709,6 +837,9 @@ pub fn show(app: &mut SolveApp, ctx: &egui::Context) {if pending(app) {return;}+ if let Some(id) = app.issue_report.refocus.take() {+ ctx.memory_mut(|m| m.request_focus(id));+ }let Some(mut draft) = app.issue_report.draft.take() else { return };let (retake, close) = form::show(app, &mut draft, ctx);if !close {@@ -1477,6 +1608,112 @@ mod tests {assert_eq!(h.app.docs.count(), tabs_before);}+ /// A report opened while the preview is being computed waits for it, open, and takes the+ /// screenshot once it is done (#7171). It used to refuse and ask to reopen the report.+ #[test]+ fn issue_report_screenshot_waits_for_the_preview_then_is_taken() {+ let mut app = app();+ let ctx = crate::fonts::test_context();+ app.preview.busy = true;+ begin(&mut app, &ctx, None, None);+ assert!(!pending(&app) && app.issue_report.waiting.is_some());+ assert!(app.issue_report.draft.as_ref().unwrap().note.contains("Waiting for the preview"));+ tick(&mut app, &ctx);+ assert!(!pending(&app), "the preview is still being computed");+ app.preview.busy = false;+ app.preview.key += 1;+ tick(&mut app, &ctx);+ assert!(pending(&app), "taken once the preview is done");+ let token = app.issue_report.pending.as_ref().unwrap().token;+ receive(&mut app, token, Arc::new(ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12])));+ let draft = app.issue_report.draft.as_ref().unwrap();+ assert!(draft.image.is_some(), "{}", draft.note);+ assert!(!draft.body.contains("still being computed"));+ // A selection changed while it waits: the report's context no longer matches the view.+ app.preview.busy = true;+ begin(&mut app, &ctx, None, None);+ app.session.selection = vec![Sel::Feature { id: 1 }];+ app.preview.busy = false;+ tick(&mut app, &ctx);+ let draft = app.issue_report.draft.as_ref().unwrap();+ assert!(!pending(&app) && draft.image.is_none() && draft.note.contains("Settings or model changed"), "{}", draft.note);+ }++ /// A preview still being computed after a while is what the screenshot shows, and the report+ /// says so: a hanging preview is often what is being reported.+ #[test]+ fn issue_report_screenshot_of_a_preview_that_takes_too_long_shows_it_unfinished() {+ let mut app = app();+ let ctx = crate::fonts::test_context();+ app.preview.busy = true;+ begin(&mut app, &ctx, None, None);+ app.issue_report.waiting.as_mut().unwrap().deadline = -1.0;+ tick(&mut app, &ctx);+ assert!(pending(&app) && app.issue_report.waiting.is_none());+ let draft = app.issue_report.draft.as_ref().unwrap();+ assert!(draft.note.contains("unfinished") && draft.body.contains("still being computed 10 s after"), "{}", draft.note);+ let token = app.issue_report.pending.as_ref().unwrap().token;+ receive(&mut app, token, Arc::new(ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12])));+ assert!(app.issue_report.draft.as_ref().unwrap().image.is_some());+ }++ /// What is typed in the frame the preview finishes, as the waiting screenshot is taken and+ /// hides the form, is kept too (#7171). A preview error the dialog shows meanwhile is not a+ /// change: it is often what is being reported.+ #[test]+ fn issue_report_typing_as_a_waiting_screenshot_is_taken_is_kept() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.app.issue_report.draft = Some(draft_for(&h.app, None, None));+ h.frames(8);+ h.frame_with(vec![egui::Event::Text("The preview ".into())]);+ // The wait ends in the next frame (here: its time is up), before the form is drawn.+ let context = context_signature(&h.app, None);+ h.app.issue_report.waiting = Some(Waiting { deadline: -1.0, context });+ h.frame_with(vec![egui::Event::Text("vanished".into())]);+ assert!(pending(&h.app) && h.app.issue_report.waiting.is_none());+ h.frame_with(vec![egui::Event::Text(".".into())]);+ let token = h.app.issue_report.pending.as_ref().unwrap().token;+ receive(&mut h.app, token, Arc::new(ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12])));+ h.frames(4);+ let draft = h.app.issue_report.draft.as_ref().unwrap();+ assert_eq!(draft.description, "The preview vanished.");+ assert!(draft.image.is_some(), "{}", draft.note);+ // The dialog's preview error is not part of the context; its inputs are.+ let mut app = app();+ app.start("solid.combine");+ let before = context_signature(&app, app.dialog.as_ref());+ if let Some(d) = app.dialog.as_mut() {+ d.error = Some("the operation failed".into());+ }+ assert_eq!(context_signature(&app, app.dialog.as_ref()), before);+ if let Some(d) = app.dialog.as_mut() {+ d.extra.insert("probe".into(), json!(1));+ }+ assert_ne!(context_signature(&app, app.dialog.as_ref()), before);+ }++ /// What is typed while a capture hides the report goes into the field it was typed in.+ #[test]+ fn issue_report_typing_while_a_capture_hides_the_report_is_kept() {+ let mut h = crate::scenario::Harness::new();+ h.app.home.open = false;+ h.app.issue_report.draft = Some(draft_for(&h.app, None, None));+ h.frames(8);+ h.frame_with(vec![egui::Event::Text("The preview ".into())]);+ let (ctx, dialog) = (h.ctx.clone(), h.app.dialog.clone());+ capture(&mut h.app, &ctx, dialog.as_ref());+ assert!(pending(&h.app));+ h.frame_with(vec![egui::Event::Text("vanished".into())]);+ h.frame_with(vec![egui::Event::Text(".".into())]);+ let token = h.app.issue_report.pending.as_ref().unwrap().token;+ receive(&mut h.app, token, Arc::new(ColorImage::new([4, 3], vec![egui::Color32::GREEN; 12])));+ h.frames(4);+ let draft = h.app.issue_report.draft.as_ref().unwrap();+ assert_eq!(draft.description, "The preview vanished.");+ assert!(draft.image.is_some());+ }+#[test]fn issue_report_capture_accepts_only_its_matching_unchanged_frame() {let mut app = app();diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 53eaa0dacf..f52388589e 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -2037,8 +2037,15 @@ impl SolveApp {control::publish_design(self, &control::DESIGN_WATCH);}- /// Inject synthetic events (one pointer event per frame).+ /// The frame's input before the app reads it: synthetic events, then what is typed while a+ /// capture hides the report waits for it (the control channel's typing too).pub fn raw_input_hook(&mut self, raw: &mut egui::RawInput) {+ self.synthetic_input(raw);+ issue_report::hold_input(self, raw);+ }++ /// Inject synthetic events (one pointer event per frame).+ fn synthetic_input(&mut self, raw: &mut egui::RawInput) {if self.synthetic.is_empty() {return;}