feat: support move xembed window on treeland

通过 treeland 提供的 API 移动 xembed 窗口

Log:

Author: BLumia

panels/dock/DockCompositor.qml

@@ -113,6 +113,18 @@ Item {
                 console.log("quick panel closed")
                 dockCompositor.popupClosed()
             }
+            
+            onMoveXEmbedWindowRequested: (wid, pluginId, itemKey, dx, dy) => {
+                console.log("move xembed window requested:", wid, pluginId, itemKey, dx, dy)
+                // Delegate to Panel which has access to WaylandDockHelper
+                if (Panel && typeof Panel.moveXEmbedWindow === 'function') {
+                    var success = Panel.moveXEmbedWindow(wid, dx, dy)
+                    pluginManager.notifyXEmbedWindowMoveResult(success)
+                } else {
+                    console.warn("Panel.moveXEmbedWindow not available")
+                    pluginManager.notifyXEmbedWindowMoveResult(false)
+                }
+            }
         }
 
         PluginScaleManager{

panels/dock/dockhelper.h

@@ -21,6 +21,9 @@ class DockHelper : public QObject
 
     void enterScreen(QScreen *screen);
     void leaveScreen();
+    
+    // Move XEmbed window relative to dock surface (no-op on X11)
+    virtual bool moveXEmbedWindow(uint32_t wid, double dx, double dy) { return false; }
 
 Q_SIGNALS:
     void isWindowOverlapChanged(bool overlap);

panels/dock/dockpanel.cpp

@@ -481,6 +481,14 @@ void DockPanel::setIsResizing(bool resizing)
     m_isResizing = resizing;
     emit isResizingChanged(m_isResizing);
 }
+
+bool DockPanel::moveXEmbedWindow(uint32_t wid, double dx, double dy)
+{
+    if (m_helper) {
+        return m_helper->moveXEmbedWindow(wid, dx, dy);
+    }
+    return false;
+}
 }
 
 #include "dockpanel.moc"

panels/dock/dockpanel.h

@@ -83,6 +83,9 @@ class DockPanel : public DS_NAMESPACE::DPanel, public QDBusContext
     Q_INVOKABLE void openDockSettings() const;
 
     Q_INVOKABLE void notifyDockPositionChanged(int offsetX, int offsetY);
+    
+    // Move XEmbed window relative to dock surface (Wayland only)
+    Q_INVOKABLE bool moveXEmbedWindow(uint32_t wid, double dx, double dy);
 
     bool showInPrimary() const;
     void setShowInPrimary(bool newShowInPrimary);

panels/dock/pluginmanagerextension.cpp

@@ -10,6 +10,7 @@
 #include <DPlatformTheme>
 
 #include <cstdint>
+#include <wayland-server-core.h>
 
 #include <QtWaylandCompositor/QWaylandSurface>
 #include <QtWaylandCompositor/QWaylandResource>
@@ -254,9 +255,15 @@ bool PluginSurface::isItemActive() const
 
 void PluginSurface::updatePluginGeometry(const QRect &geometry)
 {
+    m_itemPosition = geometry.topLeft();
     send_geometry(geometry.x(), geometry.y(), geometry.width(), geometry.height());
 }
 
+QPoint PluginSurface::itemPosition() const
+{
+    return m_itemPosition;
+}
+
 void PluginSurface::plugin_mouse_event(QtWaylandServer::plugin::Resource *resource, int32_t type)
 {
     Q_UNUSED(resource)
@@ -673,6 +680,43 @@ void PluginManager::plugin_manager_v1_create_popup_at(Resource *resource, const
     Q_EMIT pluginPopupCreated(plugin);
 }
 
+void PluginManager::plugin_manager_v1_move_xembed_window(Resource *resource, uint32_t xembed_winid, const QString &plugin_id, const QString &item_key, uint32_t callback)
+{
+    Q_UNUSED(resource)
+    qInfo() << "server pluginManager receive move_xembed_window:" << xembed_winid << plugin_id << item_key;
+    
+    // Look up the plugin surface to get its position relative to the dock window
+    double dx = 0.0, dy = 0.0;
+    PluginSurface *pluginSurface = findPluginSurface(plugin_id, item_key);
+    if (pluginSurface) {
+        dx = pluginSurface->itemPosition().x();
+        dy = pluginSurface->itemPosition().y();
+    } else {
+        qWarning() << "move_xembed_window: plugin surface not found for" << plugin_id << item_key;
+    }
+    
+    // Store pending callback for later response
+    m_pendingXEmbedCallback = callback;
+    m_pendingXEmbedClient = resource->client();
+    
+    // Emit signal with position info for QML to handle
+    Q_EMIT moveXEmbedWindowRequested(xembed_winid, plugin_id, item_key, dx, dy);
+}
+
+void PluginManager::notifyXEmbedWindowMoveResult(bool success)
+{
+    if (m_pendingXEmbedCallback > 0 && m_pendingXEmbedClient) {
+        wl_resource *callbackResource = wl_resource_create(m_pendingXEmbedClient, &wl_callback_interface, 
+                                                           1, m_pendingXEmbedCallback);
+        if (callbackResource) {
+            wl_callback_send_done(callbackResource, success ? 0 : 1);
+            wl_resource_destroy(callbackResource);
+        }
+    }
+    m_pendingXEmbedCallback = 0;
+    m_pendingXEmbedClient = nullptr;
+}
+
 QJsonObject PluginManager::getRootObj(const QString &jsonStr) {
     QJsonParseError jsonParseError;
     const QJsonDocument &resultDoc = QJsonDocument::fromJson(jsonStr.toLocal8Bit(), &jsonParseError);
@@ -757,6 +801,16 @@ void PluginManager::onActiveColorChanged()
     });
 }
 
