Struct WebviewWindow

pub struct WebviewWindow<R: Runtime = Wry> { /* private fields */ }

A type that wraps a Window together with a Webview.

Implementations

impl<R: Runtime> WebviewWindow<R>

Base webview window functions.

pub fn builder<M: Manager<R>, L: Into<String>>( manager: &M, label: L, url: WebviewUrl, ) -> WebviewWindowBuilder<'_, R, M>

Initializes a WebviewWindowBuilder with the given window label and webview URL.

Data URLs are only supported with the webview-data-url feature flag.

pub fn run_on_main_thread<F: FnOnce() + Send + 'static>( &self, f: F, ) -> Result<()>

Runs the given closure on the main thread.

pub fn label(&self) -> &str

The webview label.

pub fn on_window_event<F: Fn(&WindowEvent) + Send + 'static>(&self, f: F)

Registers a window event listener.

pub fn resolve_command_scope<T: ScopeObject>( &self, plugin: &str, command: &str, ) -> Result<Option<ResolvedScope<T>>>

Resolves the given command scope for this webview on the currently loaded URL.

If the command is not allowed, returns None.

If the scope cannot be deserialized to the given type, an error is returned.

In a command context this can be directly resolved from the command arguments via crate::ipc::CommandScope:

use tauri::ipc::CommandScope;

#[derive(Debug, serde::Deserialize)]
struct ScopeType {
  some_value: String,
}
#[tauri::command]
fn my_command(scope: CommandScope<ScopeType>) {
  // check scope
}

Examples

use tauri::Manager;

#[derive(Debug, serde::Deserialize)]
struct ScopeType {
  some_value: String,
}

tauri::Builder::default()
  .setup(|app| {
    let webview = app.get_webview_window("main").unwrap();
    let scope = webview.resolve_command_scope::<ScopeType>("my-plugin", "read");
    Ok(())
  });

impl<R: Runtime> WebviewWindow<R>

Window getters.

pub fn scale_factor(&self) -> Result<f64>

Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.

pub fn inner_position(&self) -> Result<PhysicalPosition<i32>>

Returns the position of the top-left hand corner of the window’s client area relative to the top-left hand corner of the desktop.

pub fn outer_position(&self) -> Result<PhysicalPosition<i32>>

Returns the position of the top-left hand corner of the window relative to the top-left hand corner of the desktop.

pub fn inner_size(&self) -> Result<PhysicalSize<u32>>

Returns the physical size of the window’s client area.

The client area is the content of the window, excluding the title bar and borders.

pub fn outer_size(&self) -> Result<PhysicalSize<u32>>

Returns the physical size of the entire window.

These dimensions include the title bar and borders. If you don’t want that (and you usually don’t), use inner_size instead.

pub fn is_fullscreen(&self) -> Result<bool>

Gets the window’s current fullscreen state.

pub fn is_minimized(&self) -> Result<bool>

Gets the window’s current minimized state.

pub fn is_maximized(&self) -> Result<bool>

Gets the window’s current maximized state.

pub fn is_focused(&self) -> Result<bool>

Gets the window’s current focus state.

pub fn is_decorated(&self) -> Result<bool>

Gets the window’s current decoration state.

pub fn is_resizable(&self) -> Result<bool>

Gets the window’s current resizable state.

pub fn is_enabled(&self) -> Result<bool>

Whether the window is enabled or disabled.

pub fn is_always_on_top(&self) -> Result<bool>

Determines if this window should always be on top of other windows.

Platform-specific

• iOS / Android: Unsupported.

pub fn is_maximizable(&self) -> Result<bool>

Gets the window’s native maximize button state

Platform-specific

• Linux / iOS / Android: Unsupported.

pub fn is_minimizable(&self) -> Result<bool>

Gets the window’s native minimize button state

Platform-specific

• Linux / iOS / Android: Unsupported.

pub fn is_closable(&self) -> Result<bool>

Gets the window’s native close button state

Platform-specific

• Linux / iOS / Android: Unsupported.

pub fn is_visible(&self) -> Result<bool>

Gets the window’s current visibility state.

pub fn title(&self) -> Result<String>

Gets the window’s current title.

pub fn current_monitor(&self) -> Result<Option<Monitor>>

Returns the monitor on which the window currently resides.

Returns None if current monitor can’t be detected.

pub fn primary_monitor(&self) -> Result<Option<Monitor>>

