File indexing completed on 2024-05-19 16:35:18

 /*
     SPDX-FileCopyrightText: 2014 Martin Gräßlin <mgraesslin@kde.org>
     SPDX-FileCopyrightText: 2018 David Edmundson <davidedmundson@kde.org>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 #include "display.h"
 #include "clientbufferintegration.h"
 #include "display_p.h"
 #include "drmclientbuffer.h"
 #include "output_interface.h"
 #include "shmclientbuffer.h"
 #include "utils/common.h"
 
 #include <QAbstractEventDispatcher>
 #include <QCoreApplication>
 #include <QDebug>
 #include <QRect>
 
 namespace KWaylandServer
 {
 DisplayPrivate *DisplayPrivate::get(Display *display)
 {
     return display->d.get();
 }
 
 DisplayPrivate::DisplayPrivate(Display *q)
     : q(q)
 {
 }
 
 void DisplayPrivate::registerSocketName(const QString &socketName)
 {
     socketNames.append(socketName);
     Q_EMIT q->socketNamesChanged();
 }
 
 Display::Display(QObject *parent)
     : QObject(parent)
     , d(new DisplayPrivate(this))
 {
     d->display = wl_display_create();
     d->loop = wl_display_get_event_loop(d->display);
 }
 
 Display::~Display()
 {
     wl_display_destroy_clients(d->display);
     wl_display_destroy(d->display);
 }
 
 bool Display::addSocketFileDescriptor(int fileDescriptor, const QString &name)
 {
     if (wl_display_add_socket_fd(d->display, fileDescriptor)) {
         qCWarning(KWIN_CORE, "Failed to add %d fd to display", fileDescriptor);
         return false;
     }
     if (!name.isEmpty()) {
         d->registerSocketName(name);
     }
     return true;
 }
 
 bool Display::addSocketName(const QString &name)
 {
     if (name.isEmpty()) {
         const char *socket = wl_display_add_socket_auto(d->display);
         if (!socket) {
             qCWarning(KWIN_CORE, "Failed to find a free display socket");
             return false;
         }
         d->registerSocketName(QString::fromUtf8(socket));
     } else {
         if (wl_display_add_socket(d->display, qPrintable(name))) {
             qCWarning(KWIN_CORE, "Failed to add %s socket to display", qPrintable(name));
             return false;
         }
         d->registerSocketName(name);
     }
     return true;
 }
 
 QStringList Display::socketNames() const
 {
     return d->socketNames;
 }
 
 bool Display::start()
 {
     if (d->running) {
         return true;
     }
 
     const int fileDescriptor = wl_event_loop_get_fd(d->loop);
     if (fileDescriptor == -1) {
         qCWarning(KWIN_CORE) << "Did not get the file descriptor for the event loop";
         return false;
     }
 
     d->socketNotifier = new QSocketNotifier(fileDescriptor, QSocketNotifier::Read, this);
     connect(d->socketNotifier, &QSocketNotifier::activated, this, &Display::dispatchEvents);
 
     QAbstractEventDispatcher *dispatcher = QCoreApplication::eventDispatcher();
     connect(dispatcher, &QAbstractEventDispatcher::aboutToBlock, this, &Display::flush);
 
     d->running = true;
     Q_EMIT runningChanged(true);
 
     return true;
 }
 
 void Display::dispatchEvents()
 {
     if (wl_event_loop_dispatch(d->loop, 0) != 0) {
         qCWarning(KWIN_CORE) << "Error on dispatching Wayland event loop";
     }
 }
 
 void Display::flush()
 {
     wl_display_flush_clients(d->display);
 }
 
 void Display::createShm()
 {
     Q_ASSERT(d->display);
     new ShmClientBufferIntegration(this);
 }
 
 quint32 Display::nextSerial()
 {
     return wl_display_next_serial(d->display);
 }
 
 quint32 Display::serial()
 {
     return wl_display_get_serial(d->display);
 }
 
 bool Display::isRunning() const
 {
     return d->running;
 }
 
 Display::operator wl_display *()
 {
     return d->display;
 }
 
 Display::operator wl_display *() const
 {
     return d->display;
 }
 
 QList<OutputInterface *> Display::outputs() const
 {
     return d->outputs;
 }
 
 QList<OutputDeviceV2Interface *> Display::outputDevices() const
 {
     return d->outputdevicesV2;
 }
 
 QVector<OutputInterface *> Display::outputsIntersecting(const QRect &rect) const
 {
     QVector<OutputInterface *> outputs;
     for (auto *output : std::as_const(d->outputs)) {
         if (output->handle()->geometry().intersects(rect)) {
             outputs << output;
         }
     }
     return outputs;
 }
 
 QVector<SeatInterface *> Display::seats() const
 {
     return d->seats;
 }
 
 ClientConnection *Display::getConnection(wl_client *client)
 {
     Q_ASSERT(client);
     auto it = std::find_if(d->clients.constBegin(), d->clients.constEnd(), [client](ClientConnection *c) {
         return c->client() == client;
     });
     if (it != d->clients.constEnd()) {
         return *it;
     }
     // no ConnectionData yet, create it
     auto c = new ClientConnection(client, this);
     d->clients << c;
     connect(c, &ClientConnection::disconnected, this, [this](ClientConnection *c) {
         const int index = d->clients.indexOf(c);
         Q_ASSERT(index != -1);
         d->clients.remove(index);
         Q_ASSERT(d->clients.indexOf(c) == -1);
         Q_EMIT clientDisconnected(c);
     });
     Q_EMIT clientConnected(c);
     return c;
 }
 
 QVector<ClientConnection *> Display::connections() const
 {
     return d->clients;
 }
 
 ClientConnection *Display::createClient(int fd)
 {
     Q_ASSERT(fd != -1);
     Q_ASSERT(d->display);
     wl_client *c = wl_client_create(d->display, fd);
     if (!c) {
         return nullptr;
     }
     return getConnection(c);
 }
 
 void Display::setEglDisplay(void *display)
 {
     if (d->eglDisplay != EGL_NO_DISPLAY) {
         qCWarning(KWIN_CORE) << "EGLDisplay cannot be changed";
         return;
     }
     d->eglDisplay = (EGLDisplay)display;
     new DrmClientBufferIntegration(this);
 }
 
 void *Display::eglDisplay() const
 {
     return d->eglDisplay;
 }
 
 struct ClientBufferDestroyListener : wl_listener
 {
     ClientBufferDestroyListener(Display *display, ClientBuffer *buffer);
     ~ClientBufferDestroyListener();
 
     Display *display;
 };
 
 void bufferDestroyCallback(wl_listener *listener, void *data)
 {
     ClientBufferDestroyListener *destroyListener = static_cast<ClientBufferDestroyListener *>(listener);
     DisplayPrivate *displayPrivate = DisplayPrivate::get(destroyListener->display);
 
     ClientBuffer *buffer = displayPrivate->q->clientBufferForResource(static_cast<wl_resource *>(data));
     displayPrivate->unregisterClientBuffer(buffer);
 
     buffer->markAsDestroyed();
 }
 
 ClientBufferDestroyListener::ClientBufferDestroyListener(Display *display, ClientBuffer *buffer)
     : display(display)
 {
     notify = bufferDestroyCallback;
 
     link.prev = nullptr;
     link.next = nullptr;
 
     wl_resource_add_destroy_listener(buffer->resource(), this);
 }
 
 ClientBufferDestroyListener::~ClientBufferDestroyListener()
 {
     wl_list_remove(&link);
 }
 
 ClientBuffer *Display::clientBufferForResource(wl_resource *resource) const
 {
     ClientBuffer *buffer = d->resourceToBuffer.value(resource);
     if (buffer) {
         return buffer;
     }
 
     for (ClientBufferIntegration *integration : std::as_const(d->bufferIntegrations)) {
         ClientBuffer *buffer = integration->createBuffer(resource);
         if (buffer) {
             d->registerClientBuffer(buffer);
             return buffer;
         }
     }
     return nullptr;
 }
 
 void DisplayPrivate::registerClientBuffer(ClientBuffer *buffer)
 {
     resourceToBuffer.insert(buffer->resource(), buffer);
     bufferToListener.insert(buffer, new ClientBufferDestroyListener(q, buffer));
 }
 
 void DisplayPrivate::unregisterClientBuffer(ClientBuffer *buffer)
 {
     Q_ASSERT_X(buffer->resource(), "unregisterClientBuffer", "buffer must have valid resource");
     resourceToBuffer.remove(buffer->resource());
     delete bufferToListener.take(buffer);
 }
 
 }