From 02ca8af9e2995a0b613f2d19a098182d65bb5613 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Sat, 14 Nov 2026 18:05:59 +0100 Subject: [PATCH] Add timed automatic refresh for Midra input previews --- crates/midra-layout/src/capture_ui.rs | 257 ++++++++++++++++++++++--- docs/interfaces/midra-input-preview.md | 19 +- docs/midra-layout/README.md | 9 +- docs/midra-layout/changelog.md | 2 + docs/midra-layout/plan.md | 6 +- 5 files changed, 260 insertions(+), 33 deletions(-) diff --git a/crates/midra-layout/src/capture_ui.rs b/crates/midra-layout/src/capture_ui.rs index 685730f..a393f76 100644 --- a/crates/midra-layout/src/capture_ui.rs +++ b/crates/midra-layout/src/capture_ui.rs @@ -3,15 +3,34 @@ use midra_layout::device_capture; type CaptureJob = std::sync::mpsc::Receiver>; struct LayerPreview { + input: u32, + host: String, source: usize, texture: egui::TextureHandle, name: String, enabled: bool, guides: f32, } +struct Refresh { + enabled: bool, + seconds: u64, + last_input: u32, + pending_input: Option, +} +impl Default for Refresh { + fn default() -> Self { + Self { + enabled: false, + seconds: 10, + last_input: 0, + pending_input: None, + } + } +} #[derive(Default)] pub(super) struct CaptureUi { pub open: bool, + refresh: Refresh, input: u32, layers: std::collections::BTreeMap, host: String, @@ -28,12 +47,94 @@ impl CaptureUi { self.open = false; self.discard_result = true; } + fn refresh_controls(&mut self, ui: &mut egui::Ui) { + ui.checkbox(&mut self.refresh.enabled, "Auto-refresh input previews"); + ui.add_enabled( + self.refresh.enabled, + egui::Slider::new(&mut self.refresh.seconds, 5..=300) + .text("Request interval") + .suffix(" s"), + ); + ui.small("Refreshes visible layer previews in turn, one input per interval. Paused offline or while this capture window is open."); + if self.refresh.enabled && !self.error.is_empty() { + ui.colored_label(ui.visuals().error_fg_color, &self.error); + } + } fn cooling_down(&self) -> bool { self.last_request .is_some_and(|t| t.elapsed() < std::time::Duration::from_secs(5)) } } impl Editor { + fn next_preview_refresh(&self) -> Option { + if !self.capture.refresh.enabled + || self.capture.open + || !self.device.online() + || self.capture.pending.is_some() + || self + .capture + .last_request + .is_some_and(|t| t.elapsed().as_secs() < self.capture.refresh.seconds.max(5)) + { + return None; + } + let available = self + .device + .snapshot + .as_ref() + .map(device_capture::inputs) + .unwrap_or_default(); + let inputs: std::collections::BTreeSet<_> = (0..self.layout.layers().len()) + .filter(|&i| self.layout.visible(i)) + .filter_map(|i| { + self.capture + .layers + .get(&self.layout.layer_info(i).id) + .filter(|p| { + p.enabled + && p.source == self.layout.formats().source_for[i] + && p.host == self.device.host + && available.iter().any(|a| a.id == p.input && a.enabled) + }) + .map(|p| p.input) + }) + .collect(); + inputs + .iter() + .copied() + .find(|&i| i > self.capture.refresh.last_input) + .or_else(|| inputs.first().copied()) + } + fn start_input_capture(&mut self, ctx: &egui::Context, input: u32, automatic: bool) { + self.capture.last_request = Some(std::time::Instant::now()); + self.capture.discard_result = false; + self.capture.error.clear(); + self.capture.refresh.pending_input = automatic.then_some(input); + if automatic { + self.capture.refresh.last_input = input; + } else { + self.capture.preview = None; + } + let (tx, rx) = std::sync::mpsc::channel(); + self.capture.pending = Some(rx); + let host = self.device.host.clone(); + let ctx = ctx.clone(); + std::thread::spawn(move || { + let result = device_capture::capture(&host, input).and_then(|bytes| { + super::super::reference::Reference::load( + &ctx, + &egui::DroppedFile { + name: format!("Midra input {input} · {host}"), + bytes: Some(bytes.into()), + ..Default::default() + }, + ) + }); + let _ = tx.send(result); + ctx.request_repaint(); + }); + } + pub(super) fn layer_preview(&self, i: usize) -> Option<(egui::TextureId, f32)> { self.capture .layers @@ -82,6 +183,7 @@ impl Editor { ); ui.small("Capture a still and use it for this layer to adjust guide opacity."); } + self.capture.refresh_controls(ui); if ui .add_enabled( self.device.online(), @@ -107,16 +209,37 @@ impl Editor { }; if let Some(result) = result { self.capture.pending = None; + let automatic = self.capture.refresh.pending_input.take(); if self.capture.discard_result { self.capture.discard_result = false; } else { match result { - Ok(reference) => self.capture.preview = Some(reference), + Ok(reference) => { + if let Some(input) = automatic { + if self.capture.refresh.enabled { + for preview in + self.capture.layers.values_mut().filter(|p| { + p.input == input && p.host == self.device.host + }) + { + preview.texture = reference.texture.clone(); + } + } + } else { + self.capture.preview = Some(reference); + } + } Err(error) => self.capture.error = error, } } } } + if let Some(input) = self.next_preview_refresh() { + self.start_input_capture(ctx, input, true); + } + if self.capture.refresh.enabled { + ctx.request_repaint_after(std::time::Duration::from_secs(1)); + } if !self.capture.open { return; } @@ -162,7 +285,8 @@ impl Editor { if ui.button("Cancel capture").clicked() { self.capture.discard_result = true; } } }); - ui.small("Manual capture only · at most one request every 5 seconds · no background refresh."); + ui.small("At most one request at a time, with at least 5 seconds between requests."); + self.capture.refresh_controls(ui); if cooling_down { ui.small("Capture available again shortly."); ctx.request_repaint_after(std::time::Duration::from_secs(1)); } if let Some(reference) = &self.capture.preview { ui.label(format!("{} · {} × {} px", reference.name, reference.size[0], reference.size[1])); @@ -180,29 +304,7 @@ impl Editor { self.capture.discard_result = true; } if capture { - self.capture.last_request = Some(std::time::Instant::now()); - self.capture.discard_result = false; - self.capture.preview = None; - self.capture.error.clear(); - let (tx, rx) = std::sync::mpsc::channel(); - self.capture.pending = Some(rx); - let host = self.device.host.clone(); - let input = self.capture.input; - let ctx = ctx.clone(); - std::thread::spawn(move || { - let result = device_capture::capture(&host, input).and_then(|bytes| { - super::super::reference::Reference::load( - &ctx, - &egui::DroppedFile { - name: format!("Midra input {input} · {host}"), - bytes: Some(bytes.into()), - ..Default::default() - }, - ) - }); - let _ = tx.send(result); - ctx.request_repaint(); - }); + self.start_input_capture(ctx, self.capture.input, false); } if use_layer && let Some(i) = self.layout.selected() @@ -211,6 +313,8 @@ impl Editor { self.capture.layers.insert( self.layout.layer_info(i).id, LayerPreview { + input: self.capture.input, + host: self.device.host.clone(), source: self.layout.formats().source_for[i], texture: reference.texture.clone(), name: reference.name.clone(), @@ -286,7 +390,63 @@ mod tests { assert_eq!(app.layer_preview(selected).unwrap().1, 0.35); assert!(app.edit_content); assert!(app.references.is_empty()); + // Automatic refresh is opt-in, throttled, and pauses for manual capture. + assert_eq!(app.next_preview_refresh(), None); + app.capture.refresh.enabled = true; + assert_eq!(app.next_preview_refresh(), None); + app.capture.last_request = + Some(std::time::Instant::now() - std::time::Duration::from_secs(11)); + assert_eq!(app.next_preview_refresh(), Some(3)); + app.capture.refresh.last_input = 3; + assert_eq!(app.next_preview_refresh(), Some(3)); // round-robin wraps + let id = app.layout.layer_info(selected).id; + app.capture.layers.get_mut(&id).unwrap().enabled = false; + assert_eq!(app.next_preview_refresh(), None); + app.capture.layers.get_mut(&id).unwrap().enabled = true; + app.capture.layers.get_mut(&id).unwrap().host = "other device".into(); + assert_eq!(app.next_preview_refresh(), None); + app.capture.layers.get_mut(&id).unwrap().host = app.device.host.clone(); + // Failed refresh retains the last good texture and obeys the timer. + let texture = app.layer_preview(selected).unwrap().0; + let (tx, rx) = std::sync::mpsc::channel(); + app.capture.pending = Some(rx); + app.capture.refresh.pending_input = Some(3); + app.capture.last_request = Some(std::time::Instant::now()); + assert_eq!(app.next_preview_refresh(), None); + tx.send(Err("temporary failure".into())).unwrap(); + frame(&mut app, &ctx, vec![]); + assert_eq!(app.layer_preview(selected).unwrap().0, texture); + assert_eq!(app.capture.error, "temporary failure"); + assert!(app.references.is_empty()); + // A successful automatic result updates the texture, never the references. + let (tx, rx) = std::sync::mpsc::channel(); + app.capture.pending = Some(rx); + app.capture.refresh.pending_input = Some(3); + tx.send(Ok(app.capture.preview.take().unwrap())).unwrap(); + frame(&mut app, &ctx, vec![]); + assert!(app.capture.preview.is_none()); + assert!(app.references.is_empty()); + assert_eq!(app.layer_preview(selected).unwrap().1, 0.35); + app.capture.refresh.enabled = false; + // Restore a dialog still for the separate Add as reference action. + let reference = super::super::super::reference::Reference::load( + &ctx, + &egui::DroppedFile { + name: "Captured input".into(), + bytes: Some({ + let mut bytes = std::io::Cursor::new(Vec::new()); + image::RgbaImage::new(2, 2) + .write_to(&mut bytes, image::ImageFormat::Png) + .unwrap(); + bytes.into_inner().into() + }), + ..Default::default() + }, + ) + .unwrap(); + app.capture.preview = Some(reference); app.capture.open = true; + assert_eq!(app.next_preview_refresh(), None); click_text(&mut app, &ctx, "Add as reference"); assert_eq!(app.references.len(), 1); assert_eq!(app.project().references.len(), 1); @@ -296,6 +456,51 @@ mod tests { assert!(!app.capture.cooling_down()); } #[test] + fn refresh_rotates_inputs_and_skips_changed_sources() { + let ctx = egui::Context::default(); + let mut app = Editor::default(); + app.device.snapshot = Some(midra_layout::device::Snapshot { + identity: "Test".into(), + screens: vec![], + raw: serde_json::json!({"device":{"inputList":{"items":{ + "INPUT_3":{"status":{"pp":{"isAvailable":true,"plug":"1"}},"snapshot":{"pp":{"enable":true}}}, + "INPUT_7":{"status":{"pp":{"isAvailable":true,"plug":"1"}},"snapshot":{"pp":{"enable":true}}} + }}}}), + }); + app.capture.refresh.enabled = true; + for (i, input) in [3, 7].into_iter().enumerate() { + app.capture.layers.insert( + app.layout.layer_info(i).id, + LayerPreview { + input, + host: app.device.host.clone(), + source: app.layout.formats().source_for[i], + texture: ctx.load_texture( + format!("Input {input}"), + egui::ColorImage::new([2, 2], Color32::RED), + Default::default(), + ), + name: String::new(), + enabled: true, + guides: 0.35, + }, + ); + } + assert_eq!(app.next_preview_refresh(), Some(3)); + app.capture.refresh.last_input = 3; + assert_eq!(app.next_preview_refresh(), Some(7)); + app.capture.refresh.last_input = 7; + assert_eq!(app.next_preview_refresh(), Some(3)); + let id = app.layout.layer_info(0).id; + app.capture.layers.get_mut(&id).unwrap().source = usize::MAX; + assert_eq!(app.next_preview_refresh(), Some(7)); + app.capture.open = true; + assert_eq!(app.next_preview_refresh(), None); + app.capture.open = false; + app.device.snapshot = None; + assert_eq!(app.next_preview_refresh(), None); + } + #[test] fn cancelling_keeps_request_in_flight_and_discards_its_result() { let ctx = egui::Context::default(); let mut app = Editor::default(); @@ -323,6 +528,8 @@ mod tests { app.capture.layers.insert( id, LayerPreview { + input: 3, + host: app.device.host.clone(), source: app.layout.formats().source_for[i], texture, name: "Input still".into(), diff --git a/docs/interfaces/midra-input-preview.md b/docs/interfaces/midra-input-preview.md index 36b3aaa..496972a 100644 --- a/docs/interfaces/midra-input-preview.md +++ b/docs/interfaces/midra-input-preview.md @@ -13,10 +13,10 @@ The connected snapshot's `/device/inputList/items/INPUT_N` supplies: - `snapshot.pp.enable`: capture is disabled in the editor when WebRCS snapshots are disabled. The application does not write this field or snapshot size. -One explicit **Capture still** issues +Each explicit **Capture still** or automatic timer request issues `GET http:///api/device/snapshots/inputs/N`, with N an integer 1–16 and `Cache-Control: no-cache`. IPv4 and IPv6 literal addresses are accepted; -no proxy or redirect is followed. No retries, polling, WebSocket subscription, +no proxy or redirect is followed. No immediate retries, WebSocket subscription, still-library capture or source-routing/preset writes are involved. Only one request may be in flight, with at least five seconds between starts. @@ -66,4 +66,17 @@ Layer-preview assignments, texture bytes, visibility toggles and guide opacity are not saved/exported. Add as reference remains the separate persistent path; generic artwork exports include those references only through the existing background option. Reloading a project makes no capture requests. -Automatic refresh, live feeds and separate image-file saving are not implemented. +**Auto-refresh input previews** is opt-in and session-only, with a request interval +of 5–300 seconds (default 10). Assignments also retain the device address and +physical input number in memory. Visible layers with enabled previews, unchanged +local inputs and the current device address are eligible; unavailable or +snapshot-disabled inputs are skipped. Unique inputs refresh round-robin, one +request per interval, sharing the returned texture across their assignments. +Manual and automatic capture share one worker slot and the five-second minimum. +Automatic capture pauses offline, during project loading and while the capture +dialog is open. Errors retain the last good image and wait for the next interval; +there are no immediate retries. Turning off refresh prevents applying an in-flight +automatic result. Project replacement clears assignments and discards stale results. +Automatic refresh never changes fixed references or device settings. Timer settings +are not persisted; no save schema changes are involved. +Live feeds and separate image-file saving are not implemented. diff --git a/docs/midra-layout/README.md b/docs/midra-layout/README.md index 21da5f2..398338f 100644 --- a/docs/midra-layout/README.md +++ b/docs/midra-layout/README.md @@ -1010,7 +1010,7 @@ indicators reflect the last connection refresh; an inactive input may return a blank image. If input snapshots are disabled, enable them in WebRCS and refresh the connection. -Capture is manual: no background polling, no live stream, one request in flight +Capture defaults to manual, with one request in flight and a minimum five-second gap between requests. Cancel/close ignores the response; another request waits for the old one to finish or time out (20 seconds). The returned resolution/freshness comes from the device; this is not a full-size @@ -1020,7 +1020,12 @@ input and dynamic crop/zoom. In **Crop properties**, or right-click → **Input & crop guides**, toggle **Show captured input** and adjust **Crop guide opacity**. Guides paint over the image, initially at 35%; without an enabled preview, guides are fully opaque and the slider is disabled. Selection handles stay fully visible. -Layer previews/settings are session-only and do not trigger refreshes or device writes. +Enable **Auto-refresh input previews** here or in the capture dialog to fetch +updated stills automatically. **Request interval** defaults to 10 seconds (5–300). +Visible, enabled previews refresh one input at a time; layers sharing an input +share the image. The timer pauses offline and while the capture dialog is open. +Failed requests retain the last image. Fixed reference images never auto-refresh. +Layer previews and timer settings are session-only; no device settings are changed. **Add as reference** instead creates a fixed screen guide with independent hide/show/remove controls, embedded in saved projects. Neither action changes diff --git a/docs/midra-layout/changelog.md b/docs/midra-layout/changelog.md index 79ae074..a08bb7b 100644 --- a/docs/midra-layout/changelog.md +++ b/docs/midra-layout/changelog.md @@ -4,6 +4,8 @@ ## Unreleased +- Add opt-in input-preview auto-refresh with a 5–300 second request interval (default 10). Visible previews refresh round-robin with shared input textures, one background request at a time; pause offline/manual capture, retain images on failures and keep fixed references unchanged. Timer controls and assignments remain session-only. Regression checks cover scheduling, throttling and response handling. + - Use captured input stills as toggleable layer previews, with crop guides composited above them and a 0–100% opacity slider in Crop properties and the layer context menu. Guides return to full opacity without an enabled preview; source/input/dynamic crop and ghost overflow share the same mapping. Layer-preview assignments/settings are session-only; capture remains manual and throttled. - Group the guide and supporting documentation in this tool’s folder; update portal, cross-document and packaging links for the new paths. diff --git a/docs/midra-layout/plan.md b/docs/midra-layout/plan.md index 0a4716a..be9e21f 100644 --- a/docs/midra-layout/plan.md +++ b/docs/midra-layout/plan.md @@ -35,8 +35,8 @@ device readback and physical-screen acceptance. autosave pauses while loading. - [x] Explicit Midra input snapshot capture: available-input picker, still preview, Use for selected layer, preview visibility and guide-opacity controls, - plus Add as reference. Manual only, one request at a time and at least - five seconds between requests. No live polling or automatic refresh. + plus Add as reference. Optional timed refresh (default 10 seconds), one request + at a time and at least five seconds between requests; visible previews only. - [x] Clipboard/import mapping review with per-row target/ignore, independent size/position/available-zoom toggles, draw.io stroke handling and own-copy round trips. Real draw.io clipboard sample and draw.io-exported SVG supported. @@ -77,7 +77,7 @@ device readback and physical-screen acceptance. - [ ] **Non-Centered/masked Midra layer import.** Expand conversion only after verifying those semantics. Source routing synchronization remains separate from the opt-in shared-input settings editor. -- [ ] **Optional capture extensions, if wanted.** Automatic refresh, standalone +- [ ] **Optional capture extensions, if wanted.** Standalone capture saving and persistence of layer-preview assignments are not implemented. Captures can be session-only layer textures or saved fixed reference images; low device load remains a requirement for any refresh extension.