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 on_webview_event<F: Fn(&WebviewEvent) + Send + 'static>(&self, f: F)

Registers a webview 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>

Menu APIs

pub fn on_menu_event<F: Fn(&Window<R>, MenuEvent) + Send + Sync + 'static>( &self, f: F, )

Available on desktop only.

Registers a global menu event listener.

Note that this handler is called for any menu event, whether it is coming from this window, another window or from the tray icon menu.

Also note that this handler will not be called if the window used to register it was closed.

Examples

use tauri::menu::{Menu, Submenu, MenuItem};
use tauri::{WebviewWindowBuilder, WebviewUrl};

tauri::Builder::default()
  .setup(|app| {
    let handle = app.handle();
    let save_menu_item = MenuItem::new(handle, "Save", true, None::<&str>)?;
    let menu = Menu::with_items(handle, &[
      &Submenu::with_items(handle, "File", true, &[
        &save_menu_item,
      ])?,
    ])?;
    let webview_window = WebviewWindowBuilder::new(app, "editor", WebviewUrl::default())
      .menu(menu)
      .build()
      .unwrap();

    webview_window.on_menu_event(move |window, event| {
      if event.id == save_menu_item.id() {
          // save menu item
      }
    });

    Ok(())
  });

pub fn menu(&self) -> Option<Menu<R>>

Available on desktop only.

Returns this window menu.

pub fn set_menu(&self, menu: Menu<R>) -> Result<Option<Menu<R>>>

Available on desktop only.

Sets the window menu and returns the previous one.

Platform-specific:

• macOS: Unsupported. The menu on macOS is app-wide and not specific to one window, if you need to set it, use AppHandle::set_menu instead.

pub fn remove_menu(&self) -> Result<Option<Menu<R>>>

Available on desktop only.

Removes the window menu and returns it.

Platform-specific:

• macOS: Unsupported. The menu on macOS is app-wide and not specific to one window, if you need to remove it, use AppHandle::remove_menu instead.

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

Available on desktop only.

Hides the window menu.

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

Available on desktop only.

Shows the window menu.

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

Available on desktop only.

Shows the window menu.

pub fn popup_menu<M: ContextMenu>(&self, menu: &M) -> Result<()>

Available on desktop only.

Shows the specified menu as a context menu at the cursor position.

pub fn popup_menu_at<M: ContextMenu, P: Into<Position>>( &self, menu: &M, position: P, ) -> Result<()>

Available on desktop only.

Shows the specified menu as a context menu at the specified position.

The position is relative to the window’s top-left corner.

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 gtk_window(&self) -> Result<ApplicationWindow>

Available on Linux or DragonFly BSD or FreeBSD or NetBSD or OpenBSD only.

Returns the ApplicationWindow from gtk crate that is used by this window.

Note that this type can only be used on the main thread.

pub fn default_vbox(&self) -> Result<Box>

Available on Linux or DragonFly BSD or FreeBSD or NetBSD or OpenBSD only.

Returns the vertical gtk::Box that is added by default as the sole child of this window.

Note that this type can only be used on the main thread.

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>

Desktop window getters.

pub fn cursor_position(&self) -> Result<PhysicalPosition<f64>>

Available on desktop only.

Get the cursor position relative to the top-left hand corner of the desktop.

Note that the top-left hand corner of the desktop is not necessarily the same as the screen. If the user uses a desktop with multiple monitors, the top-left hand corner of the desktop is the top-left hand corner of the main monitor on Windows and macOS or the top-left of the leftmost monitor on X11.

The coordinates can be negative if the top-left hand corner of the window is outside of the visible screen region.

impl<R: Runtime> WebviewWindow<R>

Desktop window setters and actions.

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

Available on desktop only.

Centers the window.

pub fn request_user_attention( &self, request_type: Option<UserAttentionType>, ) -> Result<()>

Available on desktop only.

Requests user attention to the window, this has no effect if the application is already focused. How requesting for user attention manifests is platform dependent, see UserAttentionType for details.

Providing None will unset the request for user attention. Unsetting the request for user attention might not be done automatically by the WM when the window receives input.

Platform-specific

• macOS: None has no effect.
• Linux: Urgency levels have the same effect.

pub fn set_resizable(&self, resizable: bool) -> Result<()>

Available on desktop only.

Determines if this window should be resizable. When resizable is set to false, native window’s maximize button is automatically disabled.

pub fn set_enabled(&self, enabled: bool) -> Result<()>

Available on desktop only.

