Struct 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 thereby 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::*, 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().to_string()
}

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(BrowserWindow) -> 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(BrowserWindow) -> F + Send + 'a, F: Future<Output = ()> + 'static,

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

Trait Implementations

impl Clone for BrowserWindowThreaded

fn clone(&self) -> BrowserWindowThreaded

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Sync for BrowserWindowThreaded