Struct AutomationQueue 

pub struct AutomationQueue { /* private fields */ }

Implementations

impl AutomationQueue

pub fn new() -> Arc<Self>

pub fn attach(&self, ctx: &Context)

Give the queue the egui context so a submit can wake an idle frame loop.

pub fn set_waker(&self, waker: Waker)

Install the app thread’s waker (the desktop event loop’s proxy). Work queued before it was installed is not stranded: the waker fires at once.

pub fn submit(&self, envelope: Envelope) -> Receiver<Reply>

Enqueue a command. The reply arrives on the returned receiver once the app has reached the command’s phase (or at once, for an unknown command or a poisoned session).

pub fn submit_before( &self, envelope: Envelope, deadline: Option<Instant>, ) -> Receiver<Reply>

A deadline applies before dispatch, never to work already accepted by a handler.

pub fn withdraw(&self, id: u64) -> Withdrawn

The host stopped waiting for command id. A command still queued is removed and answered as never dispatched; anything else was accepted.

pub fn has_frameless_work(&self) -> bool

Whether drain_frameless has anything to do: a frame-free command at the head of the queue, or polled work.

pub fn push_notice(&self, kind: NoticeKind, text: impl Into<String>)

Record something the session should know about — a toast the user would have seen, a refusal, a panic. The app’s own toast lane feeds this every frame (BrepApp::ui), so notices reports what was on screen.

pub fn take_notices(&self) -> Vec<Notice>

Drain for the notices COMMAND: everything since the last drain. The reply cursor goes back to the start with them — the buffer is empty, so the reply this drain rides out on carries nothing twice.

pub fn pointer(&self) -> Pointer

pub fn frame(&self) -> u64

pub fn has_pending(&self) -> bool

pub fn is_polling(&self, id: u64) -> bool

Whether a command has started work the queue is polling (see Outcome::Poll): a host keeps stepping frames for it past its usual frame budget, since the work is advancing, not stuck.

pub fn poison(&self, why: impl Into<String>)

Mark the session unusable (a panic unwound through the app). Every pending and future command is answered with the reason.

pub fn is_poisoned(&self) -> bool

pub fn drain_input( &self, raw: &mut RawInput, frame: u64, ppp: f32, view: Option<Rect>, ctx: &Context, )

Phase 1 of the frame: apply input commands as egui::Events and complete captures whose Event::Screenshot arrived. view is the viewport rect of the last frame (for region: viewport crops). ctx is the app’s: the pointer reads egui’s clock from it (the headless host leaves raw.time unset, and egui adds predicted_dt), and a click_gap resets its click history.

pub fn drain_app(&self, phase: Phase, ctx: &mut Ctx<'_>, frame: u64)

Phases 2 and 3 of the frame. Runs every pending command registered for phase, in order.

pub fn drain_frameless(&self, ctx: &mut Ctx<'_>) -> bool

Dispatch without a frame (the desktop loop’s service step): the queue’s head, in FIFO order, up to the first command that needs a frame (frameless); then one poll of the work they started. Returns whether polled work is still outstanding. Runs on the app’s thread, so mutations stay sequential with the UI’s own writers.

pub fn publish_view(&self, handle: &str, revision: u64)

Record which document the frame just drawn shows (called at the end of every app frame), so a capture is bound to what it pictures.

pub fn next_token(&self) -> u64

A fresh token for a screenshot request.

Trait Implementations

impl Default for AutomationQueue

fn default() -> Self

Returns the “default value” for a type.