Struct tauri::window::WindowBuilder

pub struct WindowBuilder<'a, R: Runtime = Wry> { /* private fields */ }

A builder for a webview window managed by Tauri.

Implementations

impl<'a, R: Runtime> WindowBuilder<'a, R>

pub fn new<M: Manager<R>, L: Into<String>>(
    manager: &'a M,
    label: L,
    url: WindowUrl
) -> Self

Initializes a webview window builder with the given window label and URL to load on the webview.

Known issues

On Windows, this function deadlocks when used in a synchronous command, see the Webview2 issue. You should use async commands when creating windows.

Examples

• Create a window in the setup hook:

tauri::Builder::default()
  .setup(|app| {
    let window = tauri::WindowBuilder::new(app, "label", tauri::WindowUrl::App("index.html".into()))
      .build()?;
    Ok(())
  });

• Create a window in a separate thread:

tauri::Builder::default()
  .setup(|app| {
    let handle = app.handle();
    std::thread::spawn(move || {
      let window = tauri::WindowBuilder::new(&handle, "label", tauri::WindowUrl::App("index.html".into()))
        .build()
        .unwrap();
    });
    Ok(())
  });

• Create a window in a command:

#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let window = tauri::WindowBuilder::new(&app, "label", tauri::WindowUrl::External("https://tauri.app/".parse().unwrap()))
    .build()
    .unwrap();
}

pub fn on_web_resource_request<F: Fn(&HttpRequest, &mut HttpResponse) + Send + Sync + 'static>(
    self,
    f: F
) -> Self

Defines a closure to be executed when the webview makes an HTTP request for a web resource, allowing you to modify the response.

Currently only implemented for the tauri URI protocol.

NOTE: Currently this is not executed when using external URLs such as a development server, but it might be implemented in the future. Always check the request URL.

Examples

use tauri::{
  utils::config::{Csp, CspDirectiveSources, WindowUrl},
  http::header::HeaderValue,
  window::WindowBuilder,
};
use std::collections::HashMap;
tauri::Builder::default()
  .setup(|app| {
    WindowBuilder::new(app, "core", WindowUrl::App("index.html".into()))
      .on_web_resource_request(|request, response| {
        if request.uri().starts_with("tauri://") {
          // if we have a CSP header, Tauri is loading an HTML file
          //  for this example, let's dynamically change the CSP
          if let Some(csp) = response.headers_mut().get_mut("Content-Security-Policy") {
            // use the tauri helper to parse the CSP policy to a map
            let mut csp_map: HashMap<String, CspDirectiveSources> = Csp::Policy(csp.to_str().unwrap().to_string()).into();
            csp_map.entry("script-src".to_string()).or_insert_with(Default::default).push("'unsafe-inline'");
            // use the tauri helper to get a CSP string from the map
            let csp_string = Csp::from(csp_map).to_string();
            *csp = HeaderValue::from_str(&csp_string).unwrap();
          }
        }
      })
      .build()?;
    Ok(())
  });

pub fn build(self) -> Result<Window<R>>

Creates a new webview window.

impl<'a, R: Runtime> WindowBuilder<'a, R>

Desktop APIs.

pub fn menu(self, menu: Menu) -> Self

Sets the menu for the window.

pub fn center(self) -> Self

Show window in the center of the screen.

pub fn position(self, x: f64, y: f64) -> Self

The initial position of the window’s.

pub fn inner_size(self, width: f64, height: f64) -> Self

Window size.

pub fn min_inner_size(self, min_width: f64, min_height: f64) -> Self

Window min inner size.

pub fn max_inner_size(self, max_width: f64, max_height: f64) -> Self

Window max inner size.

pub fn resizable(self, resizable: bool) -> Self

Whether the window is resizable or not.

pub fn title<S: Into<String>>(self, title: S) -> Self

The title of the window in the title bar.

pub fn fullscreen(self, fullscreen: bool) -> Self

Whether to start the window in fullscreen or not.

pub fn focus(self) -> Self

👎Deprecated since 1.2.0: The window is automatically focused by default. This function Will be removed in 2.0.0. Use focused instead.

Sets the window to be initially focused.

pub fn focused(self, focused: bool) -> Self

Whether the window will be initially focused or not.

pub fn maximized(self, maximized: bool) -> Self

Whether the window should be maximized upon creation.

pub fn visible(self, visible: bool) -> Self

Whether the window should be immediately visible upon creation.

pub fn theme(self, theme: Option<Theme>) -> Self

Forces a theme or uses the system settings if None was provided.

Platform-specific

• macOS: Only supported on macOS 10.14+.

pub fn transparent(self, transparent: bool) -> Self

Available on non-macOS or crate feature macos-private-api only.

Whether the window should be transparent. If this is true, writing colors with alpha values different than 1.0 will produce a transparent window.

pub fn decorations(self, decorations: bool) -> Self

Whether the window should have borders and bars.

pub fn always_on_top(self, always_on_top: bool) -> Self

Whether the window should always be on top of other windows.

pub fn icon(self, icon: Icon) -> Result<Self>

Sets the window icon.

pub fn skip_taskbar(self, skip: bool) -> Self

Sets whether or not the window icon should be hidden from the taskbar.

Platform-specific

• macOS: Unsupported.

pub fn accept_first_mouse(self, accept: bool) -> Self

Sets whether clicking an inactive window also clicks through to the webview.

impl<'a, R: Runtime> WindowBuilder<'a, R>

Webview attributes.

pub fn initialization_script(self, script: &str) -> Self

Adds the provided JavaScript to a list of scripts that should be run after the global object has been created, but before the HTML document has been parsed and before any other script included by the HTML document is run.

Since it runs on all top-level document and child frame page navigations, it’s recommended to check the window.location to guard your script from running on unexpected origins.

Examples

use tauri::{WindowBuilder, Runtime};

const INIT_SCRIPT: &str = r#"
  if (window.location.origin === 'https://tauri.app') {
    console.log("hello world from js init script");

    window.__MY_CUSTOM_PROPERTY__ = { foo: 'bar' };
  }
"#;

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      let window = tauri::WindowBuilder::new(app, "label", tauri::WindowUrl::App("index.html".into()))
        .initialization_script(INIT_SCRIPT)
        .build()?;
      Ok(())
    });
}

pub fn user_agent(self, user_agent: &str) -> Self

Set the user agent for the webview

pub fn data_directory(self, data_directory: PathBuf) -> Self

Data directory for the webview.

pub fn disable_file_drop_handler(self) -> Self

Disables the file drop handler. This is required to use drag and drop APIs on the front end on Windows.

pub fn enable_clipboard_access(self) -> Self

Enables clipboard access for the page rendered on Linux and Windows.

macOS doesn’t provide such method and is always enabled by default, but you still need to add menu item accelerators to use shortcuts.

Trait Implementations

impl<'a, R: Runtime> Debug for WindowBuilder<'a, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.