Struct Drive 

pub struct Drive<C: BorrowMut<Core> = Core> {
    pub core: C,
    pub exts: Extensions,
    pub viewport: Size,
    pub scale: f32,
    /* private fields */
}

The headless driver; see the module docs for an example.

C is the core it drives: its own Core by default, or a &mut Core borrowed from a harness that built one.

Fields

core: C

The core being driven.

exts: Extensions

The extensions filling the frame’s slots, routed as the runner routes them. Empty unless Drive::extension loaded one.

viewport: Size

The viewport every frame lays out against, logical px.

scale: f32

The display’s scale: 1 unless a test sets it.

Implementations

impl<C: BorrowMut<Core>> Drive<C>

pub fn new(core: C, w: f32, h: f32) -> Self

A drive over core with a w by h viewport. Turns the node snapshot on (Core::set_inspect) so Self::texts_under and Self::rect_of have a frame to read.

pub fn framing(self) -> Self

Frames after every gesture (a click, a key, typed text, the wheel, a hover, a drag), and once while a drag is held.

pub fn extension( &mut self, ns: &str, ext: impl Extension + 'static, ) -> Result<(), String>

Loads an extension under ns, as Launcher::extension_as would.

pub fn frame(&mut self, app: &mut impl App)

Builds one frame from app.view, then hands app whatever the frame produced on its own (a resize, a layout, a window event).

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

Moves the frame clock secs forward; the next frame sees it.

pub fn frames(&self) -> u64

The frames built so far.

pub fn key_of(&mut self, label: &str) -> Option<Key>

The key a node was opened under label, from the last frame.

pub fn rect_of(&self, key: Key) -> Option<Rect>

Where the last frame put the node key names, in logical px: where it is hit when it takes input (clipped, on top), else where layout put it.

pub fn texts_under(&self, label: &str) -> Vec<String>

The text of every text node under the first node labelled label in the last frame, in tree order; empty when none is labelled so.

pub fn warnings(&mut self) -> Vec<String>

Every warning the core raised since the last call, as code: message: a test asserts it empty.

pub fn input(&mut self, app: &mut impl App, ev: InputEvent) -> Vec<UiEvent>

One input, its events to app, and back to the caller too.

pub fn move_to(&mut self, app: &mut impl App, x: f32, y: f32) -> Vec<UiEvent>

The pointer to a point, nothing pressed.

pub fn hover(&mut self, app: &mut impl App, key: Key) -> Vec<UiEvent>

The pointer to the middle of the node key names.

pub fn click(&mut self, app: &mut impl App, x: f32, y: f32) -> Vec<UiEvent>

A primary click at a point: move, press, release.

pub fn double_click( &mut self, app: &mut impl App, x: f32, y: f32, ) -> Vec<UiEvent>

Two clicks at a point, the second counted as the second, as the OS counts a double click into the press.

pub fn click_key(&mut self, app: &mut impl App, key: Key) -> Vec<UiEvent>

A click on the node key names, the way assistive technology presses it — no geometry needed.

pub fn drag(&mut self, app: &mut impl App, from: Vec2, to: Vec2) -> Vec<UiEvent>

A press at from, the pointer taken past the click slop and on to to, the release: an on_drag node hears start, moves and end, and the release is no click.

pub fn wheel( &mut self, app: &mut impl App, x: f32, y: f32, dx: f32, dy: f32, ) -> Vec<UiEvent>

The wheel over a point.

pub fn scroll_gesture( &mut self, app: &mut impl App, x: f32, y: f32, delta: Vec2, begins: bool, ) -> Vec<UiEvent>

One event of a scroll gesture over a point: begins on its first, and the rest go to the target that first one picked, wherever the pointer or the content has gone since, as a native swipe latches. Self::wheel is a gesture of its own.

pub fn button_click( &mut self, app: &mut impl App, x: f32, y: f32, button: MouseButton, ) -> Vec<UiEvent>

A non-primary button pressed and released at a point: what an on_button node claiming it hears as press and release.

pub fn key( &mut self, app: &mut impl App, name: &str, mods: KeyMods, ) -> Vec<UiEvent>

A key pressed and released, by the name a binding spells it ("a", "enter", "f2"): the raw press — carrying the character (or the space) as its text when no chord modifier is held, as a keyboard’s would — then the editor event the same press means (KeyPress::edit_event, the one table every driver sends from), then the release.

pub fn keys(&mut self, app: &mut impl App, seq: &str) -> Vec<UiEvent>

keys(app, "jj ww"): Self::key for each character, unmodified, a space being the space key.

pub fn text(&mut self, app: &mut impl App, s: &str) -> Vec<UiEvent>

Typed text, as the OS delivers it to the focused editor.

pub fn commit(&mut self, app: &mut impl App, s: &str) -> Vec<UiEvent>

Text that did not come from a key press — an IME’s commit — as the OS delivers it: to a focused editor, or to a key sink as text.

pub fn focus(&mut self, app: &mut impl App, key: Key) -> Vec<UiEvent>

Focuses the node key names, as Tab or a screen reader would.

pub fn check(&self, cond: bool, what: &str) -> Result<(), String>

Ok when cond holds, else Err(what), so a scripted drive reads as a list of checks. Prints ok <what> on success.

pub fn log(&self) -> &[String]

Everything delivered so far, one line each: frame key payload.