qwaylandcompositor.cpp

Go to the documentation of this file.

// Copyright (C) 2017 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
// Copyright (C) 2020 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:critical reason:network-protocol
 
#include "qtwaylandcompositorglobal_p.h"
#include "qwaylandcompositor.h"
#include "qwaylandcompositor_p.h"
 
#include <QtWaylandCompositor/qwaylandclient.h>
#include <QtWaylandCompositor/qwaylandseat.h>
#include <QtWaylandCompositor/qwaylandoutput.h>
#include <QtWaylandCompositor/qwaylandview.h>
#include <QtWaylandCompositor/qwaylandclient.h>
#include <QtWaylandCompositor/qwaylandkeyboard.h>
#include <QtWaylandCompositor/qwaylandpointer.h>
#include <QtWaylandCompositor/qwaylandtouch.h>
#include <QtWaylandCompositor/qwaylandsurfacegrabber.h>
 
#include <QtWaylandCompositor/private/qwaylandkeyboard_p.h>
#include <QtWaylandCompositor/private/qwaylandsurface_p.h>
 
#if QT_CONFIG(wayland_datadevice)
#include "wayland_wrapper/qwldatadevice_p.h"
#include "wayland_wrapper/qwldatadevicemanager_p.h"
#endif
#include "wayland_wrapper/qwlbuffermanager_p.h"
 
#include "hardware_integration/qwlclientbufferintegration_p.h"
#include "hardware_integration/qwlclientbufferintegrationfactory_p.h"
#include "hardware_integration/qwlserverbufferintegration_p.h"
#include "hardware_integration/qwlserverbufferintegrationfactory_p.h"
 
#if QT_CONFIG(opengl)
#include "hardware_integration/qwlhwintegration_p.h"
#endif
 
#include "extensions/qwaylandqtwindowmanager.h"
 
#include "qwaylandsharedmemoryformathelper_p.h"
 
#include <QtCore/QCoreApplication>
#include <QtCore/QStringList>
#include <QtCore/QSocketNotifier>
#include <QStandardPaths>
 
#include <QtGui/QDesktopServices>
#include <QtGui/QScreen>
 
#include <QtGui/qpa/qwindowsysteminterface_p.h>
#include <QtGui/qpa/qplatformnativeinterface.h>
#include <QtGui/private/qguiapplication_p.h>
 
#if QT_CONFIG(opengl)
#   include <QOpenGLTextureBlitter>
#   include <QOpenGLTexture>
#   include <QOpenGLContext>
#   include <QOpenGLFramebufferObject>
#   include <QMatrix4x4>
#endif
 
QT_BEGIN_NAMESPACE
 
// These logging categories are public symbols. To remain binary-compatible we cannot hide them in
// a namespace like we do for all Qt-internal logging categories.
#define Q_PUBLIC_LOGGING_CATEGORY(name, ...)
    const QLoggingCategory &name()
    {
        static const QLoggingCategory category(__VA_ARGS__);
        return category;
    }
 
Q_PUBLIC_LOGGING_CATEGORY(qLcWaylandCompositor, "qt.waylandcompositor")
Q_PUBLIC_LOGGING_CATEGORY(qLcWaylandCompositorHardwareIntegration, "qt.waylandcompositor.hardwareintegration")
Q_PUBLIC_LOGGING_CATEGORY(qLcWaylandCompositorInputMethods, "qt.waylandcompositor.inputmethods")
Q_PUBLIC_LOGGING_CATEGORY(qLcWaylandCompositorTextInput, "qt.waylandcompositor.textinput")
 
namespace QtWayland {
 
class WindowSystemEventHandler : public QWindowSystemEventHandler
{
public:
    WindowSystemEventHandler(QWaylandCompositor *c) : compositor(c) {}
    bool sendEvent(QWindowSystemInterfacePrivate::WindowSystemEvent *e) override
    {
        if (e->type == QWindowSystemInterfacePrivate::Key) {
            QWindowSystemInterfacePrivate::KeyEvent *keyEvent = static_cast<QWindowSystemInterfacePrivate::KeyEvent *>(e);
            handleKeyEvent(keyEvent);
        } else {
            QWindowSystemEventHandler::sendEvent(e);
        }
        return true;
    }
 
