feat: add tray and menu javascript APIs and events, closes #6617

.changes/api-tray-menu.md

@@ -0,0 +1,5 @@
+---
+'@tauri-apps/api': 'minor:feat'
+---
+
+Add `tray` and `menu` modules to create and manage tray icons and menus from Javascript.

.scripts/ci/check-license-header.js

@@ -13,6 +13,8 @@ SPDX-License-Identifier: Apache-2.0
 SPDX-License-Identifier: MIT`
 const bundlerLicense =
   '// Copyright 2016-2019 Cargo-Bundle developers <https://github.com/burtonageo/cargo-bundle>'
+const denoLicense =
+  '// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.'
 
 const extensions = ['.rs', '.js', '.ts', '.yml', '.swift', '.kt']
 const ignore = [
@@ -26,7 +28,10 @@ const ignore = [
 ]
 
 async function checkFile(file) {
-  if (extensions.some((e) => file.endsWith(e)) && !ignore.some((i) => file.includes(`/${i}/`))) {
+  if (
+    extensions.some((e) => file.endsWith(e)) &&
+    !ignore.some((i) => file.includes(`/${i}/`))
+  ) {
     const fileStream = fs.createReadStream(file)
     const rl = readline.createInterface({
       input: fileStream,
@@ -41,7 +46,8 @@ async function checkFile(file) {
         line.length === 0 ||
         line.startsWith('#!') ||
         line.startsWith('// swift-tools-version:') ||
-        line === bundlerLicense
+        line === bundlerLicense ||
+        line === denoLicense
       ) {
         continue
       }

core/tauri-macros/src/lib.rs

@@ -16,6 +16,7 @@ use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput};
 
 mod command;
+mod menu;
 mod mobile;
 mod runtime;
 
@@ -89,3 +90,64 @@ pub fn default_runtime(attributes: TokenStream, input: TokenStream) -> TokenStre
   let input = parse_macro_input!(input as DeriveInput);
   runtime::default_runtime(attributes, input).into()
 }
+
+/// Accepets a closure-like syntax to call arbitray code on a menu item
+/// after mathcing against `kind` and retreiveing it from `resources_table` using `rid`.
+///
+/// You can optionally pass a third paraemeter to select which item kinds
+/// to match agains, by providing a `|` separated list of item kinds
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), Check | Submenu);
+/// ```
+/// You could also provide a negated list
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), !Check);
+/// do_menu_item!(|i| i.set_text(text), !Check | !Submenu);
+/// ```
+/// but you can't have mixed negations and positive kinds.
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), !Check | Submeun);
+/// ```
+///
+/// #### Example
+///
+/// ```ignore
+///  let rid = 23;
+///  let kind = ItemKind::Check;
+///  let resources_table = app.manager.resources_table();
+///  do_menu_item!(|i| i.set_text(text))
+/// ```
+/// which will expand into:
+/// ```ignore
+///  let rid = 23;
+///  let kind = ItemKind::Check;
+///  let resources_table = app.manager.resources_table();
+///  match kind {
+///  ItemKind::Submenu => {
+///    let i = resources_table.get::<Submenu<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::MenuItem => {
+///    let i = resources_table.get::<MenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Predefined => {
+///    let i = resources_table.get::<PredefinedMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Check => {
+///    let i = resources_table.get::<CheckMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Icon => {
+///    let i = resources_table.get::<IconMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  _ => unreachable!(),
+///  }
+/// ```
+#[proc_macro]
+pub fn do_menu_item(input: TokenStream) -> TokenStream {
+  let tokens = parse_macro_input!(input as menu::DoMenuItemInput);
+  menu::do_menu_item(tokens).into()
+}

core/tauri-macros/src/menu.rs

