Crate browser_window

BrowserWindow is a Rust crate that allows you to utilize a browser engine to build graphical interfaces, similar to Electron.js. You create your user interface with HTML, CSS and JavaScript. Then, you can communicate information to JavaScript and back to Rust.

Pick the underlying browser framework by setting feature cef, webkitgtk or edge2. For more info on which on you should choose and how to set them up, check this guide.

Getting Started

To start building apps with Browser Window, take a look at the application module, or this quick example:

use browser_window::{application::*, browser::*, prelude::*};
 
fn main() {
	let app = Application::initialize(&ApplicationSettings::default()).unwrap();
	let runtime = app.start();
	runtime.run_async(|app| async move {
		let mut bwb = BrowserWindowBuilder::new(Source::File("file:///my-file.html".into()));
		bwb.dev_tools(true);
		bwb.size(800, 600);
		bwb.title("Example");
		let bw = bwb.build_async(&app).await;
        bw.on_message().register_async(|h, e| async move {
            match e.cmd.as_str() {
                "command_one" => {
                    h.eval_js(&format!(
                        "js_function({}, {}, {})",
                        1,
                        "'two'",
                        JsValue::String("𝟛\n".into()) // Gets properly formatted to a JS string
                                                      // literal
                    ));
                }
                "command_two" => {
                    // ... do something else here ...
                }
                _ => {}
            }
        });
 
        bw.show();
	});
	app.finish();
}

For more detailed example code, see this example code.

Thread safety

To use the threadsafe version of BrowserWindow, enable feature threadsafe. This will use Arc instead of Rc internally, and will enable the BrowserWindowThreaded and ApplicationHandleThreaded handles. It will also require closures to be Send. Docs.rs will show the threadsafe versions of everything. If you need to know how everything is compiled in the non-threadsafe version, you need to invoke cargo doc --open in the git repo yourself.

Events

To learn how to use events, take a quick look at the event module.

Modules

application

This module contains runtime and application related handles.

browser

This module contains all browser related handles and stuff.

cookie

Module for dealing with cookies.

error

Error types.

event

This module contains all event related types.

javascript

prelude

Some common traits that need to be often available.

window

This module contains all window related functionality.

Structs

DelegateFuture

This future executes a closure on the GUI thread and returns the result.

DelegateFutureFuture

This future runs a future on the GUI thread and returns its output.

Enums

DelegateError

The error that occurs when you’re delegating work to the GUI thread, but it fails to finish and/or return a result.

Traits

HasHandle