Add native window system menus for custom title bars (#66)

Author: lijy91

src/capi/window_c.cpp

@@ -1346,6 +1346,29 @@ bool native_window_is_focusable(native_window_t window) {
   }
 }
 
+bool native_window_show_system_menu(native_window_t window, native_point_t position) {
+  auto self = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::Window>(window);
+  if (!self) {
+    return false;
+  }
+  try {
+    auto position_cpp = to_cpp_point(position);
+    return self->ShowSystemMenu(position_cpp);
+  } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_window_show_system_menu");
+    return false;
+  }
+}
+
+bool native_window_is_system_menu_supported(void) {
+  try {
+    return nativeapi::Window::IsSystemMenuSupported();
+  } catch (...) {
+    fprintf(stderr, "[nativeapi] %s: unexpected exception\n", "native_window_is_system_menu_supported");
+    return false;
+  }
+}
+
 void native_window_start_dragging(native_window_t window) {
   auto self = nativeapi::HandleTable::GetInstance().Resolve<nativeapi::Window>(window);
   if (!self) {

src/capi/window_c.h

@@ -414,6 +414,12 @@ void native_window_set_focusable(native_window_t window, bool is_focusable);
 FFI_PLUGIN_EXPORT
 bool native_window_is_focusable(native_window_t window);
 
+FFI_PLUGIN_EXPORT
+bool native_window_show_system_menu(native_window_t window, native_point_t position);
+
+FFI_PLUGIN_EXPORT
+bool native_window_is_system_menu_supported(void);
+
 FFI_PLUGIN_EXPORT
 void native_window_start_dragging(native_window_t window);
 

src/platform/android/window_android.cpp

@@ -446,6 +446,14 @@ bool Window::IsFocusable() const {
   return true;
 }
 
+bool Window::ShowSystemMenu(Point /*position*/) {
+  return false;
+}
+
+bool Window::IsSystemMenuSupported() {
+  return false;
+}
+
 void Window::StartDragging() {
   ALOGW("StartDragging not supported on Android");
 }

src/platform/ios/window_ios.mm

@@ -489,6 +489,14 @@
   return true;
 }
 
+bool Window::ShowSystemMenu(Point /*position*/) {
+  return false;
+}
+
+bool Window::IsSystemMenuSupported() {
+  return false;
+}
+
 void Window::StartDragging() {
   // Not applicable to iOS
 }

src/platform/linux/window_linux.cpp

@@ -110,6 +110,7 @@ struct Decorations {
 struct Layout {
   GdkRectangle frame = {};    // what the user sees as the window: title bar and content
   GdkRectangle content = {};  // the client area the application draws into
+  Point content_origin_in_surface = {};  // independent of global Wayland coordinates
 };
 
 // A window the window manager decorates is simple: its GdkWindow is the content and
@@ -168,6 +169,8 @@ static Layout GetLayout(GtkWidget* widget, GdkWindow* gdk_window) {
     }
     layout.frame = {origin_x + side, origin_y + shadow_top, width, height + title_height};
     layout.content = {origin_x + side, origin_y + shadow_top + title_height, width, height};
+    layout.content_origin_in_surface = {static_cast<double>(side),
+                                        static_cast<double>(shadow_top + title_height)};
 #ifdef GDK_WINDOWING_WAYLAND
     if (GDK_IS_WAYLAND_DISPLAY(gdk_window_get_display(gdk_window))) {
       layout.content.x -= layout.frame.x;
@@ -192,6 +195,7 @@ static Layout GetLayout(GtkWidget* widget, GdkWindow* gdk_window) {
 
   layout.content = {origin_x + child_x, origin_y + child_y, child_allocation.width,
                     child_allocation.height};
+  layout.content_origin_in_surface = {static_cast<double>(child_x), static_cast<double>(child_y)};
   // The frame is the content plus the title bar above it; the shadow is not part of it.
   gint frame_top = child_y;
   GtkWidget* titlebar = gtk_window_get_titlebar(GTK_WINDOW(widget));
@@ -466,7 +470,12 @@ class Window::Impl {
       : widget_(widget),
         gdk_window_(gdk_window),
         title_bar_style_(TitleBarStyle::Normal),
-        background_color_(Color::White) {}
+        background_color_(Color::White) {
+    if (widget_)
+      g_object_add_weak_pointer(G_OBJECT(widget_), reinterpret_cast<gpointer*>(&widget_));
+    if (gdk_window_)
+      g_object_add_weak_pointer(G_OBJECT(gdk_window_), reinterpret_cast<gpointer*>(&gdk_window_));
+  }
 
   ~Impl() {
     if (hints_refresh_source_) {
@@ -477,6 +486,10 @@ class Window::Impl {
       g_object_remove_weak_pointer(G_OBJECT(hints_widget_),
                                    reinterpret_cast<gpointer*>(&hints_widget_));
     }
+    if (gdk_window_)
+      g_object_remove_weak_pointer(G_OBJECT(gdk_window_), reinterpret_cast<gpointer*>(&gdk_window_));
+    if (widget_)
+      g_object_remove_weak_pointer(G_OBJECT(widget_), reinterpret_cast<gpointer*>(&widget_));
   }
 
   void ApplyGeometryHints() {
@@ -1666,6 +1679,64 @@ bool Window::IsFocusable() const {
   return AcceptsFocus(pimpl_->widget_, pimpl_->gdk_window_);
 }
 
+bool Window::ShowSystemMenu(Point position) {
+  // GTK can replace its surface when decorations are installed. Read the live
+  // widget's surface instead of keeping a menu request on the previous one.
+  GdkWindow* surface = pimpl_->widget_ ? gtk_widget_get_window(pimpl_->widget_) : pimpl_->gdk_window_;
+  if (!surface || gdk_window_is_destroyed(surface) || !gdk_window_is_viewable(surface) ||
+      gdk_window_get_window_type(surface) != GDK_WINDOW_TOPLEVEL ||
+      !std::isfinite(position.x) || !std::isfinite(position.y) || !IsSystemMenuSupported()) return false;
+  GdkDisplay* display = gdk_window_get_display(surface);
+  GdkSeat* seat = gdk_display_get_default_seat(display);
+  GdkDevice* pointer = seat ? gdk_seat_get_pointer(seat) : nullptr;
+  if (!pointer) return false;
+#ifdef GDK_WINDOWING_WAYLAND
+  if (GDK_IS_WAYLAND_DISPLAY(display)) {
+    GdkModifierType state = static_cast<GdkModifierType>(0);
+    gdk_window_get_device_position(surface, pointer, nullptr, nullptr, &state);
+    GdkWindow* under_pointer = gdk_device_get_window_at_position(pointer, nullptr, nullptr);
+    if (!under_pointer || gdk_window_get_effective_toplevel(under_pointer) != surface ||
+        !(state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK))) return false;
+  }
+#endif
+  const Layout layout = GetLayout(pimpl_->widget_, surface);
+  const double x = position.x + layout.content_origin_in_surface.x;
+  const double y = position.y + layout.content_origin_in_surface.y;
+  gint origin_x = 0, origin_y = 0;
+  gdk_window_get_origin(surface, &origin_x, &origin_y);
+  const int scale = gdk_window_get_scale_factor(surface);
+  if (std::abs((x + origin_x) * scale) > G_MAXINT ||
+      std::abs((y + origin_y) * scale) > G_MAXINT) return false;
+  GdkEvent* event = gdk_event_new(GDK_BUTTON_PRESS);
+  event->button.window = GDK_WINDOW(g_object_ref(surface));
+  event->button.time = gtk_get_current_event_time();
+  event->button.button = GDK_BUTTON_SECONDARY;
+  event->button.x = x;
+  event->button.y = y;
+  event->button.x_root = x + origin_x;
+  event->button.y_root = y + origin_y;
+  gdk_event_set_device(event, pointer);
+  gdk_event_set_source_device(event, pointer);
+  const bool accepted = gdk_window_show_window_menu(surface, event);
+  gdk_event_free(event);
+  return accepted;
+}
+
+bool Window::IsSystemMenuSupported() {
+  GdkDisplay* display = gdk_display_get_default();
+  if (!display) return false;
+#ifdef GDK_WINDOWING_X11
+  if (GDK_IS_X11_DISPLAY(display)) {
+    return gdk_x11_screen_supports_net_wm_hint(gdk_display_get_default_screen(display),
+                                              gdk_atom_intern_static_string("_GTK_SHOW_WINDOW_MENU"));
+  }
+#endif
+#ifdef GDK_WINDOWING_WAYLAND
+  if (GDK_IS_WAYLAND_DISPLAY(display)) return true;
+#endif
+  return false;
+}
+
 void Window::StartDragging() {
   if (!pimpl_->gdk_window_) {
     return;

src/platform/macos/window_macos.mm

@@ -1051,6 +1051,14 @@ static void NativeApiSendMouseUp(NSWindow* window, NSEvent* mouse_up) {
   [window sendEvent:mouse_up];
 }
 
+bool Window::ShowSystemMenu(Point /*position*/) {
+  return false;
+}
+
+bool Window::IsSystemMenuSupported() {
+  return false;
+}
+
 void Window::StartDragging() {
   NSWindow* window = pimpl_->ns_window_;
   NSEvent* event = window.currentEvent;

src/platform/ohos/window_ohos.cpp

@@ -430,6 +430,14 @@ bool Window::IsFocusable() const {
   return true;
 }
 
+bool Window::ShowSystemMenu(Point /*position*/) {
+  return false;
+}
+
+bool Window::IsSystemMenuSupported() {
+  return false;
+}
+
 void Window::StartDragging() {
   // StartDragging not supported on OpenHarmony
 }

src/platform/windows/window_windows.cpp

@@ -2021,6 +2021,65 @@ static void StartSystemFrameDrag(HWND hwnd, WPARAM hit_test) {
   PostMessage(hwnd, WM_NCLBUTTONDOWN, hit_test, MAKELPARAM(cursor.x, cursor.y));
 }
 
+namespace {
+struct SystemMenuSession {
+  HMENU menu;
+  bool initialized = false;
+};
+
+LRESULT CALLBACK ObserveSystemMenu(HWND hwnd, UINT message, WPARAM wp, LPARAM lp,
+                                  UINT_PTR, DWORD_PTR data) {
+  auto* session = reinterpret_cast<SystemMenuSession*>(data);
+  if (message == WM_INITMENUPOPUP && reinterpret_cast<HMENU>(wp) == session->menu)
+    session->initialized = true;
+  return DefSubclassProc(hwnd, message, wp, lp);
+}
+}  // namespace
+
+bool Window::ShowSystemMenu(Point position) {
+  HWND hwnd = pimpl_->hwnd_;
+  if (!IsWindow(hwnd) || !IsWindowVisible(hwnd) ||
+      (GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_CHILD) ||
+      !std::isfinite(position.x) || !std::isfinite(position.y)) return false;
+  HMENU menu = GetSystemMenu(hwnd, FALSE);
+  if (!menu || !(GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_SYSMENU)) return false;
+  POINT origin = {};
+  if (!ClientToScreen(hwnd, &origin)) return false;
+  const double scale = GetScaleFactorForWindow(hwnd);
+  const double x = origin.x + position.x * scale, y = origin.y + position.y * scale;
+  if (x < LONG_MIN || x > LONG_MAX || y < LONG_MIN || y > LONG_MAX) return false;
+  const bool minimized = IsIconic(hwnd), maximized = IsZoomed(hwnd), full_screen = IsFullScreen();
+  auto enable = [menu](UINT command, bool enabled) {
+    EnableMenuItem(menu, command, MF_BYCOMMAND | (enabled ? MF_ENABLED : MF_GRAYED));
+  };
+  enable(SC_RESTORE, minimized || maximized || full_screen);
+  enable(SC_MOVE, !maximized && !full_screen && IsMovable());
+  enable(SC_SIZE, !minimized && !maximized && !full_screen && IsResizable());
+  enable(SC_MINIMIZE, !minimized && !full_screen && IsMinimizable());
+  enable(SC_MAXIMIZE, !maximized && !full_screen && IsMaximizable());
+  // Keep the host's SC_CLOSE state and any custom items. GetSystemMenu(hwnd,
+  // TRUE) would discard them, so never reset or destroy the native menu.
+  SystemMenuSession session{menu};
+  const UINT_PTR observer_id = reinterpret_cast<UINT_PTR>(&session);
+  if (!SetWindowSubclass(hwnd, ObserveSystemMenu, observer_id,
+                          reinterpret_cast<DWORD_PTR>(&session))) return false;
+  const UINT command = TrackPopupMenuEx(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON,
+                                       static_cast<int>(std::lround(x)),
+                                       static_cast<int>(std::lround(y)), hwnd, nullptr);
+  if (IsWindow(hwnd)) RemoveWindowSubclass(hwnd, ObserveSystemMenu, observer_id);
+  if (command && IsWindow(hwnd)) {
+    if (command == SC_RESTORE && full_screen) SetFullScreen(false);
+    else PostMessageW(hwnd, WM_SYSCOMMAND, command, 0);
+  }
+  // With TPM_RETURNCMD, zero means both cancellation and failure. LastError
+  // is not reliable across the host callbacks in the nested menu loop.
+  return command != 0 || session.initialized;
+}
+
+bool Window::IsSystemMenuSupported() {
+  return true;
+}
+
 void Window::StartDragging() {
   if (pimpl_->hwnd_) {
     StartSystemFrameDrag(pimpl_->hwnd_, HTCAPTION);

src/window.h

@@ -1333,6 +1333,39 @@ class Window : public NativeObjectProvider, public std::enable_shared_from_this<
 
   // === User Interaction ===
 
+  /**
+   * @brief Shows the native window menu at a content-relative position.
+   * @param position Logical pixels from the top-left of the content area.
+   *        The operating system may reposition the menu to fit the display.
+   * @return true if the menu was displayed or the window manager accepted the
+   *         request, including cancellation; false if unsupported or rejected.
+   *
+   * Use this from a secondary-button press in a custom title bar. Windows runs
+   * a nested native menu loop until selection or cancellation; selected items
+   * are delivered as system window commands. Linux asks the window manager to
+   * show its own menu. Its contents and actions remain the manager's choice.
+   *
+   * @note Platform availability:
+   * - macOS: ❌ No equivalent - Always returns false
+   * - Windows: ✅ Native system menu with current restore/move/size/minimize/
+   *   maximize states. Requires a visible top-level window with a system menu.
+   * - Linux: ⚠️ X11 requires the _GTK_SHOW_WINDOW_MENU window-manager hint;
+   *   Wayland requires an active pointer button press in this window, and the
+   *   compositor may ignore the request. No GTK fallback menu is substituted.
+   * - Android: ❌ Not applicable - Always returns false
+   * - iOS: ❌ Not applicable - Always returns false
+   * - OpenHarmony: ❌ Not applicable - Always returns false
+   */
+  bool ShowSystemMenu(Point position);
+
+  /**
+   * @brief Checks if the active platform can request a native window menu.
+   * @return true on Windows, supported X11 managers, or Wayland; false elsewhere.
+   *         A particular window or input gesture may still be rejected.
+   * @see ShowSystemMenu() for platform availability.
+   */
+  static bool IsSystemMenuSupported();
+
   /**
    * @brief Initiates a user drag operation for moving the window.
    *

tests/CMakeLists.txt

@@ -35,6 +35,9 @@ add_test(NAME window_shadow_blur_test COMMAND window_shadow_blur_test)
 
 if(APPLE AND NOT CMAKE_SYSTEM_NAME STREQUAL "iOS")
   enable_language(OBJCXX)
+  add_executable(window_system_menu_unsupported_test window_system_menu_unsupported_test.cpp)
+  target_link_libraries(window_system_menu_unsupported_test PRIVATE nativeapi)
+  add_test(NAME window_system_menu_unsupported_test COMMAND window_system_menu_unsupported_test)
   add_executable(window_shape_macos_test window_shape_macos_test.mm)
   target_link_libraries(window_shape_macos_test PRIVATE nativeapi)
   add_test(NAME window_shape_macos_test COMMAND window_shape_macos_test)
@@ -120,6 +123,8 @@ if(WIN32 AND NATIVEAPI_ENABLE_WINUI3)
 endif()
 
 if(WIN32)
+  add_executable(window_system_menu_windows_test window_system_menu_windows_test.cpp)
+  target_link_libraries(window_system_menu_windows_test PRIVATE nativeapi)
   # Explicit desktop regression; captures only a pixel inside its own windows.
   add_executable(window_content_protection_windows_test window_content_protection_windows_test.cpp)
   target_link_libraries(window_content_protection_windows_test PRIVATE nativeapi)
@@ -151,6 +156,9 @@ endif()
 
 # Explicit desktop integration test; requires a running window manager.
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+  # Explicit integration in a private Xvfb session or Wayland negative path.
+  add_executable(window_system_menu_linux_test window_system_menu_linux_test.cpp)
+  target_link_libraries(window_system_menu_linux_test PRIVATE nativeapi)
   add_executable(window_size_constraints_linux_test window_size_constraints_linux_test.cpp)
   target_link_libraries(window_size_constraints_linux_test PRIVATE nativeapi)
 endif()