Struct HeadlessApp 

pub struct HeadlessApp { /* private fields */ }

A headless app controller.

Headless apps don’t cause external side-effects like visible windows and don’t listen to system events. They can be used for creating apps like a command line app that renders widgets, or for creating integration tests.

You can start a headless app using AppBuilder::run_headless.

Implementations

impl HeadlessApp

pub fn renderer_enabled(&mut self) -> bool

If headless rendering is enabled.

When enabled windows are still not visible but frames will be rendered and the frame image can be requested.

Note that UiNode::render is still called when a renderer is disabled and you can still query the latest frame from WINDOWS.widget_tree. The only thing that is disabled is the actual renderer that converts display lists to pixels.

pub fn update(&mut self, wait_app_event: bool) -> AppControlFlow

Does updates.

If wait_app_event is true the thread sleeps until at least one app event is received or a timer elapses, if it is false only responds to app events already in the buffer.

pub fn update_observe( &mut self, on_pre_update: impl FnOnce() + Send + 'static, ) -> bool

Does updates and calls on_pre_update on the first update.

pub fn run_task<R, T>( &mut self, task: impl IntoFuture<IntoFuture = T>, ) -> Option<R>

where R: Send + 'static, T: Future<Output = R> + Send + 'static,

Execute the async task in the UI thread, updating the app until it finishes or the app shuts-down.

Returns the task result if the app has not shutdown.

pub fn run_task_deadline<R, T>( &mut self, task: impl IntoFuture<IntoFuture = T>, deadline: impl Into<Deadline>, ) -> Option<R>

where R: Send + 'static, T: Future<Output = R> + Send + 'static,

Does run_task with a deadline.

Returns the task result if the app has not shutdown and the deadline is not reached.

If the deadline is reached an error is logged. Note that you can use with_deadline to create a future with timeout and handle the timeout error.

pub fn run_test<R, T>( &mut self, task: impl IntoFuture<IntoFuture = T>, ) -> Option<R>

where R: Send + 'static, T: Future<Output = R> + Send + 'static,

Does run_task with a deadline, panics on timeout.

pub fn exit(self)

Requests and wait for app exit.

Forces deinit if exit is cancelled.

pub fn has_exited(&self) -> bool

If the app has exited.

Exited apps cannot update anymore. The app should be dropped to unload the app scope.

Trait Implementations

impl HeadlessAppGestureExt for HeadlessApp

fn press_shortcut(&mut self, window_id: WindowId, shortcut: impl Into<Shortcut>)

Generates key press events to mimic the shortcut and updates.

impl HeadlessAppKeyboardExt for HeadlessApp

fn on_keyboard_input( &mut self, window_id: WindowId, code: KeyCode, location: KeyLocation, key: Key, state: KeyState, )

Notifies keyboard input event.

fn press_key( &mut self, window_id: WindowId, code: KeyCode, location: KeyLocation, key: Key, )

Does a key-down, key-up and updates.

fn press_modified_key( &mut self, window_id: WindowId, modifiers: ModifiersState, code: KeyCode, location: KeyLocation, key: Key, )

Does a modifiers changed, key-down, key-up, reset modifiers and updates.

impl HeadlessAppWindowExt for HeadlessApp

fn open_window<F>( &mut self, window_id: impl Into<WindowId>, new_window: impl IntoFuture<IntoFuture = F>, ) -> WindowVars

where F: Future<Output = WindowRoot> + Send + 'static,

Open a new headless window and returns the new window ID.

fn focus_window(&mut self, window_id: impl Into<WindowId>)

Cause the headless window to think it is focused in the screen.

fn blur_window(&mut self, window_id: impl Into<WindowId>)

Cause the headless window to think focus moved away from it.

fn window_frame_image( &mut self, window_id: impl Into<WindowId>, mask: Option<ImageMaskMode>, ) -> Var<ImageEntry>

Copy the current frame pixels of the window.

fn close_window(&mut self, window_id: impl Into<WindowId>) -> bool

Sends a close request.

fn run_window<F>( &mut self, window_id: impl Into<WindowId>, new_window: impl IntoFuture<IntoFuture = F>, )

where F: Future<Output = WindowRoot> + Send + 'static,

Open a new headless window and update the app until the window closes.

fn doc_test_window<F>(&mut self, new_window: impl IntoFuture<IntoFuture = F>)

where F: Future<Output = WindowRoot> + Send + 'static,

Open a new headless window and update the app until the window closes or 60 seconds elapse.