Returns the primary monitor of the system.

Returns None if it can’t identify any monitor as a primary one.

pub fn monitor_from_point(&self, x: f64, y: f64) -> Result<Option<Monitor>>

Returns the monitor that contains the given point.

pub fn available_monitors(&self) -> Result<Vec<Monitor>>

Returns the list of all the monitors available on the system.

pub fn theme(&self) -> Result<Theme>

Returns the current window theme.

Platform-specific

• macOS: Only supported on macOS 10.14+.

impl<R: Runtime> WebviewWindow<R>

Webview APIs.

pub fn with_webview<F: FnOnce(PlatformWebview) + Send + 'static>( &self, f: F, ) -> Result<()>

Executes a closure, providing it with the webview handle that is specific to the current platform.

The closure is executed on the main thread.

Note that webview2-com, webkit2gtk, objc2_web_kit and similar crates may be updated in minor releases of Tauri. Therefore it’s recommended to pin Tauri to at least a minor version when you’re using with_webview.

Examples

use tauri::Manager;

fn main() {
  tauri::Builder::default()
    .setup(|app| {
      let main_webview = app.get_webview_window("main").unwrap();
      main_webview.with_webview(|webview| {
        #[cfg(target_os = "linux")]
        {
          // see <https://docs.rs/webkit2gtk/2.0.0/webkit2gtk/struct.WebView.html>
          // and <https://docs.rs/webkit2gtk/2.0.0/webkit2gtk/trait.WebViewExt.html>
          use webkit2gtk::WebViewExt;
          webview.inner().set_zoom_level(4.);
        }

        #[cfg(windows)]
        unsafe {
          // see <https://docs.rs/webview2-com/0.19.1/webview2_com/Microsoft/Web/WebView2/Win32/struct.ICoreWebView2Controller.html>
          webview.controller().SetZoomFactor(4.).unwrap();
        }

        #[cfg(target_os = "macos")]
        unsafe {
          let view: &objc2_web_kit::WKWebView = &*webview.inner().cast();
          let controller: &objc2_web_kit::WKUserContentController = &*webview.controller().cast();
          let window: &objc2_app_kit::NSWindow = &*webview.ns_window().cast();

          view.setPageZoom(4.);
          controller.removeAllUserScripts();
          let bg_color = objc2_app_kit::NSColor::colorWithDeviceRed_green_blue_alpha(0.5, 0.2, 0.4, 1.);
          window.setBackgroundColor(Some(&bg_color));
        }

        #[cfg(target_os = "android")]
        {
          use jni::objects::JValue;
          webview.jni_handle().exec(|env, _, webview| {
            env.call_method(webview, "zoomBy", "(F)V", &[JValue::Float(4.)]).unwrap();
          })
        }
      });
      Ok(())
  });
}

pub fn url(&self) -> Result<Url>

Returns the current url of the webview.

pub fn navigate(&self, url: Url) -> Result<()>

Navigates the webview to the defined url.

pub fn reload(&self) -> Result<()>

Reloads the current page.

pub fn on_message( self, request: InvokeRequest, responder: Box<OwnedInvokeResponder<R>>, )

Handles this window receiving an crate::webview::InvokeRequest.

pub fn eval(&self, js: impl Into<String>) -> Result<()>

Evaluates JavaScript on this window.

pub fn open_devtools(&self)

Available on debug-assertions enabled or crate feature devtools only.

Opens the developer tools window (Web Inspector). The devtools is only enabled on debug builds or with the devtools feature flag.

Platform-specific

• macOS: Only supported on macOS 10.15+. This is a private API on macOS, so you cannot use this if your application will be published on the App Store.

Examples

use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    #[cfg(debug_assertions)]
    app.get_webview_window("main").unwrap().open_devtools();
    Ok(())
  });

pub fn close_devtools(&self)

Available on debug-assertions enabled or crate feature devtools only.

Closes the developer tools window (Web Inspector). The devtools is only enabled on debug builds or with the devtools feature flag.

Platform-specific

• macOS: Only supported on macOS 10.15+. This is a private API on macOS, so you cannot use this if your application will be published on the App Store.
• Windows: Unsupported.

Examples

