#[cfg(feature = "system-tray")]
pub(crate) mod tray;
use crate::{
api::ipc::CallbackFn,
command::{CommandArg, CommandItem},
hooks::{
window_invoke_responder, InvokeHandler, InvokeResponder, OnPageLoad, PageLoadPayload, SetupHook,
},
manager::{Asset, CustomProtocol, WindowManager},
plugin::{Plugin, PluginStore},
runtime::{
http::{Request as HttpRequest, Response as HttpResponse},
webview::{WebviewAttributes, WindowBuilder},
window::{PendingWindow, WindowEvent},
Dispatch, ExitRequestedEventAction, RunEvent as RuntimeRunEvent, Runtime,
},
scope::FsScope,
sealed::{ManagerBase, RuntimeOrDispatch},
utils::config::{Config, WindowUrl},
utils::{assets::Assets, Env},
Context, Invoke, InvokeError, InvokeResponse, Manager, Scopes, StateManager, Window,
};
#[cfg(shell_scope)]
use crate::scope::ShellScope;
use tauri_macros::default_runtime;
use tauri_utils::PackageInfo;
use std::{
collections::HashMap,
path::PathBuf,
sync::{mpsc::Sender, Arc, Weak},
};
use crate::runtime::menu::{Menu, MenuId, MenuIdRef};
use crate::runtime::RuntimeHandle;
#[cfg(feature = "system-tray")]
use crate::runtime::{Icon, SystemTrayEvent as RuntimeSystemTrayEvent};
#[cfg(feature = "updater")]
use crate::updater;
#[cfg(target_os = "macos")]
use crate::ActivationPolicy;
pub(crate) type GlobalMenuEventListener<R> = Box<dyn Fn(WindowMenuEvent<R>) + Send + Sync>;
pub(crate) type GlobalWindowEventListener<R> = Box<dyn Fn(GlobalWindowEvent<R>) + Send + Sync>;
#[cfg(feature = "system-tray")]
type SystemTrayEventListener<R> = Box<dyn Fn(&AppHandle<R>, tray::SystemTrayEvent) + Send + Sync>;
#[derive(Debug)]
pub struct ExitRequestApi(Sender<ExitRequestedEventAction>);
impl ExitRequestApi {
pub fn prevent_exit(&self) {
self.0.send(ExitRequestedEventAction::Prevent).unwrap();
}
}
#[derive(Debug)]
pub struct CloseRequestApi(Sender<bool>);
impl CloseRequestApi {
pub fn prevent_close(&self) {
self.0.send(true).unwrap();
}
}
#[derive(Debug)]
#[non_exhaustive]
pub enum RunEvent {
Exit,
#[non_exhaustive]
ExitRequested {
window_label: String,
api: ExitRequestApi,
},
#[non_exhaustive]
CloseRequested {
label: String,
api: CloseRequestApi,
},
WindowClosed(String),
Ready,
Resumed,
MainEventsCleared,
}
#[default_runtime(crate::Wry, wry)]
#[derive(Debug)]
pub struct WindowMenuEvent<R: Runtime> {
pub(crate) menu_item_id: MenuId,
pub(crate) window: Window<R>,
}
impl<R: Runtime> WindowMenuEvent<R> {
pub fn menu_item_id(&self) -> MenuIdRef<'_> {
&self.menu_item_id
}
pub fn window(&self) -> &Window<R> {
&self.window
}
}
#[default_runtime(crate::Wry, wry)]
#[derive(Debug)]
pub struct GlobalWindowEvent<R: Runtime> {
pub(crate) event: WindowEvent,
pub(crate) window: Window<R>,
}
impl<R: Runtime> GlobalWindowEvent<R> {
pub fn event(&self) -> &WindowEvent {
&self.event
}
pub fn window(&self) -> &Window<R> {
&self.window
}
}
#[derive(Debug, Clone)]
pub struct PathResolver {
env: Env,
config: Arc<Config>,
package_info: PackageInfo,
}
impl PathResolver {
pub fn resource_dir(&self) -> Option<PathBuf> {
crate::api::path::resource_dir(&self.package_info, &self.env)
}
pub fn app_dir(&self) -> Option<PathBuf> {
crate::api::path::app_dir(&self.config)
}
pub fn log_dir(&self) -> Option<PathBuf> {
crate::api::path::log_dir(&self.config)
}
}
#[derive(Debug, Clone)]
pub struct AssetResolver<R: Runtime> {
manager: WindowManager<R>,
}
impl<R: Runtime> AssetResolver<R> {
pub fn get(&self, path: String) -> Option<Asset> {
self.manager.get_asset(path).ok()
}
}
#[default_runtime(crate::Wry, wry)]
#[derive(Debug)]
pub struct AppHandle<R: Runtime> {
runtime_handle: R::Handle,
manager: WindowManager<R>,
global_shortcut_manager: R::GlobalShortcutManager,
clipboard_manager: R::ClipboardManager,
#[cfg(feature = "system-tray")]
tray_handle: Option<tray::SystemTrayHandle<R>>,
}
#[cfg(feature = "wry")]
impl AppHandle<crate::Wry> {
pub fn create_tao_window<
F: FnOnce() -> (String, tauri_runtime_wry::WryWindowBuilder) + Send + 'static,
>(
&self,
f: F,
) -> crate::Result<Weak<tauri_runtime_wry::Window>> {
self.runtime_handle.create_tao_window(f).map_err(Into::into)
}
pub fn send_tao_window_event(
&self,
window_id: tauri_runtime_wry::WindowId,
message: tauri_runtime_wry::WindowMessage,
) -> crate::Result<()> {
self
.runtime_handle
.send_event(tauri_runtime_wry::Message::Window(window_id, message))
.map_err(Into::into)
}
}
impl<R: Runtime> Clone for AppHandle<R> {
fn clone(&self) -> Self {
Self {
runtime_handle: self.runtime_handle.clone(),
manager: self.manager.clone(),
global_shortcut_manager: self.global_shortcut_manager.clone(),
clipboard_manager: self.clipboard_manager.clone(),
#[cfg(feature = "system-tray")]
tray_handle: self.tray_handle.clone(),
}
}
}
impl<'de, R: Runtime> CommandArg<'de, R> for AppHandle<R> {
fn from_command(command: CommandItem<'de, R>) -> Result<Self, InvokeError> {
Ok(command.message.window().app_handle)
}
}
impl<R: Runtime> AppHandle<R> {
pub fn run_on_main_thread<F: FnOnce() + Send + 'static>(&self, f: F) -> crate::Result<()> {
self
.runtime_handle
.run_on_main_thread(f)
.map_err(Into::into)
}
#[cfg(all(windows, feature = "system-tray"))]
#[cfg_attr(doc_cfg, doc(cfg(all(windows, feature = "system-tray"))))]
fn remove_system_tray(&self) -> crate::Result<()> {
self.runtime_handle.remove_system_tray().map_err(Into::into)
}
pub fn plugin<P: Plugin<R> + 'static>(&self, mut plugin: P) -> crate::Result<()> {
plugin
.initialize(
self,
self
.config()
.plugins
.0
.get(plugin.name())
.cloned()
.unwrap_or_default(),
)
.map_err(|e| crate::Error::PluginInitialization(plugin.name().to_string(), e.to_string()))?;
self
.manager()
.inner
.plugins
.lock()
.unwrap()
.register(plugin);
Ok(())
}
pub fn exit(&self, exit_code: i32) {
self.cleanup_before_exit();
std::process::exit(exit_code);
}
fn cleanup_before_exit(&self) {
#[cfg(shell_execute)]
{
crate::api::process::kill_children();
}
#[cfg(all(windows, feature = "system-tray"))]
{
let _ = self.remove_system_tray();
}
}
}
impl<R: Runtime> Manager<R> for AppHandle<R> {}
impl<R: Runtime> ManagerBase<R> for AppHandle<R> {
fn manager(&self) -> &WindowManager<R> {
&self.manager
}
fn runtime(&self) -> RuntimeOrDispatch<'_, R> {
RuntimeOrDispatch::RuntimeHandle(self.runtime_handle.clone())
}
fn app_handle(&self) -> AppHandle<R> {
self.clone()
}
}
#[default_runtime(crate::Wry, wry)]
#[derive(Debug)]
pub struct App<R: Runtime> {
runtime: Option<R>,
manager: WindowManager<R>,
global_shortcut_manager: R::GlobalShortcutManager,
clipboard_manager: R::ClipboardManager,
#[cfg(feature = "system-tray")]
tray_handle: Option<tray::SystemTrayHandle<R>>,
handle: AppHandle<R>,
}
impl<R: Runtime> Manager<R> for App<R> {}
impl<R: Runtime> ManagerBase<R> for App<R> {
fn manager(&self) -> &WindowManager<R> {
&self.manager
}
fn runtime(&self) -> RuntimeOrDispatch<'_, R> {
RuntimeOrDispatch::Runtime(self.runtime.as_ref().unwrap())
}
fn app_handle(&self) -> AppHandle<R> {
self.handle()
}
}
macro_rules! shared_app_impl {
($app: ty) => {
impl<R: Runtime> $app {
pub fn create_window<F>(
&self,
label: impl Into<String>,
url: WindowUrl,
setup: F,
) -> crate::Result<Window<R>>
where
F: FnOnce(
<R::Dispatcher as Dispatch>::WindowBuilder,
WebviewAttributes,
) -> (
<R::Dispatcher as Dispatch>::WindowBuilder,
WebviewAttributes,
),
{
let (window_builder, webview_attributes) = setup(
<R::Dispatcher as Dispatch>::WindowBuilder::new(),
WebviewAttributes::new(url),
);
self.create_new_window(PendingWindow::new(
window_builder,
webview_attributes,
label,
))
}
#[cfg(feature = "system-tray")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "system-tray")))]
pub fn tray_handle(&self) -> tray::SystemTrayHandle<R> {
self
.tray_handle
.clone()
.expect("tray not configured; use the `Builder#system_tray` API first.")
}
pub fn path_resolver(&self) -> PathResolver {
PathResolver {
env: self.state::<Env>().inner().clone(),
config: self.manager.config(),
package_info: self.manager.package_info().clone(),
}
}
pub fn global_shortcut_manager(&self) -> R::GlobalShortcutManager {
self.global_shortcut_manager.clone()
}
pub fn clipboard_manager(&self) -> R::ClipboardManager {
self.clipboard_manager.clone()
}
pub fn config(&self) -> Arc<Config> {
self.manager.config()
}
pub fn package_info(&self) -> &PackageInfo {
self.manager.package_info()
}
pub fn asset_resolver(&self) -> AssetResolver<R> {
AssetResolver {
manager: self.manager.clone(),
}
}
}
};
}
shared_app_impl!(App<R>);
shared_app_impl!(AppHandle<R>);
impl<R: Runtime> App<R> {
pub fn handle(&self) -> AppHandle<R> {
self.handle.clone()
}
#[cfg(target_os = "macos")]
#[cfg_attr(doc_cfg, doc(cfg(target_os = "macos")))]
pub fn set_activation_policy(&mut self, activation_policy: ActivationPolicy) {
self
.runtime
.as_mut()
.unwrap()
.set_activation_policy(activation_policy);
}
pub fn run<F: FnMut(&AppHandle<R>, RunEvent) + 'static>(mut self, mut callback: F) {
let app_handle = self.handle();
let manager = self.manager.clone();
self.runtime.take().unwrap().run(move |event| match event {
RuntimeRunEvent::Exit => {
app_handle.cleanup_before_exit();
on_event_loop_event(
&app_handle,
RuntimeRunEvent::Exit,
&manager,
Some(&mut callback),
);
}
_ => {
on_event_loop_event(&app_handle, event, &manager, Some(&mut callback));
}
});
}
pub fn run_iteration(&mut self) -> crate::runtime::RunIteration {
let manager = self.manager.clone();
let app_handle = self.handle();
self.runtime.as_mut().unwrap().run_iteration(move |event| {
on_event_loop_event(
&app_handle,
event,
&manager,
Option::<&mut Box<dyn FnMut(&AppHandle<R>, RunEvent)>>::None,
)
})
}
}
#[cfg(feature = "updater")]
impl<R: Runtime> App<R> {
fn run_updater_dialog(&self, window: Window<R>) {
let updater_config = self.manager.config().tauri.updater.clone();
let package_info = self.manager.package_info().clone();
crate::async_runtime::spawn(async move {
updater::check_update_with_dialog(updater_config, package_info, window).await
});
}
fn listen_updater_events(&self, window: Window<R>) {
let updater_config = self.manager.config().tauri.updater.clone();
updater::listener(updater_config, self.manager.package_info().clone(), &window);
}
fn run_updater(&self, main_window: Option<Window<R>>) {
if let Some(main_window) = main_window {
let event_window = main_window.clone();
let updater_config = self.manager.config().tauri.updater.clone();
if updater_config.dialog && updater_config.active {
self.run_updater_dialog(main_window.clone());
let config = self.manager.config().tauri.updater.clone();
let package_info = self.manager.package_info().clone();
main_window.listen(updater::EVENT_CHECK_UPDATE, move |_msg| {
let window = event_window.clone();
let package_info = package_info.clone();
let config = config.clone();
crate::async_runtime::spawn(async move {
updater::check_update_with_dialog(config, package_info, window).await
});
});
} else if updater_config.active {
self.listen_updater_events(main_window);
}
}
}
}
#[allow(clippy::type_complexity)]
pub struct Builder<R: Runtime> {
#[cfg(any(windows, target_os = "linux"))]
#[cfg_attr(doc_cfg, doc(any(windows, target_os = "linux")))]
runtime_any_thread: bool,
invoke_handler: Box<InvokeHandler<R>>,
invoke_responder: Arc<InvokeResponder<R>>,
invoke_initialization_script: String,
setup: SetupHook<R>,
on_page_load: Box<OnPageLoad<R>>,
pending_windows: Vec<PendingWindow<R>>,
plugins: PluginStore<R>,
uri_scheme_protocols: HashMap<String, Arc<CustomProtocol<R>>>,
state: StateManager,
menu: Option<Menu>,
menu_event_listeners: Vec<GlobalMenuEventListener<R>>,
window_event_listeners: Vec<GlobalWindowEventListener<R>>,
#[cfg(feature = "system-tray")]
system_tray: Option<tray::SystemTray>,
#[cfg(feature = "system-tray")]
system_tray_event_listeners: Vec<SystemTrayEventListener<R>>,
}
impl<R: Runtime> Builder<R> {
pub fn new() -> Self {
Self {
#[cfg(any(windows, target_os = "linux"))]
runtime_any_thread: false,
setup: Box::new(|_| Ok(())),
invoke_handler: Box::new(|_| ()),
invoke_responder: Arc::new(window_invoke_responder),
invoke_initialization_script:
"Object.defineProperty(window, '__TAURI_POST_MESSAGE__', { value: (message) => window.ipc.postMessage(JSON.stringify(message)) })".into(),
on_page_load: Box::new(|_, _| ()),
pending_windows: Default::default(),
plugins: PluginStore::default(),
uri_scheme_protocols: Default::default(),
state: StateManager::new(),
menu: None,
menu_event_listeners: Vec::new(),
window_event_listeners: Vec::new(),
#[cfg(feature = "system-tray")]
system_tray: None,
#[cfg(feature = "system-tray")]
system_tray_event_listeners: Vec::new(),
}
}
#[cfg(any(windows, target_os = "linux"))]
#[cfg_attr(doc_cfg, doc(any(windows, target_os = "linux")))]
#[must_use]
pub fn any_thread(mut self) -> Self {
self.runtime_any_thread = true;
self
}
#[must_use]
pub fn invoke_handler<F>(mut self, invoke_handler: F) -> Self
where
F: Fn(Invoke<R>) + Send + Sync + 'static,
{
self.invoke_handler = Box::new(invoke_handler);
self
}
#[must_use]
pub fn invoke_system<F>(mut self, initialization_script: String, responder: F) -> Self
where
F: Fn(Window<R>, InvokeResponse, CallbackFn, CallbackFn) + Send + Sync + 'static,
{
self.invoke_initialization_script = initialization_script;
self.invoke_responder = Arc::new(responder);
self
}
#[cfg_attr(
feature = "dialog",
doc = r#" tauri::api::dialog::blocking::message(Some(&main_window), "Hello", "Welcome back!");"#
)]
#[must_use]
pub fn setup<F>(mut self, setup: F) -> Self
where
F: FnOnce(&mut App<R>) -> Result<(), Box<dyn std::error::Error + Send>> + Send + 'static,
{
self.setup = Box::new(setup);
self
}
#[must_use]
pub fn on_page_load<F>(mut self, on_page_load: F) -> Self
where
F: Fn(Window<R>, PageLoadPayload) + Send + Sync + 'static,
{
self.on_page_load = Box::new(on_page_load);
self
}
#[must_use]
pub fn plugin<P: Plugin<R> + 'static>(mut self, plugin: P) -> Self {
self.plugins.register(plugin);
self
}
#[must_use]
pub fn manage<T>(self, state: T) -> Self
where
T: Send + Sync + 'static,
{
let type_name = std::any::type_name::<T>();
assert!(
self.state.set(state),
"state for type '{}' is already being managed",
type_name
);
self
}
#[must_use]
pub fn create_window<F>(mut self, label: impl Into<String>, url: WindowUrl, setup: F) -> Self
where
F: FnOnce(
<R::Dispatcher as Dispatch>::WindowBuilder,
WebviewAttributes,
) -> (
<R::Dispatcher as Dispatch>::WindowBuilder,
WebviewAttributes,
),
{
let (window_builder, webview_attributes) = setup(
<R::Dispatcher as Dispatch>::WindowBuilder::new(),
WebviewAttributes::new(url),
);
self.pending_windows.push(PendingWindow::new(
window_builder,
webview_attributes,
label,
));
self
}
#[cfg(feature = "system-tray")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "system-tray")))]
#[must_use]
pub fn system_tray(mut self, system_tray: tray::SystemTray) -> Self {
self.system_tray.replace(system_tray);
self
}
#[must_use]
pub fn menu(mut self, menu: Menu) -> Self {
self.menu.replace(menu);
self
}
#[cfg_attr(
feature = "shell-open-api",
doc = r#" api::shell::open(&event.window().shell_scope(), "https://github.com/tauri-apps/tauri".to_string(), None).unwrap();"#
)]
#[must_use]
pub fn on_menu_event<F: Fn(WindowMenuEvent<R>) + Send + Sync + 'static>(
mut self,
handler: F,
) -> Self {
self.menu_event_listeners.push(Box::new(handler));
self
}
#[must_use]
pub fn on_window_event<F: Fn(GlobalWindowEvent<R>) + Send + Sync + 'static>(
mut self,
handler: F,
) -> Self {
self.window_event_listeners.push(Box::new(handler));
self
}
#[cfg(feature = "system-tray")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "system-tray")))]
#[must_use]
pub fn on_system_tray_event<
F: Fn(&AppHandle<R>, tray::SystemTrayEvent) + Send + Sync + 'static,
>(
mut self,
handler: F,
) -> Self {
self.system_tray_event_listeners.push(Box::new(handler));
self
}
#[must_use]
pub fn register_uri_scheme_protocol<
N: Into<String>,
H: Fn(&AppHandle<R>, &HttpRequest) -> Result<HttpResponse, Box<dyn std::error::Error>>
+ Send
+ Sync
+ 'static,
>(
mut self,
uri_scheme: N,
protocol: H,
) -> Self {
self.uri_scheme_protocols.insert(
uri_scheme.into(),
Arc::new(CustomProtocol {
protocol: Box::new(protocol),
}),
);
self
}
#[allow(clippy::type_complexity)]
pub fn build<A: Assets>(mut self, context: Context<A>) -> crate::Result<App<R>> {
#[cfg(feature = "system-tray")]
let system_tray_icon = {
let icon = context.system_tray_icon.clone();
if self.system_tray.is_some() {
use std::io::{Error, ErrorKind};
#[cfg(target_os = "linux")]
if let Some(Icon::Raw(_)) = icon {
return Err(crate::Error::InvalidIcon(Box::new(Error::new(
ErrorKind::InvalidInput,
"system tray icons on linux must be a file path",
))));
}
#[cfg(not(target_os = "linux"))]
if let Some(Icon::File(_)) = icon {
return Err(crate::Error::InvalidIcon(Box::new(Error::new(
ErrorKind::InvalidInput,
"system tray icons on non-linux platforms must be the raw bytes",
))));
}
}
icon
};
#[cfg(all(feature = "system-tray", target_os = "macos"))]
let system_tray_icon_as_template = context
.config
.tauri
.system_tray
.as_ref()
.map(|t| t.icon_as_template)
.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),
);
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();
let global_shortcut_manager = runtime.global_shortcut_manager();
let clipboard_manager = runtime.clipboard_manager();
let mut app = App {
runtime: Some(runtime),
manager: manager.clone(),
global_shortcut_manager: global_shortcut_manager.clone(),
clipboard_manager: clipboard_manager.clone(),
#[cfg(feature = "system-tray")]
tray_handle: None,
handle: AppHandle {
runtime_handle,
manager,
global_shortcut_manager,
clipboard_manager,
#[cfg(feature = "system-tray")]
tray_handle: None,
},
};
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 Some(w) = &app
.manager
.config()
.tauri
.bundle
.windows
.webview_fixed_runtime_path
{
if let Some(resource_dir) = app.path_resolver().resource_dir() {
std::env::set_var("WEBVIEW2_BROWSER_EXECUTABLE_FOLDER", resource_dir.join(w));
} 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 mut tray = tray::SystemTray::new();
if let Some(menu) = system_tray.menu {
tray = tray.with_menu(menu);
}
#[cfg(not(target_os = "macos"))]
let tray_handler = app
.runtime
.as_ref()
.unwrap()
.system_tray(
tray.with_icon(
system_tray
.icon
.or(system_tray_icon)
.expect("tray icon not found; please configure it on tauri.conf.json"),
),
)
.expect("failed to run tray");
#[cfg(target_os = "macos")]
let tray_handler = app
.runtime
.as_ref()
.unwrap()
.system_tray(
tray
.with_icon(
system_tray
.icon
.or(system_tray_icon)
.expect("tray icon not found; please configure it on tauri.conf.json"),
)
.with_icon_as_template(system_tray_icon_as_template),
)
.expect("failed to run tray");
let tray_handle = tray::SystemTrayHandle {
ids: Arc::new(ids.clone()),
inner: tray_handler,
};
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.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<_>>();
#[cfg(feature = "updater")]
let mut main_window = None;
for pending in self.pending_windows {
let pending = app
.manager
.prepare_window(app.handle.clone(), pending, &window_labels)?;
let detached = app.runtime.as_ref().unwrap().create_window(pending)?;
let _window = app.manager.attach_window(app.handle(), detached);
#[cfg(feature = "updater")]
if main_window.is_none() {
main_window = Some(_window);
}
}
(self.setup)(&mut app).map_err(|e| crate::Error::Setup(e))?;
#[cfg(feature = "updater")]
app.run_updater(main_window);
Ok(app)
}
pub fn run<A: Assets>(self, context: Context<A>) -> crate::Result<()> {
self.build(context)?.run(|_, _| {});
Ok(())
}
}
fn on_event_loop_event<R: Runtime, F: FnMut(&AppHandle<R>, RunEvent) + 'static>(
app_handle: &AppHandle<R>,
event: RuntimeRunEvent,
manager: &WindowManager<R>,
callback: Option<&mut F>,
) {
if let RuntimeRunEvent::WindowClose(label) = &event {
manager.on_window_close(label);
}
let event = match event {
RuntimeRunEvent::Exit => RunEvent::Exit,
RuntimeRunEvent::ExitRequested { window_label, tx } => RunEvent::ExitRequested {
window_label,
api: ExitRequestApi(tx),
},
RuntimeRunEvent::CloseRequested { label, signal_tx } => RunEvent::CloseRequested {
label,
api: CloseRequestApi(signal_tx),
},
RuntimeRunEvent::WindowClose(label) => RunEvent::WindowClosed(label),
RuntimeRunEvent::Ready => RunEvent::Ready,
RuntimeRunEvent::Resumed => RunEvent::Resumed,
RuntimeRunEvent::MainEventsCleared => RunEvent::MainEventsCleared,
_ => unimplemented!(),
};
manager
.inner
.plugins
.lock()
.expect("poisoned plugin store")
.on_event(app_handle, &event);
if let Some(c) = callback {
c(app_handle, event);
}
}
#[cfg(feature = "wry")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "wry")))]
impl Default for Builder<crate::Wry> {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
#[test]
fn is_send_sync() {
crate::test_utils::assert_send::<super::AppHandle>();
crate::test_utils::assert_sync::<super::AppHandle>();
#[cfg(feature = "wry")]
{
crate::test_utils::assert_send::<super::AssetResolver<crate::Wry>>();
crate::test_utils::assert_sync::<super::AssetResolver<crate::Wry>>();
}
crate::test_utils::assert_send::<super::PathResolver>();
crate::test_utils::assert_sync::<super::PathResolver>();
}
}