Add pre-show/hide window hooks to C API and macOS

Author: lijy91

src/capi/window_manager_c.cpp

@@ -1,6 +1,7 @@
 #include "window_manager_c.h"
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <unordered_map>
 #include <vector>
 #include "../window_manager.h"
@@ -137,6 +138,13 @@ class CEventListener {
 
 static std::unique_ptr<CEventListener> g_event_listener;
 
+// Hook callbacks (C API)
+static std::mutex g_hook_mutex;
+static native_window_will_show_callback_t g_will_show_cb = nullptr;
+static void* g_will_show_ud = nullptr;
+static native_window_will_hide_callback_t g_will_hide_cb = nullptr;
+static void* g_will_hide_ud = nullptr;
+
 // Window manager operations
 FFI_PLUGIN_EXPORT
 native_window_t native_window_manager_create(const native_window_options_t* options) {
@@ -282,4 +290,50 @@ void native_window_manager_shutdown(void) {
 
   // Note: We don't explicitly destroy the WindowManager singleton
   // as it will be cleaned up automatically when the application exits
+}
+
+FFI_PLUGIN_EXPORT
+void native_window_manager_set_will_show_hook(native_window_will_show_callback_t callback,
+                                              void* user_data) {
+  std::lock_guard<std::mutex> lock(g_hook_mutex);
+  g_will_show_cb = callback;
+  g_will_show_ud = user_data;
+
+  auto& manager = WindowManager::GetInstance();
+  if (callback == nullptr) {
+    manager.SetWillShowHook(std::nullopt);
+    return;
+  }
+
+  // Bridge C callback through C++ hook
+  manager.SetWillShowHook([cb = callback, ud = user_data](WindowId id) {
+    try {
+      cb(id, ud);
+    } catch (...) {
+      // Swallow exceptions to avoid unwinding across API boundary
+    }
+  });
+}
+
+FFI_PLUGIN_EXPORT
+void native_window_manager_set_will_hide_hook(native_window_will_hide_callback_t callback,
+                                              void* user_data) {
+  std::lock_guard<std::mutex> lock(g_hook_mutex);
+  g_will_hide_cb = callback;
+  g_will_hide_ud = user_data;
+
+  auto& manager = WindowManager::GetInstance();
+  if (callback == nullptr) {
+    manager.SetWillHideHook(std::nullopt);
+    return;
+  }
+
+  // Bridge C callback through C++ hook
+  manager.SetWillHideHook([cb = callback, ud = user_data](WindowId id) {
+    try {
+      cb(id, ud);
+    } catch (...) {
+      // Swallow exceptions to avoid unwinding across API boundary
+    }
+  });
 }

src/capi/window_manager_c.h

@@ -117,6 +117,33 @@ bool native_window_manager_unregister_event_callback(int registration_id);
 FFI_PLUGIN_EXPORT
 void native_window_manager_shutdown(void);
 
+/**
+ * Hooks called BEFORE a native window is shown/hidden.
+ * Passing NULL clears the corresponding hook.
+ */
+typedef void (*native_window_will_show_callback_t)(native_window_id_t window_id, void* user_data);
+typedef void (*native_window_will_hide_callback_t)(native_window_id_t window_id, void* user_data);
+
+/**
+ * Set (or clear) the "will show" hook.
+ * @param callback Function called before window is shown (e.g., makeKeyAndOrderFront: on macOS).
+ * NULL to clear.
+ * @param user_data Opaque pointer passed back to callback.
+ */
+FFI_PLUGIN_EXPORT
+void native_window_manager_set_will_show_hook(native_window_will_show_callback_t callback,
+                                              void* user_data);
+
+/**
+ * Set (or clear) the "will hide" hook.
+ * @param callback Function called before window is hidden (e.g., orderOut: on macOS). NULL to
+ * clear.
+ * @param user_data Opaque pointer passed back to callback.
+ */
+FFI_PLUGIN_EXPORT
+void native_window_manager_set_will_hide_hook(native_window_will_hide_callback_t callback,
+                                              void* user_data);
+
 #ifdef __cplusplus
 }
 #endif

src/platform/macos/window_manager_macos.mm

@@ -1,4 +1,5 @@
 #import <Cocoa/Cocoa.h>
+#import <objc/runtime.h>
 #include <cstring>
 #include <iostream>
 #include <string>
@@ -23,10 +24,70 @@
  private:
   WindowManager* manager_;
   NativeAPIWindowManagerDelegate* delegate_;
+
+  // Optional pre-show/hide hooks
+  std::optional<WindowManager::WindowWillShowHook> will_show_hook_;
+  std::optional<WindowManager::WindowWillHideHook> will_hide_hook_;
+
+  friend class WindowManager;
 };
 
 }  // namespace nativeapi
 