Enable or disable the window.

pub fn set_maximizable(&self, maximizable: bool) -> Result<()>

Available on desktop only.

Determines if this window’s native maximize button should be enabled. If resizable is set to false, this setting is ignored.

Platform-specific

• macOS: Disables the “zoom” button in the window titlebar, which is also used to enter fullscreen mode.
• Linux / iOS / Android: Unsupported.

pub fn set_minimizable(&self, minimizable: bool) -> Result<()>

Available on desktop only.

Determines if this window’s native minimize button should be enabled.

Platform-specific

• Linux / iOS / Android: Unsupported.

pub fn set_closable(&self, closable: bool) -> Result<()>

Available on desktop only.

Determines if this window’s native close button should be enabled.

Platform-specific

• Linux: “GTK+ will do its best to convince the window manager not to show a close button. Depending on the system, this function may not have any effect when called on a window that is already visible”
• iOS / Android: Unsupported.

pub fn set_title(&self, title: &str) -> Result<()>

Available on desktop only.

Set this window’s title.

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

Available on desktop only.

Maximizes this window.

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

Available on desktop only.

Un-maximizes this window.

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

Available on desktop only.

Minimizes this window.

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

Available on desktop only.

Un-minimizes this window.

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

Available on desktop only.

Show this window.

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

Available on desktop only.

Hide this window.

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

Available on desktop only.

Closes this window. It emits [crate::RunEvent::CloseRequested] first like a user-initiated close request so you can intercept it.

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

Available on desktop only.

Destroys this window. Similar to Self::close but does not emit any events and force close the window instead.

pub fn set_decorations(&self, decorations: bool) -> Result<()>

Available on desktop only.

Determines if this window should be decorated.

pub fn set_shadow(&self, enable: bool) -> Result<()>

Available on desktop only.

Determines if this window should have shadow.

Platform-specific

• Windows:
  • false has no effect on decorated window, shadow are always ON.
  • true will make undecorated window have a 1px white border, and on Windows 11, it will have a rounded corners.
• Linux: Unsupported.

pub fn set_effects<E: Into<Option<WindowEffectsConfig>>>( &self, effects: E, ) -> Result<()>

Available on desktop only.

Sets window effects, pass None to clear any effects applied if possible.

Requires the window to be transparent.

See crate::window::EffectsBuilder for a convenient builder for crate::utils::config::WindowEffectsConfig.

use tauri::{Manager, window::{Color, Effect, EffectState, EffectsBuilder}};
tauri::Builder::default()
  .setup(|app| {
    let webview_window = app.get_webview_window("main").unwrap();
    webview_window.set_effects(
      EffectsBuilder::new()
        .effect(Effect::Popover)
        .state(EffectState::Active)
        .radius(5.)
        .color(Color(0, 0, 0, 255))
        .build(),
    )?;
    Ok(())
  });

Platform-specific:

• Windows: If using decorations or shadows, you may want to try this workaround https://github.com/tauri-apps/tao/issues/72#issuecomment-975607891
• Linux: Unsupported

pub fn set_always_on_bottom(&self, always_on_bottom: bool) -> Result<()>

Available on desktop only.

Determines if this window should always be below other windows.

pub fn set_always_on_top(&self, always_on_top: bool) -> Result<()>

Available on desktop only.

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

pub fn set_visible_on_all_workspaces( &self, visible_on_all_workspaces: bool, ) -> Result<()>

Available on desktop only.

Sets whether the window should be visible on all workspaces or virtual desktops.

pub fn set_content_protected(&self, protected: bool) -> Result<()>

Available on desktop only.

Prevents the window contents from being captured by other apps.

pub fn set_size<S: Into<Size>>(&self, size: S) -> Result<()>

Available on desktop only.

Resizes this window.

pub fn set_min_size<S: Into<Size>>(&self, size: Option<S>) -> Result<()>

Available on desktop only.

Sets this window’s minimum inner size.

pub fn set_max_size<S: Into<Size>>(&self, size: Option<S>) -> Result<()>

Available on desktop only.

Sets this window’s maximum inner size.

pub fn set_size_constraints( &self, constraints: WindowSizeConstraints, ) -> Result<()>

Available on desktop only.

Sets this window’s minimum inner width.

pub fn set_position<Pos: Into<Position>>(&self, position: Pos) -> Result<()>

Available on desktop only.

Sets this window’s position.

pub fn set_fullscreen(&self, fullscreen: bool) -> Result<()>