    void handleKeyEvent(QWindowSystemInterfacePrivate::KeyEvent *ke)
    {
        auto *seat = compositor->defaultSeat();
        if (!seat)
            return;
 
        QWaylandKeyboardPrivate *keyb = QWaylandKeyboardPrivate::get(seat->keyboard());
 
#if defined(Q_OS_QNX)
        // The QNX platform plugin delivers scan codes that haven't been adjusted to be
        // xkbcommon compatible. xkbcommon requires that the scan codes be bumped up by
        // 8 because that's how evdev/XKB deliver scan codes. You might think that it
        // would've been better to remove this (odd) requirement from xkbcommon on QNX
        // but it turns out that conforming to it has much less impact.
        static int offset = QGuiApplication::platformName() == QStringLiteral("qnx") ? 8 : 0;
        ke->nativeScanCode += offset;
#endif
        uint32_t code = ke->nativeScanCode;
        if (code == 0)
            code = seat->keyboard()->keyToScanCode(ke->key);
        bool isDown = ke->keyType == QEvent::KeyPress;
 
#if QT_CONFIG(xkbcommon)
        xkb_state *xkbState = keyb->xkbState();
 
        const xkb_keysym_t sym = xkb_state_key_get_one_sym(xkbState, code);
        Qt::KeyboardModifiers modifiers = QXkbCommon::modifiers(xkbState, sym);
        int qtkey = QXkbCommon::keysymToQtKey(sym, modifiers, xkbState, code);
        QString text = QXkbCommon::lookupString(xkbState, code);
 
        ke->key = qtkey;
        ke->modifiers = modifiers;
        ke->nativeVirtualKey = sym;
        ke->nativeModifiers = keyb->xkbModsMask();
        ke->unicode = text;
#endif
        if (!ke->repeat)
            keyb->keyEvent(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
 
        QWindowSystemEventHandler::sendEvent(ke);
 
        if (!ke->repeat) {
            keyb->maybeUpdateKeymap();
            keyb->updateModifierState(code, isDown ? WL_KEYBOARD_KEY_STATE_PRESSED : WL_KEYBOARD_KEY_STATE_RELEASED);
        }
    }
 
    QWaylandCompositor *compositor = nullptr;
};
 
} // namespace
 
QWaylandCompositorPrivate::QWaylandCompositorPrivate(QWaylandCompositor *compositor)
{
    // Create XDG_RUNTIME_DIR, if it does not already exist
    QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation);
 
    if (QGuiApplication::platformNativeInterface())
        display = static_cast<wl_display*>(QGuiApplication::platformNativeInterface()->nativeResourceForIntegration("server_wl_display"));
 
    if (!display) {
        display = wl_display_create();
        ownsDisplay = true;
    }
 
    eventHandler.reset(new QtWayland::WindowSystemEventHandler(compositor));
    timer.start();
 
    QWindowSystemInterfacePrivate::installWindowSystemEventHandler(eventHandler.data());
 
#if QT_CONFIG(xkbcommon)
    mXkbContext.reset(xkb_context_new(XKB_CONTEXT_NO_FLAGS));
    if (!mXkbContext) {
        qWarning("Failed to create a XKB context: keymap will not be supported");
        return;
    }
#endif
}
 
void QWaylandCompositorPrivate::init()
{
    Q_Q(QWaylandCompositor);
    QStringList arguments = QCoreApplication::instance()->arguments();
 
    if (socket_name.isEmpty()) {
        const int socketArg = arguments.indexOf(QLatin1String("--wayland-socket-name"));
        if (socketArg != -1 && socketArg + 1 < arguments.size())
            socket_name = arguments.at(socketArg + 1).toLocal8Bit();
        if (socket_name.isEmpty())
            socket_name = qgetenv("WAYLAND_DISPLAY");
    }
    wl_compositor::init(display, 5);
    wl_subcompositor::init(display, 1);
 
#if QT_CONFIG(wayland_datadevice)
    data_device_manager =  new QtWayland::DataDeviceManager(q);
#endif
    buffer_manager = new QtWayland::BufferManager(q);
 
    wl_display_init_shm(display);
 
    for (QWaylandCompositor::ShmFormat format : std::as_const(shmFormats))
        wl_display_add_shm_format(display, wl_shm_format(format));
 
    if (!socket_name.isEmpty()) {
        if (wl_display_add_socket(display, socket_name.constData()))
            qFatal("Fatal: Failed to open server socket: \"%s\". XDG_RUNTIME_DIR is: \"%s\"\n", socket_name.constData(), getenv("XDG_RUNTIME_DIR"));
    } else {
        const char *autoSocketName = wl_display_add_socket_auto(display);
        if (!autoSocketName)
            qFatal("Fatal: Failed to open default server socket. XDG_RUNTIME_DIR is: \"%s\"\n", getenv("XDG_RUNTIME_DIR"));
        socket_name = autoSocketName;
        emit q->socketNameChanged(socket_name);
    }
 
    connectToExternalSockets();
 
    loop = wl_display_get_event_loop(display);
 
    int fd = wl_event_loop_get_fd(loop);
 
    QSocketNotifier *sockNot = new QSocketNotifier(fd, QSocketNotifier::Read, q);
    QObject::connect(sockNot, SIGNAL(activated(QSocketDescriptor)), q, SLOT(processWaylandEvents()));
 
    QAbstractEventDispatcher *dispatcher = QGuiApplicationPrivate::eventDispatcher;
    QObject::connect(dispatcher, SIGNAL(aboutToBlock()), q, SLOT(processWaylandEvents()));
 
    QObject::connect(static_cast<QGuiApplication *>(QGuiApplication::instance()),
                     &QGuiApplication::applicationStateChanged,
                     q,
                     &QWaylandCompositor::applicationStateChanged);
 
    initializeHardwareIntegration();
    initializeSeats();
 
    initialized = true;
 
    for (const QPointer<QObject> &object : std::exchange(polish_objects, {})) {
        if (object) {
            QEvent polishEvent(QEvent::Polish);
            QCoreApplication::sendEvent(object.data(), &polishEvent);
        }
    }
 
    emit q->createdChanged();
}
 
