Tauri

https://docs.rs/tauri/2.9.5
Admin
Tauri is a framework for building tiny, blazing fast desktop binaries for all major platforms by...
Tokens:195,816
Snippets:1,875
Trust Score:9.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### WindowBuilder Initialization Example

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Demonstrates how to initialize a `WindowBuilder` within the `setup` hook of a Tauri application. This is a common pattern for creating the initial window when the application starts.

```rust
impl<'a, R: Runtime, M: Manager<R>> WindowBuilder<'a, R, M> {
  /// Initializes a window builder with the given window label.
  ///
  /// # 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 creating windows.
  ///
  /// # Examples
  ///
  /// - Create a window in the setup hook:
  ///
  ///
  /// #[cfg_attr(
  ///   feature = "unstable",
  ///   doc = r####"```
  /// tauri::Builder::default()
  ///   .setup(|app| {

```

--------------------------------

### Create Webview in Setup Hook

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Demonstrates creating a webview within the application's setup hook. This is suitable for initializing the main webview or other essential UI components when the application starts.

```rust
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label").build()?;
    let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::App("index.html".into()));
    let webview = window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
    Ok(())
  });

```

--------------------------------

### Example: Setting up a Menu and Event Listener

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Demonstrates how to create a menu, assign it to a window, and register an event listener for menu item interactions. This example requires the `unstable` feature.

```rust
use tauri::menu::{Menu, Submenu, MenuItem};
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 window = tauri::window::WindowBuilder::new(app, "editor")
      .menu(menu)
      .build()
      .unwrap();

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

    Ok(())
  });
```

--------------------------------

### Example: Setting Up a Menu and Event Listener (Desktop)

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Demonstrates setting up a custom menu for a webview window and registering an event listener for menu items. This example includes creating menu items and submenus.

```rust
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(())
  });

```

--------------------------------

### Tauri Stateful Commands and Setup

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Shows how to define and use stateful commands (`int_command`, `string_command`) and manage custom state (`MyInt`, `MyString`) during application setup. Demonstrates reading managed state using `app.state()` and `State` guards.

```rust
use tauri::{Manager, State};

struct MyInt(isize);
struct MyString(String);

#[tauri::command]
fn int_command(state: State<MyInt>) -> String {
    format!("The stateful int is: {}", state.0)
}

#[tauri::command]
fn string_command<'r>(state: State<'r, MyString>) {
    println!("state: {}", state.inner().0);
}

tauri::Builder::default()
  .setup(|app| {
    app.manage(MyInt(0));
    app.manage(MyString("tauri".into()));
    // `MyInt` is already managed, so `manage()` returns false
    assert!(!app.manage(MyInt(1)));
    // read the `MyInt` managed state with the turbofish syntax
    let int = app.state::<MyInt>();
    assert_eq!(int.0, 0);
    // read the `MyString` managed state with the `State` guard
    let val: State<MyString> = app.state();
    assert_eq!(val.0, "tauri");
    Ok(())
  })
  .invoke_handler(tauri::generate_handler![int_command, string_command])
  // on an actual app, remove the string argument
  .run(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while running tauri application");
```

--------------------------------

### Setup Hook for App Initialization

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Builder.html

Defines a setup hook that runs once when the Tauri application is initialized. This is useful for tasks like setting window titles or performing initial configurations.

```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let main_window = app.get_webview_window("main").unwrap();
    main_window.set_title("Tauri!")?;
    Ok(())
  });
```

--------------------------------

### start_resize_dragging

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.Window.html

Starts resize-dragging the window. Available on `desktop` only.

```APIDOC
## start_resize_dragging

### Description
Starts resize-dragging the window.

### Method
`start_resize_dragging(direction: ResizeDirection)`

### Parameters
* `direction` (ResizeDirection) - The direction to start resizing from.
```

--------------------------------

### Example: Resolve Command Scope

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Demonstrates how to resolve a command scope within the Tauri application setup. This example shows checking the scope for a hypothetical 'my-plugin' command.

```rust
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(())
  });

```

--------------------------------

### start_dragging

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Starts dragging the window. Available on `desktop` only.

```APIDOC
## start_dragging

### Description
Starts dragging the window.

### Method
`start_dragging()`

### Platform
- `desktop` only.
```

--------------------------------

### Builder::setup

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Builder.html

Defines the setup hook, which is a function that runs once when the application is set up.

```APIDOC
## Builder::setup

### Description
Defines the setup hook.

