如何将X11窗口嵌入QML界面并同步父窗口的调整与移动？

Got it, embedding an X11 window into your QML Qt app and keeping it perfectly aligned during resize/move operations is totally solvable—here’s a practical, battle-tested approach I’ve used on similar projects:

The key idea is to use a QML Item as your anchor point, then listen to its position/size changes from C++. With Qt's X11 extras and raw Xlib calls, you can sync the external X11 window's geometry to match the QML container in real-time. Since the X11 window is managed by another team, we just need to sync our container's state to it.

1. Enable X11 Support in Your Project #

First, update your .pro file to include Qt's X11 extras and link against Xlib:

QT += x11extras
LIBS += -lX11

2. Define a QML Container for the X11 Window #

Create a dedicated Item in your QML to act as the placeholder for the embedded X11 window. This gives you a clear anchor to sync against:

Item {
    id: x11Container
    anchors.fill: parent // Or set specific anchors, e.g., anchors.left: parent.left; anchors.top: parent.top
    objectName: "x11Container" // Needed to find this item from C++
}

3. Build a C++ Sync Manager Class #

Create a class to handle the synchronization logic. It will listen to the QML container's geometry changes and update the X11 window accordingly:

#include <QQuickItem>
#include <QX11Info>
#include <X11/Xlib.h>
#include <QTimer>

class X11WindowSync : public QObject
{
    Q_OBJECT
public:
    explicit X11WindowSync(Window externalX11WinId, QQuickItem* container, QObject *parent = nullptr)
        : QObject(parent), m_externalWinId(externalX11WinId), m_container(container)
    {
        // Set up a timer to debounce rapid resize/move events
        m_syncTimer = new QTimer(this);
        m_syncTimer->setSingleShot(true);
        m_syncTimer->setInterval(10); // Adjust based on your performance needs
        connect(m_syncTimer, &QTimer::timeout, this, &X11WindowSync::performSync);

        // Listen to all relevant geometry changes in the QML container
        connect(m_container, &QQuickItem::xChanged, this, &X11WindowSync::scheduleSync);
        connect(m_container, &QQuickItem::yChanged, this, &X11WindowSync::scheduleSync);
        connect(m_container, &QQuickItem::widthChanged, this, &X11WindowSync::scheduleSync);
        connect(m_container, &QQuickItem::heightChanged, this, &X11WindowSync::scheduleSync);

        // Sync once immediately to set initial position/size
        performSync();
    }

private slots:
    void scheduleSync()
    {
        // Debounce: reset the timer on each change to avoid spamming Xlib calls
        m_syncTimer->stop();
        m_syncTimer->start();
    }

    void performSync()
    {
        if (!m_container || m_externalWinId == 0) return;

        Display* display = QX11Info::display();
        if (!display) return;

        // Convert QML container's local position to global screen coordinates
        QPointF globalTopLeft = m_container->mapToGlobal(QPointF(0, 0));
        int x = static_cast<int>(globalTopLeft.x());
        int y = static_cast<int>(globalTopLeft.y());
        int width = static_cast<int>(m_container->width());
        int height = static_cast<int>(m_container->height());

        // Use Xlib to update the external window's geometry
        XMoveResizeWindow(display, m_externalWinId, x, y, width, height);
        XFlush(display); // Ensure the command is sent to the X server immediately
    }

private:
    Window m_externalWinId;
    QQuickItem* m_container;
    QTimer* m_syncTimer;
};

4. Hook Up the Sync Manager to QML #

In your C++ main code (or wherever you initialize your QML engine), find the QML container item and pass it along with the external X11 window ID to the sync manager:

#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQuickItem>

int main(int argc, char *argv[])
{
    QGuiApplication app(argc, argv);

    QQmlApplicationEngine engine;
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    // Get the external X11 window ID from the other team (this is just an example)
    Window externalX11WinId = ...; // Replace with the actual window ID provided

    // Find the QML container item
    QQuickItem* x11Container = engine.rootObjects()[0]->findChild<QQuickItem*>("x11Container");
    if (x11Container && externalX11WinId != 0) {
        new X11WindowSync(externalX11WinId, x11Container);
    }

    return app.exec();
}

• Window Hierarchy: For better stacking behavior (so the X11 window stays within your QML window), consider reparenting the external X11 window to your QML app's main window using XReparentWindow:

  Window qmlMainWinId = QX11Info::appWindow();
  XReparentWindow(display, m_externalWinId, qmlMainWinId, xRelativeToQmlWin, yRelativeToQmlWin);
  

  Note: If you reparent, you'll need to calculate the container's position relative to the QML main window instead of global coordinates.

• Thread Safety: Xlib isn't thread-safe. Make sure all Xlib calls (like XMoveResizeWindow) run on the main thread. Qt's X11 extras already handle most of this, but avoid calling Xlib functions from background threads.

• Coordination with the Other Team: Make sure the other team doesn't override the window's geometry from their side. Agree on a contract where your app controls the position/size of their X11 window.

• Cleanup: Add logic to handle cases where the QML container is destroyed or the external X11 window closes. Disconnect signals and stop timers to prevent crashes from dangling pointers.

内容的提问来源于stack exchange，提问作者letaoz