QWaylandCompositorPrivate::~QWaylandCompositorPrivate()
{
    // Take copies, since the lists will get modified as elements are deleted
    const auto clientsToDelete = clients;
    qDeleteAll(clientsToDelete);
 
    const auto outputsToDelete = outputs;
    qDeleteAll(outputsToDelete);
 
#if QT_CONFIG(wayland_datadevice)
    delete data_device_manager;
#endif
 
    // Some client buffer integrations need to clean up before the destroying the wl_display
    qDeleteAll(client_buffer_integrations);
 
    if (ownsDisplay)
        wl_display_destroy(display);
}
 
void QWaylandCompositorPrivate::preInit()
{
    Q_Q(QWaylandCompositor);
 
    if (preInitialized)
        return;
 
    if (seats.empty())
        seats.append(q->createSeat());
 
    preInitialized = true;
}
 
void QWaylandCompositorPrivate::destroySurface(QWaylandSurface *surface)
{
    Q_Q(QWaylandCompositor);
    q->surfaceAboutToBeDestroyed(surface);
 
    delete surface;
}
 
void QWaylandCompositorPrivate::unregisterSurface(QWaylandSurface *surface)
{
    if (!all_surfaces.removeOne(surface))
        qWarning("%s Unexpected state. Cant find registered surface\n", Q_FUNC_INFO);
}
 
void QWaylandCompositorPrivate::feedRetainedSelectionData(QMimeData *data)
{
    Q_Q(QWaylandCompositor);
    if (retainSelection)
        q->retainedSelectionReceived(data);
}
 
void QWaylandCompositorPrivate::addPolishObject(QObject *object)
{
    if (initialized) {
        QCoreApplication::postEvent(object, new QEvent(QEvent::Polish));
    } else {
        polish_objects.push_back(object);
    }
}
 
void QWaylandCompositorPrivate::connectToExternalSockets()
{
    // Clear out any backlog of user-supplied external socket descriptors
    for (int fd : std::as_const(externally_added_socket_fds)) {
        if (wl_display_add_socket_fd(display, fd) != 0)
            qWarning() << "Failed to integrate user-supplied socket fd into the Wayland event loop";
    }
    externally_added_socket_fds.clear();
}
 
void QWaylandCompositorPrivate::compositor_create_surface(wl_compositor::Resource *resource, uint32_t id)
{
    Q_Q(QWaylandCompositor);
    QWaylandClient *client = QWaylandClient::fromWlClient(q, resource->client());
    emit q->surfaceRequested(client, id, resource->version());
#ifndef QT_NO_DEBUG
    Q_ASSERT_X(!QWaylandSurfacePrivate::hasUninitializedSurface(), "QWaylandCompositor", QStringLiteral("Found uninitialized QWaylandSurface after emitting QWaylandCompositor::createSurface for id %1. All surfaces has to be initialized immediately after creation. See QWaylandSurface::initialize.").arg(id).toLocal8Bit().constData());
#endif
    struct wl_resource *surfResource = wl_client_get_object(client->client(), id);
 
    QWaylandSurface *surface = nullptr;
    if (surfResource) {
        surface = QWaylandSurface::fromResource(surfResource);
    } else {
        surface = createDefaultSurface();
        surface->initialize(q, client, id, resource->version());
    }
    Q_ASSERT(surface);
    all_surfaces.append(surface);
    emit q->surfaceCreated(surface);
}
 
void QWaylandCompositorPrivate::compositor_create_region(wl_compositor::Resource *resource, uint32_t id)
{
    new QtWayland::Region(resource->client(), id);
}
 
void QWaylandCompositorPrivate::subcompositor_get_subsurface(wl_subcompositor::Resource *resource, uint32_t id, wl_resource *surface, wl_resource *parent)
{
    Q_Q(QWaylandCompositor);
    QWaylandSurface *childSurface = QWaylandSurface::fromResource(surface);
    QWaylandSurface *parentSurface = QWaylandSurface::fromResource(parent);
 
    QWaylandSurfacePrivate *childSurface_d = QWaylandSurfacePrivate::get(childSurface);
    QWaylandSurfacePrivate *parentSurface_d = QWaylandSurfacePrivate::get(parentSurface);
    Q_ASSERT(childSurface_d != nullptr && parentSurface_d != nullptr);
 
    // Walk the requested parent's existing ancestor chain and reject if it already includes the
    // child surface.
    for (QWaylandSurfacePrivate *ancestor = parentSurface_d;
         ancestor != nullptr;
         ancestor = ancestor->parentSurface()) {
        if (ancestor == childSurface_d) {
            wl_resource_post_error(resource->handle,
                                   WL_SUBCOMPOSITOR_ERROR_BAD_PARENT,
                                   "surface cannot be made a transitive parent of itself");
            return;
        }
    }
 
    QWaylandSurfacePrivate::get(childSurface)->initSubsurface(parentSurface, resource->client(), id, 1);
    QWaylandSurfacePrivate::get(parentSurface)->subsurfaceChildren.append(childSurface);
    emit q->subsurfaceChanged(childSurface, parentSurface);
}
 