@@ -0,0 +1,104 @@
+// Copyright 2019-2023 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use proc_macro2::{Ident, Span, TokenStream};
+use quote::quote;
+use syn::{
+  parse::{Parse, ParseStream},
+  punctuated::Punctuated,
+  Expr, Token,
+};
+
+pub struct DoMenuItemInput {
+  var: Ident,
+  expr: Expr,
+  kinds: Vec<NegatedIdent>,
+}
+
+#[derive(Clone)]
+struct NegatedIdent(bool, Ident);
+
+impl Parse for NegatedIdent {
+  fn parse(input: ParseStream) -> syn::Result<Self> {
+    let t = input.parse::<Token![!]>();
+    let i: Ident = input.parse()?;
+    Ok(NegatedIdent(t.is_ok(), i))
+  }
+}
+
+impl Parse for DoMenuItemInput {
+  fn parse(input: ParseStream) -> syn::Result<Self> {
+    let _: Token![|] = input.parse()?;
+    let var: Ident = input.parse()?;
+    let _: Token![|] = input.parse()?;
+    let expr: Expr = input.parse()?;
+    let _: syn::Result<Token![,]> = input.parse();
+    let kinds = Punctuated::<NegatedIdent, Token![|]>::parse_terminated(input)?;
+
+    Ok(Self {
+      var,
+      expr,
+      kinds: kinds.into_iter().collect(),
+    })
+  }
+}
+
+pub fn do_menu_item(input: DoMenuItemInput) -> TokenStream {
+  let DoMenuItemInput {
+    expr,
+    var,
+    mut kinds,
+  } = input;
+
+  let defaults = vec![
+    NegatedIdent(false, Ident::new("Submenu", Span::call_site())),
+    NegatedIdent(false, Ident::new("MenuItem", Span::call_site())),
+    NegatedIdent(false, Ident::new("Predefined", Span::call_site())),
+    NegatedIdent(false, Ident::new("Check", Span::call_site())),
+    NegatedIdent(false, Ident::new("Icon", Span::call_site())),
+  ];
+
+  if kinds.is_empty() {
+    kinds.extend(defaults.clone());
+  }
+
+  let mut has_negated: bool = false;
+  for NegatedIdent(negated, _) in &kinds {
+    if *negated && !has_negated {
+      has_negated = true;
+    }
+  }
+
+  if has_negated {
+    kinds.extend(defaults);
+    kinds.sort_by(|a, b| a.1.cmp(&b.1));
+    kinds.dedup_by(|a, b| a.1 == b.1);
+  }
+
+  let (kinds, types): (Vec<Ident>, Vec<Ident>) = kinds
+    .into_iter()
+    .filter_map(|nident| match nident.1 {
+      i if i == "MenuItem" && !nident.0 => Some((i, Ident::new("MenuItem", Span::call_site()))),
+      i if i == "Submenu" && !nident.0 => Some((i, Ident::new("Submenu", Span::call_site()))),
+      i if i == "Predefined" && !nident.0 => {
+        Some((i, Ident::new("PredefinedMenuItem", Span::call_site())))
+      }
+      i if i == "Check" && !nident.0 => Some((i, Ident::new("CheckMenuItem", Span::call_site()))),
+      i if i == "Icon" && !nident.0 => Some((i, Ident::new("IconMenuItem", Span::call_site()))),
+      _ => None,
+    })
+    .unzip();
+
+  quote! {
+    match kind {
+      #(
+        ItemKind::#kinds => {
+        let #var = resources_table.get::<#types<R>>(rid)?;
+        #expr
+      }
+      )*
+      _ => unreachable!(),
+    }
+  }
+}

core/tauri/Cargo.toml

@@ -71,8 +71,8 @@ ico = { version = "0.3.0", optional = true }
 http-range = { version = "0.1.4", optional = true }
 
 [target."cfg(any(target_os = \"linux\", target_os = \"dragonfly\", target_os = \"freebsd\", target_os = \"openbsd\", target_os = \"netbsd\", target_os = \"windows\", target_os = \"macos\"))".dependencies]
-muda = { version = "0.8", default-features = false }
-tray-icon = { version = "0.8", default-features = false, optional = true }
+muda = { version = "0.8", default-features = false, features = [ "serde" ]}
+tray-icon = { version = "0.8", default-features = false, features = [ "serde" ], optional = true }
 
 [target."cfg(any(target_os = \"linux\", target_os = \"dragonfly\", target_os = \"freebsd\", target_os = \"openbsd\", target_os = \"netbsd\"))".dependencies]
 gtk = { version = "0.16", features = [ "v3_24" ] }

core/tauri/src/app.rs

@@ -798,7 +798,8 @@ macro_rules! shared_app_impl {
       /// **You should always exit the tauri app immediately after this function returns and not use any tauri-related APIs.**
       pub fn cleanup_before_exit(&self) {
         #[cfg(all(desktop, feature = "tray-icon"))]
-        self.manager.inner.tray_icons.lock().unwrap().clear()
+        self.manager.inner.tray_icons.lock().unwrap().clear();
+        self.manager.resources_table().clear();
       }
     }
   };
