Add hook checks and original show/hide calls to WindowManager

Introduces API functions to check if 'will show' and 'will hide' hooks are set, and to call the original native show/hide implementations for a window, bypassing hooks. Refactors macOS swizzling logic to use new HandleWillShow/HandleWillHide methods and adds corresponding methods to the WindowManager interface and implementation. Updates C API and headers to expose these new capabilities.

Author: lijy91

src/capi/window_manager_c.cpp

@@ -288,4 +288,44 @@ void native_window_manager_set_will_hide_hook(native_window_will_hide_callback_t
       // Swallow exceptions to avoid unwinding across API boundary
     }
   });
+}
+
+FFI_PLUGIN_EXPORT
+bool native_window_manager_has_will_show_hook(void) {
+  try {
+    auto& manager = WindowManager::GetInstance();
+    return manager.HasWillShowHook();
+  } catch (...) {
+    return false;
+  }
+}
+
+FFI_PLUGIN_EXPORT
+bool native_window_manager_has_will_hide_hook(void) {
+  try {
+    auto& manager = WindowManager::GetInstance();
+    return manager.HasWillHideHook();
+  } catch (...) {
+    return false;
+  }
+}
+
+FFI_PLUGIN_EXPORT
+bool native_window_manager_call_original_show(native_window_id_t window_id) {
+  try {
+    auto& manager = WindowManager::GetInstance();
+    return manager.CallOriginalShow(window_id);
+  } catch (...) {
+    return false;
+  }
+}
+
+FFI_PLUGIN_EXPORT
+bool native_window_manager_call_original_hide(native_window_id_t window_id) {
+  try {
+    auto& manager = WindowManager::GetInstance();
+    return manager.CallOriginalHide(window_id);
+  } catch (...) {
+    return false;
+  }
 }

src/capi/window_manager_c.h

@@ -133,6 +133,36 @@ FFI_PLUGIN_EXPORT
 void native_window_manager_set_will_hide_hook(native_window_will_hide_callback_t callback,
                                               void* user_data);
 
+/**
+ * Check if the "will show" hook is set.
+ * @return true if hook is set, false otherwise.
+ */
+FFI_PLUGIN_EXPORT
+bool native_window_manager_has_will_show_hook(void);
+
+/**
+ * Check if the "will hide" hook is set.
+ * @return true if hook is set, false otherwise.
+ */
+FFI_PLUGIN_EXPORT
+bool native_window_manager_has_will_hide_hook(void);
+
+/**
+ * Call the original native show implementation for the specified window.
+ * This bypasses the swizzled hook path on macOS.
+ * @return true on success, false if the window wasn't found or unsupported.
+ */
+FFI_PLUGIN_EXPORT
+bool native_window_manager_call_original_show(native_window_id_t window_id);
+
+/**
+ * Call the original native hide implementation for the specified window.
+ * This bypasses the swizzled hook path on macOS.
+ * @return true on success, false if the window wasn't found or unsupported.
+ */
+FFI_PLUGIN_EXPORT
+bool native_window_manager_call_original_hide(native_window_id_t window_id);
+
 #ifdef __cplusplus
 }
 #endif

src/platform/macos/coordinate_utils_macos.h

@@ -38,7 +38,7 @@ struct NSPointExt {
     NSRect primaryScreenFrame = [[NSScreen screens][0] frame];
     return NSMakePoint(topLeftPoint.x, primaryScreenFrame.size.height - topLeftPoint.y);
   }
