Add an interface for creating system trays

Cargo.toml

@@ -37,6 +37,7 @@ members = [
   'examples/mcu-embassy',
   'examples/uefi-demo',
   'examples/async-io',
+  'examples/system_tray',
   'demos/weather-demo',
   'demos/usecases/rust',
   'helper_crates/const-field-offset',
@@ -92,6 +93,7 @@ default-members = [
   'examples/todo/rust',
   'examples/virtual_keyboard/rust',
   'examples/carousel/rust',
+  'examples/system_tray',
   'demos/energy-monitor',
   'internal/backends/winit',
   'internal/backends/qt',

REUSE.toml

@@ -133,6 +133,7 @@ path = [
   "examples/orbit-animation/images/**.svg",
   "examples/sprite-sheet/images/**.png",
   "examples/speedometer/needle.png",
+  "examples/system_tray/favicon-white.png",
 
   "demos/printerdemo/ui/images/action-button-frame.png",
   "demos/printerdemo/ui/images/mcu/combo-active-background.png",

api/cpp/cbindgen.rs

@@ -320,6 +320,7 @@ fn gen_corelib(
         "Layer",
         "ContextMenu",
         "MenuItem",
+        "SystemTray",
     ];
 
     config.export.include = [

examples/system_tray/Cargo.toml

@@ -0,0 +1,21 @@
+# Copyright © SixtyFPS GmbH <info@slint.dev>
+# SPDX-License-Identifier: MIT
+
+[package]
+name = "system_tray"
+version = "1.16.0"
+authors = ["Slint Developers <info@slint.dev>"]
+edition.workspace = true
+publish = false
+license = "MIT"
+
+[[bin]]
+path = "main.rs"
+name = "system_tray"
+
+[dependencies]
+slint = { path = "../../api/rs/slint", default-features = false, features = ["renderer-femtovg", "backend-winit-x11", "compat-1-2"] }
+i-slint-core = { workspace = true, features = ["system-tray"] }
+
+[build-dependencies]
+slint-build = { path = "../../api/rs/build" }

examples/system_tray/build.rs

@@ -0,0 +1,6 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+fn main() {
+    println!("cargo:rustc-env=SLINT_ENABLE_EXPERIMENTAL_FEATURES=1");
+}

examples/system_tray/main.rs

@@ -0,0 +1,13 @@
+// Copyright © SixtyFPS GmbH <info@slint.dev>
+// SPDX-License-Identifier: MIT
+
+slint::slint! {
+    export component ExampleTray inherits SystemTray {
+        icon: @image-url("favicon-white.png");
+    }
+}
+
+fn main() {
+    let _tray = ExampleTray::new().unwrap();
+    slint::run_event_loop().unwrap();
+}

internal/compiler/builtins.slint

@@ -829,3 +829,8 @@ export global NativePalette {
     //-is_non_item_type
     //-is_internal
 }
+
+export component SystemTray {
+    in property <image> icon;
+    in property <string> title;
+}

internal/compiler/passes/windows.rs

@@ -143,7 +143,7 @@ pub fn ensure_window(
 
 pub fn inherits_window(component: &Rc<Component>) -> bool {
     component.root_element.borrow().builtin_type().is_none_or(|b| {
-        matches!(b.name.as_str(), "Window" | "Dialog" | "WindowItem" | "PopupWindow")
+        matches!(b.name.as_str(), "Window" | "Dialog" | "WindowItem" | "PopupWindow" | "SystemTray")
     })
 }
 

internal/compiler/typeregister.rs

@@ -630,6 +630,8 @@ impl TypeRegister {
         register.elements.remove("DropArea").unwrap();
         register.types.remove("DropEvent").unwrap(); // Also removed in xtask/src/slintdocs.rs
 
+        register.elements.remove("SystemTray").unwrap();
+
         match register.elements.get_mut("Window").unwrap() {
             ElementType::Builtin(b) => {
                 Rc::get_mut(b)

internal/core/Cargo.toml

@@ -43,6 +43,7 @@ std = [
   "i-slint-common/markdown",
   "taffy/std",
 ]
+system-tray = ["dep:ksni", "dep:tray-icon"]
 # Unsafe feature meaning that there is only one core running and all thread_local are static.
 # You can only enable this feature if you are sure that any API of this crate is only called
 # from a single core, and not in a interrupt or signal handler.
@@ -146,6 +147,12 @@ taffy = { version = "0.9", default-features = false, features = ["flexbox", "taf
 [target.'cfg(target_family = "unix")'.dependencies]
 gettext-rs = { version = "0.7.1", optional = true, features = ["gettext-system"] }
 
+[target.'cfg(any(target_os = "macos", target_os = "windows"))'.dependencies]
+tray-icon = { version = "0.21", optional = true }
+
+[target.'cfg(not(any(target_os = "macos", target_os = "windows")))'.dependencies]
+ksni = { version = "0.3.3", optional = true, features = ["blocking"] }
+
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 web-time = { version = "1.0", optional = true }
 wasm-bindgen = { version = "0.2" }

internal/core/items.rs

@@ -39,6 +39,7 @@ pub use crate::menus::MenuItem;
 use crate::rtti::*;
 use crate::window::{WindowAdapter, WindowAdapterRc, WindowInner};
 use crate::{Callback, Coord, Property, SharedString};
+use alloc::boxed::Box;
 use alloc::rc::Rc;
 use const_field_offset::FieldOffsets;
 use core::cell::Cell;
@@ -1774,6 +1775,168 @@ declare_item_vtable! {
     fn slint_get_BoxShadowVTable() -> BoxShadowVTable for BoxShadow
 }
 
+#[repr(C)]
+/// Wraps the internal data structure for the SystemTray
+pub struct SystemTrayDataBox(core::ptr::NonNull<SystemTrayData>);
+
+impl Default for SystemTrayDataBox {
+    fn default() -> Self {
+        SystemTrayDataBox(Box::leak(Box::<SystemTrayData>::default()).into())
+    }
+}
+impl Drop for SystemTrayDataBox {
+    fn drop(&mut self) {
+        // Safety: the self.0 was constructed from a Box::leak in SystemTrayDataBox::default
+        drop(unsafe { Box::from_raw(self.0.as_ptr()) });
+    }
+}
+
+impl core::ops::Deref for SystemTrayDataBox {
+    type Target = SystemTrayData;
+    fn deref(&self) -> &Self::Target {
+        // Safety: initialized in SystemTrayDataBox::default
+        unsafe { self.0.as_ref() }
+    }
+}
+
+#[derive(Default)]
+pub struct SystemTrayData {
+    #[cfg(feature = "system-tray")]
+    inner: std::cell::OnceCell<crate::system_tray::SystemTray>,
+    #[cfg_attr(not(feature = "system-tray"), allow(unused))]
+    change_tracker: crate::properties::ChangeTracker,
+}
+
+#[repr(C)]
+#[derive(FieldOffsets, Default, SlintElement)]
+#[pin]
+pub struct SystemTray {
+    pub icon: Property<crate::graphics::Image>,
+    pub title: Property<SharedString>,
+    pub cached_rendering_data: CachedRenderingData,
+    data: SystemTrayDataBox,
+}
+
+impl Item for SystemTray {
+    #[cfg_attr(not(feature = "system-tray"), allow(unused))]
+    fn init(self: Pin<&Self>, self_rc: &ItemRc) {
+        #[cfg(feature = "system-tray")]
+        self.data.change_tracker.init_delayed(
+            self_rc.downgrade(),
+            |_| true,
+            |self_weak, has_icon| {
+                let Some(tray_rc) = self_weak.upgrade() else {
+                    return;
+                };
+                let Some(tray) = tray_rc.downcast::<SystemTray>() else {
+                    return;
+                };
+                if !*has_icon {
+                    return;
+                }
+                let tray = tray.as_pin_ref();
+                let system_tray =
+                    match crate::system_tray::SystemTray::new(crate::system_tray::Params {
+                        icon: &tray.icon(),
+                        title: &tray.title(),
+                    }) {
+                        Ok(system_tray) => system_tray,
+                        Err(err) => panic!("{}", err),
+                    };
+
+                let _ = tray.data.inner.set(system_tray);
+            },
+        );
+    }
+
+    fn layout_info(
+        self: Pin<&Self>,
+        _orientation: Orientation,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+    ) -> LayoutInfo {
+        LayoutInfo::default()
+    }
+
+    fn input_event_filter_before_children(
+        self: Pin<&Self>,
+        _: &MouseEvent,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+        _: &mut MouseCursor,
+    ) -> InputEventFilterResult {
+        InputEventFilterResult::ForwardAndIgnore
+    }
+
+    fn input_event(
+        self: Pin<&Self>,
+        _: &MouseEvent,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+        _: &mut MouseCursor,
+    ) -> InputEventResult {
+        InputEventResult::EventIgnored
+    }
+
+    fn capture_key_event(
+        self: Pin<&Self>,
+        _: &InternalKeyEvent,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+    ) -> KeyEventResult {
+        KeyEventResult::EventIgnored
+    }
+
+    fn key_event(
+        self: Pin<&Self>,
+        _: &InternalKeyEvent,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+    ) -> KeyEventResult {
+        KeyEventResult::EventIgnored
+    }
+
+    fn focus_event(
+        self: Pin<&Self>,
+        _: &FocusEvent,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+    ) -> FocusEventResult {
+        FocusEventResult::FocusIgnored
+    }
+
+    fn render(
+        self: Pin<&Self>,
+        _backend: &mut ItemRendererRef,
+        _self_rc: &ItemRc,
+        _size: LogicalSize,
+    ) -> RenderingResult {
+        RenderingResult::ContinueRenderingChildren
+    }
+
+    fn bounding_rect(
+        self: core::pin::Pin<&Self>,
+        _window_adapter: &Rc<dyn WindowAdapter>,
+        _self_rc: &ItemRc,
+        geometry: LogicalRect,
+    ) -> LogicalRect {
+        geometry
+    }
+
+    fn clips_children(self: core::pin::Pin<&Self>) -> bool {
+        false
+    }
+}
+
+impl ItemConsts for SystemTray {
+    const cached_rendering_data_offset: const_field_offset::FieldOffset<Self, CachedRenderingData> =
+        Self::FIELD_OFFSETS.cached_rendering_data().as_unpinned_projection();
+}
+
+declare_item_vtable! {
+    fn slint_get_SystemTrayVTable() -> SystemTrayVTable for SystemTray
+}
+
 declare_item_vtable! {
     fn slint_get_ComponentContainerVTable() -> ComponentContainerVTable for ComponentContainer
 }

internal/core/lib.rs

@@ -57,6 +57,8 @@ pub mod sharedvector;
 pub mod slice;
 pub mod string;
 pub mod styled_text;
+#[cfg(feature = "system-tray")]
+pub mod system_tray;
 pub mod tests;
 pub mod textlayout;
 pub mod timers;