Refactor menu and tray icon to use shared host window

Menus and tray icons now use a shared hidden host window provided by WindowMessageDispatcher, improving resource management and message routing. Removed redundant window creation and destruction logic from tray icon implementation. Added GetHostWindow method to WindowMessageDispatcher and updated related logic for handler registration and hook management.

Author: lijy91

src/platform/windows/menu_windows.cpp

@@ -8,6 +8,7 @@
 #include "../../menu.h"
 #include "../../menu_event.h"
 #include "string_utils_windows.h"
+#include "window_message_dispatcher.h"
 
 namespace nativeapi {
 
@@ -86,74 +87,6 @@ std::pair<UINT, UINT> ConvertAccelerator(
   return std::make_pair(key, modifiers);
 }
 
-// Helper function to get the main window for the current thread
-HWND GetMainWindowForCurrentThread() {
-  static HWND main_window = nullptr;
-
-  // First try to get the foreground window
-  HWND hwnd = nullptr;
-
-  // Use EnumWindows to find the main window
-  struct EnumData {
-    HWND main_window;
-    DWORD current_thread_id;
-  };
-
-  EnumData data = {nullptr, GetCurrentThreadId()};
-
-  EnumWindows(
-      [](HWND hwnd, LPARAM lParam) -> BOOL {
-        EnumData* data = reinterpret_cast<EnumData*>(lParam);
-
-        // Check if window belongs to current thread
-        DWORD window_thread_id = GetWindowThreadProcessId(hwnd, nullptr);
-        if (window_thread_id != data->current_thread_id) {
-          return TRUE;  // Continue enumeration
-        }
-
-        // Check if window is visible and not a tool window
-        if (!IsWindowVisible(hwnd)) {
-          return TRUE;  // Continue enumeration
-        }
-
-        // Skip tool windows
-        if (GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_TOOLWINDOW) {
-          return TRUE;  // Continue enumeration
-        }
-
-        // Skip message-only windows
-        if (hwnd == HWND_MESSAGE) {
-          return TRUE;  // Continue enumeration
-        }
-
-        // Check if it's a main window (has a title bar, not a child window)
-        if (GetParent(hwnd) != nullptr) {
-          return TRUE;  // Continue enumeration
-        }
-
-        // Found a candidate main window
-        data->main_window = hwnd;
-        return FALSE;  // Stop enumeration
-      },
-      reinterpret_cast<LPARAM>(&data));
-
-  if (data.main_window) {
-    return data.main_window;
-  }
-
-  // Fallback: try to find any top-level window
-  hwnd = FindWindow(nullptr, nullptr);
-  if (hwnd && IsWindow(hwnd)) {
-    return hwnd;
-  }
-
-  return nullptr;
-}
-
-}  // namespace nativeapi
-
-namespace nativeapi {
-
 // MenuItem::Impl implementation
 class MenuItem::Impl {
  public:
@@ -550,12 +483,20 @@ bool Menu::Open(double x, double y) {
   pimpl_->visible_ = true;
 
   POINT pt = {static_cast<int>(x), static_cast<int>(y)};
-  // Use the helper function to get the main window for current thread
-  HWND hwnd = GetMainWindowForCurrentThread();
 
-  // Show the context menu
+  // Get the host window for menus
+  HWND host_window = WindowMessageDispatcher::GetInstance().GetHostWindow();
+  if (!host_window) {
+    pimpl_->visible_ = false;
+    return false;
+  }
+
+  // Set the host window as foreground to ensure menu can be displayed
+  SetForegroundWindow(host_window);
+
+  // Show the context menu using the host window
   TrackPopupMenu(pimpl_->hmenu_, TPM_BOTTOMALIGN | TPM_LEFTALIGN, pt.x, pt.y, 0,
-                 hwnd, nullptr);
+                 host_window, nullptr);
 
   pimpl_->visible_ = false;
   return true;

src/platform/windows/tray_icon_windows.cpp

@@ -33,18 +33,16 @@ class TrayIcon::Impl {
   using RightClickedCallback = std::function<void(TrayIconId)>;
   using DoubleClickedCallback = std::function<void(TrayIconId)>;
 
-  Impl() : hwnd_(nullptr), icon_handle_(nullptr), owns_window_(false) {
+  Impl() : hwnd_(nullptr), icon_handle_(nullptr) {
     tray_icon_id_ = IdAllocator::Allocate<TrayIcon>();
   }
 
   Impl(HWND hwnd,
-       bool owns_window,
        ClickedCallback clicked_callback,
        RightClickedCallback right_clicked_callback,
        DoubleClickedCallback double_clicked_callback)
       : hwnd_(hwnd),
         icon_handle_(nullptr),
-        owns_window_(owns_window),
         clicked_callback_(std::move(clicked_callback)),
         right_clicked_callback_(std::move(right_clicked_callback)),
         double_clicked_callback_(std::move(double_clicked_callback)) {
@@ -71,10 +69,7 @@ class TrayIcon::Impl {
 
     if (hwnd_) {
       Shell_NotifyIconW(NIM_DELETE, &nid_);
-      // Destroy the window if we own it
-      if (owns_window_) {
-        DestroyWindow(hwnd_);
-      }
+      // Note: We don't destroy the shared host window
     }
     if (icon_handle_) {
       DestroyIcon(icon_handle_);
@@ -121,7 +116,6 @@ class TrayIcon::Impl {
   std::shared_ptr<Menu> context_menu_;
   HICON icon_handle_;
   TrayIconId tray_icon_id_;
-  bool owns_window_;  // Whether we created the window and should destroy it
 
   // Callback functions for event emission
   ClickedCallback clicked_callback_;
@@ -133,45 +127,10 @@ TrayIcon::TrayIcon() : TrayIcon(nullptr) {}
 
 TrayIcon::TrayIcon(void* native_tray_icon) {
   HWND hwnd = nullptr;
-  bool owns_window = false;
 
   if (native_tray_icon == nullptr) {
-    // Create a new tray icon - need a window handle for receiving messages
-    HINSTANCE hInstance = GetModuleHandle(nullptr);
-
-    // Register window class for message-only window (once per process)
-    static bool class_registered = false;
-    static std::wstring class_name = L"NativeAPITrayIconWindow";
-
-    if (!class_registered) {
-      WNDCLASSW wc = {};
-      // Use WindowMessageDispatcher to route messages to registered handlers
-      wc.lpfnWndProc = WindowMessageDispatcher::DispatchWindowProc;
-      wc.hInstance = hInstance;
-      wc.lpszClassName = class_name.c_str();
-
-      if (RegisterClassW(&wc)) {
-        class_registered = true;
-      }
-    }
-
-    // Create a message-only window (HWND_MESSAGE as parent)
-    if (class_registered) {
-      hwnd = CreateWindowExW(
-          0,                   // Extended styles
-          class_name.c_str(),  // Window class
-          L"",                 // Window title (empty for message-only window)
-          0,                   // Window style
-          0, 0, 0, 0,          // Position and size (ignored for message-only)
-          HWND_MESSAGE,        // Parent: message-only window
-          nullptr,             // Menu
-          hInstance,           // Instance
-          nullptr);            // Additional data
-
-      if (hwnd) {
-        owns_window = true;
-      }
-    }
+    // Use the shared host window from WindowMessageDispatcher
+    hwnd = WindowMessageDispatcher::GetInstance().GetHostWindow();
   } else {
     // Wrap existing native tray icon
     // In a real implementation, you'd extract HWND from the tray parameter
@@ -196,7 +155,7 @@ TrayIcon::TrayIcon(void* native_tray_icon) {
     };
 
     pimpl_ = std::make_unique<Impl>(
-        hwnd, owns_window, std::move(clicked_callback),
+        hwnd, std::move(clicked_callback),
         std::move(right_clicked_callback), std::move(double_clicked_callback));
   } else {
     // Failed to create window, create uninitialized Impl

src/platform/windows/window_message_dispatcher.cpp

@@ -12,6 +12,12 @@ WindowMessageDispatcher& WindowMessageDispatcher::GetInstance() {
 WindowMessageDispatcher::~WindowMessageDispatcher() {
   std::lock_guard<std::mutex> lock(mutex_);
 
+  // Destroy host window if it exists
+  if (host_window_) {
+    DestroyWindow(host_window_);
+    host_window_ = nullptr;
+  }
+
   // Uninstall all hooks before destruction
   for (const auto& [hwnd, _] : original_procs_) {
     UninstallHook(hwnd);
@@ -29,42 +35,57 @@ int WindowMessageDispatcher::RegisterHandler(WindowMessageHandler handler) {
 
 int WindowMessageDispatcher::RegisterHandler(HWND hwnd,
                                              WindowMessageHandler handler) {
-  std::lock_guard<std::mutex> lock(mutex_);
-
-  int id = next_id_++;
-  handlers_[id] = {std::move(handler), hwnd};
+  // Check if hook needs to be installed (outside of lock to avoid deadlock)
+  bool needs_hook = false;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    needs_hook = (original_procs_.find(hwnd) == original_procs_.end());
+  }
 
-  // Install hook for this window if not already installed
-  if (original_procs_.find(hwnd) == original_procs_.end()) {
+  // Install hook if needed (outside of lock)
+  if (needs_hook) {
     InstallHook(hwnd);
   }
 
+  // Register the handler (inside lock)
+  std::lock_guard<std::mutex> lock(mutex_);
+  int id = next_id_++;
+  handlers_[id] = {std::move(handler), hwnd};
+
   return id;
 }
 
 bool WindowMessageDispatcher::UnregisterHandler(int id) {
-  std::lock_guard<std::mutex> lock(mutex_);
+  HWND target_hwnd = HWND(0);
+  bool should_uninstall = false;
 
-  auto it = handlers_.find(id);
-  if (it == handlers_.end()) {
-    return false;
-  }
+  {
+    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);
+    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;
-        });
+    // 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);
+      should_uninstall = !has_other_handlers;
     }
   }
 
+  // Uninstall hook if needed (outside of lock to avoid deadlock)
+  if (should_uninstall) {
+    UninstallHook(target_hwnd);
+  }
+
   return true;
 }
 
@@ -125,6 +146,11 @@ bool WindowMessageDispatcher::InstallHook(HWND hwnd) {
     return false;
   }
 
+  // If the window already has DispatchWindowProc, don't install it again
+  if (current_proc == DispatchWindowProc) {
+    return true;  // Already installed
+  }
+
   // Store original procedure
   original_procs_[hwnd] = current_proc;
 
@@ -143,12 +169,75 @@ void WindowMessageDispatcher::UninstallHook(HWND hwnd) {
 
   WNDPROC original_proc = it->second;
 
-  // Restore original window procedure
-  SetWindowLongPtr(hwnd, GWLP_WNDPROC,
-                   reinterpret_cast<LONG_PTR>(original_proc));
+  // Don't restore window procedure for host window - it should keep DispatchWindowProc
+  if (hwnd != host_window_) {
+    // Restore original window procedure
+    SetWindowLongPtr(hwnd, GWLP_WNDPROC,
+                     reinterpret_cast<LONG_PTR>(original_proc));
+  }
 
   // Remove from our tracking
   original_procs_.erase(it);
 }
 
+HWND WindowMessageDispatcher::GetHostWindow() {
+  // Check if host window already exists (without holding lock to avoid deadlock)
+  if (host_window_ && IsWindow(host_window_)) {
+    return host_window_;
+  }
+
+  // Create a hidden window class for hosting
+  static const wchar_t* class_name = L"NativeApiHostWindow";
+  
+  WNDCLASSW wc = {};
+  wc.lpfnWndProc = DispatchWindowProc;  // Use dispatcher for host window
+  wc.hInstance = GetModuleHandle(nullptr);
+  wc.lpszClassName = class_name;
+  
+  // Register the window class (only once)
+  static bool class_registered = false;
+  if (!class_registered) {
+    if (RegisterClassW(&wc)) {
+      class_registered = true;
+    } else {
+      return nullptr;
+    }
+  }
+
+  // Create the hidden host window (outside of lock to avoid deadlock)
+  HWND new_host_window = CreateWindowExW(
+      WS_EX_TOOLWINDOW,           // Extended style: tool window
+      class_name,                 // Window class
+      L"NativeApi Host",         // Window title
+      WS_OVERLAPPED,             // Window style: overlapped window
+      0, 0,                      // Position
+      1, 1,                      // Size (minimal)
+      HWND_MESSAGE,              // Parent: message-only window
+      nullptr,                   // Menu
+      GetModuleHandle(nullptr),  // Instance
+      nullptr                    // Additional data
+  );
+
+  if (new_host_window) {
+    // Ensure the window is hidden
+    ShowWindow(new_host_window, SW_HIDE);
+    
+    // Now acquire lock to register the window
+    std::lock_guard<std::mutex> lock(mutex_);
+    
+    // Double-check if another thread created the window while we were creating it
+    if (host_window_ && IsWindow(host_window_)) {
+      // Another thread won, destroy our window and use theirs
+      DestroyWindow(new_host_window);
+      return host_window_;
+    }
+    
+    // Register the host window in original_procs_ with DefWindowProc as fallback
+    host_window_ = new_host_window;
+    original_procs_[host_window_] = DefWindowProcW;
+  }
+
+  return host_window_;
+}
+
 }  // namespace nativeapi