feat(bar): windows systray widget

A new System Tray widget has been added to komorebi-bar, bringing native
Windows system tray functionality directly into the bar.

Special thanks to the Zebar project and its contributors for developing
the systray-util crate library that makes Windows system tray
integration possible.

The widget intercepts system tray icon data by creating a hidden "spy"
window that mimics the Windows taskbar. When applications use the
Shell_NotifyIcon API to manage their tray icons, the widget receives the
same broadcast messages, allowing it to monitor all system tray activity
while forwarding messages to the real taskbar to avoid disruption.

Users can configure which icons to hide using flexible rules. A plain
string matches by exe name (case-insensitive). A structured object can
match on exe, tooltip, and/or GUID fields using AND logic. Each field
supports matching strategies from komorebi's window rules (Equals,
StartsWith, EndsWith, Contains, Regex, and their negated variants),
allowing precise filtering even when multiple icons share the same exe
and GUID. An info button opens a floating panel listing all icons with
their properties and copy buttons, making it easy to identify which
values to use in filter rules.

The widget fully supports mouse interactions including left-click,
right-click, middle-click, and double-click actions on tray icons.
Double-click support uses the LeftDoubleClick action from systray-util
0.2.0, which sends WM_LBUTTONDBLCLK and NIN_SELECT messages. It handles
right-aligned placement correctly by adjusting the rendering order and
toggle button arrow directions to maintain consistent visual appearance
regardless of which panel the widget is placed in.

Some system tray icons register a click callback but never actually
respond to click messages, effectively becoming "zombie" icons from an
interaction standpoint. The widget includes fallback commands for known
problematic icons that override the native click action with a direct
shell command (e.g. opening Windows Security or volume settings).

The implementation uses a background thread with its own tokio runtime
to handle the async systray events, communicating with the UI thread
through crossbeam channels. Icon images are cached efficiently using
hash-based keys that update when icons change. Rapid icon updates are
deduplicated to prevent UI freezing, and image conversion (RgbaImage to
ColorImage) is performed on the background thread to keep the UI
responsive.

The widget automatically detects and removes stale icons whose owning
process has exited, using the Win32 IsWindow API on a configurable
interval. A manual refresh button is also available for immediate
cleanup.

A shortcuts button can be configured to toggle komorebi-shortcuts by
killing the process if running or starting it otherwise. The refresh,
info, and shortcuts buttons can each be placed in the main visible area
or in the overflow section.

komorebi-bar/Cargo.toml

@@ -18,6 +18,7 @@ dirs = { workspace = true }
 dunce = { workspace = true }
 eframe = { workspace = true }
 egui-phosphor = { git = "https://github.com/amPerl/egui-phosphor", rev = "d13688738478ecd12b426e3e74c59d6577a85b59" }
+egui_extras = { workspace = true }
 font-loader = "0.11"
 hotwatch = { workspace = true }
 image = "0.25"
@@ -27,6 +28,7 @@ num = "0.4"
 num-derive = "0.4"
 num-traits = "0.2"
 parking_lot = { workspace = true }
+regex = "1"
 random_word = { version = "0.5", features = ["en"] }
 reqwest = { version = "0.12", features = ["blocking"] }
 schemars = { workspace = true, optional = true }
@@ -34,6 +36,8 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 starship-battery = "0.10"
 sysinfo = { workspace = true }
+systray-util = "0.2.0"
+tokio = { version = "1", features = ["rt", "sync", "time"] }
 tracing = { workspace = true }
 tracing-subscriber = { workspace = true }
 which = { workspace = true }

komorebi-bar/src/bar.rs

@@ -18,6 +18,7 @@ use crate::render::Color32Ext;
 use crate::render::Grouping;
 use crate::render::RenderConfig;
 use crate::render::RenderExt;
+use crate::take_widget_clicked;
 use crate::widgets::komorebi::Komorebi;
 use crate::widgets::komorebi::MonitorInfo;
 use crate::widgets::widget::BarWidget;
@@ -1082,6 +1083,10 @@ impl eframe::App for Komobar {
         let frame = render_config.change_frame_on_bar(frame, &ctx.style());
 
         CentralPanel::default().frame(frame).show(ctx, |ui| {
+            // Variable to store command to execute after widgets are rendered
+            // This allows widgets to mark clicks as consumed before bar processes them
+            let mut pending_command: Option<crate::config::MouseMessage> = None;
+
             if let Some(mouse_config) = &self.config.mouse {
                 let command = if ui
                     .input(|i| i.pointer.button_double_clicked(PointerButton::Primary))
@@ -1182,9 +1187,9 @@ impl eframe::App for Komobar {
                     &None
                 };
 
-                if let Some(command) = command {
-                    command.execute(self.mouse_follows_focus);
-                }
+                // Store the command to execute after widgets are rendered
+                // This allows widgets to mark clicks as consumed
+                pending_command = command.clone();
             }
 
             // Apply grouping logic for the bar as a whole
@@ -1316,6 +1321,13 @@ impl eframe::App for Komobar {
                         });
                     });
             }
+
+            // Execute the deferred mouse command only if no widget consumed the click
+            if let Some(command) = pending_command
+                && !take_widget_clicked()
+            {
+                command.execute(self.mouse_follows_focus);
+            }
         });
     }
 }

komorebi-bar/src/main.rs