### Method
`pub fn setup<F>(self, setup: F) -> Self`
where F: FnOnce(&mut App<R>) -> Result<(), Box<dyn Error>> + Send + 'static
```

--------------------------------

### Get Hosting Window

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Returns the `Window` object that hosts this webview.

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

--------------------------------

### Get Configuration

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Returns a reference to the application's configuration object.

```rust
fn config(&self) -> &Config {
    self.manager().config()
  }
```

--------------------------------

### fullscreen

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.WindowBuilder.html

Specifies whether the window should start in fullscreen mode.

```APIDOC
## fullscreen

### Description
Whether to start the window in fullscreen or not.

### Method
`fullscreen(self, fullscreen: bool) -> Self`

### Platform
Available on `desktop` only.
```

--------------------------------

### Get Hosting Window

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Returns the `Window` object that hosts this webview.

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

### Description
The window that is hosting this webview.
```

--------------------------------

### WindowBuilder::new

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.WindowBuilder.html

Initializes a window builder with a given window label. This is the primary way to start building a new window.

```APIDOC
## WindowBuilder::new

### Description
Initializes a window builder with the given window label.

### Signature
```rust
pub fn new<L: Into<String>>(manager: &'a M, label: L) -> Self
```

### Parameters
* `manager`: A reference to the manager that will handle the window.
* `label`: The unique label for the window.

### Known Issues
On Windows, this function deadlocks when used in a synchronous command or event handlers. Use `async` commands and separate threads when creating windows.

### Examples
```rust
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label")
      .build()?;
    Ok(())
  });
```
```

--------------------------------

### Create a new AboutMetadataBuilder

Source: https://docs.rs/tauri/2.9.5/tauri/menu/struct.AboutMetadataBuilder.html

Initializes a new instance of the AboutMetadataBuilder. This is the starting point for configuring about metadata.

```rust
pub fn new() -> Self
```

--------------------------------

### Example tauri.config.json File

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Config.html

Illustrates a typical tauri.config.json file, showing how to configure application name, version, build commands, and window settings.

```json
{
  "productName": "tauri-app",
  "version": "0.1.0",
  "build": {
    "beforeBuildCommand": "",
    "beforeDevCommand": "",
    "devUrl": "http://localhost:3000",
    "frontendDist": "../dist"
  },
  "app": {
    "security": {
      "csp": null
    },
    "windows": [
      {
        "fullscreen": false,
        "height": 600,
        "resizable": true,
        "title": "Tauri App",
        "width": 800
      }
    ]
  },
  "bundle": {},
  "plugins": {}
}
```

--------------------------------

### Get Package Information

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Returns a reference to the application's package information, including name, version, etc.

```rust
fn package_info(&self) -> &PackageInfo {
    self.manager().package_info()
  }
```

--------------------------------

### parse

Source: https://docs.rs/tauri/2.9.5/tauri/path/struct.PathResolver.html

Parses a given path, resolving a `BaseDirectory` variable if the path starts with one. Includes an example of usage.

```APIDOC
## parse<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf>

### Description
Parse the given path, resolving a `BaseDirectory` variable if the path starts with one.

### Examples
```rust
use tauri::Manager;
tauri::Builder::default()
  .setup(|app| {
    let path = app.path().parse("$HOME/.bashrc")?;
    assert_eq!(path.to_str().unwrap(), "/home/${whoami}/.bashrc");
    Ok(())
  });
```
```

--------------------------------

### Create Webview from Configuration

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Demonstrates initializing a webview builder using configuration from `tauri.conf.json`. This is useful for pre-defined window settings and simplifies webview setup when using configuration files.

```rust
#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::new(&app, "label").build().unwrap();
  let webview_builder = tauri::webview::WebviewBuilder::from_config(&app.config().app.windows.get(0).unwrap().clone());
  window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
}

```

--------------------------------

### Get Cursor Position

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Retrieves the cursor's position relative to the top-left corner of the desktop. Handles multi-monitor setups and can return negative coordinates.

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

--------------------------------

### Get Cookie Value

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Cookie.html

Retrieves the raw value of a cookie. Use `value_trimmed()` to get the value with surrounding quotes removed.

```rust
use cookie::Cookie;

let c = Cookie::new("name", "value");
assert_eq!(c.value(), "value");

let c = Cookie::new("name", "\"value\"");
assert_eq!(c.value(), "\"value\"");
```

--------------------------------

### Window Builder Initialization

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.Window.html

Initializes a window builder with a given window label. This is the starting point for creating or configuring a new window.

```APIDOC
## pub fn builder<M: Manager<R>, L: Into<String>>( manager: &M, label: L, ) -> WindowBuilder<'_, R, M>

### Description
Initializes a window builder with the given window label.

### Parameters
* `manager`: A reference to the application's manager.
* `label`: The label for the new window.
```

