Struct browser_window::application::ApplicationHandleThreaded

pub struct ApplicationHandleThreaded { /* fields omitted */ }

Note: Only available with feature threadsafe enabled.

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_delayed<'a, F>(&self, func: F, delay: Duration) -> bool where
    F: FnOnce(ApplicationHandle) + Send + 'a, 

Queues the given closure func to be executed on the GUI thread somewhere in the future, at least after the given delay. 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.

Methods from Deref<Target = ApplicationHandle>

pub fn cookie_jar(&self) -> CookieJar

pub fn exit(&self, exit_code: i32)

Causes the Runtime to terminate. The Runtime’s Runtime::run or spawn command will return the exit code provided. This will mean that not all tasks might complete. If you were awaiting

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

Spawns the given future, executing it on the GUI thread somewhere in the near future.

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

Queues the given closure func to be executed on the GUI thread somewhere in the future, at least after the given delay. 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 async fn sleep(&self, duration: Duration)

Will wait the given duration before returning execution back to the caller. This does not put the current thread in a sleeping state, it just waits.

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 Deref for ApplicationHandleThreaded

type Target = ApplicationHandle

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl From<ApplicationHandle> for ApplicationHandleThreaded

fn from(other: ApplicationHandle) -> Self

Performs the conversion.

impl Copy for ApplicationHandleThreaded

impl Send for ApplicationHandleThreaded

impl Sync for ApplicationHandleThreaded