Struct Webview

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

Webview.

Implementations

impl<R: Runtime> Webview<R>

Base webview functions.

pub fn builder<L: Into<String>>(label: L, url: WebviewUrl) -> WebviewBuilder<R>

Available on crate feature unstable only.

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

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_webview_event<F: Fn(&WebviewEvent) + 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 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> Webview<R>

Desktop webview setters and actions.

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

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

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

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.

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

Closes this webview.

pub fn set_bounds(&self, bounds: Rect) -> Result<()>

Resizes this webview.

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

Resizes this webview.

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

Sets this webviews’s position.

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

Focus the webview.

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

Hide the webview.

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

Show the webview.

pub fn reparent(&self, window: &Window<R>) -> Result<()>

Move the webview to the given window.

pub fn set_auto_resize(&self, auto_resize: bool) -> Result<()>

Sets whether the webview should automatically grow and shrink its size and position when the parent window resizes.

pub fn bounds(&self) -> Result<Rect>

Returns the bounds of the webviews’s client area.

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

Returns the webview position.

• For child webviews, returns the position of the top-left hand corner of the webviews’s client area relative to the top-left hand corner of the parent window.
• For webview window, returns the inner position of the window.

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

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

impl<R: Runtime> Webview<R>

Webview APIs.

pub fn window(&self) -> Window<R>

The window that is hosting this webview.

pub fn window_ref(&self) -> MutexGuard<'_, Window<R>>

A reference to the window that is hosting this webview.

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("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 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("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("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("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 set_background_color(&self, color: Option<Color>) -> Result<()>

Specify the webview background color.

Platfrom-specific:

• macOS / iOS: Not implemented.
• Windows:
  • On Windows 7, transparency is not supported and the alpha value will be ignored.
  • On Windows higher than 7: translucent colors are not supported so any alpha value other than 0 will be replaced by 255

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

Clear all browsing data for this webview.

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 Webview<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 Webview<R>

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

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

impl<R: Runtime> Debug for Webview<R>

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

Formats the value using the given formatter.

impl<R: Runtime> Emitter<R> for Webview<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 Webview<R>

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

Gets the type of an argument as a DataType.

impl<R: Runtime> Hash for Webview<R>

fn hash<H: Hasher>(&self, state: &mut H)

Only use the Webview’s label to represent its hash.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R: Runtime> Listener<R> for Webview<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.

Examples

use tauri::{Manager, Listener};

tauri::Builder::default()
  .setup(|app| {
    let webview = app.get_webview("main").unwrap();
    webview.listen("component-loaded", move |event| {
      println!("webview 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 webview only once.

See Self::listen for more information.

fn unlisten(&self, id: EventId)

Unlisten to an event on this webview.

Examples

use tauri::{Manager, Listener};

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

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

    // stop listening to the event when you do not need it anymore
    webview.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 Webview<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 Webview<R>

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

Only use the Webview’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 Webview<R>