--------------------------------

### Context::new

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Constructs a new `Context` instance with all the necessary configuration and assets for the application. This is the primary way to initialize the application's context.

```APIDOC
## Context::new

### Description
Creates a new [`Context`] from the minimal required items.

### Method
`Context::new`

### Parameters

#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* **config** (Config) - The application configuration.
* **assets** (Box<dyn Assets<R>>) - Application assets.
* **default_window_icon** (Option<image::Image<'static>>) - The default icon for windows.
* **app_icon** (Option<Vec<u8>>) - The application icon.
* **package_info** (PackageInfo) - Information about the application package.
* **pattern** (Pattern) - The application startup pattern.
* **runtime_authority** (RuntimeAuthority) - The runtime authority.
* **plugin_global_api_scripts** (Option<&'static [&'static str]>) - Optional global API scripts for plugins.

### Request Example
None

### Response
#### Success Response (200)
Returns a new `Context` instance.

#### Response Example
None
```

--------------------------------

### Mock Runtime Window Configuration Methods

Source: https://docs.rs/tauri/2.9.5/src/tauri/test/mock_runtime.rs.html

Provides a comprehensive set of builder-style methods for configuring various window properties. These methods allow for granular control over window behavior, appearance, and state, facilitating detailed testing scenarios.

```rust
fn with_config(config: &WindowConfig) -> Self {
    Self {}
  }

  fn center(self) -> Self {
    self
  }

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

  fn inner_size(self, min_width: f64, min_height: f64) -> Self {
    self
  }

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

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

  fn inner_size_constraints(
    self,
    constraints: tauri_runtime::window::WindowSizeConstraints,
  ) -> Self {
    self
  }

  fn prevent_overflow(self) -> Self {
    self
  }

  fn prevent_overflow_with_margin(self, margin: tauri_runtime::dpi::Size) -> Self {
    self
  }

  fn resizable(self, resizable: bool) -> Self {
    self
  }

  fn maximizable(self, resizable: bool) -> Self {
    self
  }

  fn minimizable(self, resizable: bool) -> Self {
    self
  }

  fn closable(self, resizable: bool) -> Self {
    self
  }

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

  fn fullscreen(self, fullscreen: bool) -> Self {
    self
  }

  fn focused(self, focused: bool) -> Self {
    self
  }

  fn focusable(self, focusable: bool) -> Self {
    self
  }

  fn maximized(self, maximized: bool) -> Self {
    self
  }

  fn visible(self, visible: bool) -> Self {
    self
  }

  #[cfg(any(not(target_os = "macos"), feature = "macos-private-api"))]
  #[cfg_attr(
    docsrs,
    doc(cfg(any(not(target_os = "macos"), feature = "macos-private-api")))
  )]
  fn transparent(self, transparent: bool) -> Self {
    self
  }

  fn decorations(self, decorations: bool) -> Self {
    self
  }

  fn always_on_bottom(self, always_on_bottom: bool) -> Self {
    self
  }

  fn always_on_top(self, always_on_top: bool) -> Self {
    self
  }

  fn visible_on_all_workspaces(self, visible_on_all_workspaces: bool) -> Self {
    self
  }

  fn content_protected(self, protected: bool) -> Self {
    self
  }

  fn icon(self, icon: Icon<'_>) -> Result<Self> {
    Ok(self)
  }

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

  fn window_classname<S: Into<String>>(self, classname: S) -> Self {
    self
  }

  fn shadow(self, enable: bool) -> Self {
    self
  }

  #[cfg(windows)]
  fn owner(self, owner: HWND) -> Self {
    self
  }

  #[cfg(windows)]
  fn parent(self, parent: HWND) -> Self {
    self
  }

  #[cfg(target_os = "macos")]
  fn parent(self, parent: *mut std::ffi::c_void) -> Self {
    self
  }

  #[cfg(any(
    target_os = "linux",
    target_os = "dragonfly",
    target_os = "freebsd",
    target_os = "netbsd",
    target_os = "openbsd"
  ))]
  fn transient_for(self, parent: &impl gtk::glib::IsA<gtk::Window>) -> Self {
    self
  }

  #[cfg(windows)]
  fn drag_and_drop(self, enabled: bool) -> Self {
    self
  }

  #[cfg(target_os = "macos")]
  fn title_bar_style(self, style: TitleBarStyle) -> Self {
    self
  }

  #[cfg(target_os = "macos")]
  fn traffic_light_position<P: Into<Position>>(self, position: P) -> Self {
    self
  }

  #[cfg(target_os = "macos")]
  fn hidden_title(self, transparent: bool) -> Self {
    self
  }

  #[cfg(target_os = "macos")]
  fn tabbing_identifier(self, identifier: &str) -> Self {
    self
  }

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

  fn background_color(self, _color: tauri_utils::config::Color) -> Self {
    self
  }
```

