f67d38b35cc5
control.rs
use super::{ControlRequest, FilmcraftApp, capture, json};
use crate::control;
impl FilmcraftApp {
// ---------------------------------------------------------------- control channel
/// Make the UI pass run for a control request without stealing the user's keyboard focus.
pub(crate) fn raise_for_control(&mut self, ctx: &egui::Context) {
if let Some(raise) = self.hooks.raise_without_focus.as_mut() {
raise();
}
ctx.request_repaint();
}
/// Drain queued control requests without blocking: UI requests wait for a layout pass with a 3 s deadline (except screenshots), non-UI requests run now,
/// and hidden windows are raised and repainted.
pub(super) fn drain_control(&mut self, ctx: &egui::Context) {
let Some(rx) = self.control_rx.take() else { return };
let now = self.now();
let mut reqs: Vec<(ControlRequest, f64)> = std::mem::take(&mut self.deferred);
while let Ok(req) = rx.try_recv() {
// UI requests need rendered frames: raise the window if `ui` hasn't run recently
// (occluded macOS windows stop running `ui`).
if req.method.starts_with("ui.") && now - self.last_ui_time > 0.25 {
self.raise_for_control(ctx);
// A hidden native window still needs a real UI pass for widget state/geometry.
ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
}
reqs.push((req, now + 3.0));
}
for (req, deadline) in reqs {
if req.method.starts_with("ui.") && req.method != "ui.screenshot" {
self.ui_requests.push((req, deadline));
ctx.request_repaint();
ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
continue;
}
let reply = req.reply.clone();
match control::handle(self, ctx, &req) {
control::Outcome::Done(v) => {
let _ = reply.send(v);
}
control::Outcome::Retry(msg) => {
if now < deadline {
self.deferred.push((req, deadline));
ctx.request_repaint();
} else {
let _ = reply.send(json!({"ok": false, "error": msg}));
}
}
control::Outcome::AfterInput => self.input_waiters.push(reply),
control::Outcome::Screenshot { path, crop } => {
capture::admit(self, ctx, path, crop, reply);
}
}
}
self.control_rx = Some(rx);
self.ui_requests.retain(|(req, deadline)| {
if now > *deadline {
let _ = req.reply.send(json!({"ok": false, "error": "no UI pass ran before the control request deadline"}));
false
} else {
true
}
});
}
/// Process control requests that need the current layout/response. Called at the end of a
/// final, non-discarded UI pass; `ui.click`/`ui.drag` queue synthetic input for the next pass.
pub(super) fn drain_ui_requests(&mut self, ctx: &egui::Context) {
let reqs = std::mem::take(&mut self.ui_requests);
let now = self.now();
let mut pending = reqs.into_iter();
while let Some((req, deadline)) = pending.next() {
// A panel/dock/resize request changes the next layout. Anything after it in this
// batch (ui.click, ui.elements, ui.screenshot, …) must see the new geometry, so it
// waits for the next accepted pass rather than reading the layout drawn before it.
let changes_layout = matches!(req.method.as_str(), "ui.set" | "ui.panel.show" | "ui.panel.close" | "ui.resize");
let reply = req.reply.clone();
match control::handle(self, ctx, &req) {
control::Outcome::Done(v) => {
let _ = reply.send(v);
}
control::Outcome::Retry(msg) => {
if now < deadline {
self.ui_requests.push((req, deadline));
ctx.request_repaint();
} else {
let _ = reply.send(json!({"ok": false, "error": msg}));
}
}
control::Outcome::AfterInput => self.input_waiters.push(reply),
control::Outcome::Screenshot { path, crop } => capture::admit(self, ctx, path, crop, reply),
}
if changes_layout {
let rest: Vec<_> = pending.collect();
if !rest.is_empty() {
self.ui_requests.extend(rest);
ctx.request_repaint();
ctx.send_viewport_cmd(egui::ViewportCommand::RequestPaintWhileHidden);
}
break;
}
}
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.