/*!
  \internal
  Used to create a fallback QWaylandSurface when no surface was
  created by emitting the QWaylandCompositor::createSurface signal.
*/
QWaylandSurface *QWaylandCompositorPrivate::createDefaultSurface()
{
    return new QWaylandSurface();
}
 
class SharedMemoryClientBufferIntegration : public QtWayland::ClientBufferIntegration
{
public:
    void initializeHardware(wl_display *display) override;
    QtWayland::ClientBuffer *createBufferFor(wl_resource *buffer) override;
};
 
void SharedMemoryClientBufferIntegration::initializeHardware(wl_display *)
{
}
 
QtWayland::ClientBuffer *SharedMemoryClientBufferIntegration::createBufferFor(wl_resource *buffer)
{
    if (wl_shm_buffer_get(buffer))
        return new QtWayland::SharedMemoryBuffer(buffer);
    return nullptr;
}
 
void QWaylandCompositorPrivate::initializeHardwareIntegration()
{
    client_buffer_integrations.prepend(new SharedMemoryClientBufferIntegration); // TODO: clean up the opengl dependency
 
#if QT_CONFIG(opengl)
    Q_Q(QWaylandCompositor);
    if (use_hw_integration_extension)
        hw_integration.reset(new QtWayland::HardwareIntegration(q));
 
    loadClientBufferIntegration();
    loadServerBufferIntegration();
 
    for (auto *integration : std::as_const(client_buffer_integrations))
        integration->initializeHardware(display);
#endif
}
 
void QWaylandCompositorPrivate::initializeSeats()
{
    for (QWaylandSeat *seat : std::as_const(seats))
        seat->initialize();
}
 
void QWaylandCompositorPrivate::loadClientBufferIntegration()
{
#if QT_CONFIG(opengl)
    Q_Q(QWaylandCompositor);
    QStringList keys = QtWayland::ClientBufferIntegrationFactory::keys();
    QStringList targetKeys;
    QByteArray clientBufferIntegration = qgetenv("QT_WAYLAND_HARDWARE_INTEGRATION");
    if (clientBufferIntegration.isEmpty())
        clientBufferIntegration = qgetenv("QT_WAYLAND_CLIENT_BUFFER_INTEGRATION");
 
    const QList<QByteArray> clientBufferIntegrations = clientBufferIntegration.split(';');
    for (const auto &b : clientBufferIntegrations) {
        QString s = QString::fromLocal8Bit(b);
        if (keys.contains(s))
            targetKeys.append(s);
    }
 
    if (!clientBufferIntegration.isEmpty() && targetKeys.isEmpty()) {
        qCWarning(qLcWaylandCompositorHardwareIntegration)
            << "Failed to find any requested client buffer integration:"
            << clientBufferIntegration
            << ", available integrations:"
            << keys;
    }
 
    if (targetKeys.isEmpty()) {
        if (keys.contains(QString::fromLatin1("wayland-egl"))) {
            targetKeys.append(QString::fromLatin1("wayland-egl"));
        } else if (!keys.isEmpty()) {
            targetKeys.append(keys.first());
        }
    }
 
    QString hwIntegrationName;
 
    for (const auto &targetKey : std::as_const(targetKeys)) {
        auto *integration = QtWayland::ClientBufferIntegrationFactory::create(targetKey, QStringList());
        if (integration) {
            integration->setCompositor(q);
            client_buffer_integrations.append(integration);
            if (hwIntegrationName.isEmpty())
                hwIntegrationName = targetKey;
        }
    }
 
    if (hw_integration && !hwIntegrationName.isEmpty())
        hw_integration->setClientBufferIntegrationName(hwIntegrationName);
 
#endif
}
 
void QWaylandCompositorPrivate::loadServerBufferIntegration()
{
#if QT_CONFIG(opengl)
    Q_Q(QWaylandCompositor);
    QStringList keys = QtWayland::ServerBufferIntegrationFactory::keys();
    QString targetKey;
    QByteArray serverBufferIntegration = qgetenv("QT_WAYLAND_SERVER_BUFFER_INTEGRATION");
    if (keys.contains(QString::fromLocal8Bit(serverBufferIntegration.constData()))) {
        targetKey = QString::fromLocal8Bit(serverBufferIntegration.constData());
    }
    if (!targetKey.isEmpty()) {
        server_buffer_integration.reset(QtWayland::ServerBufferIntegrationFactory::create(targetKey, QStringList()));
        if (server_buffer_integration) {
            qCDebug(qLcWaylandCompositorHardwareIntegration)
                    << "Loaded server buffer integration:" << targetKey;
            if (!server_buffer_integration->initializeHardware(q)) {
                qCWarning(qLcWaylandCompositorHardwareIntegration)
                        << "Failed to initialize hardware for server buffer integration:" << targetKey;
                server_buffer_integration.reset();
            }
        } else {
            qCWarning(qLcWaylandCompositorHardwareIntegration)
                    << "Failed to load server buffer integration:" << targetKey;
        }
    }
 
    if (server_buffer_integration && hw_integration)
        hw_integration->setServerBufferIntegrationName(targetKey);
#endif
}
 
