Add content bounds API for window management

Introduces SetContentBounds and GetContentBounds methods to the Window class and platform implementations, allowing direct manipulation and querying of the window's content area (excluding decorations). Updates C API and headers to expose these functions for FFI usage. Refactors macOS menu positioning to use screen coordinates and simplifies coordinate conversion logic.

Author: lijy91

src/capi/window_c.cpp

@@ -291,6 +291,30 @@ native_size_t native_window_get_content_size(native_window_t window) {
   return result;
 }
 
+FFI_PLUGIN_EXPORT
+void native_window_set_content_bounds(native_window_t window, native_rectangle_t bounds) {
+  if (!window)
+    return;
+  auto* win = static_cast<nativeapi::Window*>(window);
+  nativeapi::Rectangle rect = {bounds.x, bounds.y, bounds.width, bounds.height};
+  win->SetContentBounds(rect);
+}
+
+FFI_PLUGIN_EXPORT
+native_rectangle_t native_window_get_content_bounds(native_window_t window) {
+  native_rectangle_t result = {0.0, 0.0, 0.0, 0.0};
+  if (!window)
+    return result;
+
+  auto* win = static_cast<nativeapi::Window*>(window);
+  nativeapi::Rectangle bounds = win->GetContentBounds();
+  result.x = bounds.x;
+  result.y = bounds.y;
+  result.width = bounds.width;
+  result.height = bounds.height;
+  return result;
+}
+
 FFI_PLUGIN_EXPORT
 void native_window_set_minimum_size(native_window_t window, double width, double height) {
   if (!window)

src/capi/window_c.h

@@ -139,6 +139,12 @@ void native_window_set_content_size(native_window_t window, double width, double
 FFI_PLUGIN_EXPORT
 native_size_t native_window_get_content_size(native_window_t window);
 
+FFI_PLUGIN_EXPORT
+void native_window_set_content_bounds(native_window_t window, native_rectangle_t bounds);
+
+FFI_PLUGIN_EXPORT
+native_rectangle_t native_window_get_content_bounds(native_window_t window);
+
 FFI_PLUGIN_EXPORT
 void native_window_set_minimum_size(native_window_t window, double width, double height);
 

src/platform/android/window_android.cpp

@@ -188,6 +188,16 @@ Size Window::GetContentSize() const {
   return GetSize();
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  // On Android, content bounds is the same as window bounds
+  SetBounds(bounds);
+}
+
+Rectangle Window::GetContentBounds() const {
+  // On Android, content bounds is the same as window bounds
+  return GetBounds();
+}
+
 void Window::SetMinimumSize(Size size) {
   ALOGW("SetMinimumSize not fully supported on Android");
 }

src/platform/ios/window_ios.mm

@@ -188,6 +188,16 @@
   return GetSize();
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  // On iOS, content bounds is the same as window bounds
+  SetBounds(bounds);
+}
+
+Rectangle Window::GetContentBounds() const {
+  // On iOS, content bounds is the same as window bounds
+  return GetBounds();
+}
+
 void Window::SetMinimumSize(Size size) {
   // Not applicable to iOS windows
 }

src/platform/linux/window_linux.cpp

@@ -201,6 +201,16 @@ Size Window::GetContentSize() const {
   return GetSize();
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  // For GDK windows, content bounds is the same as window bounds
+  SetBounds(bounds);
+}
+
+Rectangle Window::GetContentBounds() const {
+  // For GDK windows, content bounds is the same as window bounds
+  return GetBounds();
+}
+
 void Window::SetMinimumSize(Size size) {
   // GTK minimum size constraints would need to be set on the widget level
   // For now, we'll provide a basic implementation that doesn't enforce

src/platform/macos/display_manager_macos.mm

@@ -81,10 +81,10 @@ static Display CreateDisplayFromNSScreen(NSScreen* screen, bool isPrimary) {
 
 Point DisplayManager::GetCursorPosition() {
   NSPoint mouseLocation = [NSEvent mouseLocation];
-  
+
   // Convert from bottom-left (macOS default) to top-left coordinate system
   CGPoint topLeftPoint = NSPointExt::topLeft(mouseLocation);
-  
+
   Point point;
   point.x = topLeftPoint.x;
   point.y = topLeftPoint.y;

src/platform/macos/menu_macos.mm

@@ -6,6 +6,7 @@
 #include "../../image.h"
 #include "../../menu.h"
 #include "../../menu_event.h"
+#include "coordinate_utils_macos.h"
 
 // Import Cocoa headers
 #import <Cocoa/Cocoa.h>
@@ -666,7 +667,7 @@ - (void)menuDidClose:(NSMenu*)menu {
       break;
 
     case PositioningStrategy::Type::CursorPosition: {
-      NSPoint mouse_location = [NSEvent mouseLocation];
+      NSPoint mouse_location = NSPointExt::topLeft([NSEvent mouseLocation]);
       x = mouse_location.x;
       y = mouse_location.y;
       break;
@@ -756,53 +757,18 @@ - (void)menuDidClose:(NSMenu*)menu {
       break;
   }
 
-  // Get the main window
-  NSWindow* main_window = [[NSApplication sharedApplication] mainWindow];
-  if (!main_window) {
-    // Fallback to key window if main window is not available
-    main_window = [[NSApplication sharedApplication] keyWindow];
-  }
-
-  if (!main_window) {
-    // If still no window, use the old implementation
-    NSPoint point = NSMakePoint(x, y);
-    NSEvent* event = [NSEvent mouseEventWithType:NSEventTypeRightMouseDown
-                                        location:point
-                                   modifierFlags:0
-                                       timestamp:0
-                                    windowNumber:0
-                                         context:nil
-                                     eventNumber:0
-                                      clickCount:1
-                                        pressure:1.0];
-
-    @autoreleasepool {
-      NSView* dummy_view = [[NSView alloc] init];
-      [NSMenu popUpContextMenu:pimpl_->ns_menu_ withEvent:event forView:dummy_view];
-    }
-
-    return true;
-  }
-
-  NSView* content_view = [main_window contentView];
-  if (!content_view) {
-    return false;
-  }
-
-  // Convert coordinates if the content view is not flipped
-  // In macOS, the default coordinate system has origin at bottom-left
-  // If view is not flipped, we need to convert from top-left origin
-  CGFloat final_y = y;
-  if (![content_view isFlipped]) {
-    CGFloat frame_height = [content_view frame].size.height;
-    final_y = frame_height - y;
-  }
-
-  NSPoint point = NSMakePoint(x, final_y);
+  // Convert coordinates from top-left origin to macOS screen coordinates (bottom-left origin)
+  // macOS screen coordinates: origin at bottom-left, y grows upward
+  // Our coordinates: origin at top-left, y grows downward
+  CGPoint top_left_point = CGPointMake(x, y);
+  NSPoint point = NSPointExt::bottomLeft(top_left_point);
 
   // Use dispatch to ensure menu popup happens on the main run loop
+  // Show the menu using screen coordinates (inView:nil)
   dispatch_async(dispatch_get_main_queue(), ^{
-    [pimpl_->ns_menu_ popUpMenuPositioningItem:nil atLocation:point inView:content_view];
+    @autoreleasepool {
+      [pimpl_->ns_menu_ popUpMenuPositioningItem:nil atLocation:point inView:nil];
+    }
   });
 
   return true;

src/platform/macos/window_macos.mm

@@ -151,6 +151,25 @@
   return size;
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  // Convert from topLeft coordinate system to bottom-left (macOS default)
+  NSRect topLeftRect = NSMakeRect(bounds.x, bounds.y, bounds.width, bounds.height);
+  NSRect contentRect = NSRectExt::bottomLeft(topLeftRect);
+
+  // Set the content view frame
+  NSRect frameRect = [pimpl_->ns_window_ frameRectForContentRect:contentRect];
+  [pimpl_->ns_window_ setFrame:frameRect display:YES];
+}
+
+Rectangle Window::GetContentBounds() const {
+  NSRect contentRect = [pimpl_->ns_window_ contentRectForFrameRect:[pimpl_->ns_window_ frame]];
+  // Convert from bottom-left (macOS default) to top-left coordinate system
+  CGPoint topLeft = NSRectExt::topLeft(contentRect);
+  Rectangle bounds = {topLeft.x, topLeft.y, static_cast<double>(contentRect.size.width),
+                      static_cast<double>(contentRect.size.height)};
+  return bounds;
+}
+
 void Window::SetMinimumSize(Size size) {
   [pimpl_->ns_window_ setMinSize:NSMakeSize(size.width, size.height)];
 }

src/platform/ohos/window_ohos.cpp

@@ -170,6 +170,16 @@ Size Window::GetContentSize() const {
   return GetSize();
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  // On OpenHarmony, content bounds is the same as window bounds
+  SetBounds(bounds);
+}
+
+Rectangle Window::GetContentBounds() const {
+  // On OpenHarmony, content bounds is the same as window bounds
+  return GetBounds();
+}
+
 void Window::SetMinimumSize(Size size) {
   // SetMinimumSize not fully supported on OpenHarmony
 }

src/platform/windows/window_windows.cpp

@@ -224,6 +224,54 @@ Size Window::GetContentSize() const {
   return size;
 }
 
+void Window::SetContentBounds(Rectangle bounds) {
+  if (pimpl_->hwnd_) {
+    RECT windowRect, clientRect;
+    GetWindowRect(pimpl_->hwnd_, &windowRect);
+    GetClientRect(pimpl_->hwnd_, &clientRect);
+
+    // Calculate the difference between window and client area
+    int borderWidth = (windowRect.right - windowRect.left) - clientRect.right;
+    int borderHeight = (windowRect.bottom - windowRect.top) - clientRect.bottom;
+
+    // Get current client area position in screen coordinates
+    POINT clientTopLeft = {0, 0};
+    ClientToScreen(pimpl_->hwnd_, &clientTopLeft);
+
+    // Calculate the offset from window top-left to client top-left
+    int offsetX = clientTopLeft.x - windowRect.left;
+    int offsetY = clientTopLeft.y - windowRect.top;
+
+    // Calculate window position so that client area is at bounds position
+    int windowX = static_cast<int>(bounds.x) - offsetX;
+    int windowY = static_cast<int>(bounds.y) - offsetY;
+    int windowWidth = static_cast<int>(bounds.width) + borderWidth;
+    int windowHeight = static_cast<int>(bounds.height) + borderHeight;
+
+    SetWindowPos(pimpl_->hwnd_, nullptr, windowX, windowY, windowWidth, windowHeight, SWP_NOZORDER);
+  }
+}
+
+Rectangle Window::GetContentBounds() const {
+  Rectangle bounds = {0, 0, 0, 0};
+  if (pimpl_->hwnd_) {
+    RECT clientRect;
+    GetClientRect(pimpl_->hwnd_, &clientRect);
+
+    // Convert client rect to screen coordinates
+    POINT topLeft = {clientRect.left, clientRect.top};
+    POINT bottomRight = {clientRect.right, clientRect.bottom};
+    ClientToScreen(pimpl_->hwnd_, &topLeft);
+    ClientToScreen(pimpl_->hwnd_, &bottomRight);
+
+    bounds.x = topLeft.x;
+    bounds.y = topLeft.y;
+    bounds.width = bottomRight.x - topLeft.x;
+    bounds.height = bottomRight.y - topLeft.y;
+  }
+  return bounds;
+}
+
 void Window::SetMinimumSize(Size size) {
   // Windows minimum size would be handled in WM_GETMINMAXINFO message
   // This is a placeholder implementation