Add WindowMessageDispatcher for tray icon events

Author: lijy91

src/platform/windows/tray_icon_windows.cpp

@@ -15,7 +15,7 @@
 #include "../../tray_icon.h"
 #include "../../tray_icon_event.h"
 #include "string_utils_windows.h"
-#include "window_proc_delegate_manager.h"
+#include "window_message_dispatcher.h"
 
 namespace nativeapi {
 
@@ -57,15 +57,18 @@ class TrayIcon::Impl {
     nid_.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
     nid_.uCallbackMessage = WM_USER + 1;  // Custom message for tray icon events
 
-    window_proc_id_ = WindowProcDelegateManager::GetInstance().RegisterDelegate(
-        [this](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
+    window_proc_handle_id_ = WindowMessageDispatcher::GetInstance().RegisterHandler(
+        hwnd, [this](HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) {
           return HandleWindowProc(hwnd, message, wparam, lparam);
         });
   }
 
   ~Impl() {
-    WindowProcDelegateManager::GetInstance().UnregisterDelegate(
-        window_proc_id_);
+    // Unregister window procedure handler
+    if (window_proc_handle_id_ != -1) {
+      WindowMessageDispatcher::GetInstance().UnregisterHandler(window_proc_handle_id_);
+    }
+
     if (hwnd_) {
       Shell_NotifyIconW(NIM_DELETE, &nid_);
       // Destroy the window if we own it
@@ -112,7 +115,7 @@ class TrayIcon::Impl {
     return std::nullopt;  // Let default window procedure handle it
   }
 
-  int window_proc_id_;
+  int window_proc_handle_id_;
   HWND hwnd_;
   NOTIFYICONDATAW nid_;
   std::shared_ptr<Menu> context_menu_;
@@ -142,8 +145,8 @@ TrayIcon::TrayIcon(void* native_tray_icon) {
 
     if (!class_registered) {
       WNDCLASSW wc = {};
-      // Use WindowProcDelegateManager to route messages to registered delegates
-      wc.lpfnWndProc = WindowProcDelegateManager::InternalWindowProc;
+      // Use WindowMessageDispatcher to route messages to registered handlers
+      wc.lpfnWndProc = WindowMessageDispatcher::DispatchWindowProc;
       wc.hInstance = hInstance;
       wc.lpszClassName = class_name.c_str();
 

src/platform/windows/window_message_dispatcher.cpp

@@ -0,0 +1,154 @@
+#include "window_message_dispatcher.h"
+#include <algorithm>
+#include <vector>
+
+namespace nativeapi {
+
+WindowMessageDispatcher& WindowMessageDispatcher::GetInstance() {
+  static WindowMessageDispatcher instance;
+  return instance;
+}
+
+WindowMessageDispatcher::~WindowMessageDispatcher() {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  // Uninstall all hooks before destruction
+  for (const auto& [hwnd, _] : original_procs_) {
+    UninstallHook(hwnd);
+  }
+  original_procs_.clear();
+}
+
+int WindowMessageDispatcher::RegisterHandler(WindowMessageHandler handler) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  int id = next_id_++;
+  handlers_[id] = {std::move(handler), HWND(0)};  // HWND(0) for global handler
+  return id;
+}
+
+int WindowMessageDispatcher::RegisterHandler(HWND hwnd,
+                                             WindowMessageHandler handler) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  int id = next_id_++;
+  handlers_[id] = {std::move(handler), hwnd};
+
+  // Install hook for this window if not already installed
+  if (original_procs_.find(hwnd) == original_procs_.end()) {
+    InstallHook(hwnd);
+  }
+
+  return id;
+}
+
+bool WindowMessageDispatcher::UnregisterHandler(int id) {
+  std::lock_guard<std::mutex> lock(mutex_);
+
+  auto it = handlers_.find(id);
+  if (it == handlers_.end()) {
+    return false;
+  }
+
+  HWND target_hwnd = it->second.target_hwnd;
+  handlers_.erase(it);
+
+  // Check if this was the last handler for this window
+  if (target_hwnd != HWND(0)) {
+    bool has_other_handlers = std::any_of(
+        handlers_.begin(), handlers_.end(), [target_hwnd](const auto& pair) {
+          return pair.second.target_hwnd == target_hwnd;
+        });
+
+    if (!has_other_handlers) {
+      UninstallHook(target_hwnd);
+    }
+  }
+
+  return true;
+}
+
+LRESULT CALLBACK WindowMessageDispatcher::DispatchWindowProc(HWND hwnd,
+                                                             UINT msg,
+                                                             WPARAM wparam,
+                                                             LPARAM lparam) {
+  auto& dispatcher = GetInstance();
+
+  // Get original window procedure and copy handlers while holding lock
+  WNDPROC original_proc = nullptr;
+  std::vector<std::pair<int, HandlerEntry>> handlers_vector;
+
+  {
+    std::lock_guard<std::mutex> lock(dispatcher.mutex_);
+
+    // Get original window procedure
+    auto proc_it = dispatcher.original_procs_.find(hwnd);
+    if (proc_it == dispatcher.original_procs_.end()) {
+      return DefWindowProc(hwnd, msg, wparam, lparam);
+    }
+
+    original_proc = proc_it->second;
+
+    // Copy handlers while holding lock (to avoid deadlock when handlers call
+    // back)
+    handlers_vector.assign(dispatcher.handlers_.begin(),
+                           dispatcher.handlers_.end());
+  }
+
+  // Try handlers in reverse order (most recently registered first)
+  // Process handlers without holding the mutex to avoid deadlock
+  for (auto it = handlers_vector.rbegin(); it != handlers_vector.rend(); ++it) {
+    const auto& [id, entry] = *it;
+
+    // Check if this handler applies to this window
+    if (entry.target_hwnd == HWND(0) || entry.target_hwnd == hwnd) {
+      auto result = entry.handler(hwnd, msg, wparam, lparam);
+      if (result.has_value()) {
+        return result.value();
+      }
+    }
+  }
+
+  // No handler consumed the message, call original procedure
+  return CallWindowProc(original_proc, hwnd, msg, wparam, lparam);
+}
+
+bool WindowMessageDispatcher::InstallHook(HWND hwnd) {
+  if (!hwnd || !IsWindow(hwnd)) {
+    return false;
+  }
+
+  // Get current window procedure
+  WNDPROC current_proc =
+      reinterpret_cast<WNDPROC>(GetWindowLongPtr(hwnd, GWLP_WNDPROC));
+  if (!current_proc) {
+    return false;
+  }
+
+  // Store original procedure
+  original_procs_[hwnd] = current_proc;
+
+  // Install our dispatcher as the new window procedure
+  SetWindowLongPtr(hwnd, GWLP_WNDPROC,
+                   reinterpret_cast<LONG_PTR>(DispatchWindowProc));
+
+  return true;
+}
+
+void WindowMessageDispatcher::UninstallHook(HWND hwnd) {
+  auto it = original_procs_.find(hwnd);
+  if (it == original_procs_.end()) {
+    return;
+  }
+
+  WNDPROC original_proc = it->second;
+
+  // Restore original window procedure
+  SetWindowLongPtr(hwnd, GWLP_WNDPROC,
+                   reinterpret_cast<LONG_PTR>(original_proc));
+
+  // Remove from our tracking
+  original_procs_.erase(it);
+}
+
+}  // namespace nativeapi

src/platform/windows/window_message_dispatcher.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <windows.h>
+#include <functional>
+#include <mutex>
+#include <optional>
+#include <unordered_map>
+
+namespace nativeapi {
+
+/**
+ * @brief Function type for handling Windows messages.
+ *
+ * @param hwnd Window handle receiving the message
+ * @param msg Message identifier (WM_* constants)
+ * @param wparam Message-specific parameter
+ * @param lparam Message-specific parameter
+ * @return std::optional<LRESULT> If a value is returned, the message is
+ * considered handled. If std::nullopt is returned, the message continues to
+ * other handlers.
+ */
+using WindowMessageHandler = std::function<
+    std::optional<LRESULT>(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)>;
+
+/**
+ * @brief Singleton dispatcher for Windows message handling across multiple
+ * windows.
+ *
+ * This class provides a centralized way to register message handlers for
+ * Windows messages. It supports both global handlers (applied to all windows)
+ * and window-specific handlers. The dispatcher automatically hooks into window
+ * procedures using SetWindowLongPtr and restores original procedures when
+ * handlers are unregistered.
+ *
+ * Thread Safety: All public methods are thread-safe.
+ *
+ * Usage Example:
+ * ```cpp
+ * auto& dispatcher = WindowMessageDispatcher::GetInstance();
+ *
+ * // Register global handler for all windows
+ * int global_id = dispatcher.RegisterHandler([](HWND hwnd, UINT msg, WPARAM wp,
+ * LPARAM lp) { if (msg == WM_SIZE) {
+ *         // Handle window resize
+ *         return std::make_optional<LRESULT>(0);
+ *     }
+ *     return std::nullopt; // Let other handlers process
+ * });
+ *
+ * // Register window-specific handler
+ * int window_id = dispatcher.RegisterHandler(specific_hwnd, [](HWND hwnd, UINT
+ * msg, WPARAM wp, LPARAM lp) { if (msg == WM_CLOSE) {
+ *         // Prevent window from closing
+ *         return std::make_optional<LRESULT>(0);
+ *     }
+ *     return std::nullopt;
+ * });
+ *
+ * // Unregister when done
+ * dispatcher.UnregisterHandler(global_id);
+ * dispatcher.UnregisterHandler(window_id);
+ * ```
+ */
+class WindowMessageDispatcher {
+ public:
+  /**
+   * @brief Get the singleton instance of the dispatcher.
+   * @return Reference to the singleton WindowMessageDispatcher instance.
+   */
+  static WindowMessageDispatcher& GetInstance();
+
+  /**
+   * @brief Register a global message handler that applies to all windows.
+   *
+   * @param handler Function to call for Windows messages
+   * @return int Handler ID for unregistration
+   */
+  int RegisterHandler(WindowMessageHandler handler);
+
+  /**
+   * @brief Register a message handler for a specific window.
+   *
+   * This method automatically installs a hook into the window's procedure
+   * if not already installed. The hook is removed when the last handler
+   * for the window is unregistered.
+   *
+   * @param hwnd Target window handle
+   * @param handler Function to call for Windows messages
+   * @return int Handler ID for unregistration
+   */
+  int RegisterHandler(HWND hwnd, WindowMessageHandler handler);
+
+  /**
+   * @brief Unregister a message handler by ID.
+   *
+   * @param id Handler ID returned from RegisterHandler
+   * @return bool true if handler was found and removed, false otherwise
+   */
+  bool UnregisterHandler(int id);
+
+  /**
+   * @brief Internal window procedure function used for message dispatching.
+   *
+   * This function is installed as the window procedure for windows that have
+   * registered handlers. It processes messages through registered handlers
+   * and falls back to the original window procedure if no handler consumes
+   * the message.
+   *
+   * @param hwnd Window handle
+   * @param msg Message identifier
+   * @param wparam Message parameter
+   * @param lparam Message parameter
+   * @return LRESULT Message processing result
+   */
+  static LRESULT CALLBACK DispatchWindowProc(HWND hwnd,
+                                             UINT msg,
+                                             WPARAM wparam,
+                                             LPARAM lparam);
+
+ private:
+  WindowMessageDispatcher() = default;
+  ~WindowMessageDispatcher();
+
+  /**
+   * @brief Entry for a registered message handler.
+   */
+  struct HandlerEntry {
+    WindowMessageHandler handler;  ///< The handler function
+    HWND target_hwnd;  ///< Target window (HWND(0) for global handlers)
+  };
+
+  /**
+   * @brief Install message hook for a window.
+   *
+   * @param hwnd Window handle to hook
+   * @return bool true if hook was installed successfully
+   */
+  bool InstallHook(HWND hwnd);
+
+  /**
+   * @brief Uninstall message hook for a window.
+   *
+   * @param hwnd Window handle to unhook
+   */
+  void UninstallHook(HWND hwnd);
+
+  ///< Mutex for thread safety
+  mutable std::mutex mutex_;
+  ///< Registered handlers by ID
+  std::unordered_map<int, HandlerEntry> handlers_;
+  ///< Original window procedures
+  std::unordered_map<HWND, WNDPROC> original_procs_;
+  ///< Next available handler ID
+  int next_id_ = 1;
+};
+
+}  // namespace nativeapi