QWaylandSeat *QWaylandCompositorPrivate::seatFor(QInputEvent *inputEvent)
{
    QWaylandSeat *dev = nullptr;
    for (int i = 0; i < seats.size(); i++) {
        QWaylandSeat *candidate = seats.at(i);
        if (candidate->isOwner(inputEvent)) {
            dev = candidate;
            break;
        }
    }
    return dev;
}
 
/*!
  \qmltype WaylandCompositor
  \nativetype QWaylandCompositor
  \inqmlmodule QtWayland.Compositor
  \since 5.8
  \brief Manages the Wayland display server.
 
  The WaylandCompositor manages the connections to the clients, as well as the different
  \l{WaylandOutput}{outputs} and \l{QWaylandSeat}{seats}.
 
  Normally, a compositor application will have a single WaylandCompositor
  instance, which can have several outputs as children. When a client
  requests the compositor to create a surface, the request is handled by
  the onSurfaceRequested handler.
 
  Extensions that are supported by the compositor should be instantiated and added to the
  extensions property or simply as direct children of WaylandCompositor.
*/
 
 
/*!
   \class QWaylandCompositor
   \inmodule QtWaylandCompositor
   \since 5.8
   \brief The QWaylandCompositor class manages the Wayland display server.
 
   The QWaylandCompositor manages the connections to the clients, as well as the different \l{QWaylandOutput}{outputs}
   and \l{QWaylandSeat}{seats}.
 
   Normally, a compositor application will have a single WaylandCompositor
   instance, which can have several outputs as children.
*/
 
/*!
  \qmlsignal void QtWayland.Compositor::WaylandCompositor::surfaceRequested(WaylandClient client, int id, int version)
 
  This signal is emitted when a \a client has created a surface with id \a id.
  The interface \a version is also available.
 
  The slot connecting to this signal may create and initialize a WaylandSurface
  instance in the scope of the slot. Otherwise a default surface is created.
*/
 
/*!
  \fn void QWaylandCompositor::surfaceRequested(QWaylandClient *client, uint id, int version)
 
  This signal is emitted when a \a client has created a surface with id \a id.
  The interface \a version is also available.
 
  The slot connecting to this signal may create and initialize a QWaylandSurface
  instance in the scope of the slot. Otherwise a default surface is created.
 
  Connections to this signal must be of Qt::DirectConnection connection type.
*/
 
/*!
  \qmlsignal void QtWayland.Compositor::WaylandCompositor::surfaceCreated(WaylandSurface surface)
 
  This signal is emitted when a new WaylandSurface instance \a surface has been created.
*/
 
/*!
  \fn void QWaylandCompositor::surfaceCreated(QWaylandSurface *surface)
 
  This signal is emitted when a new QWaylandSurface instance \a surface has been created.
*/
 
/*!
 * Constructs a QWaylandCompositor with the given \a parent.
 */
QWaylandCompositor::QWaylandCompositor(QObject *parent)
    : QWaylandObject(*new QWaylandCompositorPrivate(this), parent)
{
}
 
/*!
 * \internal
 * Constructs a QWaylandCompositor with the private object \a dptr and \a parent.
 */
QWaylandCompositor::QWaylandCompositor(QWaylandCompositorPrivate &dptr, QObject *parent)
    : QWaylandObject(dptr, parent)
{
}
 
/*!
 * Destroys the QWaylandCompositor
 */
QWaylandCompositor::~QWaylandCompositor()
{
}
 
/*!
 * Initializes the QWaylandCompositor.
 * If you override this function in your subclass, be sure to call the base class implementation.
 */
void QWaylandCompositor::create()
{
    Q_D(QWaylandCompositor);
    d->preInit();
    d->init();
}
 
/*!
 * \qmlproperty bool QtWayland.Compositor::WaylandCompositor::created
 *
 * This property is true if WaylandCompositor has been initialized,
 * otherwise it's false.
 */
 
/*!
 * \property QWaylandCompositor::created
 *
 * This property is true if QWaylandCompositor has been initialized,
 * otherwise it's false.
 */
bool QWaylandCompositor::isCreated() const
{
    Q_D(const QWaylandCompositor);
    return d->initialized;
}
 
/*!
 * \qmlproperty string QtWayland.Compositor::WaylandCompositor::socketName
 *
 * This property holds the socket name used by WaylandCompositor to communicate with
 * clients. It must be set before the component is completed.
 *
 * If the socketName is empty (the default), the contents of the start argument
 * \c --wayland-socket-name are used instead. If the argument is not set, the
 * compositor tries to find a socket name, which is \c{wayland-0} by default.
 */
 