--------------------------------

### resources_table

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Get a reference to the resources table of this manager.

```APIDOC
## resources_table

### Description
Get a reference to the resources table of this manager.

### Signature
```rust
fn resources_table(&self) -> MutexGuard<'_, ResourceTable>;
```

### Returns
* `MutexGuard<'_, ResourceTable>` - A mutex guard for the application's resource table.
```

--------------------------------

### WindowBuilder::from_config

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.WindowBuilder.html

Initializes a window builder from a WindowConfig, typically loaded from tauri.conf.json.

```APIDOC
## WindowBuilder::from_config

### Description
Initializes a window builder from a `WindowConfig` from tauri.conf.json. Ensure that the label is unique if creating multiple windows.

### Signature
```rust
pub fn from_config(manager: &'a M, config: &WindowConfig) -> Result<Self>
```

### Parameters
* `manager`: A reference to the manager that will handle the window.
* `config`: The `WindowConfig` to initialize the builder with.

### Known Issues
On Windows, this function deadlocks when used in a synchronous command or event handlers. Use `async` commands and separate threads when creating windows.

### Examples
```rust
#[tauri::command]
async fn reopen_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::from_config(&app, &app.config().app.windows.get(0).unwrap().clone())
    .unwrap()
    .build()
    .unwrap();
}
```
```

--------------------------------

### WindowBuilder::build

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Creates a new window with default configurations.

```APIDOC
## WindowBuilder::build

### Description
Creates a new window with default configurations.

### Method
```
pub fn build(self) -> crate::Result<Window<R>>
```

### Returns
A `Result` containing the newly created `Window` on success, or an error on failure.
```

--------------------------------

### Get Window Menu

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.Window.html

Retrieves the menu associated with this window.

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

### Description
Returns this window menu.

### Returns
An `Option<Menu<R>>` which is `Some` if a menu is set, `None` otherwise.
```

--------------------------------

### Register Global Menu Event Listener

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Demonstrates how to set up a global menu event listener for all windows and the tray icon. The listener is active as long as the window used for registration is open.

```rust
use tauri::menu::{Menu, Submenu, MenuItem};
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 window = tauri::window::WindowBuilder::new(app, "editor")
      .menu(menu)
      .on_menu_event(move |window, event| {
        if event.id == save_menu_item.id() {
          // save menu item
        }
      })
      .build()
      .unwrap();

    Ok(())
  });
```

--------------------------------

### CheckMenuItem::text

Source: https://docs.rs/tauri/2.9.5/tauri/menu/struct.CheckMenuItem.html

Gets the current text displayed for the CheckMenuItem.

```APIDOC
## CheckMenuItem::text

### Description
Gets the text for this menu item.

### Signature
```rust
pub fn text(&self) -> Result<String>
```

### Returns
A `Result` containing the menu item's text.
```

--------------------------------

### With Webview Configuration

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Set the webview configuration. Useful if you need to share the use a predefined webview configuration, for instance when using the `on_new_window`.

```APIDOC
## with_webview_configuration

### Description
Set the webview configuration.
Useful if you need to share the use a predefined webview configuration, for instance when using the [`Self::on_new_window`].

### Platform-specific

- **Linux / Windows / Android / FreeBSD / NetBSD / OpenBSD / Dragonfly:** Unsupported.

### Parameters
- **webview_configuration** (objc2::rc::Retained<objc2_web_kit::WKWebViewConfiguration>) - The webview configuration to set.
```

--------------------------------

### MenuItem::text

Source: https://docs.rs/tauri/2.9.5/src/tauri/menu/normal.rs.html

Gets the current text of the menu item.

```APIDOC
## MenuItem::text

### Description
Gets the text for this menu item.

### Signature
```rust
pub fn text(&self) -> crate::Result<String>
```

### Returns
A `Result` containing the menu item's text.
```

--------------------------------

### Create Webview in Command

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Illustrates creating a webview from within a Tauri command. This allows dynamic webview creation in response to user actions or other events.

```rust
#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::new(&app, "label").build().unwrap();
  let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::External("https://tauri.app/".parse().unwrap()));
  window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
}

```

--------------------------------

### Cookie::build

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Cookie.html

Starts building a Cookie using a CookieBuilder.