+// MARK: - NSWindow Swizzling
+
+// Swizzled implementations call into WindowManager hooks, then forward to original implementations
+@interface NSWindow (NativeAPISwizzle)
+- (void)na_swizzled_makeKeyAndOrderFront:(id)sender;
+- (void)na_swizzled_orderOut:(id)sender;
+@end
+
+@implementation NSWindow (NativeAPISwizzle)
+
+- (void)na_swizzled_makeKeyAndOrderFront:(id)sender {
+  // Invoke hook before showing
+  nativeapi::WindowManager::GetInstance().InvokeWillShowHook([self windowNumber]);
+  // Call original implementation (swapped)
+  [self na_swizzled_makeKeyAndOrderFront:sender];
+}
+
+- (void)na_swizzled_orderOut:(id)sender {
+  // Invoke hook before hiding
+  nativeapi::WindowManager::GetInstance().InvokeWillHideHook([self windowNumber]);
+  // Call original implementation (swapped)
+  [self na_swizzled_orderOut:sender];
+}
+
+@end
+
+static void NativeAPIInstallNSWindowWillShowSwizzleOnce() {
+  static dispatch_once_t onceTokenShow;
+  dispatch_once(&onceTokenShow, ^{
+    Class cls = [NSWindow class];
+    SEL originalSel = @selector(makeKeyAndOrderFront:);
+    SEL swizzledSel = @selector(na_swizzled_makeKeyAndOrderFront:);
+    Method original = class_getInstanceMethod(cls, originalSel);
+    Method swizzled = class_getInstanceMethod(cls, swizzledSel);
+    if (original && swizzled) {
+      method_exchangeImplementations(original, swizzled);
+    }
+  });
+}
+
+static void NativeAPIInstallNSWindowWillHideSwizzleOnce() {
+  static dispatch_once_t onceTokenHide;
+  dispatch_once(&onceTokenHide, ^{
+    Class cls = [NSWindow class];
+    SEL originalSel = @selector(orderOut:);
+    SEL swizzledSel = @selector(na_swizzled_orderOut:);
+    Method original = class_getInstanceMethod(cls, originalSel);
+    Method swizzled = class_getInstanceMethod(cls, swizzledSel);
+    if (original && swizzled) {
+      method_exchangeImplementations(original, swizzled);
+    }
+  });
+}
+
 // Objective-C delegate class to handle NSWindow notifications
 @interface NativeAPIWindowManagerDelegate : NSObject
 @property(nonatomic, assign) void* impl;  // Use void* instead of private class
@@ -286,19 +347,29 @@ - (void)windowWillClose:(NSNotification*)notification {
 }
 
 void WindowManager::SetWillShowHook(std::optional<WindowWillShowHook> hook) {
-  // Empty implementation
+  pimpl_->will_show_hook_ = std::move(hook);
+  if (pimpl_->will_show_hook_) {
+    NativeAPIInstallNSWindowWillShowSwizzleOnce();
+  }
 }
 
 void WindowManager::SetWillHideHook(std::optional<WindowWillHideHook> hook) {
-  // Empty implementation
+  pimpl_->will_hide_hook_ = std::move(hook);
+  if (pimpl_->will_hide_hook_) {
+    NativeAPIInstallNSWindowWillHideSwizzleOnce();
+  }
 }
 
 void WindowManager::InvokeWillShowHook(WindowId id) {
-  // Empty implementation
+  if (pimpl_->will_show_hook_) {
+    (*pimpl_->will_show_hook_)(id);
+  }
 }
 
 void WindowManager::InvokeWillHideHook(WindowId id) {
-  // Empty implementation
+  if (pimpl_->will_hide_hook_) {
+    (*pimpl_->will_hide_hook_)(id);
+  }
 }
 
 }  // namespace nativeapi