+PluginSurface* PluginManager::findPluginSurface(const QString &pluginId, const QString &itemKey) const
+{
+    for (PluginSurface *plugin : m_pluginSurfaces) {
+        if (plugin->pluginId() == pluginId && plugin->itemKey() == itemKey) {
+            return plugin;
+        }
+    }
+    return nullptr;
+}
+
 void PluginManager::onThemeChanged()
 {
     foreachPluginSurface([this](Resource *source) {

panels/dock/pluginmanagerextension_p.h

@@ -65,6 +65,10 @@ class PluginManager : public QWaylandCompositorExtensionTemplate<PluginManager>,
 
     Q_INVOKABLE void updateDockOverflowState(int state);
     Q_INVOKABLE void setPopupMinHeight(int height);
+    
+    // Called from QML when moveXEmbedWindowRequested is handled
+    // result: true = success, false = error
+    Q_INVOKABLE void notifyXEmbedWindowMoveResult(bool result);
 
     uint32_t dockPosition() const;
     void setDockPosition(uint32_t dockPosition);
@@ -92,6 +96,9 @@ class PluginManager : public QWaylandCompositorExtensionTemplate<PluginManager>,
     void messageRequest(PluginSurface *, const QString &msg);
     void dockSizeChanged();
     void requestShutdown(const QString &type);
+    // Signal emitted when XEmbed window move is requested
+    // Parameters: wid (window ID), pluginId, itemKey, dx (relative x offset), dy (relative y offset)
+    void moveXEmbedWindowRequested(uint32_t wid, const QString &pluginId, const QString &itemKey, double dx, double dy);
 
 private Q_SLOTS:
     void onFontChanged();
@@ -103,6 +110,7 @@ private Q_SLOTS:
     virtual void plugin_manager_v1_request_message(Resource *resource, const QString &plugin_id, const QString &item_key, const QString &msg) override;
     virtual void plugin_manager_v1_create_popup_at(Resource *resource, const QString &plugin_id, const QString &item_key, int32_t type, int32_t x, int32_t y, struct ::wl_resource *surface, uint32_t id) override;
     virtual void plugin_manager_v1_create_plugin(Resource *resource, const QString &plugin_id, const QString &item_key, const QString &display_name, int32_t plugin_flags, int32_t type, int32_t size_policy, struct ::wl_resource *surface, uint32_t id) override;
+    virtual void plugin_manager_v1_move_xembed_window(Resource *resource, uint32_t xembed_winid, const QString &plugin_id, const QString &item_key, uint32_t callback) override;
 
 private:
     static QJsonObject getRootObj(const QString &jsonStr);
@@ -113,6 +121,7 @@ private Q_SLOTS:
     QString popupMinHeightMsg() const;
     using PluginSurfaceCallback = std::function<void(Resource *)>;
     void foreachPluginSurface(PluginSurfaceCallback callback);
+    PluginSurface* findPluginSurface(const QString &pluginId, const QString &itemKey) const;
 
 private:
     QList<PluginSurface*> m_pluginSurfaces;
@@ -121,6 +130,10 @@ private Q_SLOTS:
     uint32_t m_dockColorTheme = 0;
     QSize m_dockSize;
     int m_popupMinHeight = 0;
+    
+    // For pending XEmbed callback response
+    uint32_t m_pendingXEmbedCallback = 0;
+    struct ::wl_client *m_pendingXEmbedClient = nullptr;
 };
 
 class PluginSurface : public QWaylandShellSurfaceTemplate<PluginSurface>, public QtWaylandServer::plugin
@@ -173,6 +186,9 @@ class PluginSurface : public QWaylandShellSurfaceTemplate<PluginSurface>, public
     Q_INVOKABLE void updatePluginGeometry(const QRect &geometry);
     Q_INVOKABLE void setGlobalPos(const QPoint &pos);
 
+    // Position relative to the dock window, set from QML via updatePluginGeometry
+    QPoint itemPosition() const;
+
     int margins() const;
     void setMargins(int newMargins);
 
@@ -211,6 +227,7 @@ class PluginSurface : public QWaylandShellSurfaceTemplate<PluginSurface>, public
     int m_margins = 0;
     int m_height;
     int m_width;
+    QPoint m_itemPosition; // Position relative to dock window, for XEmbed window positioning
 };
 
 class PluginPopup : public QWaylandShellSurfaceTemplate<PluginPopup>, public QtWaylandServer::plugin_popup

panels/dock/waylanddockhelper.cpp

@@ -28,6 +28,14 @@ WaylandDockHelper::WaylandDockHelper(DockPanel *panel)
     if (auto applet = bridge.applet()) {
         connect(applet, SIGNAL(windowFullscreenChanged(bool)), this, SLOT(setCurrentActiveWindowFullscreened(bool)));
     }
+    
+    // Store dock window's wl_surface for XEmbed window positioning
+    if (m_panel->window()) {
+        auto waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(m_panel->window()->handle());
+        if (waylandWindow) {
+            m_dockWlSurface = waylandWindow->waylandSurface()->object();
+        }
+    }
 
     connect(m_panel, &DockPanel::rootObjectChanged, this, [this]() {
         m_wallpaperColorManager->watchScreen(dockScreenName());
@@ -144,6 +152,27 @@ void WaylandDockHelper::setDockColorTheme(const ColorTheme &theme)
     m_panel->setColorTheme(theme);
 }
 
+bool WaylandDockHelper::moveXEmbedWindow(uint32_t wid, double dx, double dy)
+{
+    // Update dock wl_surface if needed
+    if (!m_dockWlSurface && m_panel->window()) {
+        auto waylandWindow = dynamic_cast<QtWaylandClient::QWaylandWindow*>(m_panel->window()->handle());
+        if (waylandWindow && waylandWindow->waylandSurface()) {
+            m_dockWlSurface = waylandWindow->waylandSurface()->object();
+        }
+    }
+    
+    if (!m_ddeShellManager || !m_ddeShellManager->isActive() || !m_dockWlSurface) {
+        qWarning() << "WaylandDockHelper::moveXEmbedWindow: not ready, manager active:" 
+                   << (m_ddeShellManager && m_ddeShellManager->isActive())
+                   << "surface:" << (m_dockWlSurface != nullptr);
+        return false;
+    }
+    
+    m_ddeShellManager->setXWindowPositionRelative(wid, m_dockWlSurface, dx, dy);
+    return true;
+}
+
 WallpaperColorManager::WallpaperColorManager(WaylandDockHelper *helper)
     : QWaylandClientExtensionTemplate<WallpaperColorManager>(treeland_wallpaper_color_manager_v1_interface.version)
     , m_helper(helper)
@@ -169,6 +198,14 @@ TreeLandDDEShellManager::TreeLandDDEShellManager()
 {
 }
 
+struct ::wl_callback *TreeLandDDEShellManager::setXWindowPositionRelative(uint32_t wid, struct ::wl_surface *anchor, double dx, double dy)
+{
+    if (!isActive()) {
+        return nullptr;
+    }
+    return QtWayland::treeland_dde_shell_manager_v1::set_xwindow_position_relative(wid, anchor, wl_fixed_from_double(dx), wl_fixed_from_double(dy));
+}
+
 TreeLandWindowOverlapChecker::TreeLandWindowOverlapChecker(WaylandDockHelper *helper, struct ::treeland_window_overlap_checker *checker)
     : QWaylandClientExtensionTemplate<TreeLandWindowOverlapChecker>(treeland_dde_shell_manager_v1_interface.version)
     , m_helper(helper)

panels/dock/waylanddockhelper.h

@@ -30,6 +30,11 @@ class WaylandDockHelper : public DockHelper
 
     void setDockColorTheme(const ColorTheme &theme);
     QString dockScreenName();
+    
+    // Move XEmbed window relative to dock surface
+    // dx, dy: offset relative to dock surface top-left
+    // Returns true if the request was sent successfully
+    bool moveXEmbedWindow(uint32_t wid, double dx, double dy) override;
 
 protected:
     bool currentActiveWindowFullscreened() override;
@@ -51,6 +56,7 @@ protected Q_SLOTS:
     QScopedPointer<WallpaperColorManager> m_wallpaperColorManager;
     QScopedPointer<TreeLandWindowOverlapChecker> m_overlapChecker;
     QScopedPointer<TreeLandDDEShellManager> m_ddeShellManager;
+    struct ::wl_surface *m_dockWlSurface = nullptr;  // Dock's wl_surface for XEmbed positioning
 };
 
 class WallpaperColorManager : public QWaylandClientExtensionTemplate<WallpaperColorManager>, public QtWayland::treeland_wallpaper_color_manager_v1
@@ -75,6 +81,10 @@ class TreeLandDDEShellManager : public QWaylandClientExtensionTemplate<TreeLandD
 
 public:
     explicit TreeLandDDEShellManager();
+    
+    // Move XEmbed window to position relative to anchor surface
+    // Returns wl_callback* or nullptr if not active
+    struct ::wl_callback *setXWindowPositionRelative(uint32_t wid, struct ::wl_surface *anchor, double dx, double dy);
 };
 
 class TreeLandWindowOverlapChecker : public QWaylandClientExtensionTemplate<TreeLandWindowOverlapChecker>, public QtWayland::treeland_window_overlap_checker