```APIDOC
## Cookie::build

### Description
Creates a new `CookieBuilder` starting from a `base` cookie. Any type that implements `T: Into<Cookie>` can be used as a `base`.

### Signature
```rust
pub fn build<C>(base: C) -> CookieBuilder<'c>
where C: Into<Cookie<'c>>,
```

### Parameters
- `base`: The initial cookie or value to build upon.

### Example
```rust
use cookie::Cookie;

// Use `(K, V)` as the base, setting a name and value.
let b1 = Cookie::build(("name", "value")).path("/");
assert_eq!(b1.inner().name_value(), ("name", "value"));
assert_eq!(b1.inner().path(), Some("/"));

// Use `&str` as the base, setting a name and empty value.
let b2 = Cookie::build("name");
assert_eq!(b2.inner().name_value(), ("name", ""));
```
```

--------------------------------

### Create a window

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Demonstrates how to create a new window with a specified label.

```APIDOC
## Create a window

### Description
Creates a new window with a given label.

### Method
`WindowBuilder::new()`

### Parameters
- `manager`: A reference to the application's manager.
- `label`: The unique label for the new window.
```

--------------------------------

### Get Window Label

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Returns a reference to the label of the current window.

```rust
pub fn label(&self) -> &str {
    &self.window.label
  }
```

--------------------------------

### Create Window in Command

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.WindowBuilder.html

Shows how to create a window from within an asynchronous Tauri command. This approach helps mitigate deadlocks on Windows.

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

--------------------------------

### Get Window Label

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.Window.html

Retrieves the unique label associated with this window.

```APIDOC
## pub fn label(&self) -> &str

### Description
The label of this window.

### Returns
A string slice representing the window's label.
```

--------------------------------

### Create a WebviewBuilder

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Initializes a `WebviewBuilder` with a given window label and URL. This method is only available when the `unstable` feature is enabled.

```rust
pub fn builder<L: Into<String>>(label: L, url: WebviewUrl) -> WebviewBuilder<R> {
    WebviewBuilder::new(label.into(), url)
  }
```

--------------------------------

### Get Window Menu (Desktop)

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Retrieves the menu associated with this window.

```APIDOC
## menu(&self) -> Option<Menu<R>>

Available on **`desktop`**only.
Returns this window menu.
```

--------------------------------

### Initialize Webview Builder

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Use this function to start building a new webview instance, specifying its unique label and the initial URL to load. Data URLs are supported with the `webview-data-url` feature flag.

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

--------------------------------

### With Environment

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Set the environment for the webview. Useful if you need to share the same environment, for instance when using the `on_new_window`.

```APIDOC
## with_environment

### Description
Set the environment for the webview.
Useful if you need to share the same environment, for instance when using the [`Self::on_new_window`].

### Platform-specific

- **Linux / Android / iOS / macOS:** Unsupported.

### Parameters
- **environment** (webview2_com::Microsoft::Web::WebView2::Win32::ICoreWebView2Environment) - The webview environment to set.
```

--------------------------------

### Initialize and Insert Data into Tauri State

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Demonstrates initializing a `Storage` and `DbConnection` and inserting data into storage using `storage_insert` command. The `connect` command initializes the database connection.

```rust
struct DbConnection {
  db: Mutex<Option<Connection>>,
}

#[tauri::command]
fn connect(connection: State<DbConnection>) {
  // initialize the connection, mutating the state with interior mutability
  *connection.db.lock().unwrap() = Some(Connection {});
}

#[tauri::command]
fn storage_insert(key: u64, value: String, storage: State<Storage>) {
  // mutate the storage behind the Mutex
  storage.store.lock().unwrap().insert(key, value);
}

tauri::Builder::default()
  .manage(Storage { store: Default::default() })
  .manage(DbConnection { db: Default::default() })
  .invoke_handler(tauri::generate_handler![connect, storage_insert])
  // on an actual app, remove the string argument
  .run(tauri::generate_context!("test/fixture/src-tauri/tauri.conf.json"))
  .expect("error while running tauri application");
```

--------------------------------

### Get Webview Label

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Retrieves the unique label associated with the webview.

```APIDOC
## pub fn label(&self) -> &str

### Description
Returns the label of the webview.
```

--------------------------------

### Create a new Webview instance

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Constructs a new `Webview` instance, initializing it with the provided window, detached webview, and HTTPS scheme configuration.

```rust
pub(crate) fn new(
    window: Window<R>,
    webview: DetachedWebview<EventLoopMessage, R>,
    use_https_scheme: bool,
  ) -> Self {
    Self {
      manager: window.manager.clone(),
      app_handle: window.app_handle.clone(),
      window: Arc::new(Mutex::new(window)),
      webview,
      resources_table: Default::default(),
      use_https_scheme,
    }
  }
```