use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    #[cfg(debug_assertions)]
    {
      let webview = app.get_webview_window("main").unwrap();
      webview.open_devtools();
      std::thread::spawn(move || {
        std::thread::sleep(std::time::Duration::from_secs(10));
        webview.close_devtools();
      });
    }
    Ok(())
  });

pub fn is_devtools_open(&self) -> bool

Available on debug-assertions enabled or crate feature devtools only.

Checks if the developer tools window (Web Inspector) is opened. The devtools is only enabled on debug builds or with the devtools feature flag.

Platform-specific

• macOS: Only supported on macOS 10.15+. This is a private API on macOS, so you cannot use this if your application will be published on the App Store.
• Windows: Unsupported.

Examples

use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    #[cfg(debug_assertions)]
    {
      let webview = app.get_webview_window("main").unwrap();
      if !webview.is_devtools_open() {
        webview.open_devtools();
      }
    }
    Ok(())
  });

pub fn set_zoom(&self, scale_factor: f64) -> Result<()>

Set the webview zoom level

Platform-specific:

• Android: Not supported.
• macOS: available on macOS 11+ only.
• iOS: available on iOS 14+ only.

pub fn clear_all_browsing_data(&self) -> Result<()>

Clear all browsing data for this webview window.

pub fn cookies_for_url(&self, url: Url) -> Result<Vec<Cookie<'static>>>

Returns all cookies in the runtime’s cookie store including HTTP-only and secure cookies.

