Struct zng_app::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 AppExtended::run_headless.

Implementations

impl HeadlessApp

pub fn block_on<A>( &mut self, handler: &mut dyn AppHandler<A>, args: &A, timeout: Duration, ) -> Result<(), String>

where A: Clone + 'static,

Calls an AppHandler<A> once and blocks until the update tasks started during the call complete.

This function spins until all update tasks are completed. Timers or send events can be received during execution but the loop does not sleep, it just spins requesting an update for each pass.

pub fn block_on_multi<A>( &mut self, handlers: Vec<&mut dyn AppHandler<A>>, args: &A, timeout: Duration, ) -> Result<(), String>

where A: Clone + 'static,

Calls multiple AppHandler<A> once each and blocks until all update tasks are complete.

This function spins until all update tasks are completed. Timers or send events can be received during execution but the loop does not sleep, it just spins requesting an update for each pass.

pub fn block_on_fut<F: Future>( &mut self, future: F, timeout: Duration, ) -> Result<F::Output, String>

Polls a future and updates the app repeatedly until it completes or the timeout is reached.

pub fn doc_test<A, H>(args: A, handler: H)

where A: Clone + 'static, H: AppHandler<A>,

Calls the handler once and block_on it with a 60 seconds timeout using the minimal headless app.

pub fn doc_test_multi<A>(args: A, handlers: Vec<Box<dyn AppHandler<A>>>)

where A: Clone + 'static,

Calls the handlers once each and block_on_multi with a 60 seconds timeout.

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 unobserved.

See update_observed for more details.

pub fn update_observe( &mut self, on_update: impl FnMut(), wait_app_event: bool, ) -> AppControlFlow

Does updates observing update only.

See update_observed for more details.

pub fn update_observe_event( &mut self, on_event: impl FnMut(&mut EventUpdate), wait_app_event: bool, ) -> AppControlFlow

Does updates observing event only.

See update_observed for more details.

pub fn update_observed<O: AppEventObserver>( &mut self, observer: &mut O, wait_app_event: bool, ) -> AppControlFlow

Does updates with an AppEventObserver.

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 run_task<R, T>( &mut self, task: impl IntoFuture<IntoFuture = T>, ) -> Option<R>

where R: 'static, T: Future<Output = R> + Send + Sync + '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 shut-down.

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.