--------------------------------

### Get SameSite Attribute

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Cookie.html

Retrieves the SameSite attribute of a cookie if specified.

```rust
use cookie::{Cookie, SameSite};

let c = Cookie::parse("name=value; SameSite=Lax").unwrap();
assert_eq!(c.same_site(), Some(SameSite::Lax));
```

--------------------------------

### Text Manipulation

Source: https://docs.rs/tauri/2.9.5/src/tauri/menu/icon.rs.html

Methods for getting and setting the text of a menu item.

```APIDOC
## text

### Description
Get the text for this menu item.

### Method
`text()`

### Returns
- `crate::Result<String>`: The text of the menu item.
```

```APIDOC
## set_text

### Description
Set the text for this menu item. `text` could optionally contain
an `&` before a character to assign this character as the mnemonic
for this menu item. To display a `&` without assigning a mnemenonic, use `&&`.

### Method
`set_text<S: AsRef<str>>(&self, text: S) -> crate::Result<()>`

### Parameters
- `text` (S: AsRef<str>): The new text for the menu item.
```

--------------------------------

### env

Source: https://docs.rs/tauri/2.9.5/src/tauri/lib.rs.html

Gets the managed Env. This provides access to environment-specific configuration.

```APIDOC
## env

### Description
Gets the managed [`Env`]. This provides access to environment-specific configuration.

### Signature
```rust
fn env(&self) -> Env;
```

### Returns
* `Env` - The application's environment configuration.
```

--------------------------------

### Set Application Menu

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Builder.html

Demonstrates how to define and set a custom menu for all windows in a Tauri desktop application.

```rust
use tauri::menu::{Menu, MenuItem, PredefinedMenuItem, Submenu};

tauri::Builder::default()
  .menu(|handle| Menu::with_items(handle, &[
    &Submenu::with_items(
      handle,
      "File",
      true,
      &[
        &PredefinedMenuItem::close_window(handle, None)?,
        #[cfg(target_os = "macos")]
        &MenuItem::new(handle, "Hello", true, None::<&str>)?,
      ],
    )?
  ]));
```

--------------------------------

### Webview Builder

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Initializes a webview builder with a given window label and URL. This is the entry point for creating a new webview instance.

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

### Description
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.

### Parameters
#### Path Parameters
- **label** (L) - Required - The label for the new webview window.
- **url** (WebviewUrl) - Required - The URL to load in the webview.
```

--------------------------------

### Show Window Menu (Windows/Linux)

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Shows the current window's menu. On Windows, it calls `show_for_hwnd`. On Linux, it calls `show_for_gtk_window`. macOS is unsupported for window-specific menus.

```rust
pub fn show_menu(&self) -> crate::Result<()> {
    // remove from the window
    #[cfg_attr(target_os = "macos", allow(unused_variables))]
    if let Some(window_menu) = &*self.menu_lock() {
      let window = self.clone();
      let menu_ = window_menu.menu.clone();
      self.run_on_main_thread(move || {
        #[cfg(windows)]
        if let Ok(hwnd) = window.hwnd() {
          let _ = unsafe { menu_.inner().show_for_hwnd(hwnd.0 as _) };
        }
        #[cfg(any(
          target_os = "linux",
          target_os = "dragonfly",
          target_os = "freebsd",
          target_os = "netbsd",
          target_os = "openbsd"
        ))]
        if let Ok(gtk_window) = window.gtk_window() {
          let _ = menu_.inner().show_for_gtk_window(&gtk_window);
        }
      })?;
    }

    Ok(())
  }
```

--------------------------------

### Get Event Payload

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Event.html

Retrieves the event payload as a string slice.

```rust
pub fn payload(&self) -> &str
```

--------------------------------

### listen

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Listens to an event on this webview. Example provided for listening to 'component-loaded'.

```APIDOC
## listen

### Description
Listen to an event on this webview.

### Examples
```rust
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(())
  });
```

### Method
```rust
pub fn listen<F>(&self, event: impl Into<String>, handler: F)
where
  F: Fn(Event) + Send + Sync + 'static,
```
```

--------------------------------

### WindowBuilder::build_internal

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Creates a new window with an optional pre-configured webview.

```APIDOC
## WindowBuilder::build_internal

### Description
Creates a new window with an optional pre-configured webview.

### Method
```rust
fn build_internal(
  self,
  webview: Option<PendingWebview<EventLoopMessage, R>>,
) -> crate::Result<Window<R>>
```

