diff --git a/Cargo.lock b/Cargo.lock index e9c425cde..041928688 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4038,7 +4038,7 @@ dependencies = [ [[package]] name = "ecolor" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "bytemuck", "emath", @@ -4094,7 +4094,7 @@ dependencies = [ [[package]] name = "eframe" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "ahash", "bytemuck", @@ -4129,7 +4129,7 @@ dependencies = [ [[package]] name = "egui" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "accesskit", "ahash", @@ -4148,7 +4148,7 @@ dependencies = [ [[package]] name = "egui-wgpu" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "ahash", "bytemuck", @@ -4167,7 +4167,7 @@ dependencies = [ [[package]] name = "egui-winit" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "block2 0.6.2", "bytemuck", @@ -4187,7 +4187,7 @@ dependencies = [ [[package]] name = "egui_glow" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "bytemuck", "egui", @@ -4200,7 +4200,7 @@ dependencies = [ [[package]] name = "egui_kittest" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "eframe", "egui", @@ -4268,7 +4268,7 @@ dependencies = [ [[package]] name = "emath" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "bytemuck", ] @@ -4329,7 +4329,7 @@ dependencies = [ [[package]] name = "epaint" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" dependencies = [ "ahash", "bytemuck", @@ -4355,7 +4355,7 @@ dependencies = [ [[package]] name = "epaint_default_fonts" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" [[package]] name = "equivalent" @@ -12498,19 +12498,19 @@ dependencies = [ [[patch.unused]] name = "egui_demo_lib" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" [[patch.unused]] name = "egui_extras" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" [[patch.unused]] name = "egui_inspection" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" [[patch.unused]] name = "egui_system_font_provider" version = "0.37.0" -source = "git+https://github.com/storytold/egui.git?rev=dcd4de1fbc7502c3a2d69476d9665610947440df#dcd4de1fbc7502c3a2d69476d9665610947440df" +source = "git+https://github.com/storytold/egui.git?rev=5d6f991d5159b51f464c210b43d650a279cd844a#5d6f991d5159b51f464c210b43d650a279cd844a" diff --git a/Cargo.toml b/Cargo.toml index 77502bb4b..b70426dcb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -220,20 +220,20 @@ hayro-jbig2 = { path = "vendor/hayro-jbig2" } hayro-cmap = { path = "vendor/hayro-cmap" } hayro-postscript = { path = "vendor/hayro-postscript" } linesweeper = { path = "vendor/linesweeper" } -ecolor = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -emath = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -epaint = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -epaint_default_fonts = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui-winit = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui-wgpu = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_glow = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_extras = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_kittest = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_system_font_provider = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -eframe = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_demo_lib = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } -egui_inspection = { git = "https://github.com/storytold/egui.git", rev = "dcd4de1fbc7502c3a2d69476d9665610947440df" } +ecolor = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +emath = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +epaint = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +epaint_default_fonts = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui-winit = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui-wgpu = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_glow = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_extras = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_kittest = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_system_font_provider = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +eframe = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_demo_lib = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } +egui_inspection = { git = "https://github.com/storytold/egui.git", rev = "5d6f991d5159b51f464c210b43d650a279cd844a" } winit = { git = "https://github.com/storytold/winit.git", rev = "a517b3846ee8457d84ee4975110bfda6797c44dc" } # symphonia's FLAC decoder restores LPC samples as `residual + (prediction as i32)`. In a valid diff --git a/crates/automation/src/screenshot.rs b/crates/automation/src/screenshot.rs index cb726824e..45b8be284 100644 --- a/crates/automation/src/screenshot.rs +++ b/crates/automation/src/screenshot.rs @@ -1,19 +1,21 @@ //! `ui.screenshot`: bounded, cancellable capture requests over [`WindowHost::screenshot`]. //! //! The slot correlates one capture with one image. This queue owns what the slot leaves to the -//! app: request identity (token, output path, reply), deadlines and settling, the admission budget -//! ([`MAX_PENDING`] requests, [`MAX_IMAGE_BYTES`] per image, [`MAX_TOTAL_BYTES`] in all), the -//! document identity fixed at admission, the geometry epoch recorded at issue so an image is saved -//! only for the layout it was rendered from (a size, scale, zoom or minimised change between issue -//! and collection is a retry, at most [`MAX_RETRIES`]), and a monotonic clock. A request that -//! arrives before the first UI pass recorded the geometry waits instead of failing. +//! app: request identity (token, output path, reply, the viewport it shoots), deadlines and +//! settling, the admission budget ([`MAX_PENDING`] requests, [`MAX_IMAGE_BYTES`] per image, +//! [`MAX_TOTAL_BYTES`] in all), the document identity fixed at admission, each viewport's geometry +//! epoch recorded at issue so an image is saved only for the layout it was rendered from (a size, +//! scale, zoom or minimised change between issue and collection is a retry, at most +//! [`MAX_RETRIES`]), and a monotonic clock. A request for a viewport whose geometry is not recorded +//! yet waits instead of failing; one whose window is not open fails with [`WINDOW_CLOSED`]. //! //! Phases: [`Captures::issue`] runs in the UI pass (settling counts real layout passes; a -//! discarded pass is skipped); [`Captures::note_geometry`] and [`Captures::drain`] run in the -//! logic phase. The image is encoded and written on the UI thread by +//! discarded pass is skipped); [`Captures::note_windows`] (or [`Captures::note_geometry`] for a +//! synthetic geometry) and [`Captures::drain`] run in the logic phase. The image is encoded and written on the UI thread by //! [`ControlChannel::finish_captures`](crate::control::ControlChannel::finish_captures), never //! inside the callback. +use std::collections::HashMap; use std::sync::Arc; use std::sync::mpsc::Sender; use std::time::{Duration, Instant}; @@ -64,7 +66,7 @@ impl DocumentId { } } -/// The layout of the root viewport a capture is rendered from: size in points, pixels per point, +/// The layout of the viewport a capture is rendered from: size in points, pixels per point, /// zoom, the texture side limit and whether the window is minimised. Window position is not part /// of it. #[derive(Clone, Copy, Debug, PartialEq)] @@ -189,7 +191,7 @@ impl Finished { } } -/// A request admitted before any geometry was recorded. +/// A request not yet queued: it waits while its viewport's geometry is not recorded. struct WaitingAdmit { token: u64, viewport: ViewportId, @@ -200,13 +202,21 @@ struct WaitingAdmit { document: Option, } +/// What one viewport's window measured: its geometry this pass, `None` while the window is not +/// open, and the epoch that advances on each layout change. +#[derive(Clone, Copy, Default)] +struct Window { + geometry: Option, + epoch: u64, +} + /// The screenshot request queue and its admission budget. #[derive(Default)] pub struct Captures { records: Vec, waiting: Vec, - geometry: Option, - epoch: u64, + /// One entry per recorded viewport; a viewport with no entry was never measured. + windows: HashMap, } impl Captures { @@ -232,38 +242,54 @@ impl Captures { /// The geometry recorded by the last [`Self::note_geometry`] for `viewport`, if any. pub fn last_geometry(&self, viewport: ViewportId) -> Option { - let _ = viewport; // P3(canvas-widgets-w13): cw.C69 geometry per viewport. - self.geometry + self.windows.get(&viewport).and_then(|window| window.geometry) } /// Record this pass's geometry of `viewport`; advances and returns that viewport's epoch when /// it changed. pub fn note_geometry(&mut self, viewport: ViewportId, geometry: CaptureGeometry) -> u64 { - let _ = viewport; // P3(canvas-widgets-w13): cw.C69 geometry per viewport. - let changed = self.geometry.is_none_or(|old| !old.same_layout(&geometry)); + let window = self.windows.entry(viewport).or_default(); + let changed = window.geometry.is_none_or(|old| !old.same_layout(&geometry)); if changed { - self.epoch = self.epoch.wrapping_add(1); + window.epoch = window.epoch.wrapping_add(1); } - self.geometry = Some(geometry); - self.epoch + window.geometry = Some(geometry); + window.epoch } /// The app's one call per pass: for the root and each viewport a pending or waiting request /// names, records `CaptureGeometry::from_facts` of `host.screenshot_facts(viewport)`, or marks - /// the viewport closed when that is `None`. - #[allow(dead_code)] // P3(canvas-widgets-w13): cw.C69 + /// the viewport closed when that is `None`. Viewports no request names are forgotten, so a + /// window measured for an earlier request is measured afresh for the next. pub fn note_windows(&mut self, host: &WindowHost, document: Option) { - let _ = (host, document); - todo!("cw.C69") + let mut named = vec![ViewportId::ROOT]; + for viewport in self.records.iter().map(|r| r.viewport).chain(self.waiting.iter().map(|w| w.viewport)) { + if !named.contains(&viewport) { + named.push(viewport); + } + } + self.windows.retain(|viewport, _| named.contains(viewport)); + for viewport in named { + match host.screenshot_facts(viewport) { + Some(facts) => { + self.note_geometry(viewport, CaptureGeometry::from_facts(facts, document)); + } + None if host.is_open(viewport) => {} + None => self.windows.entry(viewport).or_default().geometry = None, + } + } } - /// Admit a request against the budget. `Err` returns the reply sender with the error text: + /// Admit a request for `viewport` against the budget. `Err` returns the reply sender with the + /// error text: /// `screenshot token {token} is already pending`, /// `too many screenshots pending (at most {MAX_PENDING})`, + /// `screenshot {token} failed: {WINDOW_CLOSED}`, /// `the viewport is not capturable ({w}×{h} points at {ppp} px/pt, texture side {side})`, /// `a {N} MiB screenshot is over the {MAX_IMAGE_BYTES / 1 MiB} MiB per-image limit` (`N` the /// expected bytes / 1 MiB, integer division), or - /// `screenshot budget exhausted: {total} bytes reserved of a {MAX_TOTAL_BYTES}-byte aggregate limit`. With no geometry yet the request waits. + /// `screenshot budget exhausted: {total} bytes reserved of a {MAX_TOTAL_BYTES}-byte aggregate limit`. + /// While the viewport's geometry is not recorded the request waits. pub fn admit( &mut self, token: u64, @@ -280,32 +306,33 @@ impl Captures { if self.pending() >= MAX_PENDING { return Err((reply, format!("too many screenshots pending (at most {MAX_PENDING})"))); } - if self.geometry.is_none() { - self.waiting.push(WaitingAdmit { token, viewport, path, reply, deadline: now + DEADLINE, settle_ms, document }); - return Ok(()); + let request = WaitingAdmit { token, viewport, path, reply, deadline: now + DEADLINE, settle_ms, document }; + match self.windows.get(&viewport).copied() { + None => { + self.waiting.push(request); + Ok(()) + } + Some(Window { geometry: None, .. }) => Err((request.reply, window_closed_error(token))), + Some(Window { geometry: Some(geometry), epoch }) => self.admit_with_geometry(request, geometry, epoch), } - self.admit_with_geometry(token, path, viewport, reply, document, settle_ms, now) } + /// Queues `request` at `geometry` and `epoch`, what its viewport's window recorded. fn admit_with_geometry( &mut self, - token: u64, - path: Option, - viewport: ViewportId, - reply: Sender, - document: Option, - settle_ms: f64, - now: Instant, + request: WaitingAdmit, + geometry: CaptureGeometry, + epoch: u64, ) -> Result<(), (Sender, String)> { + let WaitingAdmit { token, viewport, path, reply, deadline, settle_ms, document } = request; + // The request's clock started when it arrived. + let arrived = deadline - DEADLINE; if self.records.iter().any(|r| r.token == token) { return Err((reply, format!("screenshot token {token} is already pending"))); } if self.records.len() >= MAX_PENDING { return Err((reply, format!("too many screenshots pending (at most {MAX_PENDING})"))); } - let Some(geometry) = self.geometry else { - return Err((reply, "the window geometry is not known yet; try again after a frame has been drawn".into())); - }; let expected = match image_budget(&geometry) { Ok(bytes) => bytes, Err(e) => return Err((reply, e)), @@ -320,11 +347,11 @@ impl Captures { viewport, path, reply: Some(reply), - deadline: now + DEADLINE, - ready_at: now + Duration::from_secs_f64(settle / 1000.0), + deadline, + ready_at: arrived + Duration::from_secs_f64(settle / 1000.0), settle_passes: 0, geometry, - epoch: self.epoch, + epoch, issued_epoch: None, reserved_bytes: expected, document, @@ -334,7 +361,8 @@ impl Captures { Ok(()) } - /// Move waiting requests into the queue once geometry is known; expire the rest. + /// Move waiting requests into the queue once their viewport's geometry is known, fail those + /// whose window is closed, and expire the rest at their deadline. pub fn admit_waiting(&mut self, now: Instant) { if self.waiting.is_empty() { return; @@ -346,13 +374,15 @@ impl Captures { let _ = w.reply.send(serde_json::json!({"ok": false, "error": timeout_error(w.token)})); continue; } - if self.geometry.is_none() { - still_waiting.push(w); - continue; - } - // The request's clock started when it arrived. - let arrived = w.deadline - DEADLINE; - if let Err((reply, e)) = self.admit_with_geometry(w.token, w.path, w.viewport, w.reply, w.document, w.settle_ms, arrived) { + let admitted = match self.windows.get(&w.viewport).copied() { + None => { + still_waiting.push(w); + continue; + } + Some(Window { geometry: None, .. }) => Err((w.reply, window_closed_error(w.token))), + Some(Window { geometry: Some(geometry), epoch }) => self.admit_with_geometry(w, geometry, epoch), + }; + if let Err((reply, e)) = admitted { let _ = reply.send(serde_json::json!({"ok": false, "error": e})); } } @@ -366,14 +396,10 @@ impl Captures { } } - /// UI phase: issue due requests through `host` (a fresh slot each), return the ones that - /// expired meanwhile. + /// UI phase: issue due requests through `host` (a fresh slot each), each in its own viewport, + /// and return the ones that expired or whose window closed meanwhile. pub fn issue(&mut self, host: &WindowHost, now: Instant, document: Option) -> Vec { let mut finished = Vec::new(); - let Some(current) = self.geometry else { return finished }; - // A document switch inside the pass means neither the drawn frame nor the pass's - // document identity is trustworthy. - let pass_changed = !same_activation(current.document, document); for i in 0..self.records.len() { if self.records[i].issued() { continue; @@ -383,11 +409,18 @@ impl Captures { finished.push(finish(&mut self.records[i], Err(timeout_error(token)))); continue; } + let Some(window) = self.windows.get(&self.records[i].viewport).copied() else { continue }; + let Some(current) = window.geometry else { + finished.push(finish(&mut self.records[i], Err(window_closed_error(token)))); + continue; + }; if !same_activation(document, self.records[i].document) || !same_activation(current.document, self.records[i].document) { finished.push(finish(&mut self.records[i], Err(document_changed_error(token)))); continue; } - if pass_changed { + // A document switch inside the pass means neither the drawn frame nor the pass's + // document identity is trustworthy. + if !same_activation(current.document, document) { continue; } // A minimised window has no surface to read back. @@ -400,10 +433,9 @@ impl Captures { } // No pixels exist yet: finalise the geometry at issue, re-checking the budget, and // let the new layout settle for another pass. - if self.records[i].epoch != self.epoch || !current.same_layout(&self.records[i].geometry) { + if self.records[i].epoch != window.epoch || !current.same_layout(&self.records[i].geometry) { let others: usize = self.records.iter().enumerate().filter(|(j, _)| *j != i).map(|(_, r)| r.reserved_bytes).sum(); - let epoch = self.epoch; - if let Err(e) = revalidate_reservation(&mut self.records[i], others, current, epoch) { + if let Err(e) = revalidate_reservation(&mut self.records[i], others, current, window.epoch) { finished.push(finish(&mut self.records[i], Err(e))); } continue; @@ -411,16 +443,17 @@ impl Captures { let slot = host.screenshot(self.records[i].viewport, MAX_IMAGE_BYTES); let r = &mut self.records[i]; r.slot = Some(slot); - r.issued_epoch = Some(self.epoch); + r.issued_epoch = Some(window.epoch); } self.records.retain(|r| !finished.iter().any(|f| f.token == r.token)); finished } - /// Logic phase: collect completed images (retrying after an epoch advance), expire the late. + /// Logic phase: collect completed images (retrying after an epoch advance), expire the late + /// and fail those whose window closed. Each request is read against the geometry its own + /// viewport recorded this pass. pub fn drain(&mut self, now: Instant, document: Option) -> Vec { - let current = self.geometry; // P3(canvas-widgets-w13): cw.C69 per-viewport geometry. - // Requests that arrived before the first UI pass start here, once its geometry is known. + // Requests that arrived before their viewport was measured start here, once it is. self.admit_waiting(now); let mut finished = Vec::new(); for i in 0..self.records.len() { @@ -430,6 +463,12 @@ impl Captures { finished.push(finish(&mut self.records[i], Err(timeout_error(token)))); continue; } + let window = self.windows.get(&self.records[i].viewport).copied(); + if window.is_some_and(|window| window.geometry.is_none()) { + finished.push(finish(&mut self.records[i], Err(window_closed_error(token)))); + continue; + } + let current = window.and_then(|window| window.geometry); if !same_activation(document, self.records[i].document) || !same_activation(current.and_then(|c| c.document), self.records[i].document) { finished.push(finish(&mut self.records[i], Err(document_changed_error(token)))); continue; @@ -447,13 +486,13 @@ impl Captures { continue; } }; - let Some(current) = current else { + let Some((current, epoch)) = window.and_then(|window| window.geometry.map(|geometry| (geometry, window.epoch))) else { finished.push(finish(&mut self.records[i], Err(format!("screenshot {token} failed: the window geometry is unknown")))); continue; }; // An epoch advance since issue means the image may belong to an intermediate layout, // even if the values changed back. - let epoch_advanced = self.records[i].issued_epoch.is_none_or(|issued| issued != self.epoch); + let epoch_advanced = self.records[i].issued_epoch.is_none_or(|issued| issued != epoch); let pass_mixed = !same_activation(current.document, document); if epoch_advanced || !current.same_layout(&self.records[i].geometry) || pass_mixed { slot.cancel(); @@ -463,7 +502,6 @@ impl Captures { } self.records[i].retries = self.records[i].retries.saturating_add(1); let others: usize = self.records.iter().enumerate().filter(|(j, _)| *j != i).map(|(_, r)| r.reserved_bytes).sum(); - let epoch = self.epoch; match revalidate_reservation(&mut self.records[i], others, current, epoch) { Ok(()) => self.records[i].ready_at = now, Err(e) => finished.push(finish(&mut self.records[i], Err(e))), @@ -597,6 +635,10 @@ fn timeout_error(token: u64) -> String { format!("screenshot {token} timed out: no frame was presented within {} s", DEADLINE.as_secs()) } +fn window_closed_error(token: u64) -> String { + format!("screenshot {token} failed: {WINDOW_CLOSED}") +} + fn document_changed_error(token: u64) -> String { format!("screenshot {token} failed: the document changed while the capture was queued") } diff --git a/crates/automation/src/security.rs b/crates/automation/src/security.rs index 50ce4063c..d6ae9ce11 100644 --- a/crates/automation/src/security.rs +++ b/crates/automation/src/security.rs @@ -262,7 +262,7 @@ pub fn client_token( } /// Counts live connections against [`MAX_CONNECTIONS`]; a [`ConnectionPermit`] releases one when -/// dropped. +/// released or dropped. #[derive(Debug, Default)] pub struct ConnectionLimiter { live: std::sync::Arc, @@ -283,30 +283,38 @@ impl ConnectionLimiter { return None; } match self.live.compare_exchange_weak(current, current + 1, Ordering::AcqRel, Ordering::Acquire) { - Ok(_) => return Some(ConnectionPermit { live: std::sync::Arc::clone(&self.live) }), + Ok(_) => return Some(ConnectionPermit { live: std::sync::Arc::clone(&self.live), released: false }), Err(actual) => current = actual, } } } } -/// One live connection's share of [`ConnectionLimiter`]; dropping it frees the slot. +/// One live connection's share of [`ConnectionLimiter`]; [`Self::release`] or dropping it frees +/// the slot. #[derive(Debug)] pub struct ConnectionPermit { live: std::sync::Arc, + /// The slot was freed by [`Self::release`], so `Drop` must not free it again. + released: bool, } impl ConnectionPermit { /// Frees the slot once, atomically, without `Drop` freeing it again; answers whether this was - /// the last live connection. - pub fn release(self) -> bool { - todo!("fx.F21") + /// the last live connection. One atomic decrement decides it, so of two connections ending + /// together exactly one sees itself as the last. A connection admitted between the decrement and + /// `end_injection` may lose input it sends before authenticating; it sends none. + pub fn release(mut self) -> bool { + self.released = true; + self.live.fetch_sub(1, Ordering::AcqRel) == 1 } } impl Drop for ConnectionPermit { fn drop(&mut self) { - self.live.fetch_sub(1, Ordering::AcqRel); + if !self.released { + self.live.fetch_sub(1, Ordering::AcqRel); + } } } diff --git a/crates/automation/src/server.rs b/crates/automation/src/server.rs index 0ccf4d75a..afeea2d61 100644 --- a/crates/automation/src/server.rs +++ b/crates/automation/src/server.rs @@ -51,8 +51,12 @@ pub fn start_with_deadline( let host = host.clone(); let token = Arc::clone(&token); std::thread::spawn(move || { - let _permit = permit; serve(stream, &token, &tx, &host, auth_deadline); + // What the last client held down would otherwise stay held with no one left to + // release it; while another connection is live, its input is left alone. + if permit.release() { + host.end_injection(); + } }); } }); diff --git a/crates/automation/tests/it/control.rs b/crates/automation/tests/it/control.rs index 6ea346842..2422537fc 100644 --- a/crates/automation/tests/it/control.rs +++ b/crates/automation/tests/it/control.rs @@ -46,6 +46,24 @@ fn deadlines_distinguish_expired_from_timed_out() { assert_eq!(abandoned_reply.try_recv().expect("a reply")["error"], json!(expired_error())); } +/// A request sent without a deadline runs even when nobody waits for its reply any more: a fire-and-forget step +/// (a key press, a release) still happens. +#[trial] +fn a_request_without_a_deadline_is_dispatched_after_its_reply_receiver_is_dropped() { + let (tx, rx) = channel(); + let mut channel = ControlChannel::new(rx); + + let (request, reply) = ControlRequest::new("ui.key", json!({"key": "Escape"})); + assert!(request.deadline.is_none(), "a new request has no deadline"); + drop(reply); + tx.send(request).expect("sent"); + + let next = channel.next_request().expect("the deadline-free request is dispatched"); + assert_eq!(next.method, "ui.key"); + assert_eq!(next.params, json!({"key": "Escape"})); + assert!(channel.next_request().is_none(), "the request runs once"); +} + /// A job's reply goes to the requests waiting on that job only, as the app built it (an error with partial results /// keeps both); the other job's waiter keeps waiting. #[trial] diff --git a/crates/automation/tests/it/screenshot.rs b/crates/automation/tests/it/screenshot.rs index cc3ccc18b..dbda61fad 100644 --- a/crates/automation/tests/it/screenshot.rs +++ b/crates/automation/tests/it/screenshot.rs @@ -1,6 +1,7 @@ //! `Captures`: admission budgets, settling, deadlines, cancellation, document identity, the -//! geometry epoch and the image checks. +//! geometry epoch per viewport, the window a capture names, and the image checks. +use std::cell::RefCell; use std::sync::Arc; use std::sync::mpsc::{Receiver, channel}; use std::time::{Duration, Instant}; @@ -8,11 +9,14 @@ use std::time::{Duration, Instant}; use craft_automation::control::ControlResponse; use craft_automation::screenshot::{ CaptureGeometry, Captures, DEADLINE, DocumentId, Finished, MAX_IMAGE_BYTES, MAX_PENDING, MAX_RETRIES, MAX_TOTAL_BYTES, SETTLE_PASSES, + WINDOW_CLOSED, }; use craft_ui::runtime::motion; use craft_ui::runtime::windows::WindowHost; use craft_ui::testing::trial; -use egui::{Color32, ColorImage, Context, ScreenshotCallback, ViewportCommand, ViewportId}; +use egui::{ + Color32, ColorImage, Context, FullOutput, Pos2, RawInput, Rect, ScreenshotCallback, Vec2, ViewportBuilder, ViewportCommand, ViewportId, ViewportIdMap, ViewportInfo, +}; const DOC: Option = Some(DocumentId::new(1, 1)); @@ -26,13 +30,19 @@ fn geometry_of(width: f32, height: f32, document: Option) -> Capture g } -fn admit_for(captures: &mut Captures, token: u64, document: Option, now: Instant) -> Result, String> { +fn admit_for( + captures: &mut Captures, + token: u64, + viewport: ViewportId, + document: Option, + now: Instant, +) -> Result, String> { let (tx, rx) = channel(); - captures.admit(token, None, egui::ViewportId::ROOT, tx, document, 0.0, now).map(|()| rx).map_err(|(_, e)| e) + captures.admit(token, None, viewport, tx, document, 0.0, now).map(|()| rx).map_err(|(_, e)| e) } fn admit(captures: &mut Captures, token: u64, now: Instant) -> Result, String> { - admit_for(captures, token, None, now) + admit_for(captures, token, ViewportId::ROOT, None, now) } fn filled(size: [usize; 2], color: Color32) -> Arc { @@ -43,13 +53,11 @@ fn image(geometry: &CaptureGeometry) -> Arc { filled(geometry.expected_pixels().expect("a capturable geometry"), Color32::from_rgb(240, 240, 240)) } -/// The callbacks of the screenshot commands the context's window host sent since the last pass. -fn sent(ctx: &Context) -> Vec { - let mut output = ctx.run_ui(Default::default(), |_| {}); - output.textures_delta.clear(); +/// The callbacks of the screenshot commands `output` carries for `viewport`. +fn screenshots(output: &FullOutput, viewport: ViewportId) -> Vec { output .viewport_output - .get(&ViewportId::ROOT) + .get(&viewport) .map(|out| { out.commands .iter() @@ -59,14 +67,22 @@ fn sent(ctx: &Context) -> Vec { .unwrap_or_default() } +/// The callbacks of the screenshot commands the context's window host sent to `viewport` since +/// the last pass. +fn sent(ctx: &Context, viewport: ViewportId) -> Vec { + let mut output = ctx.run_ui(Default::default(), |_| {}); + output.textures_delta.clear(); + screenshots(&output, viewport) +} + /// Settles and issues through the context's window host: the requests that finished, and the -/// callbacks of the captures sent. +/// callbacks of the root captures sent. fn settle_and_issue(captures: &mut Captures, ctx: &Context, now: Instant, document: Option) -> (Vec, Vec) { for _ in 0..SETTLE_PASSES { captures.note_pass(); } let finished = captures.issue(&WindowHost::of(ctx), now, document); - (finished, sent(ctx)) + (finished, sent(ctx, ViewportId::ROOT)) } fn issue_one(captures: &mut Captures, ctx: &Context, now: Instant) -> ScreenshotCallback { @@ -180,7 +196,7 @@ fn settling_counts_passes_and_issues_once() { for pass in 1..=SETTLE_PASSES + 2 { captures.note_pass(); assert!(captures.issue(&host, now, None).is_empty()); - issued += sent(&ctx).len(); + issued += sent(&ctx, ViewportId::ROOT).len(); assert_eq!(issued, usize::from(pass >= SETTLE_PASSES), "after pass {pass}"); } assert!(!captures.any_unissued()); @@ -278,7 +294,7 @@ fn a_capture_follows_the_document_generation() { for (after, captured) in [(other, false), (edited, true)] { let mut captures = Captures::default(); captures.note_geometry(egui::ViewportId::ROOT, g); - admit_for(&mut captures, 21, DOC, now).expect("admitted"); + admit_for(&mut captures, 21, ViewportId::ROOT, DOC, now).expect("admitted"); let (_, mut callbacks) = settle_and_issue(&mut captures, &ctx, now, DOC); callbacks.pop().expect("one capture").complete(image(&g)); let current = geometry_of(800.0, 600.0, after); @@ -294,7 +310,7 @@ fn a_capture_follows_the_document_generation() { // The pass began in generation 1 and ended in 2: no capture of a mixed frame. let mut captures = Captures::default(); captures.note_geometry(egui::ViewportId::ROOT, g); - admit_for(&mut captures, 23, DOC, now).expect("admitted"); + admit_for(&mut captures, 23, ViewportId::ROOT, DOC, now).expect("admitted"); let (finished, callbacks) = settle_and_issue(&mut captures, &ctx, now, other); assert!(callbacks.is_empty()); assert_eq!(finished.len(), 1); @@ -377,18 +393,126 @@ fn the_image_must_match_the_issued_viewport() { } } -/// A minimised window has no surface: the request fails before anything is issued. +const ROOT_SIZE: Vec2 = Vec2::new(800.0, 600.0); +const CHILD_SIZE: Vec2 = Vec2::new(400.0, 300.0); + +thread_local! { + /// The screenshot callbacks the child's own passes sent out. + static CHILD_SHOTS: RefCell> = const { RefCell::new(Vec::new()) }; +} + +fn child() -> ViewportId { + ViewportId::from_hash_of("craft_automation.screenshot.child") +} + +/// A window of `size` at one pixel per point, as the integration reports it. +fn window_info(size: Vec2) -> ViewportInfo { + ViewportInfo { inner_rect: Some(Rect::from_min_size(Pos2::ZERO, size)), native_pixels_per_point: Some(1.0), ..ViewportInfo::default() } +} + +/// A renderer like eframe's: the child's pass runs nested inside the root's. +fn render_child(ctx: &Context, viewport: egui::ImmediateViewport<'_>) { + let mut show = viewport.viewport_ui_cb; + let mut viewports = ViewportIdMap::default(); + viewports.insert(viewport.ids.this, ViewportInfo { parent: Some(viewport.ids.parent), ..window_info(CHILD_SIZE) }); + let input = RawInput { + viewport_id: viewport.ids.this, + screen_rect: Some(Rect::from_min_size(Pos2::ZERO, CHILD_SIZE)), + viewports, + ..RawInput::default() + }; + let mut output = ctx.run_ui(input, |ui| show(ui)); + output.textures_delta.clear(); + CHILD_SHOTS.with(|shots| shots.borrow_mut().extend(screenshots(&output, viewport.ids.this))); +} + +/// One frame of a root that shows the child window while `open`, and lists it in the windows the +/// integration reports. Returns the screenshot callbacks sent to the root and to the child. +fn frame(ctx: &Context, open: bool) -> (Vec, Vec) { + let mut viewports = ViewportIdMap::default(); + viewports.insert(ViewportId::ROOT, window_info(ROOT_SIZE)); + if open { + viewports.insert(child(), window_info(CHILD_SIZE)); + } + let input = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, ROOT_SIZE)), viewports, ..RawInput::default() }; + let mut output = ctx.run_ui(input, |ui| { + if open { + ui.ctx().show_viewport_immediate(child(), ViewportBuilder::default(), |_, _| {}); + } + }); + output.textures_delta.clear(); + let mut to_child = screenshots(&output, child()); + to_child.extend(CHILD_SHOTS.with(|shots| std::mem::take(&mut *shots.borrow_mut()))); + (screenshots(&output, ViewportId::ROOT), to_child) +} + +/// A capture names its window: it is sized from that window's geometry and shot in that viewport, +/// and once the window is gone it fails at once instead of waiting out the deadline. #[trial] -fn a_minimized_window_is_refused_before_issue() { +fn a_screenshot_names_its_window_and_fails_once_it_closes() { let ctx = Context::default(); + ctx.set_embed_viewports(false); + Context::set_immediate_viewport_renderer(render_child); + let host = WindowHost::of(&ctx); let now = motion::now(); let mut captures = Captures::default(); - let mut g = geometry(800.0, 600.0); - g.minimized = true; - captures.note_geometry(egui::ViewportId::ROOT, g); - admit(&mut captures, 52, now).expect("admitted"); - let (finished, callbacks) = settle_and_issue(&mut captures, &ctx, now, None); - assert!(callbacks.is_empty()); + frame(&ctx, true); + + let rx = admit_for(&mut captures, 81, child(), None, now).expect("waits for the child's geometry"); + captures.note_windows(&host, None); + assert_eq!(captures.last_geometry(child()).map(|g| g.size_points), Some([CHILD_SIZE.x, CHILD_SIZE.y])); + assert!(captures.drain(now, None).is_empty()); + assert_eq!(captures.reserved_bytes(), 400 * 300 * 4, "reserved at the child's size, not the root's"); + for _ in 0..SETTLE_PASSES { + captures.note_pass(); + } + assert!(captures.issue(&host, now, None).is_empty()); + let (to_root, mut to_child) = frame(&ctx, true); + assert!(to_root.is_empty(), "the root is not shot"); + assert_eq!(to_child.len(), 1, "the child is shot"); + to_child.remove(0).complete(filled([400, 300], Color32::WHITE)); + captures.note_windows(&host, None); + let finished = captures.drain(now, None); assert_eq!(finished.len(), 1); - assert!(error(&finished[0]).contains("minimized")); + assert_eq!(finished[0].result.as_ref().map(|image| image.size), Ok([400, 300])); + assert!(rx.try_recv().is_err(), "the caller replies from the Finished"); + + admit_for(&mut captures, 82, child(), None, now).expect("admitted while the child is open"); + frame(&ctx, false); + captures.note_windows(&host, None); + let finished = captures.drain(now, None); + assert_eq!(finished.len(), 1, "no wait for the deadline"); + assert_eq!(error(&finished[0]), format!("screenshot 82 failed: {WINDOW_CLOSED}")); + assert_eq!(captures.pending(), 0); + let e = admit_for(&mut captures, 83, child(), None, now).expect_err("the window is closed"); + assert_eq!(e, format!("screenshot 83 failed: {WINDOW_CLOSED}")); +} + +/// A child window the integration lists before it reports a size is open, not closed: its request keeps waiting, and +/// is shot once the size arrives. +#[trial] +fn a_window_listed_without_a_size_keeps_its_request_waiting() { + let ctx = Context::default(); + ctx.set_embed_viewports(false); + Context::set_immediate_viewport_renderer(render_child); + let host = WindowHost::of(&ctx); + let now = motion::now(); + let mut captures = Captures::default(); + + let mut viewports = ViewportIdMap::default(); + viewports.insert(ViewportId::ROOT, window_info(ROOT_SIZE)); + viewports.insert(child(), ViewportInfo::default()); + let input = RawInput { screen_rect: Some(Rect::from_min_size(Pos2::ZERO, ROOT_SIZE)), viewports, ..RawInput::default() }; + ctx.run_ui(input, |_| {}).textures_delta.clear(); + assert!(host.is_open(child()) && host.screenshot_facts(child()).is_none()); + + admit_for(&mut captures, 91, child(), None, now).expect("waits for the child's geometry"); + captures.note_windows(&host, None); + assert!(captures.drain(now, None).is_empty(), "not failed as closed"); + assert_eq!(captures.pending(), 1); + + frame(&ctx, true); + captures.note_windows(&host, None); + assert_eq!(captures.last_geometry(child()).map(|g| g.size_points), Some([CHILD_SIZE.x, CHILD_SIZE.y])); + assert!(captures.drain(now, None).is_empty()); } diff --git a/crates/automation/tests/it/synthetic.rs b/crates/automation/tests/it/synthetic.rs index 32ad12778..6be4ffe30 100644 --- a/crates/automation/tests/it/synthetic.rs +++ b/crates/automation/tests/it/synthetic.rs @@ -139,7 +139,7 @@ fn a_held_key_stays_down_until_its_release() { #[trial] fn a_wheel_turn_carries_its_modifiers() { let mut rig = Rig::new(); - rig.send("ui.wheel", json!({"x": 30, "y": 20, "dy": 40, "command": true})); + rig.send("ui.wheel", json!({"x": 30, "y": 20, "dy": 40, "alt": true})); let passes = rig.take(); let turn = passes.iter().find_map(|pass| { pass.events.iter().find_map(|event| match event { @@ -149,7 +149,7 @@ fn a_wheel_turn_carries_its_modifiers() { }); let (pos, delta, modifiers) = turn.expect("a pass saw the turn"); assert_eq!(pos, Some(pos2(30.0, 20.0))); - assert!(delta.y > 0.0 && delta.x == 0.0 && modifiers.command); + assert!(delta.y > 0.0 && delta.x == 0.0 && modifiers.alt); } /// The injected Caps Lock state wins over the platform's until it is cleared. @@ -247,3 +247,15 @@ fn queued_input_is_withdrawn_when_its_target_changes() { assert!(answer["error"].as_str().is_some_and(|error| error.contains(TARGET_CHANGED)), "{answer}"); assert!(host.injected_idle()); } + +/// A queued pass of the root keeps the host busy until one pass of the root ran. +#[trial] +fn a_queued_pass_holds_idle_until_it_ran() { + let mut rig = Rig::new(); + let host = rig.host(); + host.inject_pass(ViewportId::ROOT); + assert!(!host.injected_idle(), "the pass has not run"); + rig.fx.frame(Vec::new()); + rig.fx.frame(Vec::new()); + assert!(host.injected_idle(), "the pass ran"); +} diff --git a/crates/color/src/ui/screen_picker.rs b/crates/color/src/ui/screen_picker.rs index 1963ef520..5b5339061 100644 --- a/crates/color/src/ui/screen_picker.rs +++ b/crates/color/src/ui/screen_picker.rs @@ -28,7 +28,7 @@ use craft_ui::bars::StatusMessage; use craft_ui::contract::{Pattern, Props as _, Show as _, ShowContainer as _}; use craft_ui::runtime::env::{Env, Label}; use craft_ui::runtime::windows::{ScreenshotSlot, WindowHost}; -use egui::{Color32, Context, Pos2, Rect, Ui, ViewportId, pos2, vec2}; +use egui::{Color32, Context, Pos2, Rect, Ui, pos2, vec2}; use super::ScreenPickGesture; @@ -440,8 +440,9 @@ impl ScreenPick { } }; let windows = WindowHost::of(ctx); - // P3(canvas-widgets-w13): cw.C66 — `screenshot_facts` takes the viewport and gives `None` when it is not running. - let Some(size) = windows.screenshot_facts(windows.current()) else { + // The frame is measured and shot in the same viewport, so a pick inside a child window samples that window. + let viewport = windows.current(); + let Some(size) = windows.screenshot_facts(viewport) else { self.hold = None; return None; }; @@ -458,7 +459,7 @@ impl ScreenPick { let sampled = hold.frame.as_ref().filter(|_| inside).and_then(|frame| sample_frame(frame, size.pixels_per_point, at, back.as_deref())); if !released { if hold.slot.is_none() { - hold.slot = Some(windows.screenshot(ViewportId::ROOT, FRAME_BYTES)); + hold.slot = Some(windows.screenshot(viewport, FRAME_BYTES)); } ctx.request_repaint(); return sampled; diff --git a/crates/ui-contract/src/runtime/egui/access.rs b/crates/ui-contract/src/runtime/egui/access.rs index b926d1878..2970881ce 100644 --- a/crates/ui-contract/src/runtime/egui/access.rs +++ b/crates/ui-contract/src/runtime/egui/access.rs @@ -27,9 +27,21 @@ pub use tree::{AccessTree, Declared, NodeKey}; /// The rect `id`'s response had in the last finished pass, converted as the node's bounds are; `None` when absent, /// without area, or behind the open modal. The ids it answers are component and item widget ids; parts have none. +/// It answers for the context's current viewport (the root between frames); a child window's rects are read inside +/// that window's pass. pub fn bounds(ctx: &Context, id: Id) -> Option { - let _ = (ctx, id); - todo!("cw.C67") + let widget = ctx.widget_rect_last_pass(id)?; + if behind_modal(ctx, ctx.viewport_id(), widget.layer_id) { + return None; + } + let rect = widget.rect; + (rect.is_finite() && rect.width() > 0.0 && rect.height() > 0.0).then_some(rect) +} + +/// Whether a widget on `layer` sits behind the open modal of `viewport`: a modal layer is open there and `layer` is +/// not above it. The access tree and [`bounds`] both ask this, so automation never gets a rect the tree hides. +fn behind_modal(ctx: &Context, viewport: ViewportId, layer: egui::LayerId) -> bool { + crate::runtime::commands::modal_root(ctx, viewport).is_some() && !ctx.memory(|memory| memory.is_above_modal_layer(layer)) } /// The AccessKit role of a node. @@ -161,11 +173,12 @@ pub(crate) fn order_children(ctx: &Context) { /// While a modal layer is open in `viewport`, hides the nodes the runtime wrote on layers below it: what sits behind /// a modal is inert for assistive technology, as it is for the pointer and the keys. fn hide_behind_modal(ctx: &Context, viewport: ViewportId, written: &HashSet) { + // Without a modal nothing is behind one; this spares reading every written node's response. if crate::runtime::commands::modal_root(ctx, viewport).is_none() { return; } for id in written { - let behind = ctx.read_response(*id).is_some_and(|response| !ctx.memory(|memory| memory.is_above_modal_layer(response.layer_id))); + let behind = ctx.read_response(*id).is_some_and(|response| behind_modal(ctx, viewport, response.layer_id)); if behind { hide(ctx, *id); } diff --git a/crates/ui-contract/src/runtime/egui/injected.rs b/crates/ui-contract/src/runtime/egui/injected.rs index 2e03fbc82..9c7fafdc6 100644 --- a/crates/ui-contract/src/runtime/egui/injected.rs +++ b/crates/ui-contract/src/runtime/egui/injected.rs @@ -230,6 +230,8 @@ struct Flight { #[derive(Default)] struct Lane { + /// The frame whose first pass took the latest step: later passes of that frame take none. + entered: Option, queue: VecDeque, flight: Option, /// The application withdrew the lane's input ([`withdraw`]); the next input hook carries it out. @@ -303,6 +305,7 @@ fn remove_event_run(events: &mut Vec, step: &[Event]) { pub(crate) fn input_hook(ctx: &Context, input: &mut egui::RawInput) -> bool { let viewport = input.viewport_id; let (pass_nr, focused) = (pass::pass_nr(ctx, viewport), crate::runtime::focus::record(ctx, viewport).focused); + let frame = pass::frame_nr(ctx, viewport); let mut wake = None; let follow = Service::::run(ctx, |injected| { let Some(lane) = injected.lanes.get_mut(&viewport) else { return false }; @@ -337,6 +340,11 @@ pub(crate) fn input_hook(ctx: &Context, input: &mut egui::RawInput) -> bool { return !lane.queue.is_empty(); } } + if lane.entered == Some(frame) { + // A later pass of the frame whose first pass took a step takes none: input enters a frame's first pass + // only. The step in flight still ends, or is withdrawn, as above. + return !lane.queue.is_empty(); + } if let Some(step) = lane.queue.pop_front() { input.events.extend(step.events.iter().cloned()); let until = (step.rest > 0.0).then_some(input.time).flatten().map(|now| now + step.rest); @@ -344,6 +352,7 @@ pub(crate) fn input_hook(ctx: &Context, input: &mut egui::RawInput) -> bool { let before = held.clone(); held.apply(&step.events); lane.flight = Some(Flight { step, pass: pass_nr, focus: focused, until, before }); + lane.entered = Some(frame); return !lane.queue.is_empty(); } false @@ -461,6 +470,14 @@ pub(crate) fn inject_text(ctx: &Context, viewport: ViewportId, text: &str) { }); } +/// Queues one pass of `viewport` behind its queue, with no events: `idle` stays false until that pass ran. +pub(crate) fn inject_pass(ctx: &Context, viewport: ViewportId) { + queue(ctx, viewport, |request| { + let mods = request.held.mods; + request.step(mods, []); + }); +} + /// Sets the Caps Lock state injected input holds in place of the platform's; `None` returns to the platform's. pub(crate) fn set_caps_lock(ctx: &Context, on: Option) { Service::::run(ctx, |injected| injected.caps_lock = on); diff --git a/crates/ui-contract/src/runtime/egui/screenshot.rs b/crates/ui-contract/src/runtime/egui/screenshot.rs index e469d8c1a..64257989f 100644 --- a/crates/ui-contract/src/runtime/egui/screenshot.rs +++ b/crates/ui-contract/src/runtime/egui/screenshot.rs @@ -103,7 +103,7 @@ pub struct ScreenshotSlot { shared: Arc, } -/// What a screenshot of the running viewport measures this pass. +/// What a screenshot of one viewport measures this pass. #[non_exhaustive] #[derive(Clone, Copy, Debug, PartialEq)] pub struct ScreenshotFacts { @@ -129,16 +129,20 @@ pub(crate) fn issue(ctx: &Context, viewport: ViewportId, max_image_bytes: usize) slot } -/// What a screenshot of `viewport` measures this pass; `None` when the viewport is not running. +/// What a screenshot of `viewport` measures this pass, from the window that viewport reported; `None` when the +/// viewport is not open. The size is the window's inner rect; only the running viewport falls back to its input +/// rect, since another viewport's input is not this pass's. pub(crate) fn facts(ctx: &Context, viewport: ViewportId) -> Option { - let _ = viewport; // P3(canvas-widgets-w13): cw.C66 - let window = viewports::current(ctx); - let size_points = ctx.input(|input| window.inner.map_or_else(|| input.viewport_rect().size(), |inner| inner.size())); - let max_texture_side = ctx.input(|input| input.max_texture_side); + let window = viewports::reported(ctx).into_iter().find_map(|(id, facts)| (id == viewport).then_some(facts))?; + let running = ctx.viewport_id() == viewport; + let (size_points, max_texture_side) = ctx.input(|input| { + let size = window.inner.map(|inner| inner.size()).or_else(|| running.then(|| input.viewport_rect().size())); + (size, input.max_texture_side) + }); let zoom = ctx.zoom_factor(); let pixels_per_point = window.native_scale.filter(|scale| scale.is_finite() && *scale > 0.0).map_or_else(|| ctx.pixels_per_point(), |scale| scale * zoom); - Some(ScreenshotFacts { size_points, pixels_per_point, zoom, max_texture_side, minimized: window.minimized }) + Some(ScreenshotFacts { size_points: size_points?, pixels_per_point, zoom, max_texture_side, minimized: window.minimized }) } impl ScreenshotSlot { diff --git a/crates/ui-contract/src/runtime/frame.rs b/crates/ui-contract/src/runtime/frame.rs index 06ea15f3f..9b0d37388 100644 --- a/crates/ui-contract/src/runtime/frame.rs +++ b/crates/ui-contract/src/runtime/frame.rs @@ -415,7 +415,8 @@ pub fn discardable(ctx: &Context) -> bool { } /// Discards the running pass, so nothing of it paints, and runs it again, when [`discardable`]: for a host that learns -/// only after a part ran that the part showed what it must not. +/// only after a part ran that the part showed what it must not. A pass after a discard carries no input (events, +/// injected steps and press edges enter a frame's first pass only); held state persists. pub fn discard_pass(ctx: &Context, reason: &'static str) { crate::runtime::egui::sizing::request_discard(ctx, crate::runtime::egui::sizing::Rerun::App(reason)); } diff --git a/crates/ui-contract/src/runtime/pointer.rs b/crates/ui-contract/src/runtime/pointer.rs index 336a1a051..baa3bf73a 100644 --- a/crates/ui-contract/src/runtime/pointer.rs +++ b/crates/ui-contract/src/runtime/pointer.rs @@ -23,7 +23,10 @@ pub(crate) const WHEEL_LINE_POINTS: f32 = 40.0; /// Points one wheel page adds to `PointerFrame.scroll`. pub(crate) const WHEEL_PAGE_POINTS: f32 = 400.0; -/// The pointer input of one pass of one viewport, egui-converted. +/// The pointer input of one pass of one viewport, egui-converted. Input enters a frame's first pass only (egui hands +/// the frame's events to it, and injected steps and held-back presses follow the frame): a rerun pass of the +/// frame carries no events, so its `delta`, `press`, `release` and `scroll` are empty while the held facts (`pos`, +/// `buttons`) persist. A consumer applies what its pass hands it and never turns a held fact into an event. #[derive(Clone, Debug)] #[non_exhaustive] pub struct PointerFrame { @@ -67,7 +70,8 @@ pub struct PressTargets { pub drag: Option, } -/// What the begin hook read of the pass, for the sensing core and the services. +/// What the begin hook read of the pass, for the sensing core and the services. Built from the pass's own events, +/// so a rerun pass of a frame (see [`PointerFrame`]) reads none. #[derive(Clone, Debug, Default)] #[doc(hidden)] pub struct PassPointer { diff --git a/crates/ui-contract/src/runtime/windows/host.rs b/crates/ui-contract/src/runtime/windows/host.rs index bb7d723df..589ae3ffb 100644 --- a/crates/ui-contract/src/runtime/windows/host.rs +++ b/crates/ui-contract/src/runtime/windows/host.rs @@ -100,6 +100,11 @@ impl WindowHost { screenshot::issue(&self.ctx, viewport, max_image_bytes) } + /// Whether `viewport`'s window is open this pass, measured or not. + pub fn is_open(&self, viewport: ViewportId) -> bool { + viewports::reported(&self.ctx).iter().any(|(id, _)| *id == viewport) + } + /// What a screenshot of `viewport` measures this pass; `None` when the viewport is not running. pub fn screenshot_facts(&self, viewport: ViewportId) -> Option { screenshot::facts(&self.ctx, viewport) @@ -171,6 +176,12 @@ impl WindowHost { injected::inject_text(&self.ctx, viewport, text); } + /// Queues `event` as the platform's input method would deliver it (a preedit or a commit), behind earlier + /// injected input. + pub fn inject_ime(&self, viewport: ViewportId, event: egui::ImeEvent) { + injected::inject_ime(&self.ctx, viewport, event); + } + /// Withdraws the injected input of `viewport` (the document changed) at its next input hook: a step whose pass /// has not run and the queue behind it; what is dropped counts as withdrawn /// ([`take_injected_withdrawn`](Self::take_injected_withdrawn)). Called from the raw input hook, so every @@ -184,12 +195,22 @@ impl WindowHost { injected::cancel(&self.ctx) } - /// Ends the injection session: the automation connection that fed it is gone. + /// Ends the injection session: the automation connection that fed it is gone. Drops every queue and step in + /// flight, queues the release of every button, key and modifier injected input holds (they run on each + /// viewport's next pass), and returns Caps Lock to the platform's state. pub fn end_injection(&self) { injected::end(&self.ctx); } - /// Whether no injected step is queued or awaits its pass: the application may answer its waiters. + /// Queues a pass of `viewport` behind its injected input: `injected_idle` stays false until that pass ran. A + /// component that keeps injected input of its own for its next pass (the tool host's `ToolHost::inject`) calls + /// it, so automation's idle answer waits for the pass that takes the input. + pub fn inject_pass(&self, viewport: ViewportId) { + injected::inject_pass(&self.ctx, viewport); + } + + /// Whether no injected step is queued or awaits its pass (see [`inject_pass`](Self::inject_pass)): the + /// application may answer its waiters. pub fn injected_idle(&self) -> bool { injected::idle(&self.ctx) } diff --git a/crates/ui-contract/tests/it/access/bounds.rs b/crates/ui-contract/tests/it/access/bounds.rs new file mode 100644 index 000000000..fa9f9f710 --- /dev/null +++ b/crates/ui-contract/tests/it/access/bounds.rs @@ -0,0 +1,94 @@ +//! `runtime::access::bounds`: the rect automation clicks hides what the access tree hides. + +use craft_ui::contract::{ + Common, Component, Container, ContainerProps, Cx, Mount, Overlay, Props as _, Role, Show as _, ShowContainer as _, +}; +use craft_ui::runtime::access::bounds; +use craft_ui::style::StyleCx; +use craft_ui::testing::{Frames, trial}; +use craft_ui_test_kit::contract::PlainStyle; +use egui::{Rect, Response, Ui, Vec2}; +use std::cell::Cell; + +/// A button-like leaf with a fixed size. +#[derive(craft_ui::contract::Component)] +struct Apply { + #[common] + common: Common, +} + +impl Component for Apply { + const ROLE: Role = Role::BUTTON; + type Style = PlainStyle; + type Output = Response; + + fn style(_: &StyleCx<'_>, _: ApplyStyleKey) -> PlainStyle { + PlainStyle::min(Vec2::new(80.0, 24.0)) + } + + fn finish(self, cx: Cx<'_, Self>) -> Response { + cx.response.clone() + } +} + +/// A modal layer with an empty body. +#[derive(craft_ui::contract::Component)] +#[component(container)] +struct Modal { + #[common] + common: Common, + #[container] + props: ContainerProps, +} + +impl Component for Modal { + const ROLE: Role = Role::GROUP; + type Style = PlainStyle; + type Output = Response; + + fn style(_: &StyleCx<'_>, _: ModalStyleKey) -> PlainStyle { + PlainStyle::min(Vec2::new(120.0, 60.0)) + } + + fn finish(self, cx: Cx<'_, Self>) -> Response { + cx.response.clone() + } +} + +impl Container for Modal {} + +/// A shown button answers its last pass's rect; a button not shown this pass answers `None`; the same button behind +/// an open modal answers `None`, as the access tree hides it. +#[trial] +fn bounds_of_a_part_behind_a_modal_is_none() { + let mut frames = Frames::new(); + let shown: Cell> = Cell::new(None); + let button = |ui: &mut Ui| { + let response = Apply { common: Common::new() }.label("Apply").id_salt("apply").show(ui); + shown.set(Some((response.id, response.rect))); + }; + + for _ in 0..2 { + frames.frame(vec![], button); + } + let Some((id, rect)) = shown.get() else { panic!("the button was shown") }; + assert!(rect.width() > 0.0 && rect.height() > 0.0, "the button has area: {rect:?}"); + assert_eq!(bounds(&frames.ctx, id), Some(rect), "a shown button answers its rect"); + + frames.frame(vec![], |_| {}); + assert_eq!(bounds(&frames.ctx, id), None, "a button not shown this pass has no rect"); + + // The modal registers at the end of a pass and egui takes its layer at the next pass's start, so a few frames + // settle it before the check. + for _ in 0..4 { + frames.frame(vec![], |ui| { + button(ui); + let props = ContainerProps::new().mount(Mount::Layer(Overlay::modal())); + Modal { common: Common::new(), props }.id_salt("modal").show(ui, |_, _| {}); + }); + } + let Some((behind, _)) = shown.get() else { panic!("the button was shown") }; + assert_eq!(behind, id, "the button keeps its id under the modal"); + assert!(frames.ctx.read_response(id).is_some(), "the button was shown this pass"); + assert_eq!(bounds(&frames.ctx, id), None, "a button behind the open modal has no rect"); +} diff --git a/crates/ui-contract/tests/it/runtime/pointer.rs b/crates/ui-contract/tests/it/runtime/pointer.rs index 37de35743..c0f5fbf32 100644 --- a/crates/ui-contract/tests/it/runtime/pointer.rs +++ b/crates/ui-contract/tests/it/runtime/pointer.rs @@ -239,3 +239,65 @@ fn a_held_press_reads_down_once_through_a_discard_pass_and_later_frames() { assert!(phases.iter().all(|phase| phase.button_down() || matches!(phase, PressPhase::Release { .. })), "{phases:?}"); assert!(matches!(phases.last(), Some(PressPhase::Release { .. })), "{phases:?}"); } + +/// Input enters the first pass of a frame only: a frame with a pointer move, a wheel notch, a key press and an +/// injected step, forced to rerun, hands each to its consumer once. The rerun pass is not stirred, its wheel taker +/// has no share, its focused component has no intent and it carries no injected step. +#[trial] +fn a_rerun_pass_delivers_none_of_the_frames_input_again() { + use craft_behavior::{Input, WheelTaker}; + use craft_ui::runtime::focus::{FocusTarget, KeyUse}; + use craft_ui::testing::focus::{Stop, intents_of, named_id, register_stop, widget}; + use craft_ui::testing::input::key_press; + use craft_ui::testing::wheel::{register, take}; + + #[derive(Default)] + struct Pass { + stirred: bool, + wheel: bool, + moves: usize, + injected: bool, + } + let field = named_id("rerun_field"); + let log: Rc>> = Rc::default(); + let sink = log.clone(); + let mut show = move |ui: &mut Ui| { + let ctx = ui.ctx().clone(); + widget(ui, field); + register_stop(&ctx, Stop::new(field, KeyUse::of(Input::Text))); + register(&ctx, WheelTaker::new(field, Rect::from_min_size(Pos2::ZERO, Vec2::splat(400.0))).vertical(true)); + let mut intents = intents_of(&ctx, Some(field), false); + let mut moves = 0; + while intents.take_move().is_some() { + moves += 1; + } + sink.borrow_mut().push(Pass { + stirred: craft_ui::runtime::pointer::with_pass_pointer(&ctx, |pass| pass.stirred), + wheel: take(&ctx, field).is_some(), + moves, + injected: craft_ui::runtime::windows::WindowHost::of(&ctx).injected_pass(), + }); + }; + let mut frames = Frames::new(); + frames.idle(2, &mut show); + craft_ui::runtime::focus::request(&frames.ctx, FocusTarget::Id(field)); + frames.idle(2, &mut show); + craft_ui::runtime::windows::WindowHost::of(&frames.ctx).inject_text(egui::ViewportId::ROOT, "x"); + log.borrow_mut().clear(); + let mut first = true; + let events = vec![pointer::moved(Pos2::new(20.0, 20.0)), pointer::wheel(-30.0), key_press(egui::Key::ArrowRight, egui::Modifiers::NONE)]; + let passes = frames.frame(events, |ui| { + if std::mem::take(&mut first) { + craft_ui::runtime::frame::discard_pass(ui.ctx(), "test"); + } + show(ui); + }); + assert_eq!(passes, 2, "the frame reruns"); + let log = log.borrow(); + assert_eq!(log.len(), 2); + assert_eq!(log.iter().filter(|pass| pass.stirred).count(), 1, "one pass saw the pointer move"); + assert_eq!(log.iter().filter(|pass| pass.wheel).count(), 1, "one pass took the wheel notch"); + assert_eq!(log.iter().map(|pass| pass.moves).sum::(), 1, "the key's intent arrived once"); + assert_eq!(log.iter().filter(|pass| pass.injected).count(), 1, "the injected step entered once"); + assert!(log[0].stirred && log[0].injected && !log[1].stirred && !log[1].injected, "the first pass carries the input"); +}