Struct tauri::Context

pub struct Context<A: Assets> { /* private fields */ }

User supplied data required inside of a Tauri application.

Stability

This is the output of the generate_context macro, and is not considered part of the stable API. Unless you know what you are doing and are prepared for this type to have breaking changes, do not create it yourself.

Implementations

impl<A: Assets> Context<A>

pub fn config(&self) -> &Config

The config the application was prepared with.

pub fn config_mut(&mut self) -> &mut Config

A mutable reference to the config the application was prepared with.

pub fn assets(&self) -> Arc<A>

The assets to be served directly by Tauri.

pub fn assets_mut(&mut self) -> &mut Arc<A>

A mutable reference to the assets to be served directly by Tauri.

pub fn default_window_icon(&self) -> Option<&Icon>

The default window icon Tauri should use when creating windows.

pub fn default_window_icon_mut(&mut self) -> &mut Option<Icon>

A mutable reference to the default window icon Tauri should use when creating windows.

pub fn system_tray_icon(&self) -> Option<&Icon>

The icon to use on the system tray UI.

pub fn system_tray_icon_mut(&mut self) -> &mut Option<Icon>

A mutable reference to the icon to use on the system tray UI.

pub fn package_info(&self) -> &PackageInfo

Package information.

Examples found in repository

src/app.rs (line 1348)

  pub fn build<A: Assets>(mut self, context: Context<A>) -> crate::Result<App<R>> {
    #[cfg(target_os = "macos")]
    if self.menu.is_none() && self.enable_macos_default_menu {
      self.menu = Some(Menu::os_default(&context.package_info().name));
    }

    #[cfg(feature = "system-tray")]
    let system_tray_icon = context.system_tray_icon.clone();

    #[cfg(all(feature = "system-tray", target_os = "macos"))]
    let (system_tray_icon_as_template, system_tray_menu_on_left_click) = context
      .config
      .tauri
      .system_tray
      .as_ref()
      .map(|t| (t.icon_as_template, t.menu_on_left_click))
      .unwrap_or_default();

    #[cfg(shell_scope)]
    let shell_scope = context.shell_scope.clone();

    let manager = WindowManager::with_handlers(
      context,
      self.plugins,
      self.invoke_handler,
      self.on_page_load,
      self.uri_scheme_protocols,
      self.state,
      self.window_event_listeners,
      (self.menu, self.menu_event_listeners),
      (self.invoke_responder, self.invoke_initialization_script),
    );

    // set up all the windows defined in the config
    for config in manager.config().tauri.windows.clone() {
      let url = config.url.clone();
      let label = config.label.clone();
      let file_drop_enabled = config.file_drop_enabled;

      let mut webview_attributes = WebviewAttributes::new(url);
      if !file_drop_enabled {
        webview_attributes = webview_attributes.disable_file_drop_handler();
      }

      self.pending_windows.push(PendingWindow::with_config(
        config,
        webview_attributes,
        label,
      )?);
    }

    #[cfg(any(windows, target_os = "linux"))]
    let runtime = if self.runtime_any_thread {
      R::new_any_thread()?
    } else {
      R::new()?
    };
    #[cfg(not(any(windows, target_os = "linux")))]
    let runtime = R::new()?;

    let runtime_handle = runtime.handle();

    #[cfg(feature = "global-shortcut")]
    let global_shortcut_manager = runtime.global_shortcut_manager();

    #[cfg(feature = "clipboard")]
    let clipboard_manager = runtime.clipboard_manager();

    let mut app = App {
      runtime: Some(runtime),
      manager: manager.clone(),
      #[cfg(feature = "global-shortcut")]
      global_shortcut_manager: global_shortcut_manager.clone(),
      #[cfg(feature = "clipboard")]
      clipboard_manager: clipboard_manager.clone(),
      #[cfg(feature = "system-tray")]
      tray_handle: None,
      handle: AppHandle {
        runtime_handle,
        manager,
        #[cfg(feature = "global-shortcut")]
        global_shortcut_manager,
        #[cfg(feature = "clipboard")]
        clipboard_manager,
        #[cfg(feature = "system-tray")]
        tray_handle: None,
        #[cfg(updater)]
        updater_settings: self.updater_settings,
      },
    };

    let env = Env::default();
    app.manage(Scopes {
      fs: FsScope::for_fs_api(
        &app.manager.config(),
        app.package_info(),
        &env,
        &app.config().tauri.allowlist.fs.scope,
      )?,
      #[cfg(protocol_asset)]
      asset_protocol: FsScope::for_fs_api(
        &app.manager.config(),
        app.package_info(),
        &env,
        &app.config().tauri.allowlist.protocol.asset_scope,
      )?,
      #[cfg(http_request)]
      http: crate::scope::HttpScope::for_http_api(&app.config().tauri.allowlist.http.scope),
      #[cfg(shell_scope)]
      shell: ShellScope::new(shell_scope),
    });
    app.manage(env);

    #[cfg(windows)]
    {
      if let crate::utils::config::WebviewInstallMode::FixedRuntime { path } = &app
        .manager
        .config()
        .tauri
        .bundle
        .windows
        .webview_install_mode
      {
        if let Some(resource_dir) = app.path_resolver().resource_dir() {
          std::env::set_var(
            "WEBVIEW2_BROWSER_EXECUTABLE_FOLDER",
            resource_dir.join(path),
          );
        } else {
          #[cfg(debug_assertions)]
          eprintln!(
            "failed to resolve resource directory; fallback to the installed Webview2 runtime."
          );
        }
      }
    }

    #[cfg(feature = "system-tray")]
    if let Some(system_tray) = self.system_tray {
      let mut ids = HashMap::new();
      if let Some(menu) = system_tray.menu() {
        tray::get_menu_ids(&mut ids, menu);
      }
      let tray_icon = if let Some(icon) = system_tray.icon {
        Some(icon)
      } else if let Some(tray_icon) = system_tray_icon {
        Some(tray_icon.try_into()?)
      } else {
        None
      };
      let mut tray = tray::SystemTray::new()
        .with_icon(tray_icon.expect("tray icon not found; please configure it on tauri.conf.json"));
      if let Some(menu) = system_tray.menu {
        tray = tray.with_menu(menu);
      }
      #[cfg(target_os = "macos")]
      let tray = tray
        .with_icon_as_template(system_tray_icon_as_template)
        .with_menu_on_left_click(system_tray_menu_on_left_click);

      let tray_handler = app
        .runtime
        .as_ref()
        .unwrap()
        .system_tray(tray)
        .expect("failed to run tray");

      let tray_handle = tray::SystemTrayHandle {
        ids: Arc::new(std::sync::Mutex::new(ids)),
        inner: tray_handler,
      };
      let ids = tray_handle.ids.clone();
      app.tray_handle.replace(tray_handle.clone());
      app.handle.tray_handle.replace(tray_handle);
      for listener in self.system_tray_event_listeners {
        let app_handle = app.handle();
        let ids = ids.clone();
        let listener = Arc::new(std::sync::Mutex::new(listener));
        app
          .runtime
          .as_mut()
          .unwrap()
          .on_system_tray_event(move |event| {
            let app_handle = app_handle.clone();
            let event = match event {
              RuntimeSystemTrayEvent::MenuItemClick(id) => tray::SystemTrayEvent::MenuItemClick {
                id: ids.lock().unwrap().get(id).unwrap().clone(),
              },
              RuntimeSystemTrayEvent::LeftClick { position, size } => {
                tray::SystemTrayEvent::LeftClick {
                  position: *position,
                  size: *size,
                }
              }
              RuntimeSystemTrayEvent::RightClick { position, size } => {
                tray::SystemTrayEvent::RightClick {
                  position: *position,
                  size: *size,
                }
              }
              RuntimeSystemTrayEvent::DoubleClick { position, size } => {
                tray::SystemTrayEvent::DoubleClick {
                  position: *position,
                  size: *size,
                }
              }
            };
            let listener = listener.clone();
            listener.lock().unwrap()(&app_handle, event);
          });
      }
    }

    app.manager.initialize_plugins(&app.handle())?;

    let window_labels = self
      .pending_windows
      .iter()
      .map(|p| p.label.clone())
      .collect::<Vec<_>>();

    for pending in self.pending_windows {
      let pending =
        app
          .manager
          .prepare_window(app.handle.clone(), pending, &window_labels, None)?;
      let detached = app.runtime.as_ref().unwrap().create_window(pending)?;
      let _window = app.manager.attach_window(app.handle(), detached);
    }

    (self.setup)(&mut app).map_err(|e| crate::Error::Setup(e.into()))?;

    #[cfg(updater)]
    app.run_updater();

    Ok(app)
  }

pub fn package_info_mut(&mut self) -> &mut PackageInfo

A mutable reference to the package information.

pub fn pattern(&self) -> &Pattern

The application pattern.

pub fn allowed_commands(&self) -> &ShellScopeConfig

The scoped shell commands, where the HashMap key is the name each configuration.

pub fn new(
    config: Config,
    assets: Arc<A>,
    default_window_icon: Option<Icon>,
    app_icon: Option<Vec<u8>>,
    system_tray_icon: Option<Icon>,
    package_info: PackageInfo,
    info_plist: (),
    pattern: Pattern,
    shell_scope: ShellScopeConfig
) -> Self

Create a new Context from the minimal required items.

Trait Implementations

impl<A: Assets> Debug for Context<A>

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

Formats the value using the given formatter.