/*!
 * \property QWaylandCompositor::socketName
 *
 * This property holds the socket name used by QWaylandCompositor to communicate with
 * clients. This must be set before the QWaylandCompositor is \l{create()}{created}.
 *
 * If the socketName is empty (the default), the contents of the start argument
 * \c --wayland-socket-name are used instead. If the argument is not set, the
 * compositor tries to find a socket name, which is \c{wayland-0} by default.
 */
void QWaylandCompositor::setSocketName(const QByteArray &name)
{
    Q_D(QWaylandCompositor);
 
    if (d->socket_name == name)
        return;
 
    if (d->initialized) {
        qWarning("%s: Changing socket name after initializing the compositor is not supported.\n", Q_FUNC_INFO);
        return;
    }
 
    d->socket_name = name;
    emit socketNameChanged(name);
}
 
QByteArray QWaylandCompositor::socketName() const
{
    Q_D(const QWaylandCompositor);
    return d->socket_name;
}
 
/*!
 * \qmlmethod void QtWayland.Compositor::WaylandCompositor::addSocketDescriptor(fd)
 * \since 5.12
 *
 * Listen for client connections on a file descriptor, \a fd, referring to a
 * server socket already bound and listening.
 *
 * Does not take ownership of the file descriptor; it must be closed
 * explicitly if needed.
 *
 * \note This method is only available with libwayland 1.10.0 or
 * newer. If built against an earlier libwayland runtime, this
 * method is a noop.
 */
 
/*!
 * Listen for client connections on a file descriptor, \a fd, referring to a
 * server socket already bound and listening.
 *
 * Does not take ownership of the file descriptor; it must be closed
 * explicitly if needed.
 *
 * \note This method is only available with libwayland 1.10.0 or
 * newer. If built against an earlier libwayland runtime, this
 * method is a noop.
 *
 * \since 5.12
 */
void QWaylandCompositor::addSocketDescriptor(int fd)
{
    Q_D(QWaylandCompositor);
    d->externally_added_socket_fds.append(fd);
    if (isCreated())
        d->connectToExternalSockets();
}
 
/*!
 * \internal
 */
struct wl_display *QWaylandCompositor::display() const
{
    Q_D(const QWaylandCompositor);
    return d->display;
}
 
/*!
 * \internal
 */
uint32_t QWaylandCompositor::nextSerial()
{
    Q_D(QWaylandCompositor);
    return wl_display_next_serial(d->display);
}
 
/*!
 * \internal
 */
QList<QWaylandClient *>QWaylandCompositor::clients() const
{
    Q_D(const QWaylandCompositor);
    return d->clients;
}
 
/*!
 * \qmlmethod void QtWayland.Compositor::WaylandCompositor::destroyClientForSurface(surface)
 *
 * From the compositor side, destroys the client to which the WaylandSurface \a surface belongs
 * by disconnecting from it.
 */
 
/*!
 * Destroys the client for the \a surface.
 */
void QWaylandCompositor::destroyClientForSurface(QWaylandSurface *surface)
{
    destroyClient(surface->client());
}
 
/*!
 * \qmlmethod void QtWayland.Compositor::WaylandCompositor::destroyClient(client)
 *
 * From the compositor side, destroys the given WaylandClient \a client by disconnecting from it.
 */
 
/*!
 * Destroys the \a client.
 */
void QWaylandCompositor::destroyClient(QWaylandClient *client)
{
    if (!client)
        return;
 
    QWaylandQtWindowManager *wmExtension = QWaylandQtWindowManager::findIn(this);
    if (wmExtension)
        wmExtension->sendQuitMessage(client);
 
    wl_client_destroy(client->client());
}
 
/*!
 * \internal
 */
QList<QWaylandSurface *> QWaylandCompositor::surfacesForClient(QWaylandClient* client) const
{
    Q_D(const QWaylandCompositor);
    QList<QWaylandSurface *> surfs;
    for (QWaylandSurface *surface : d->all_surfaces) {
        if (surface->client() == client)
            surfs.append(surface);
    }
    return surfs;
}
 
/*!
 * \internal
 */
QList<QWaylandSurface *> QWaylandCompositor::surfaces() const
{
    Q_D(const QWaylandCompositor);
    return d->all_surfaces;
}
 
/*!
 * Returns the QWaylandOutput that is connected to the given \a window.
 */
QWaylandOutput *QWaylandCompositor::outputFor(QWindow *window) const
{
    Q_D(const QWaylandCompositor);
    for (QWaylandOutput *output : d->outputs) {
        if (output->window() == window)
            return output;
    }
 
    return nullptr;
}
 
/*!
 * \qmlproperty WaylandOutput QtWayland.Compositor::WaylandCompositor::defaultOutput
 *
 * This property contains the first in the list of outputs added to the
 * WaylandCompositor, or null if no outputs have been added.
 *
 * Setting a new default output prepends it to the output list, making
 * it the new default, but the previous default is not removed from
 * the list.
 */