@@ -811,6 +812,11 @@ impl<R: Runtime> App<R> {
   fn register_core_plugins(&self) -> crate::Result<()> {
     self.handle.plugin(crate::path::init())?;
     self.handle.plugin(crate::event::init())?;
+    self.handle.plugin(crate::resources::plugin::init())?;
+    #[cfg(desktop)]
+    self.handle.plugin(crate::menu::plugin::init())?;
+    #[cfg(all(desktop, feature = "tray-icon"))]
+    self.handle.plugin(crate::tray::plugin::init())?;
     Ok(())
   }
 

core/tauri/src/error.rs

@@ -110,4 +110,10 @@ pub enum Error {
   #[cfg(all(desktop, feature = "tray-icon"))]
   #[cfg_attr(doc_cfg, doc(cfg(all(desktop, feature = "tray-icon"))))]
   BadTrayIcon(#[from] tray_icon::BadIcon),
+  /// The resource id is invalid.
+  #[error("The resource id {0} is invalid.")]
+  BadResourceId(crate::resources::ResourceId),
+  /// The anyhow crate error.
+  #[error(transparent)]
+  Anyhow(#[from] anyhow::Error),
 }

core/tauri/src/lib.rs

@@ -85,6 +85,7 @@ mod manager;
 mod pattern;
 pub mod plugin;
 pub(crate) mod protocol;
+mod resources;
 mod vibrancy;
 pub mod window;
 use tauri_runtime as runtime;
@@ -168,7 +169,7 @@ pub type Result<T> = std::result::Result<T, Error>;
 /// A task to run on the main thread.
 pub type SyncTask = Box<dyn FnOnce() + Send>;
 
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::{
   collections::HashMap,
   fmt::{self, Debug},
@@ -910,6 +911,40 @@ mod tests {
   }
 }
 
+#[derive(Deserialize)]
+#[serde(untagged)]
+pub(crate) enum IconDto {
+  #[cfg(any(feature = "icon-png", feature = "icon-ico"))]
+  File(std::path::PathBuf),
+  #[cfg(any(feature = "icon-png", feature = "icon-ico"))]
+  Raw(Vec<u8>),
+  Rgba {
+    rgba: Vec<u8>,
+    width: u32,
+    height: u32,
+  },
+}
+
+impl From<IconDto> for Icon {
+  fn from(icon: IconDto) -> Self {
+    match icon {
+      #[cfg(any(feature = "icon-png", feature = "icon-ico"))]
+      IconDto::File(path) => Self::File(path),
+      #[cfg(any(feature = "icon-png", feature = "icon-ico"))]
+      IconDto::Raw(raw) => Self::Raw(raw),
+      IconDto::Rgba {
+        rgba,
+        width,
+        height,
+      } => Self::Rgba {
+        rgba,
+        width,
+        height,
+      },
+    }
+  }
+}
+
 #[allow(unused)]
 macro_rules! run_main_thread {
   ($self:ident, $ex:expr) => {{

core/tauri/src/manager.rs

@@ -37,6 +37,7 @@ use crate::{
   ipc::{Invoke, InvokeHandler, InvokeResponder},
   pattern::PatternJavascript,
   plugin::PluginStore,
+  resources::ResourceTable,
   runtime::{
     webview::WindowBuilder,
     window::{
@@ -273,6 +274,8 @@ pub struct InnerWindowManager<R: Runtime> {
   invoke_initialization_script: String,
   /// Application pattern.
   pub(crate) pattern: Pattern,
+  /// Application Resources Table
+  resources_table: Arc<Mutex<ResourceTable>>,
 }
 
 impl<R: Runtime> fmt::Debug for InnerWindowManager<R> {
@@ -363,6 +366,7 @@ impl<R: Runtime> WindowManager<R> {
         tray_icon: context.tray_icon,
         package_info: context.package_info,
         pattern: context.pattern,
+        resources_table: Arc::default(),
         uri_scheme_protocols,
         #[cfg(desktop)]
         menus: Default::default(),
@@ -389,6 +393,15 @@ impl<R: Runtime> WindowManager<R> {
     &self.inner.pattern
   }
 
+  /// Resources table managed by the application.
+  pub(crate) fn resources_table(&self) -> MutexGuard<'_, ResourceTable> {
+    self
+      .inner
+      .resources_table
+      .lock()
+      .expect("poisoned window manager")
+  }
+
   /// Get a locked handle to the windows.
   pub(crate) fn windows_lock(&self) -> MutexGuard<'_, HashMap<String, Window<R>>> {
     self.inner.windows.lock().expect("poisoned window manager")

core/tauri/src/menu/check.rs

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-License-Identifier: MIT
 
-use crate::{menu::MenuId, run_main_thread, AppHandle, Manager, Runtime};
+use crate::{menu::MenuId, resources::Resource, run_main_thread, AppHandle, Manager, Runtime};
 
-/// A menu item inside a [`Menu`] or [`Submenu`] and contains only text.
+/// A menu item inside a [`Menu`] or [`Submenu`]
+/// and usually contains a text and a check mark or a similar toggle
+/// that corresponds to a checked and unchecked states.
 ///
 /// [`Menu`]: super::Menu
 /// [`Submenu`]: super::Submenu
@@ -31,7 +33,7 @@ unsafe impl<R: Runtime> Sync for CheckMenuItem<R> {}
 unsafe impl<R: Runtime> Send for CheckMenuItem<R> {}
 
 impl<R: Runtime> super::sealed::IsMenuItemBase for CheckMenuItem<R> {
-  fn inner(&self) -> &dyn muda::IsMenuItem {
+  fn inner_muda(&self) -> &dyn muda::IsMenuItem {
     &self.inner
   }
 }
@@ -146,3 +148,5 @@ impl<R: Runtime> CheckMenuItem<R> {
     run_main_thread!(self, |self_: Self| self_.inner.set_checked(checked))
   }
 }
+
+impl<R: Runtime> Resource for CheckMenuItem<R> {}