add linux support for ShowSystemMenu

Wing-summer · Wing-summer · commit 8678773aaa3c · 2025-12-02T08:54:43.000+08:00
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
@@ -66,6 +66,17 @@ else()
             contexts/qtwindowcontext_p.h
             contexts/qtwindowcontext.cpp
         )
+
+        if(LINUX)
+            list(APPEND _src
+                contexts/linuxdesktopenvapi.h
+                contexts/linuxdesktopenvapi.cpp
+                contexts/linuxx11context_p.h
+                contexts/linuxx11context.cpp
+                contexts/linuxwaylandcontext_p.h
+                contexts/linuxwaylandcontext.cpp
+            )
+        endif()
     endif()
 endif()
 
@@ -101,4 +112,4 @@ qwk_add_library(${PROJECT_NAME} AUTOGEN
 )
 
 set(QWINDOWKIT_ENABLED_TARGETS ${QWINDOWKIT_ENABLED_TARGETS} ${PROJECT_NAME} PARENT_SCOPE)
-set(QWINDOWKIT_ENABLED_SUBDIRECTORIES ${QWINDOWKIT_ENABLED_SUBDIRECTORIES} core PARENT_SCOPE)
+set(QWINDOWKIT_ENABLED_SUBDIRECTORIES ${QWINDOWKIT_ENABLED_SUBDIRECTORIES} core PARENT_SCOPE)
diff --git a/src/core/contexts/abstractwindowcontext.cpp b/src/core/contexts/abstractwindowcontext.cpp
@@ -126,7 +126,7 @@ namespace QWK {
             return false;
         }
 