/*!
 * \property QWaylandCompositor::defaultOutput
 *
 * This property contains the first in the list of outputs added to the
 * QWaylandCompositor, or null if no outputs have been added.
 *
 * Setting a new default output prepends it to the output list, making
 * it the new default, but the previous default is not removed from
 * the list. If the new default output was already in the list of outputs,
 * it is moved to the beginning of the list.
 */
QWaylandOutput *QWaylandCompositor::defaultOutput() const
{
    Q_D(const QWaylandCompositor);
    return d->defaultOutput();
}
 
void QWaylandCompositor::setDefaultOutput(QWaylandOutput *output)
{
    Q_D(QWaylandCompositor);
    if (Q_UNLIKELY(!output)) {
        qWarning("Changing default output to null is not supported");
        return;
    }
    if (d->outputs.size() && d->outputs.first() == output)
        return;
    bool alreadyAdded = d->outputs.removeOne(output);
    d->outputs.prepend(output);
    if (!alreadyAdded)
        emit outputAdded(output);
    emit defaultOutputChanged();
}
 
/*!
 * \internal
 */
QList<QWaylandOutput *> QWaylandCompositor::outputs() const
{
    Q_D(const QWaylandCompositor);
    return d->outputs;
}
 
/*!
 * \internal
 */
uint QWaylandCompositor::currentTimeMsecs() const
{
    Q_D(const QWaylandCompositor);
    return d->timer.elapsed();
}
 
/*!
 * \internal
 */
void QWaylandCompositor::processWaylandEvents()
{
    Q_D(QWaylandCompositor);
    int ret = wl_event_loop_dispatch(d->loop, 0);
    if (ret)
        fprintf(stderr, "wl_event_loop_dispatch error: %d\n", ret);
    wl_display_flush_clients(d->display);
}
 
/*!
 * \internal
 */
QWaylandSeat *QWaylandCompositor::createSeat()
{
    return new QWaylandSeat(this);
}
 
/*!
 * \internal
 */
QWaylandPointer *QWaylandCompositor::createPointerDevice(QWaylandSeat *seat)
{
    return new QWaylandPointer(seat);
}
 
/*!
 * \internal
 */
QWaylandKeyboard *QWaylandCompositor::createKeyboardDevice(QWaylandSeat *seat)
{
    return new QWaylandKeyboard(seat);
}
 
/*!
 * \internal
 */
QWaylandTouch *QWaylandCompositor::createTouchDevice(QWaylandSeat *seat)
{
    return new QWaylandTouch(seat);
}
 
/*!
 * \qmlproperty bool QtWayland.Compositor::WaylandCompositor::retainedSelection
 * \default false
 *
 * This property controls whether the compositor retains a copy of clipboard selection data.
 * When \c true, the compositor eagerly reads and caches all clipboard data from the owning client.
 * This incurs a performance cost.
 */
 
/*!
 * \property QWaylandCompositor::retainedSelection
 *
 * This property controls whether the compositor retains a copy of clipboard selection data.
 * When \c true, the compositor eagerly reads and caches all clipboard data from the owning client.
 * This incurs a performance cost. The default is \c false.
 *
 * \sa QWaylandCompositor::retainedSelectionReceived(), QWaylandSurface::updateSelection()
 */
void QWaylandCompositor::setRetainedSelectionEnabled(bool enabled)
{
    Q_D(QWaylandCompositor);
 
    if (d->retainSelection == enabled)
        return;
 
    d->retainSelection = enabled;
    emit retainedSelectionChanged(enabled);
}
 
bool QWaylandCompositor::retainedSelectionEnabled() const
{
    Q_D(const QWaylandCompositor);
    return d->retainSelection;
}
 
/*!
 * \internal
 */
void QWaylandCompositor::retainedSelectionReceived(QMimeData *)
{
}
 
/*!
 * \internal
 */
void QWaylandCompositor::overrideSelection(const QMimeData *data)
{
    Q_D(QWaylandCompositor);
#if QT_CONFIG(wayland_datadevice)
    d->data_device_manager->overrideSelection(*data);
#endif
}
 
/*!
 * \qmlproperty WaylandSeat QtWayland.Compositor::WaylandCompositor::defaultSeat
 *
 * This property contains the default seat for this
 * WaylandCompositor.
 */
 
/*!
 * \property QWaylandCompositor::defaultSeat
 *
 * This property contains the default seat for this
 * QWaylandCompositor.
 */
QWaylandSeat *QWaylandCompositor::defaultSeat() const
{
    Q_D(const QWaylandCompositor);
    if (d->seats.size())
        return d->seats.first();
    return nullptr;
}
 
/*!
 * Select the seat for a given input event \a inputEvent.
 * Currently, Qt only supports a single seat.
 */
QWaylandSeat *QWaylandCompositor::seatFor(QInputEvent *inputEvent)
{
    Q_D(QWaylandCompositor);
    return d->seatFor(inputEvent);
}
 
/*!
 * \qmlproperty bool QtWayland.Compositor::WaylandCompositor::useHardwareIntegrationExtension
 * \default true
 *
 * This property holds whether the hardware integration extension should be enabled for
 * this WaylandCompositor.
 *
 * This property must be set before the compositor component is completed.
 */
 