### Parameters
#### Path Parameters
- **webview** (Option<PendingWebview<EventLoopMessage, R>>) - An optional `PendingWebview` to attach to the new window.

### Returns
A `Result` containing the newly created `Window` on success, or an error on failure.
```

--------------------------------

### Initialize WebviewWindowBuilder

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Initializes a WebviewWindowBuilder with a manager, label, and URL. Data URLs require the 'webview-data-url' feature flag.

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

--------------------------------

### WebviewWindow Handle Accessors

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Methods to get handles to the display controller and the window itself.

```APIDOC
## display_handle

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

### Signature
```rust
fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError>
```

### Returns
A `Result` containing a `DisplayHandle` on success, or a `HandleError` on failure.

## window_handle

### Description
Get a handle to the window.

### Signature
```rust
fn window_handle(&self) -> Result<WindowHandle<'_>, HandleError>
```

### Returns
A `Result` containing a `WindowHandle` on success, or a `HandleError` on failure.
```

--------------------------------

### Run Application

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Builder.html

Builds the configured application and runs it. This is a convenient shorthand for calling `Self::build` followed by `App::run`.

```APIDOC
## run

### Description
Builds the configured application and runs it.
This is a shorthand for `Self::build` followed by `App::run`. For more flexibility, consider using those functions manually.

### Method Signature
`pub fn run(self, context: Context<R>) -> Result<()>`

### Arguments
* `context` (Context<R>) - The application context, which includes configuration and setup information.
```

--------------------------------

### Get Webview Position

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Retrieves the current position of the webview. This is a desktop-specific feature.

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

### Description
Returns the webview position. For child webviews, returns the position relative to the parent window. For top-level webviews, returns the inner position of the window.

### Availability
Available on `desktop` only.
```

--------------------------------

### Webview::new

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Creates a new webview instance attached to a given window.

```APIDOC
## Webview::new

### Description
Creates a new webview instance that is attached to the provided window.

### Parameters
- `window` (Window<R>): The window to which the webview will be attached.
- `webview` (DetachedWebview<EventLoopMessage, R>): The detached webview instance.
- `use_https_scheme` (bool): A boolean indicating whether the HTTPS scheme should be used.

### Returns
- `Self`: A new `Webview` instance.
```

--------------------------------

### Get Cookie Name and Value

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Cookie.html

Returns the name and value of a cookie as a tuple.

```rust
use cookie::Cookie;

let c = Cookie::new("name", "value");
assert_eq!(c.name_value(), ("name", "value"));
```

--------------------------------

### Build Application

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Builder.html

Builds the application with the specified context. This is a prerequisite step before running the application.

```APIDOC
## build

### Description
Builds the application.

### Method Signature
`pub fn build<R>(self, context: Context<R>) -> Result<App<R>>`

### Arguments
* `context` (Context<R>) - The application context, which includes configuration and setup information.
```

--------------------------------

### Get Webview Label

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Retrieves the unique label associated with this webview instance.

```rust
pub fn label(&self) -> &str
```

--------------------------------

### Getting the Application Handle

Source: https://docs.rs/tauri/2.9.5/tauri/menu/struct.MenuItem.html

Retrieves the application handle associated with the menu item.

```APIDOC
## pub fn app_handle(&self) -> &AppHandle<R>

### Description
The application handle associated with this type.

### Returns
A reference to the `AppHandle<R>`.
```

--------------------------------

### Create a window in a command

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Illustrates how to create a window from within a Tauri command.

```APIDOC
## Create a window in a command

### Description
Creates a new window from within an async Tauri command.

### Method
`#[tauri::command]`

### Example
```rust
#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::new(&app, "label")
    .build()
    .unwrap();
}
```
```

--------------------------------

### Webview::builder

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Initializes a webview builder with a label and a URL.

```APIDOC
## Webview::builder

### Description
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.

### Parameters
- `label` (L: Into<String>): The label for the webview window.
- `url` (WebviewUrl): The URL to load in the webview.