Available on desktop only.

Determines if this window should be fullscreen.

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

Available on desktop only.

Bring the window to front and focus.

pub fn set_focusable(&self, focusable: bool) -> Result<()>

Available on desktop only.

Sets whether the window can be focused.

Platform-specific

• macOS: If the window is already focused, it is not possible to unfocus it after calling set_focusable(false). In this case, you might consider calling Window::set_focus but it will move the window to the back i.e. at the bottom in terms of z-order.

pub fn set_icon(&self, icon: Image<'_>) -> Result<()>

Available on desktop only.

Sets this window’ icon.

pub fn set_background_color(&self, color: Option<Color>) -> Result<()>

Available on desktop only.

Sets the window background color.

Platform-specific:

• iOS / Android: Unsupported.
• macOS: Not implemented for the webview layer..
• Windows:
  • alpha channel is ignored for the window layer.
  • On Windows 7, transparency is not supported and the alpha value will be ignored for the webview layer..
  • On Windows 8 and newer: translucent colors are not supported so any alpha value other than 0 will be replaced by 255 for the webview layer.

pub fn set_skip_taskbar(&self, skip: bool) -> Result<()>

Available on desktop only.

Whether to hide the window icon from the taskbar or not.

Platform-specific

• macOS: Unsupported.

pub fn set_cursor_grab(&self, grab: bool) -> Result<()>

Available on desktop only.

Grabs the cursor, preventing it from leaving the window.

There’s no guarantee that the cursor will be hidden. You should hide it by yourself if you want so.

Platform-specific

• Linux: Unsupported.
• macOS: This locks the cursor in a fixed location, which looks visually awkward.

pub fn set_cursor_visible(&self, visible: bool) -> Result<()>

Available on desktop only.

Modifies the cursor’s visibility.

If false, this will hide the cursor. If true, this will show the cursor.

Platform-specific

• Windows: The cursor is only hidden within the confines of the window.
• macOS: The cursor is hidden as long as the window has input focus, even if the cursor is outside of the window.

pub fn set_cursor_icon(&self, icon: CursorIcon) -> Result<()>

Available on desktop only.

Modifies the cursor icon of the window.

pub fn set_cursor_position<Pos: Into<Position>>( &self, position: Pos, ) -> Result<()>

Available on desktop only.

Changes the position of the cursor in window coordinates.

pub fn set_ignore_cursor_events(&self, ignore: bool) -> Result<()>

Available on desktop only.

Ignores the window cursor events.

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

Available on desktop only.

Starts dragging the window.

pub fn set_badge_count(&self, count: Option<i64>) -> Result<()>

Available on desktop only.

Sets the taskbar badge count. Using 0 or None will remove the badge

Platform-specific

• Windows: Unsupported, use [WebviewWindow::set_overlay_icon] instead.
• iOS: iOS expects i32, the value will be clamped to i32::MIN, i32::MAX.
• Android: Unsupported.

pub fn set_progress_bar(&self, progress_state: ProgressBarState) -> Result<()>

Available on desktop only.

Sets the taskbar progress state.

Platform-specific

• Linux / macOS: Progress bar is app-wide and not specific to this window.
• Linux: Only supported desktop environments with libunity (e.g. GNOME).
• iOS / Android: Unsupported.

pub fn set_title_bar_style(&self, style: TitleBarStyle) -> Result<()>

Available on desktop only.

Sets the title bar style. macOS only.

pub fn set_theme(&self, theme: Option<Theme>) -> Result<()>

Available on desktop only.

Sets the theme for this window.

Platform-specific

• Linux / macOS: Theme is app-wide and not specific to this window.
• iOS / Android: Unsupported.

impl<R: Runtime> WebviewWindow<R>

Desktop webview setters and actions.

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

Available on desktop only.

Opens the dialog to prints the contents of the webview. Currently only supported on macOS on wry. window.print() works on all platforms.

impl<R: Runtime> WebviewWindow<R>

Webview APIs.

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

Available on crate feature wry only.

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

See Self::cookies.

Known issues

See Self::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.

pub fn set_cookie(&self, cookie: Cookie<'_>) -> Result<()>

Set a cookie for the webview.

Stability

See Self::cookies.

pub fn delete_cookie(&self, cookie: Cookie<'_>) -> Result<()>

Delete a cookie for the webview.

Stability

See Self::cookies.

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.

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>

Available on crate feature specta only.

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

Available on crate feature protocol-asset only.

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 Webview’s label to compare equality.

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>