Struct browser_window::browser::BrowserWindowThreaded

pub struct BrowserWindowThreaded { /* private fields */ }

Note: Only available with feature threadsafe enabled.

A thread-safe handle to a browser window. It allows you to dispatch code to the GUI thread and obtain manipulate the browser window from any thread. To do this, you will need to use the functions dispatch, dispatch_async, delegate and delegate_async.

Example

This example fetches a value from within JavaScript:

use browser_window::application::*;
use browser_window::browser::*;

async fn get_cookies( app: ApplicationHandleThreaded ) -> String {
 
    let mut builder = BrowserWindowBuilder::new(Source::Url("https://www.duckduckgo.com/".into()));
    builder.title("test");

    let bw: BrowserWindowThreaded = builder.build_threaded( app ).await.unwrap();
 
    // Waits for `eval_js` to give back its result from the GUI thread
    let result = bw.delegate_async( |handle| async move {
        // Execute `eval_js` on the GUI thread
        handle.eval_js("document.cookies").await
    } ).await.unwrap();

    result.unwrap()
}

Implementations

impl BrowserWindowThreaded

pub fn app(&self) -> ApplicationHandleThreaded

The thread-safe application handle associated with this browser window.

pub fn close(self) -> bool

Closes the browser.

pub fn delegate<'a, F, R>(&self, func: F) -> BrowserDelegateFuture<'a, R>

where F: FnOnce(BrowserWindowHandle) -> R + Send + 'a, R: Send,

Executes the given closure within the GUI thread, and return the value that the closure returned. Also see ApplicationThreaded::delegate.

The function signature is practically the same as:

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

pub fn delegate_async<'a, C, F, R>( &self, func: C ) -> DelegateFutureFuture<'a, R>

where C: FnOnce(BrowserWindowHandle) -> 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. Also see ApplicationThreaded::delegate_async.

pub fn delegate_future<'a, F, R>(&self, fut: F) -> DelegateFutureFuture<'a, R>

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

Executes the given future on the GUI thread, and gives back the result when done. Also see ApplicationThreaded::delegate_future.

pub fn dispatch<'a, F>(&self, func: F) -> bool

where F: FnOnce(BrowserWindowHandle) + Send + 'a,

Executes the given close on the GUI thread. See also Application::dispatch.

pub fn dispatch_async<'a, C, F>(&self, func: C) -> bool

where C: FnOnce(BrowserWindowHandle) -> F + Send + 'a, F: Future<Output = ()> + 'static,

Executes the given closure on the GUI thread. See also Application::dispatch.

Trait Implementations

impl HasAppHandle for BrowserWindowThreaded

fn app_handle(&self) -> ApplicationHandle

impl OwnedBrowserWindow for BrowserWindowThreaded

fn browser_handle(&self) -> BrowserWindowHandle

impl OwnedWindow for BrowserWindowThreaded

fn window_handle(&self) -> WindowHandle

impl Sync for BrowserWindowThreaded