### Returns
- `WebviewBuilder<R>`: A new `WebviewBuilder` instance.
```

--------------------------------

### Get Event ID

Source: https://docs.rs/tauri/2.9.5/tauri/struct.Event.html

Retrieves the `EventId` of the handler that was triggered for a given event.

```rust
pub fn id(&self) -> EventId
```

--------------------------------

### Show Webview

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.Webview.html

Makes the webview window visible.

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

--------------------------------

### Get Temporary Directory

Source: https://docs.rs/tauri/2.9.5/src/tauri/path/desktop.rs.html

Retrieves the system's temporary directory path.

```rust
/// A temporary directory. Resolves to [`std::env::temp_dir`].
pub fn temp_dir(&self) -> Result<PathBuf> {
  Ok(std::env::temp_dir())
}
```

--------------------------------

### Build the capability file

Source: https://docs.rs/tauri/2.9.5/tauri/ipc/struct.CapabilityBuilder.html

Finalize the capability configuration and create a `CapabilityFile`. This is the output of the builder pattern.

```rust
fn build(self) -> CapabilityFile
```

--------------------------------

### Get menu item ID

Source: https://docs.rs/tauri/2.9.5/src/tauri/menu/normal.rs.html

Retrieves the unique identifier for this menu item.

```rust
pub fn id(&self) -> &MenuId {
    &self.0.id
}
```

--------------------------------

### Get application handle

Source: https://docs.rs/tauri/2.9.5/src/tauri/menu/normal.rs.html

Returns the application handle associated with this menu item.

```rust
pub fn app_handle(&self) -> &AppHandle<R> {
    &self.0.app_handle
}
```

--------------------------------

### WindowBuilder::new

Source: https://docs.rs/tauri/2.9.5/src/tauri/window/mod.rs.html

Initializes a window builder with the given window label. Data URLs are only supported with the `webview-data-url` feature flag.

```APIDOC
## builder<M: Manager<R>, L: Into<String>>(manager: &M, label: L) -> WindowBuilder<'_, R, M>

### Description
Initializes a window builder with the given window label.

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

### Parameters
* `manager`: A reference to the application manager.
* `label`: The label for the new window.
```

--------------------------------

### WebviewBuilder::new

Source: https://docs.rs/tauri/2.9.5/src/tauri/webview/mod.rs.html

Initializes a new webview builder with a given label and URL. This is the primary way to create a webview instance programmatically. It's important to note potential deadlocks on Windows when used in synchronous contexts, recommending asynchronous operations.

```APIDOC
## WebviewBuilder::new

### Description
Initializes a webview builder with the given webview label and URL to load.

On Windows, this function deadlocks when used in a synchronous command or event handlers. You should use `async` commands and separate threads when creating webviews.

### Method
`WebviewBuilder::new(label: L, url: WebviewUrl) -> Self`

### Parameters
* **label** (string) - The unique label for the webview window.
* **url** (WebviewUrl) - The URL or path to load in the webview.

### Examples

- Create a webview in the setup hook:
```rust
tauri::Builder::default()
  .setup(|app| {
    let window = tauri::window::WindowBuilder::new(app, "label").build()?;
    let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::App("index.html".into()));
    let webview = window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
    Ok(())
  });
```

- Create a webview in a separate thread:
```rust
tauri::Builder::default()
  .setup(|app| {
    let handle = app.handle().clone();
    std::thread::spawn(move || {
      let window = tauri::window::WindowBuilder::new(&handle, "label").build().unwrap();
      let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::App("index.html".into()));
      window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
    });
    Ok(())
  });
```

- Create a webview in a command:
```rust
#[tauri::command]
async fn create_window(app: tauri::AppHandle) {
  let window = tauri::window::WindowBuilder::new(&app, "label").build().unwrap();
  let webview_builder = tauri::webview::WebviewBuilder::new("label", tauri::WebviewUrl::External("https://tauri.app/".parse().unwrap()));
  window.add_child(webview_builder, tauri::LogicalPosition::new(0, 0), window.inner_size().unwrap());
}
```
```

--------------------------------

### Initialize Window Builder

Source: https://docs.rs/tauri/2.9.5/tauri/window/struct.Window.html

Initializes a window builder with a given label. Data URLs are only supported with the `webview-data-url` feature flag. Available on `unstable` crate feature only.

```rust
pub fn builder<M: Manager<R>, L: Into<String>>( manager: &M, label: L, ) -> WindowBuilder<'_, R, M>
```

--------------------------------

### WebviewWindow Specta Integration

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Provides a method to get the `DataType` for use with the Specta crate.

```APIDOC
## to_datatype

### Description
Gets the type of an argument as a `DataType`.

### Signature
```rust
fn to_datatype(_: &mut TypeMap) -> Option<DataType>
```

### Parameters
* `_`: A mutable reference to a `TypeMap`.

### Returns
An `Option<DataType>` representing the type, or `None` if it cannot be determined.
```

--------------------------------

### Get Window Menu (Desktop)

Source: https://docs.rs/tauri/2.9.5/tauri/webview/struct.WebviewWindow.html

Retrieves the menu associated with this window. Available only on desktop.

```rust
pub fn menu(&self) -> Option<Menu<R>>
```
Tokens:
Raw