-        for (auto item : m_hitTestVisibleItems) {
+        for (const auto &item : m_hitTestVisibleItems) {
             if (item && m_delegate->isVisible(item) &&
                 m_delegate->mapGeometryToScene(item).contains(pos)) {
                 return false;
diff --git a/src/core/contexts/linuxdesktopenvapi.cpp b/src/core/contexts/linuxdesktopenvapi.cpp
@@ -0,0 +1,76 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+#include "linuxdesktopenvapi.h"
+
+#include <QString>
+#include <QGuiApplication>
+#include <QLibrary>
+
+namespace QWK {
+
+    bool LinuxDesktopEnvAPI::isWaylandPlatform() {
+        static const bool isWayland = QGuiApplication::platformName().startsWith(
+            QStringLiteral("wayland"), Qt::CaseInsensitive);
+        return isWayland;
+    }
+
+    bool LinuxDesktopEnvAPI::isX11Platform() {
+        static const bool isX11 =
+            QGuiApplication::platformName().startsWith(QStringLiteral("xcb"), Qt::CaseInsensitive);
+        return isX11;
+    }
+
+    LinuxX11API &QWK::LinuxDesktopEnvAPI::x11API() {
+        static LinuxX11API api;
+        if (!api.isValid() && isX11Platform()) {
+            QString libName = QStringLiteral(
+#if defined(__CYGWIN__)
+                "libX11-6.so"
+#elif defined(__OpenBSD__) || defined(__NetBSD__)
+                "libX11.so"
+#else
+                "libX11.so.6"
+#endif
+            );
+            QLibrary x11lib(libName);
+            if (x11lib.load()) {
+                api.XInternAtom =
+                    reinterpret_cast<LinuxX11API::XInternAtomFn>(x11lib.resolve("XInternAtom"));
+                api.XSendEvent =
+                    reinterpret_cast<LinuxX11API::XSendEventFn>(x11lib.resolve("XSendEvent"));
+                api.XFlush = reinterpret_cast<LinuxX11API::XFlushFn>(x11lib.resolve("XFlush"));
+            }
+        }
+        return api;
+    }
+
+    LinuxWaylandAPI &LinuxDesktopEnvAPI::waylandAPI() {
+        static LinuxWaylandAPI api;
+        if (!api.isValid() && isWaylandPlatform()) {
+            QLibrary waylib(QStringLiteral("libwayland-client.so"));
+            bool loaded = false;
+            if (waylib.load()) {
+                loaded = true;
+            } else {
+                waylib.setFileName(QStringLiteral("libwayland-client.so.0"));
+                if (waylib.load()) {
+                    loaded = true;
+                }
+            }
+
+            if (loaded) {
+                api.wl_display_flush = reinterpret_cast<LinuxWaylandAPI::wl_display_flush_fn>(
+                    waylib.resolve("wl_display_flush"));
+                api.wl_proxy_marshal_flags =
+                    reinterpret_cast<LinuxWaylandAPI::wl_proxy_marshal_flags_fn>(
+                        waylib.resolve("wl_proxy_marshal_flags"));
+                api.wl_proxy_get_version =
+                    reinterpret_cast<LinuxWaylandAPI::wl_proxy_get_version_fn>(
+                        waylib.resolve("wl_proxy_get_version"));
+            }
+        }
+        return api;
+    }
+}
diff --git a/src/core/contexts/linuxdesktopenvapi.h b/src/core/contexts/linuxdesktopenvapi.h
@@ -0,0 +1,72 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef LINUXDESKTOPENVAPI_H
+#define LINUXDESKTOPENVAPI_H
+
+//
+//  W A R N I N G !!!
+//  -----------------
+//
+// This file is not part of the QWindowKit API. It is used purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or may even be removed.
+//
+
+#include "qguiapplication_platform.h"
+
+// some declarations about x11
+using Atom = unsigned long;
+using Bool = int;
+using XID = unsigned long;
+using Window = XID;
+
+union _XEvent;
+using XEvent = union _XEvent;
+
+namespace QWK {
+    struct LinuxX11API {
+        using XInternAtomFn = Atom (*)(Display *, const char *, Bool);
+        using XSendEventFn = int (*)(Display *, Window, Bool, long, XEvent *);
+        using XFlushFn = int (*)(Display *);
+
+        XInternAtomFn XInternAtom = nullptr;
+        XSendEventFn XSendEvent = nullptr;
+        XFlushFn XFlush = nullptr;
+
+        inline bool isValid() const {
+            return XInternAtom && XSendEvent && XFlush;
+        }
+    };
+
+    struct LinuxWaylandAPI {
+        using wl_display_flush_fn = int (*)(struct wl_display *);
+        using wl_proxy_marshal_flags_fn = void (*)(struct wl_proxy *, uint32_t,
+                                                   const struct wl_interface *, uint32_t, uint32_t,
+                                                   ...);
+        using wl_proxy_get_version_fn = int (*)(struct wl_proxy *);
+
+        wl_display_flush_fn wl_display_flush = nullptr;
+        wl_proxy_marshal_flags_fn wl_proxy_marshal_flags = nullptr;
+        wl_proxy_get_version_fn wl_proxy_get_version = nullptr;
+
+        inline bool isValid() const {
+            return wl_display_flush && wl_proxy_marshal_flags && wl_proxy_get_version;
+        }
+    };
+
+
+    class LinuxDesktopEnvAPI {
+    public:
+        static bool isWaylandPlatform();
+
+        static bool isX11Platform();
+
+    public:
+        static LinuxX11API &x11API();
+        static LinuxWaylandAPI &waylandAPI();
+    };
+}
+
+#endif // LINUXDESKTOPENVAPI_H
diff --git a/src/core/contexts/linuxwaylandcontext.cpp b/src/core/contexts/linuxwaylandcontext.cpp
@@ -0,0 +1,64 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+#include "linuxwaylandcontext_p.h"
+
+#include "linuxdesktopenvapi.h"
+
+#include <QtGui/qpa/qplatformnativeinterface.h>
+
+namespace QWK {
+    static inline void xdg_toplevel_show_window_menu(struct xdg_toplevel *xdg_toplevel,
+                                                     struct wl_seat *seat, uint32_t serial,
+                                                     int32_t x, int32_t y) {
+        constexpr auto XDG_TOPLEVEL_SHOW_WINDOW_MENU = 4;
+        auto &api = LinuxDesktopEnvAPI::waylandAPI();
+        Q_ASSERT(api.isValid());
+        api.wl_proxy_marshal_flags((struct wl_proxy *) xdg_toplevel, XDG_TOPLEVEL_SHOW_WINDOW_MENU,
+                                   NULL, api.wl_proxy_get_version((struct wl_proxy *) xdg_toplevel),
+                                   0, seat, serial, x, y);
+    }
+
+    LinuxWaylandContext::LinuxWaylandContext() : QtWindowContext() {
+    }
+
+    LinuxWaylandContext::~LinuxWaylandContext() = default;
+
+    QString LinuxWaylandContext::key() const {
+        return QStringLiteral("wayland");
+    }
+
+    void LinuxWaylandContext::virtual_hook(int id, void *data) {
+        if (id == ShowSystemMenuHook) {
+            auto *native = QGuiApplication::platformNativeInterface();
+            auto *waylandApp = qApp->nativeInterface<QNativeInterface::QWaylandApplication>();
+            if (!waylandApp) {
+                return;
+            }
+            uint serial = waylandApp->lastInputSerial();
+            wl_seat *seat = waylandApp->lastInputSeat();
+            if (serial == 0 || !seat) {
+                return;
+            }
+            void *rawToplevel = native->nativeResourceForWindow("xdg_toplevel", m_windowHandle);
+            if (!rawToplevel) {
+                return;
+            }
+            xdg_toplevel *toplevel = static_cast<xdg_toplevel *>(rawToplevel);
+            auto pos = static_cast<QPoint *>(data);
+            int lx = pos->x();
+            int ly = pos->y();
+            xdg_toplevel_show_window_menu(toplevel, seat, serial, lx, ly);
+
+            wl_display *d = waylandApp->display();
+            if (d) {
+                auto &api = LinuxDesktopEnvAPI::waylandAPI();
+                Q_ASSERT(api.isValid());
+                api.wl_display_flush(d);
+            }
+        } else {
+            QtWindowContext::virtual_hook(id, data);
+        }
+    }
+}
diff --git a/src/core/contexts/linuxwaylandcontext_p.h b/src/core/contexts/linuxwaylandcontext_p.h
@@ -0,0 +1,35 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef LINUXWAYLANDCONTEXT_P_H
+#define LINUXWAYLANDCONTEXT_P_H
+
+//
+//  W A R N I N G !!!
+//  -----------------
+//
+// This file is not part of the QWindowKit API. It is used purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or may even be removed.
+//
+
+
+#include "qtwindowcontext_p.h"
+
+namespace QWK {
+
+    class LinuxWaylandContext : public QtWindowContext {
+        Q_OBJECT
+    public:
+        LinuxWaylandContext();
+        ~LinuxWaylandContext() override;
+
+        QString key() const override;
+        void virtual_hook(int id, void *data) override;
+    };
+
+}
+
+#endif // LINUXWAYLANDCONTEXT_P_H
diff --git a/src/core/contexts/linuxx11context.cpp b/src/core/contexts/linuxx11context.cpp
@@ -0,0 +1,70 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+
+#include "linuxx11context_p.h"
+
+#include "linuxdesktopenvapi.h"
+
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+
+namespace QWK {
+
+    LinuxX11Context::LinuxX11Context() : QtWindowContext() {
+    }
+
+    LinuxX11Context::~LinuxX11Context() = default;
+
+    QString LinuxX11Context::key() const {
+        return QStringLiteral("xcb");
+    }
+
+    void LinuxX11Context::virtual_hook(int id, void *data) {
+        if (id == ShowSystemMenuHook) {
+            auto *x11app = qApp->nativeInterface<QNativeInterface::QX11Application>();
+            if (!x11app) {
+                return;
+            }
+
+            auto display = x11app->display();
+            if (!display) {
+                return;
+            }
+
+            auto api = LinuxDesktopEnvAPI::x11API();
+            Q_ASSERT(api.isValid());
+
+            // use window id (XID)
+            Window xwin = static_cast<Window>(m_windowId);
+            Atom atom = api.XInternAtom(display, "_GTK_SHOW_WINDOW_MENU", False);
+            if (atom == None)
+                return; // WM might not support this atom
+            auto pos = static_cast<QPoint *>(data);
+            XEvent ev;
+            memset(&ev, 0, sizeof(ev));
+            ev.xclient.type = ClientMessage;
+            ev.xclient.window = xwin;
+            ev.xclient.message_type = atom;
+            ev.xclient.format = 32;
+
+            QScreen *screen = QGuiApplication::screenAt(*pos);
+            qreal dpr = screen ? screen->devicePixelRatio() : m_windowHandle->devicePixelRatio();
+            int root_x = qRound(pos->x() * dpr);
+            int root_y = qRound(pos->y() * dpr);
+
+            ev.xclient.data.l[0] = 3;
+            ev.xclient.data.l[1] = root_x;
+            ev.xclient.data.l[2] = root_y;
+            ev.xclient.data.l[3] = 0;
+
+            Window root = DefaultRootWindow(display);
+            api.XSendEvent(display, root, False, SubstructureRedirectMask | SubstructureNotifyMask,
+                           &ev);
+            api.XFlush(display);
+        } else {
+            QtWindowContext::virtual_hook(id, data);
+        }
+    }
+}
diff --git a/src/core/contexts/linuxx11context_p.h b/src/core/contexts/linuxx11context_p.h
@@ -0,0 +1,33 @@
+// Copyright (C) 2023-2024 Stdware Collections (https://www.github.com/stdware)
+// Copyright (C) 2021-2023 wangwenx190 (Yuhang Zhao)
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef LINUXX11CONTEXT_P_H
+#define LINUXX11CONTEXT_P_H
+
+//
+//  W A R N I N G !!!
+//  -----------------
+//
+// This file is not part of the QWindowKit API. It is used purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or may even be removed.
+//
+
+#include "qtwindowcontext_p.h"
+
+namespace QWK {
+
+    class LinuxX11Context : public QtWindowContext {
+        Q_OBJECT
+    public:
+        LinuxX11Context();
+        ~LinuxX11Context() override;
+
+        QString key() const override;
+        void virtual_hook(int id, void *data) override;
+    };
+
+}
+
+#endif // LINUXX11CONTEXT_P_H
diff --git a/src/core/contexts/qtwindowcontext.cpp b/src/core/contexts/qtwindowcontext.cpp
diff --git a/src/core/windowagentbase.cpp b/src/core/windowagentbase.cpp

Original file line number	Diff line number	Diff line change
`@@ -126,7 +126,7 @@ namespace QWK {`
`126`	`126`	`return false;`
`127`	`127`	`}`
`128`	`128`
`129`		`- for (auto item : m_hitTestVisibleItems) {`
	`129`	`+ for (const auto &item : m_hitTestVisibleItems) {`
`130`	`130`	`if (item && m_delegate->isVisible(item) &&`
`131`	`131`	`m_delegate->mapGeometryToScene(item).contains(pos)) {`
`132`	`132`	`return false;`