/*!
 * \property QWaylandCompositor::useHardwareIntegrationExtension
 *
 * This property holds whether the hardware integration extension should be enabled for
 * this QWaylandCompositor.
 *
 * This property must be set before the compositor is \l{create()}{created}.
 */
bool QWaylandCompositor::useHardwareIntegrationExtension() const
{
#if QT_CONFIG(opengl)
    Q_D(const QWaylandCompositor);
    return d->use_hw_integration_extension;
#else
    return false;
#endif
}
 
void QWaylandCompositor::setUseHardwareIntegrationExtension(bool use)
{
#if QT_CONFIG(opengl)
    Q_D(QWaylandCompositor);
    if (use == d->use_hw_integration_extension)
        return;
 
    if (d->initialized)
        qWarning("Setting QWaylandCompositor::useHardwareIntegrationExtension after initialization has no effect");
 
    d->use_hw_integration_extension = use;
    useHardwareIntegrationExtensionChanged();
#else
    if (use)
        qWarning() << "Hardware integration not supported without OpenGL support";
#endif
}
 
/*!
 * Grab the surface content from the given \a buffer.
 * The default implementation requires a OpenGL context to be bound to the current thread
 * to work. If this is not possible, reimplement this function in your compositor subclass
 * to implement custom logic.
 * The default implementation only grabs shared memory and OpenGL buffers, reimplement this in your
 * compositor subclass to handle more buffer types.
 * \note You should not call this manually, but rather use QWaylandSurfaceGrabber (\a grabber).
 */
void QWaylandCompositor::grabSurface(QWaylandSurfaceGrabber *grabber, const QWaylandBufferRef &buffer)
{
    if (buffer.isSharedMemory()) {
        emit grabber->success(buffer.image());
    } else {
#if QT_CONFIG(opengl)
        if (QOpenGLContext::currentContext()) {
            QOpenGLFramebufferObject fbo(buffer.size());
            fbo.bind();
            QOpenGLTextureBlitter blitter;
            blitter.create();
 
 
            glViewport(0, 0, buffer.size().width(), buffer.size().height());
 
            QOpenGLTextureBlitter::Origin surfaceOrigin =
                buffer.origin() == QWaylandSurface::OriginTopLeft
                ? QOpenGLTextureBlitter::OriginTopLeft
                : QOpenGLTextureBlitter::OriginBottomLeft;
 
            auto texture = buffer.toOpenGLTexture();
            blitter.bind(texture->target());
            blitter.blit(texture->textureId(), QMatrix4x4(), surfaceOrigin);
            blitter.release();
 
            emit grabber->success(fbo.toImage());
        } else
#endif
        emit grabber->failed(QWaylandSurfaceGrabber::UnknownBufferType);
    }
}
 
/*!
 * \qmlproperty list<enum> QtWayland.Compositor::WaylandCompositor::additionalShmFormats
 *
 * This property holds the list of additional wl_shm formats advertised as supported by the
 * compositor.
 *
 * By default, only the required ShmFormat_ARGB8888 and ShmFormat_XRGB8888 are listed and this
 * list will be empty. Additional formats may require conversion internally and can thus affect
 * performance.
 *
 * This property must be set before the compositor component is completed. Subsequent changes
 * will have no effect.
 *
 * \since 6.0
 */
 
/*!
 * \property QWaylandCompositor::additionalShmFormats
 *
 * This property holds the list of additional wl_shm formats advertised as supported by the
 * compositor.
 *
 * By default, only the required ShmFormat_ARGB8888 and ShmFormat_XRGB8888 are listed and this
 * list will be empty.
 *
 * This property must be set before the compositor is \l{create()}{created}. Subsequent changes
 * will have no effect.
 *
 * \since 6.0
 */
void QWaylandCompositor::setAdditionalShmFormats(const QVector<ShmFormat> &additionalShmFormats)
{
    Q_D(QWaylandCompositor);
    if (d->initialized)
        qCWarning(qLcWaylandCompositorHardwareIntegration) << "Setting QWaylandCompositor::additionalShmFormats after initialization has no effect";
 
    d->shmFormats = additionalShmFormats;
    emit additionalShmFormatsChanged();
}
 
QVector<QWaylandCompositor::ShmFormat> QWaylandCompositor::additionalShmFormats() const
{
    Q_D(const QWaylandCompositor);
    return d->shmFormats;
}
 
void QWaylandCompositor::applicationStateChanged(Qt::ApplicationState state)
{
#if QT_CONFIG(xkbcommon)
    if (state == Qt::ApplicationInactive) {
        auto *seat = defaultSeat();
        if (seat != nullptr) {
            QWaylandKeyboardPrivate *keyb = QWaylandKeyboardPrivate::get(seat->keyboard());
            keyb->resetKeyboardState();
        }
    }
#else
    Q_UNUSED(state);
#endif
}
 
QT_END_NAMESPACE
 
#include "moc_qwaylandcompositor.cpp"