Struct Driver 

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

Drives a Runtime headless. See the module docs.

Fields

runtime: Runtime<D>

Implementations

impl<D: Document> Driver<D>

pub fn new(runtime: Runtime<D>) -> Self

A 1280×800 point screen at time 0.

pub fn into_runtime(self) -> Runtime<D>

Stop driving; the runtime is handed back (e.g. to Runtime::abandon it).

pub fn ctx(&self) -> &Context

pub fn set_screen(&mut self, width: f32, height: f32)

pub fn time(&self) -> f64

Virtual seconds since the start.

pub fn frames(&self) -> u64

Frames run so far.

pub fn is_closed(&self) -> bool

The app closed its window.

pub fn push_event(&mut self, e: Event)

Queue raw input for the next frame (it also wakes the loop).

pub fn set_screenshots(&mut self, deliver: bool)

Whether screenshots are delivered (on by default). Off, the loop behaves like a window that is covered or on a locked screen: capture requests are dropped.

pub fn set_hidden(&mut self, hidden: bool)

Minimize the window (or show it again). Hidden, a frame runs Runtime::logic with no egui pass, the way eframe treats a minimized or covered window, then the runtime’s Runtime::hidden_pass for pending debugger work; other input waits for the next shown frame. A raise from the app (Focus, Minimized(false), Visible(true)) shows it again.

pub fn is_hidden(&self) -> bool

Whether the window is hidden (Driver::set_hidden).

pub fn request_close(&mut self)

Ask to close the window, as the window’s close button does.

pub fn frame(&mut self) -> FullOutput

Run one frame now, whether or not one was asked for.

pub fn advance(&mut self, secs: f64) -> u64

Let secs of virtual time pass, running every frame that is asked for (at most one per 1/120 s, like a display would). Returns the frames run.

pub fn settle(&mut self, max: u64) -> u64

Run frames until none is asked for (at most max); returns how many ran. Timers further than horizon seconds away do not count as pending.

pub fn request(&mut self, method: &str, params: Value) -> Reply

Send a control request (as the control port would) and run frames until it is answered: one frame for the request, then only the frames something asks for, on the virtual clock (a request that needs frames nobody asks for is reported, not papered over by polling).

pub fn call(&mut self, method: &str, params: Value) -> Result<Value, String>

Driver::request expecting success.