@@ -38,6 +38,8 @@ use windows::Win32::UI::WindowsAndMessaging::EnumThreadWindows;
 use windows::Win32::UI::WindowsAndMessaging::GetWindowThreadProcessId;
 use windows_core::BOOL;
 
+use std::sync::atomic::AtomicBool;
+
 pub static MAX_LABEL_WIDTH: AtomicI32 = AtomicI32::new(400);
 pub static MONITOR_LEFT: AtomicI32 = AtomicI32::new(0);
 pub static MONITOR_TOP: AtomicI32 = AtomicI32::new(0);
@@ -46,6 +48,20 @@ pub static MONITOR_INDEX: AtomicUsize = AtomicUsize::new(0);
 pub static BAR_HEIGHT: f32 = 50.0;
 pub static DEFAULT_PADDING: f32 = 10.0;
 
+/// Flag to indicate that a widget has consumed a click event this frame.
+/// This prevents the bar's global mouse handler from also processing the click.
+pub static WIDGET_CLICKED: AtomicBool = AtomicBool::new(false);
+
+/// Mark that a widget has consumed a click event this frame.
+pub fn mark_widget_clicked() {
+    WIDGET_CLICKED.store(true, Ordering::SeqCst);
+}
+
+/// Check if a widget has consumed a click event this frame and reset the flag.
+pub fn take_widget_clicked() -> bool {
+    WIDGET_CLICKED.swap(false, Ordering::SeqCst)
+}
+
 pub static AUTO_SELECT_FILL_COLOUR: AtomicU32 = AtomicU32::new(0);
 pub static AUTO_SELECT_TEXT_COLOUR: AtomicU32 = AtomicU32::new(0);
 

komorebi-bar/src/widgets/mod.rs

@@ -20,6 +20,8 @@ pub mod media;
 pub mod memory;
 pub mod network;
 pub mod storage;
+#[cfg(target_os = "windows")]
+pub mod systray;
 pub mod time;
 pub mod update;
 pub mod widget;
@@ -92,10 +94,16 @@ impl IconsCache {
     pub fn insert_image(&self, id: ImageIconId, image: Arc<ColorImage>) {
         self.images.write().unwrap().insert(id, image);
     }
+
+    /// Removes the cached image and texture for the given icon ID.
+    pub fn remove(&self, id: &ImageIconId) {
+        self.images.write().unwrap().remove(id);
+        self.textures.write().unwrap().1.remove(id);
+    }
 }
 
 #[inline]
-fn rgba_to_color_image(rgba_image: &RgbaImage) -> ColorImage {
+pub(crate) fn rgba_to_color_image(rgba_image: &RgbaImage) -> ColorImage {
     let size = [rgba_image.width() as usize, rgba_image.height() as usize];
     let pixels = rgba_image.as_flat_samples();
     ColorImage::from_rgba_unmultiplied(size, pixels.as_slice())
@@ -156,6 +164,8 @@ pub enum ImageIconId {
     Path(Arc<Path>),
     /// Windows HWND handle.
     Hwnd(isize),
+    /// System tray icon identifier.
+    SystrayIcon(String),
 }
 
 impl From<&Path> for ImageIconId {

komorebi-bar/src/widgets/widget.rs

@@ -19,6 +19,10 @@ use crate::widgets::network::Network;
 use crate::widgets::network::NetworkConfig;
 use crate::widgets::storage::Storage;
 use crate::widgets::storage::StorageConfig;
+#[cfg(target_os = "windows")]
+use crate::widgets::systray::Systray;
+#[cfg(target_os = "windows")]
+use crate::widgets::systray::SystrayConfig;
 use crate::widgets::time::Time;
 use crate::widgets::time::TimeConfig;
 use crate::widgets::update::Update;
@@ -66,6 +70,10 @@ pub enum WidgetConfig {
     /// Storage widget configuration
     #[cfg_attr(feature = "schemars", schemars(title = "Storage"))]
     Storage(StorageConfig),
+    /// System Tray widget configuration (Windows only)
+    #[cfg(target_os = "windows")]
+    #[cfg_attr(feature = "schemars", schemars(title = "Systray"))]
+    Systray(SystrayConfig),
     /// Time widget configuration
     #[cfg_attr(feature = "schemars", schemars(title = "Time"))]
     Time(TimeConfig),
@@ -87,6 +95,8 @@ impl WidgetConfig {
             WidgetConfig::Memory(config) => Box::new(Memory::from(*config)),
             WidgetConfig::Network(config) => Box::new(Network::from(*config)),
             WidgetConfig::Storage(config) => Box::new(Storage::from(*config)),
+            #[cfg(target_os = "windows")]
+            WidgetConfig::Systray(config) => Box::new(Systray::from(config)),
             WidgetConfig::Time(config) => Box::new(Time::from(config.clone())),
             WidgetConfig::Update(config) => Box::new(Update::from(*config)),
         }
@@ -112,6 +122,8 @@ impl WidgetConfig {
             WidgetConfig::Memory(config) => config.enable,
             WidgetConfig::Network(config) => config.enable,
             WidgetConfig::Storage(config) => config.enable,
+            #[cfg(target_os = "windows")]
+            WidgetConfig::Systray(config) => config.enable,
             WidgetConfig::Time(config) => config.enable,
             WidgetConfig::Update(config) => config.enable,
         }