Note that cookies will only be returned for URLs with an http or https scheme. Cookies set through javascript for local files (such as those served from the tauri://) protocol are not currently supported.

Stability

The return value of this function leverages tauri_runtime::Cookie which re-exports the cookie crate. This dependency might receive updates in minor Tauri releases.

Known issues

On Windows, this function deadlocks when used in a synchronous command or event handlers, see the Webview2 issue. You should use async commands and separate threads when reading cookies.

pub fn cookies(&self) -> Result<Vec<Cookie<'static>>>

Returns all cookies in the runtime’s cookie store for all URLs including HTTP-only and secure cookies.

Note that cookies will only be returned for URLs with an http or https scheme. Cookies set through javascript for local files (such as those served from the tauri://) protocol are not currently supported.

Stability

The return value of this function leverages tauri_runtime::Cookie which re-exports the cookie crate. This dependency might receive updates in minor Tauri releases.

Known issues

On Windows, this function deadlocks when used in a synchronous command or event handlers, see the Webview2 issue. You should use async commands and separate threads when reading cookies.

Platform-specific

• Android: Unsupported, always returns an empty Vec.

Trait Implementations

impl<R: Runtime> AsRef<Webview<R>> for WebviewWindow<R>

fn as_ref(&self) -> &Webview<R>

Converts this type into a shared reference of the (usually inferred) input type.

impl<R: Runtime> Clone for WebviewWindow<R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, R: Runtime> CommandArg<'de, R> for WebviewWindow<R>

fn from_command(command: CommandItem<'de, R>) -> Result<Self, InvokeError>

Grabs the Window from the CommandItem. This will never fail.

impl<R: Debug + Runtime> Debug for WebviewWindow<R>

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

Formats the value using the given formatter.

impl<R: Runtime> Emitter<R> for WebviewWindow<R>

fn emit<S: Serialize + Clone>(&self, event: &str, payload: S) -> Result<()>

Emits an event to all targets.

fn emit_str(&self, event: &str, payload: String) -> Result<()>

Similar to Emitter::emit but the payload is json serialized.

fn emit_to<I, S>(&self, target: I, event: &str, payload: S) -> Result<()>

where I: Into<EventTarget>, S: Serialize + Clone,

Emits an event to all targets matching the given target.

fn emit_str_to<I>(&self, target: I, event: &str, payload: String) -> Result<()>

where I: Into<EventTarget>,

Similar to Emitter::emit_to but the payload is json serialized.

fn emit_filter<S, F>(&self, event: &str, payload: S, filter: F) -> Result<()>

where S: Serialize + Clone, F: Fn(&EventTarget) -> bool,

Emits an event to all targets based on the given filter.

fn emit_str_filter<F>( &self, event: &str, payload: String, filter: F, ) -> Result<()>

where F: Fn(&EventTarget) -> bool,

Similar to Emitter::emit_filter but the payload is json serialized.

impl<R: Runtime> FunctionArg for WebviewWindow<R>

fn to_datatype(_: &mut TypeMap) -> Option<DataType>

Gets the type of an argument as a DataType.

impl<R: Runtime> HasDisplayHandle for WebviewWindow<R>

fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>

Get a handle to the display controller of the windowing system.

impl<R: Runtime> HasWindowHandle for WebviewWindow<R>

fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>

Get a handle to the window.

impl<R: Runtime> Listener<R> for WebviewWindow<R>

fn listen<F>(&self, event: impl Into<String>, handler: F) -> EventId

where F: Fn(Event) + Send + 'static,

Listen to an event on this webview window.

Examples

use tauri::{Manager, Listener};

tauri::Builder::default()
  .setup(|app| {
    let webview_window = app.get_webview_window("main").unwrap();
    webview_window.listen("component-loaded", move |event| {
      println!("window just loaded a component");
    });

    Ok(())
  });

fn once<F>(&self, event: impl Into<String>, handler: F) -> EventId

where F: FnOnce(Event) + Send + 'static,

Listen to an event on this window webview only once.

See Self::listen for more information.

fn unlisten(&self, id: EventId)

Unlisten to an event on this webview window.

Examples

use tauri::{Manager, Listener};

tauri::Builder::default()
  .setup(|app| {
    let webview_window = app.get_webview_window("main").unwrap();
    let webview_window_ = webview_window.clone();
    let handler = webview_window.listen("component-loaded", move |event| {
      println!("webview_window just loaded a component");

      // we no longer need to listen to the event
      // we also could have used `webview_window.once` instead
      webview_window_.unlisten(event.id());
    });

    // stop listening to the event when you do not need it anymore
    webview_window.unlisten(handler);

    Ok(())
});

fn listen_any<F>(&self, event: impl Into<String>, handler: F) -> EventId

where F: Fn(Event) + Send + 'static,

Listen to an emitted event to any target.

fn once_any<F>(&self, event: impl Into<String>, handler: F) -> EventId

where F: FnOnce(Event) + Send + 'static,

Listens once to an emitted event to any target .

impl<R: Runtime> Manager<R> for WebviewWindow<R>

fn resources_table(&self) -> MutexGuard<'_, ResourceTable>

Get a reference to the resources table of this manager.

fn app_handle(&self) -> &AppHandle<R>

The application handle associated with this manager.

fn config(&self) -> &Config

The Config the manager was created with.

fn package_info(&self) -> &PackageInfo

The PackageInfo the manager was created with.

fn get_window(&self, label: &str) -> Option<Window<R>>

Available on crate feature unstable only.

Fetch a single window from the manager.

fn get_focused_window(&self) -> Option<Window<R>>

Available on crate feature unstable only.

Fetch the focused window. Returns None if there is not any focused window.

fn windows(&self) -> HashMap<String, Window<R>>

Available on crate feature unstable only.

Fetch all managed windows.

fn get_webview(&self, label: &str) -> Option<Webview<R>>

Available on crate feature unstable only.

Fetch a single webview from the manager.

fn webviews(&self) -> HashMap<String, Webview<R>>

Available on crate feature unstable only.

Fetch all managed webviews.

fn get_webview_window(&self, label: &str) -> Option<WebviewWindow<R>>

Fetch a single webview window from the manager.

fn webview_windows(&self) -> HashMap<String, WebviewWindow<R>>

Fetch all managed webview windows.

fn manage<T>(&self, state: T) -> bool

where T: Send + Sync + 'static,

Add state to the state managed by the application.

fn unmanage<T>(&self) -> Option<T>

where T: Send + Sync + 'static,

👎Deprecated since 2.3.0: This method is unsafe, since it can cause dangling references.

Removes the state managed by the application for T. Returns the state if it was actually removed.

fn state<T>(&self) -> State<'_, T>

where T: Send + Sync + 'static,

Retrieves the managed state for the type T.

fn try_state<T>(&self) -> Option<State<'_, T>>

where T: Send + Sync + 'static,

Attempts to retrieve the managed state for the type T.

fn env(&self) -> Env

Gets the managed Env.

fn asset_protocol_scope(&self) -> Scope

Gets the scope for the asset protocol.

fn path(&self) -> &PathResolver<R>

The path resolver.

impl<R: Runtime> PartialEq for WebviewWindow<R>

fn eq(&self, other: &Self) -> bool

Only use the Window’s label to compare equality.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: Runtime> Eq for WebviewWindow<R>