feat: click through

Xinrea · Xinrea · commit c0beab419bd1 · 2026-02-12T00:42:07.000+08:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "3.0.3"
+version = "3.0.4"
 edition = "2021"
 authors = ["JLiverTool Contributors"]
 license = "MIT"
diff --git a/crates/jlivertool-ui/src/app.rs b/crates/jlivertool-ui/src/app.rs
@@ -262,6 +262,10 @@ pub fn run_app_with_tray(
         let pending_open_settings = Arc::new(std::sync::atomic::AtomicBool::new(false));
         let pending_open_settings_for_spawn = pending_open_settings.clone();
 
+        // Create shared flag for click-through toggle from tray
+        let pending_click_through = Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let pending_click_through_for_spawn = pending_click_through.clone();
+
         // Create main window bounds - use saved or default
         let bounds = if main_window_config.width > 0 && main_window_config.height > 0 {
             Bounds::new(
@@ -320,6 +324,8 @@ pub fn run_app_with_tray(
                         }
                         // Set shared pending_open_settings flag
                         view.set_pending_open_settings_flag(pending_open_settings.clone());
+                        // Set shared pending_click_through flag
+                        view.set_pending_click_through_flag(pending_click_through.clone());
                         view
                     });
 
@@ -377,6 +383,16 @@ pub fn run_app_with_tray(
                             TrayCommand::StopLive(room_id) => {
                                 let _ = command_tx_clone.send(UiCommand::StopLive { room_id });
                             }
+                            TrayCommand::ToggleClickThrough => {
+                                let click_through = tray_mgr.lock().toggle_click_through();
+                                pending_click_through_for_spawn.store(true, std::sync::atomic::Ordering::Relaxed);
+                                let _ = cx.update(|cx| {
+                                    let _ = cx.update_window(window_handle, |_, window, _cx| {
+                                        crate::platform::set_window_click_through(window, click_through);
+                                    });
+                                    cx.refresh_windows();
+                                });
+                            }
                             TrayCommand::Quit => {
                                 let _ = cx.update(|cx| {
                                     cx.quit();
diff --git a/crates/jlivertool-ui/src/lib.rs b/crates/jlivertool-ui/src/lib.rs
@@ -13,7 +13,7 @@ pub mod views;
 pub use app::{run_app, run_app_with_plugins, run_app_with_tray, window_bounds_from_config, EventReceiver, UiCommand};
 pub use components::QrCodeView;
 pub use http::IsahcHttpClient;
-pub use platform::{hide_window, is_window_visible, set_window_always_on_top, show_window};
+pub use platform::{hide_window, is_window_visible, set_window_always_on_top, set_window_click_through, show_window};
 pub use theme::{set_theme, update_gpui_component_theme};
 pub use tray::{TrayCommand, TrayManager, TrayState};
 pub use views::setting_view::PluginInfo;
diff --git a/crates/jlivertool-ui/src/platform.rs b/crates/jlivertool-ui/src/platform.rs
@@ -144,6 +144,42 @@ mod macos {
             visible == YES
         }
     }
+    /// Set window click-through (ignores mouse events)
+    pub fn set_window_click_through(window: &Window, click_through: bool) {
+        use objc::runtime::Object;
+        use objc::{msg_send, sel, sel_impl};
+
+        let handle = match HasWindowHandle::window_handle(window) {
+            Ok(h) => h,
+            Err(e) => {
+                tracing::warn!("Failed to get window handle: {:?}", e);
+                return;
+            }
+        };
+
+        let raw_window_handle::RawWindowHandle::AppKit(appkit_handle) = handle.as_raw() else {
+            tracing::warn!("Not an AppKit window handle");
+            return;
+        };
+
+        let ns_view = appkit_handle.ns_view.as_ptr() as *mut Object;
+
+        unsafe {
+            let ns_window: *mut Object = msg_send![ns_view, window];
+            if ns_window.is_null() {
+                tracing::warn!("Failed to get NSWindow from NSView");
+                return;
+            }
+
+            let ignore: objc::runtime::BOOL = if click_through {
+                objc::runtime::YES
+            } else {
+                objc::runtime::NO
+            };
+            let _: () = msg_send![ns_window, setIgnoresMouseEvents: ignore];
+            tracing::info!("Set window click-through: {}", click_through);
+        }
+    }
 }
 
 #[cfg(target_os = "windows")]
@@ -253,6 +289,39 @@ mod windows_impl {
 
         unsafe { IsWindowVisible(hwnd).as_bool() }
     }
+
+    /// Set window click-through (ignores mouse events)
+    pub fn set_window_click_through(window: &Window, click_through: bool) {
+        use windows::Win32::UI::WindowsAndMessaging::{
+            GetWindowLongW, SetWindowLongW, GWL_EXSTYLE, WS_EX_TRANSPARENT, WS_EX_LAYERED,
+        };
+
+        let handle = match HasWindowHandle::window_handle(window) {
+            Ok(h) => h,
+            Err(e) => {
+                tracing::warn!("Failed to get window handle: {:?}", e);
+                return;
+            }
+        };
+
+        let raw_window_handle::RawWindowHandle::Win32(win32_handle) = handle.as_raw() else {
+            tracing::warn!("Not a Win32 window handle");
+            return;
+        };
+
+        let hwnd = HWND(win32_handle.hwnd.get() as *mut _);
+
+        unsafe {
+            let ex_style = GetWindowLongW(hwnd, GWL_EXSTYLE);
+            let new_style = if click_through {
+                ex_style | WS_EX_TRANSPARENT.0 as i32 | WS_EX_LAYERED.0 as i32
+            } else {
+                ex_style & !(WS_EX_TRANSPARENT.0 as i32)
+            };
+            SetWindowLongW(hwnd, GWL_EXSTYLE, new_style);
+            tracing::info!("Set window click-through: {}", click_through);
+        }
+    }
 }
 
 #[cfg(not(any(target_os = "macos", target_os = "windows")))]
@@ -278,13 +347,18 @@ mod other {
     pub fn is_window_visible(_window: &Window) -> bool {
         true
     }
+
+    /// Set window click-through (no-op on unsupported platforms)
+    pub fn set_window_click_through(_window: &Window, _click_through: bool) {
+        tracing::warn!("Click-through is not supported on this platform");
+    }
 }
 
 #[cfg(target_os = "macos")]
-pub use macos::{hide_window, is_window_visible, set_window_always_on_top, show_window};
+pub use macos::{hide_window, is_window_visible, set_window_always_on_top, set_window_click_through, show_window};
 
 #[cfg(target_os = "windows")]
-pub use windows_impl::{hide_window, is_window_visible, set_window_always_on_top, show_window};
+pub use windows_impl::{hide_window, is_window_visible, set_window_always_on_top, set_window_click_through, show_window};
 
 #[cfg(not(any(target_os = "macos", target_os = "windows")))]
-pub use other::{hide_window, is_window_visible, set_window_always_on_top, show_window};
+pub use other::{hide_window, is_window_visible, set_window_always_on_top, set_window_click_through, show_window};
diff --git a/crates/jlivertool-ui/src/tray/menu.rs b/crates/jlivertool-ui/src/tray/menu.rs
@@ -6,6 +6,7 @@ use muda::{Menu, MenuItem, PredefinedMenuItem};
 /// Menu item IDs for event handling
 pub struct MenuIds {
     pub show_hide: MenuItem,
+    pub click_through: MenuItem,
     pub room_info: MenuItem,
     pub live_status: MenuItem,
     pub start_live: MenuItem,
@@ -27,6 +28,15 @@ pub fn build_menu(state: &TrayState) -> Result<(Menu, MenuIds), Box<dyn std::err
     let show_hide = MenuItem::new(show_hide_text, true, None);
     menu.append(&show_hide)?;
 
+    // Click-through toggle
+    let click_through_text = if state.click_through {
+        "关闭鼠标穿透"
+    } else {
+        "开启鼠标穿透"
+    };
+    let click_through = MenuItem::new(click_through_text, true, None);
+    menu.append(&click_through)?;
+
     menu.append(&PredefinedMenuItem::separator())?;
 
     // Room Info (disabled label)
@@ -77,6 +87,7 @@ pub fn build_menu(state: &TrayState) -> Result<(Menu, MenuIds), Box<dyn std::err
 
     let menu_ids = MenuIds {
         show_hide,
+        click_through,
         room_info,
         live_status,
         start_live,
diff --git a/crates/jlivertool-ui/src/tray/mod.rs b/crates/jlivertool-ui/src/tray/mod.rs
@@ -24,6 +24,8 @@ pub enum TrayCommand {
     StartLive(u64, u64),
     /// Stop live streaming (room_id)
     StopLive(u64),
+    /// Toggle click-through mode
+    ToggleClickThrough,
     /// Quit the application
     Quit,
 }
@@ -39,6 +41,7 @@ pub struct TrayState {
     pub is_room_owner: bool,
     pub connected: bool,
     pub window_visible: bool,
+    pub click_through: bool,
 }
 
 /// Manages the system tray icon and menu
@@ -87,7 +90,10 @@ impl TrayManager {
 
     /// Update the tray state and refresh the menu
     pub fn update_state(&mut self, state: TrayState) {
+        // Preserve click_through state since it's managed by TrayManager
+        let click_through = self.state.click_through;
         self.state = state.clone();
+        self.state.click_through = click_through;
 
         // Update menu items based on state
         self.update_menu();
@@ -115,6 +121,14 @@ impl TrayManager {
         };
         self.menu_ids.show_hide.set_text(show_hide_text);
 
+        // Update click-through text
+        let click_through_text = if self.state.click_through {
+            "关闭鼠标穿透"
+        } else {
+            "开启鼠标穿透"
+        };
+        self.menu_ids.click_through.set_text(click_through_text);
+
         // Update room info
         let room_info = if let Some(room_id) = self.state.room_id {
             if self.state.room_title.is_empty() {
@@ -173,6 +187,8 @@ impl TrayManager {
                 Some(TrayCommand::ToggleWindow)
             } else if event.id == self.menu_ids.settings.id() {
                 Some(TrayCommand::OpenSettings)
+            } else if event.id == self.menu_ids.click_through.id() {
+                Some(TrayCommand::ToggleClickThrough)
             } else if event.id == self.menu_ids.start_live.id() {
                 self.state.room_id.map(|room_id| {
                     TrayCommand::StartLive(room_id, self.state.area_id)
@@ -199,4 +215,16 @@ impl TrayManager {
     pub fn command_sender(&self) -> mpsc::Sender<TrayCommand> {
         self.command_tx.clone()
     }
+
+    /// Toggle click-through state and update menu
+    pub fn toggle_click_through(&mut self) -> bool {
+        self.state.click_through = !self.state.click_through;
+        self.update_menu();
+        self.state.click_through
+    }
+
+    /// Get current click-through state
+    pub fn click_through_enabled(&self) -> bool {
+        self.state.click_through
+    }
 }
diff --git a/crates/jlivertool-ui/src/views/main_view/mod.rs b/crates/jlivertool-ui/src/views/main_view/mod.rs
@@ -100,6 +100,10 @@ pub struct MainView {
     always_on_top: bool,
     // Flag to apply always_on_top on next render
     pending_always_on_top: Option<bool>,
+    // Click-through mode
+    click_through: bool,
+    // Pending click-through change from tray (Arc for thread-safe sharing)
+    pending_click_through: Arc<AtomicBool>,
     // Scroll handle for danmu list
     scroll_handle: UniformListScrollHandle,
     // Window handles for single-instance windows
@@ -476,6 +480,8 @@ impl MainView {
             level_effect: false,
             always_on_top: false,
             pending_always_on_top: None,
+            click_through: false,
+            pending_click_through: Arc::new(AtomicBool::new(false)),
             scroll_handle: UniformListScrollHandle::new(),
             settings_window: None,
             gift_window: None,
@@ -587,6 +593,11 @@ impl MainView {
         self.pending_open_settings = flag;
     }
 
+    /// Set the pending_click_through flag (shared with tray command handler)
+    pub fn set_pending_click_through_flag(&mut self, flag: Arc<AtomicBool>) {
+        self.pending_click_through = flag;
+    }
+
     /// Get the pending_open_settings flag for tray command handling
     pub fn pending_open_settings_flag(&self) -> Arc<AtomicBool> {
         self.pending_open_settings.clone()
@@ -610,6 +621,7 @@ impl MainView {
                 is_room_owner,
                 connected: self.connected,
                 window_visible: true, // We don't track this in MainView currently
+                click_through: false, // Managed by TrayManager directly
             };
             tray.lock().update_state(state);
 
@@ -1074,6 +1086,7 @@ impl MainView {
 
         let gift_view = self.gift_view.clone();
         let always_on_top = self.always_on_top;
+        let click_through = self.click_through;
         let command_tx = self.command_tx.clone();
 
         if let Ok(handle) = cx.open_window(
@@ -1092,6 +1105,9 @@ impl MainView {
                 if always_on_top {
                     crate::platform::set_window_always_on_top(new_window, true);
                 }
+                if click_through {
+                    crate::platform::set_window_click_through(new_window, true);
+                }
                 let tracker =
                     cx.new(|_| WindowBoundsTracker::new(gift_view, WindowType::Gift, command_tx));
                 cx.new(|cx| Root::new(tracker, new_window, cx))
@@ -1135,6 +1151,7 @@ impl MainView {
 
         let superchat_view = self.superchat_view.clone();
         let always_on_top = self.always_on_top;
+        let click_through = self.click_through;
         let command_tx = self.command_tx.clone();
 
         if let Ok(handle) = cx.open_window(
@@ -1153,6 +1170,9 @@ impl MainView {
                 if always_on_top {
                     crate::platform::set_window_always_on_top(new_window, true);
                 }
+                if click_through {
+                    crate::platform::set_window_click_through(new_window, true);
+                }
                 let tracker = cx.new(|_| {
                     WindowBoundsTracker::new(superchat_view, WindowType::SuperChat, command_tx)
                 });
diff --git a/crates/jlivertool-ui/src/views/main_view/render.rs b/crates/jlivertool-ui/src/views/main_view/render.rs
@@ -562,7 +562,7 @@ impl MainView {
                         }),
                     )),
             )
-            .child(
+            .when(!self.lite_mode, |el| el.child(
                 div()
                     .relative()
                     .w_full()
@@ -748,7 +748,7 @@ impl MainView {
                                 ),
                         )
                     }),
-            )
+            ))
     }
 
     pub(super) fn render_danmu_list(
@@ -807,6 +807,23 @@ impl Render for MainView {
             crate::platform::set_window_always_on_top(window, always_on_top);
         }
 
+        // Check if tray toggled click-through mode
+        if self.pending_click_through.swap(false, std::sync::atomic::Ordering::Relaxed) {
+            // Read the actual state from tray manager
+            let click_through = self
+                .tray_manager
+                .as_ref()
+                .map(|t| t.lock().click_through_enabled())
+                .unwrap_or(false);
+            self.click_through = click_through;
+            // Apply to all secondary windows
+            for handle in [self.gift_window, self.superchat_window].into_iter().flatten() {
+                let _ = cx.update_window(handle, |_, win, _cx| {
+                    crate::platform::set_window_click_through(win, click_through);
+                });
+            }
+        }
+
         // Check if tray requested to open settings
         // Use cx.spawn to defer window opening to after render completes
         // Opening a window during render causes segfault due to GPUI global state modification
