Struct Runtime 

pub struct Runtime<D: Document> { /* private fields */ }

One app instance’s frame loop. Built by App::runtime (tests, benches) or App::run.

Implementations

impl<D: Document> Runtime<D>

pub fn apply_scene(&mut self, name: &str) -> Result<(), String>

Run the scene called name (crate::App::scene) on the session. Its effects run on the next frame.

pub fn session(&self) -> &Session<D>

pub fn session_mut(&mut self) -> &mut Session<D>

pub fn settings(&self) -> &Settings

pub fn toasts(&self) -> &Toasts

pub fn log_frames(&mut self, path: impl AsRef<Path>) -> Result<()>

Write one JSON line per frame to path (what ASHLAR_FRAME_LOG=path does; see crate::frame_log), from the next frame on. Replaces an earlier log.

pub fn record_to(&mut self, path: impl AsRef<Path>) -> Result<()>

Record every frame’s input and time, and every control request, to path (what ASHLAR_RECORD=path does; see crate::record), from the next frame on. Replaces an earlier recording. crate::Driver::replay plays it back.

pub fn stats(&self) -> &FrameStats

Frame-time statistics (app.stats).

pub fn stats_mut(&mut self) -> &mut FrameStats

pub fn wakes(&self) -> WakeStats

Frames and wake requests per Reason (app.stats → wakes).

pub fn passes(&self) -> u64

Passes run so far (frames, plus egui’s occasional extra layout pass).

pub fn set_preferences(&mut self, source: impl FnMut() -> Preferences + 'static)

Replace the OS preferences (reduced motion, accent, contrast) with source (tests). Call it before the first frame; it is read again whenever the window gains focus.

pub fn set_file_picker( &mut self, picker: impl FnMut(Pick) -> Option<PathBuf> + 'static, )

Replace the native file dialogs (tests, scripted runs).

pub fn execute( &mut self, id: &str, params: Value, ) -> Result<Value, CommandError>

Run a command through the chokepoint now.

pub fn inject_request(&mut self, req: Request)

Hand a control request to the runtime as if it came from the control port (tests).

pub fn control_port(&self) -> Option<u16>

The control port, when one is serving.

pub fn is_closing(&self) -> bool

Whether the app has decided to close (the window should go away).

pub fn view_error(&self) -> Option<&str>

The error that suspended the view, if one did.

pub fn logic(&mut self, ctx: &Context)

Work that needs no drawing: control requests, finished jobs, effects, autosave, settings. eframe calls it before every frame (and while the window is hidden).

pub fn hidden_pass( &mut self, ctx: &Context, time: Option<f64>, events: Vec<Event>, ) -> Option<FullOutput>

eframe runs no UI pass while the window is minimized or covered. While debugger work waits (ui input, snapshots, waits, screenshots), run one here, after Runtime::logic: what it draws is not presented (screenshots render off screen) and nothing raises the window, so agents drive a covered window without taking the focus. Its window commands go to the context; the output is returned for the caller to hand its texture changes to the renderer. time and events are for the pass (eframe gives none: the wall clock goes on; the headless driver passes its virtual clock and delivers its screenshots this way).

pub fn raw_input_hook(&mut self, ctx: &Context, raw: &mut RawInput)

The start of a frame (eframe’s raw_input_hook, before Runtime::logic): set the frame’s time (app.clock may hold it), then credit the frame to the wake reasons that were due. (Injected agent input is handed to egui by the debugger’s plugin.)

pub fn ui(&mut self, ui: &mut Ui)

Draw the frame.

pub fn shutdown(&mut self, _discarded: bool)

Settle everything before the process ends: stop jobs, flush settings, end autosave.

pub fn abandon(self)

End without any cleanup, as if the process had died: autosave files stay for the next launch to recover, settings are not flushed. For crash-recovery tests.

pub fn title(&self) -> &str

The window title the runtime last set (name • — App when there are unsaved changes).

Trait Implementations

impl<D: Document> Drop for Runtime<D>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.