-  
+
   // Convert top-left window position to bottom-left window position
   // This is the correct method for converting window positions, as it accounts for window height
   static NSPoint bottomLeftForWindow(CGPoint topLeftPoint, CGFloat windowHeight) {

src/platform/macos/window_manager_macos.mm

@@ -46,28 +46,33 @@ - (void)na_swizzled_orderOut:(id)sender;
 @implementation NSWindow (NativeAPISwizzle)
 
 - (void)na_swizzled_makeKeyAndOrderFront:(id)sender {
-    // Ensure registry is in sync and then invoke hook with correct WindowId
+  // Resolve window id and handle hook if present
+  if (nativeapi::WindowManager::GetInstance().HasWillShowHook()) {
     auto windows = nativeapi::WindowManager::GetInstance().GetAll();
     for (const auto& window : windows) {
       if (window->GetNativeObject() == (__bridge void*)self) {
-        nativeapi::WindowManager::GetInstance().InvokeWillShowHook(window->GetId());
-        break;
+        nativeapi::WindowManager::GetInstance().HandleWillShow(window->GetId());
+        // Hook handles all logic; never call original here
+        return;
       }
     }
-    // First call original implementation so properties like title are up-to-date
-    [self na_swizzled_makeKeyAndOrderFront:sender];
+  }
+  // No window found in registry, call original implementation (swapped)
+  [self na_swizzled_makeKeyAndOrderFront:sender];
 }
 
 - (void)na_swizzled_orderOut:(id)sender {
-  // Invoke hook before hiding, resolving id via registry without using windowNumber
-  auto windows = nativeapi::WindowManager::GetInstance().GetAll();
-  for (const auto& window : windows) {
-    if (window->GetNativeObject() == (__bridge void*)self) {
-      nativeapi::WindowManager::GetInstance().InvokeWillHideHook(window->GetId());
-      break;
+  // Resolve window id and handle hook if present
+  if (nativeapi::WindowManager::GetInstance().HasWillHideHook()) {
+    auto windows = nativeapi::WindowManager::GetInstance().GetAll();
+    for (const auto& window : windows) {
+      if (window->GetNativeObject() == (__bridge void*)self) {
+        nativeapi::WindowManager::GetInstance().HandleWillHide(window->GetId());
+        return;
+      }
     }
   }
-  // Call original implementation (swapped)
+  // No window found in registry, call original implementation (swapped)
   [self na_swizzled_orderOut:sender];
 }
 
@@ -277,7 +282,7 @@ - (void)windowWillClose:(NSNotification*)notification {
     // Create or get Window wrapper - this will handle ID assignment via associated object
     auto window = std::make_shared<Window>((__bridge void*)ns_window);
     WindowId window_id = window->GetId();
-    
+
     // Add to registry if not already present
     if (!WindowRegistry::GetInstance().Get(window_id)) {
       WindowRegistry::GetInstance().Add(window_id, window);
@@ -299,12 +304,12 @@ - (void)windowWillClose:(NSNotification*)notification {
     // Create or get Window wrapper - this will handle ID retrieval via associated object
     auto window = std::make_shared<Window>((__bridge void*)ns_window);
     WindowId window_id = window->GetId();
-    
+
     // Ensure it's in the registry
     if (!WindowRegistry::GetInstance().Get(window_id)) {
       WindowRegistry::GetInstance().Add(window_id, window);
     }
-    
+
     return window;
   }
   return nullptr;
@@ -324,18 +329,54 @@ - (void)windowWillClose:(NSNotification*)notification {
   }
 }
 
-void WindowManager::InvokeWillShowHook(WindowId id) {
+bool WindowManager::HasWillShowHook() const {
+  return pimpl_->will_show_hook_.has_value();
+}
+
+bool WindowManager::HasWillHideHook() const {
+  return pimpl_->will_hide_hook_.has_value();
+}
+
+void WindowManager::HandleWillShow(WindowId id) {
   if (pimpl_->will_show_hook_) {
     (*pimpl_->will_show_hook_)(id);
   }
 }
 
-void WindowManager::InvokeWillHideHook(WindowId id) {
+void WindowManager::HandleWillHide(WindowId id) {
   if (pimpl_->will_hide_hook_) {
     (*pimpl_->will_hide_hook_)(id);
   }
 }
 
+bool WindowManager::CallOriginalShow(WindowId id) {
+  auto window = Get(id);
+  if (!window) {
+    return false;
+  }
+  void* native = window->GetNativeObject();
+  if (!native) {
+    return false;
+  }
+  NSWindow* ns_window = (__bridge NSWindow*)native;
+  [ns_window na_swizzled_makeKeyAndOrderFront:nil];
+  return true;
+}
+
+bool WindowManager::CallOriginalHide(WindowId id) {
+  auto window = Get(id);
+  if (!window) {
+    return false;
+  }
+  void* native = window->GetNativeObject();
+  if (!native) {
+    return false;
+  }
+  NSWindow* ns_window = (__bridge NSWindow*)native;
+  [ns_window na_swizzled_orderOut:nil];
+  return true;
+}
+
 void WindowManager::StartEventListening() {
   pimpl_->StartEventListening();
 }
@@ -345,7 +386,7 @@ - (void)windowWillClose:(NSNotification*)notification {
 }
 
 void WindowManager::DispatchWindowEvent(const WindowEvent& event) {
-  Emit(event);  // Use Dispatch instead of DispatchSync
+  Emit(event);
 }
 
 }  // namespace nativeapi

src/platform/windows/window_manager_windows.cpp

@@ -36,13 +36,13 @@ static WindowId GetWindowIdFromHwnd(HWND hwnd) {
   // Use shared_ptr so it can be properly registered in WindowRegistry
   auto window = std::make_shared<Window>(hwnd);
   WindowId window_id = window->GetId();
-  
+
   // Register the window manually since constructor's shared_from_this() fails
   // during construction (shared_ptr control block not fully initialized yet)
   if (window_id != IdAllocator::kInvalidId) {
     WindowRegistry::GetInstance().Add(window_id, window);
   }
-  
+
   return window_id;
 }
 
@@ -95,7 +95,8 @@ static BOOL WINAPI HookedShowWindow(HWND hwnd, int nCmdShow) {
 }
 
 static BOOL WINAPI HookedShowWindowAsync(HWND hwnd, int nCmdShow) {
-  std::cout << "HookedShowWindowAsync called for hwnd: " << hwnd << " with nCmdShow: " << nCmdShow << std::endl;
+  std::cout << "HookedShowWindowAsync called for hwnd: " << hwnd << " with nCmdShow: " << nCmdShow
+            << std::endl;
   InvokePreShowHideHooks(hwnd, nCmdShow);
   if (g_original_show_window_async) {
     std::cout << "Calling original ShowWindowAsync" << std::endl;
@@ -365,19 +366,19 @@ std::shared_ptr<Window> WindowManager::Get(WindowId id) {
   if (window) {
     return window;
   }
-  
+
   // If not in registry, enumerate all windows to find it
   // This will create and register the window if it exists
   GetAll();
-  
+
   // Try again after enumeration
   return WindowRegistry::GetInstance().Get(id);
 }
 
 // Callback for EnumWindows to collect all top-level windows
 static BOOL CALLBACK EnumWindowsCallback(HWND hwnd, LPARAM lParam) {
   auto* windows = reinterpret_cast<std::vector<HWND>*>(lParam);
-  
+
   // Only include visible windows that are not minimized to taskbar
   // and have a title (filters out many background windows)
   if (IsWindowVisible(hwnd)) {
@@ -390,23 +391,23 @@ static BOOL CALLBACK EnumWindowsCallback(HWND hwnd, LPARAM lParam) {
       }
     }
   }
-  
+
   return TRUE;  // Continue enumeration
 }
 
 std::vector<std::shared_ptr<Window>> WindowManager::GetAll() {
   std::vector<HWND> hwnds;
-  
+
   // Enumerate all top-level windows
   EnumWindows(EnumWindowsCallback, reinterpret_cast<LPARAM>(&hwnds));
-  
+
   std::vector<std::shared_ptr<Window>> windows;
   windows.reserve(hwnds.size());
-  
+
   for (HWND hwnd : hwnds) {
     // Get window ID from HWND, creating Window object if needed
     WindowId window_id = GetWindowIdFromHwnd(hwnd);
-    
+
     if (window_id != IdAllocator::kInvalidId) {
       // Try to get existing window from registry
       auto window = WindowRegistry::GetInstance().Get(window_id);
@@ -415,7 +416,7 @@ std::vector<std::shared_ptr<Window>> WindowManager::GetAll() {
       }
     }
   }
-  
+
   return windows;
 }
 

src/platform/windows/window_windows.cpp

@@ -127,7 +127,7 @@ Window::Window() {
 
 Window::Window(void* native_window) {
   HWND hwnd = static_cast<HWND>(native_window);
-  
+
   if (!hwnd) {
     // Allocate ID even for null window to maintain consistency
     WindowId id = IdAllocator::Allocate<Window>();
@@ -138,11 +138,11 @@ Window::Window(void* native_window) {
   // Check if window already has an ID stored as a custom property
   HANDLE prop_handle = GetProp(hwnd, kWindowIdProperty);
   WindowId id = IdAllocator::kInvalidId;
-  
+
   if (prop_handle) {
     id = static_cast<WindowId>(reinterpret_cast<uintptr_t>(prop_handle));
   }
-  
+
   if (id == IdAllocator::kInvalidId || id == 0) {
     // Allocate new ID if window doesn't have one
     id = IdAllocator::Allocate<Window>();
@@ -165,7 +165,7 @@ Window::~Window() {
   // Remove window from registry on destruction
   if (pimpl_ && pimpl_->window_id_ != IdAllocator::kInvalidId) {
     WindowRegistry::GetInstance().Remove(pimpl_->window_id_);
-    
+
     // Remove the custom property from HWND if window is still valid
     if (pimpl_->hwnd_) {
       RemoveProp(pimpl_->hwnd_, kWindowIdProperty);

src/window_manager.h

@@ -118,7 +118,6 @@ class WindowManager : public EventEmitter<WindowEvent> {
    */
   std::shared_ptr<Window> GetCurrent();
 
-
   /**
    * Hooks invoked before native window show/hide operations (e.g., via swizzling).
    * These are declarations only; platform implementations can register and invoke them.
@@ -130,9 +129,21 @@ class WindowManager : public EventEmitter<WindowEvent> {
   void SetWillShowHook(std::optional<WindowWillShowHook> hook);
   void SetWillHideHook(std::optional<WindowWillHideHook> hook);
 
+  // Check if hooks are set
+  bool HasWillShowHook() const;
+  bool HasWillHideHook() const;
+
   // Called by platform layer BEFORE the actual show/hide happens
-  void InvokeWillShowHook(WindowId id);
-  void InvokeWillHideHook(WindowId id);
+  void HandleWillShow(WindowId id);
+  void HandleWillHide(WindowId id);
+
+  /**
+   * Call the platform's original show/hide implementations for a window,
+   * bypassing swizzled paths. Returns true if successfully invoked.
+   * On unsupported platforms, these return false.
+   */
+  bool CallOriginalShow(WindowId id);
+  bool CallOriginalHide(WindowId id);
 
  protected:
   /**