Struct browser_window::application::ApplicationHandleThreaded

pub struct ApplicationHandleThreaded { /* fields omitted */ }

A thread-safe application handle. This handle also allows you to dispatch code to be executed on the GUI thread from any other thread.

Implementations

impl ApplicationHandleThreaded

pub fn delegate<'a, F, R>(&self, func: F) -> ApplicationDelegateFuture<'a, R> where
    F: FnOnce(ApplicationHandle) -> R + Send + 'a,
    R: Send, 

Executes the given closure func on the GUI thread, and gives back the result when done. This only works when the runtime is still running. If the closure panicked, or the runtime is not running, this will return an error.

The function signature is practically the same as:

pub async fn delegate<'a,F,R>( &self, func: F ) -> Result<R, DelegateError> where
	F: FnOnce( ApplicationHandle ) -> R + Send + 'a,
	R: Send { /* ... */ }

Keep in mind that in multi-threaded environments, it is generally a good idea to put the output on the heap. The output value will be copied.

Example

let my_value: String = app.delegate(|handle| {
	"String".to_owned()
}).unwrap();

pub fn delegate_future<F, R>(&self, future: F) -> DelegateFutureFuture<'_, R> where
    F: Future<Output = R> + 'static,
    R: Send + 'static, 

Executes the given future on the GUI thread, and gives back its output when done. This only works when the runtime is still running. If the future panicked during a poll, or the runtime is not running, this will return an error. See also delegate.

The function signature is practically the same as:

pub async fn delegate_future<'a,F,R>( &self, func: F ) -> Result<R, DelegateError> where
	F: Future<Output=R> + 'static,,
	R: Send { /* ... */ }

Example

let my_value: String = app.delegate_future(async {
	"String".to_owned()
}).unwrap();

pub fn delegate_async<'a, C, F, R>(
    &self,
    func: C
) -> DelegateFutureFuture<'a, R> where
    C: FnOnce(ApplicationHandle) -> F + Send + 'a,
    F: Future<Output = R>,
    R: Send + 'static, 

Executes the given async closure func on the GUI thread, and gives back the result when done. This only works when the runtime is still running. If the closure panicked, or the runtime is not running, this will return an error.

Except, async closures are not yet supported in stable Rust. What we actually mean are closures of the form:

|handle| async move { /* ... */ }

The function signature is practically the same as:

pub async fn delegate_async<'a,C,F,R>( &self, func: C ) -> Result<R, DelegateError> where
	C: FnOnce( ApplicationHandle ) -> F + Send + 'a,
	F: Future<Output=R>,
	R: Send + 'static
{ /* ... */ }

Example

let my_value: String = app.delegate_async(|handle| async move {
	"String".to_owned()
}).unwrap();

pub fn dispatch<'a, F>(&self, func: F) -> bool where
    F: FnOnce(ApplicationHandle) + Send + 'a, 

Queues the given closure func to be executed on the GUI thread somewhere in the future. The closure will only execute when and if the runtime is still running. Returns whether or not the closure will be able to execute.

pub fn dispatch_async<'a, C, F>(&self, func: C) -> bool where
    C: FnOnce(ApplicationHandle) -> F + Send + 'a,
    F: Future<Output = ()> + 'static, 

Queues the given async closure func to be executed on the GUI thread somewhere in the future. The closure will only execute when and if the runtime is still running. However, there is no guarantee that the whole closure will execute. The runtime might exit when the given closure is at a point of waiting. Returns whether or not the closure will be able to execute its first part.

pub fn exit(&self, exit_code: i32)

Signals the runtime to exit. This will cause Runtime::run to stop and return the provided exit code.

pub fn spawn<F>(&self, future: F) where
    F: Future<Output = ()> + 'static, 

Executes the given future on the GUI thread somewhere in the near future.

Trait Implementations

impl Clone for ApplicationHandleThreaded

fn clone(&self) -> ApplicationHandleThreaded

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ApplicationHandleThreaded

impl From<ApplicationHandle> for ApplicationHandleThreaded

fn from(other: ApplicationHandle) -> Self

Performs the conversion.

impl Send for ApplicationHandleThreaded

impl Sync for ApplicationHandleThreaded