File indexing completed on 2024-05-12 05:32:32

 /*
     SPDX-FileCopyrightText: 2017 Marco Martin <notmart@gmail.com>
     SPDX-FileCopyrightText: 2021 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
     SPDX-FileCopyrightText: 2023 Kai Uwe Broulik <kde@broulik.de>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "display.h"
 #include "xdgforeign_v2_p.h"
 
 #include <QUuid>
 
 namespace KWin
 {
 static const quint32 s_exporterVersion = 1;
 static const quint32 s_importerVersion = 1;
 
 XdgExportedSurface::XdgExportedSurface(SurfaceInterface *surface)
     : QObject()
     , m_handle(QUuid::createUuid().toString(QUuid::WithoutBraces))
     , m_surface(surface)
 {
     connect(m_surface, &QObject::destroyed, this, &XdgExportedSurface::handleSurfaceDestroyed);
 }
 
 QString XdgExportedSurface::handle() const
 {
     return m_handle;
 }
 
 SurfaceInterface *XdgExportedSurface::surface() const
 {
     return m_surface;
 }
 
 void XdgExportedSurface::handleSurfaceDestroyed()
 {
     delete this;
 }
 
 XdgForeignV2InterfacePrivate::XdgForeignV2InterfacePrivate(Display *display, XdgForeignV2Interface *_q)
     : q(_q)
     , exporter(new XdgExporterV2Interface(display, _q))
     , importer(new XdgImporterV2Interface(display, _q))
 {
 }
 
 XdgForeignV2Interface::XdgForeignV2Interface(Display *display, QObject *parent)
     : QObject(parent)
     , d(new XdgForeignV2InterfacePrivate(display, this))
 {
 }
 
 XdgForeignV2Interface::~XdgForeignV2Interface()
 {
 }
 
 SurfaceInterface *XdgForeignV2Interface::transientFor(SurfaceInterface *surface)
 {
     return d->importer->transientFor(surface);
 }
 
 XdgExportedSurface *XdgForeignV2Interface::exportSurface(SurfaceInterface *surface)
 {
     return d->exporter->exportSurface(surface);
 }
 
 XdgExporterV2Interface::XdgExporterV2Interface(Display *display, XdgForeignV2Interface *foreign)
     : QObject(foreign)
     , QtWaylandServer::zxdg_exporter_v2(*display, s_exporterVersion)
 {
 }
 
 XdgExportedSurface *XdgExporterV2Interface::exportedSurface(const QString &handle) const
 {
     return m_exportedSurfaces.value(handle);
 }
 
 XdgExportedSurface *XdgExporterV2Interface::exportSurface(SurfaceInterface *surface)
 {
     auto *exported = new XdgExportedSurface(surface);
     addExported(exported);
     return exported;
 }
 
 void XdgExporterV2Interface::addExported(XdgExportedSurface *exported)
 {
     const QString handle = exported->handle();
     connect(exported, &XdgExportedSurface::destroyed, this, [this, handle] {
         m_exportedSurfaces.remove(handle);
     });
     m_exportedSurfaces[handle] = exported;
 }
 
 void XdgExporterV2Interface::zxdg_exporter_v2_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void XdgExporterV2Interface::zxdg_exporter_v2_export_toplevel(Resource *resource, uint32_t id, wl_resource *surface_resource)
 {
     SurfaceInterface *surface = SurfaceInterface::get(surface_resource);
     if (!surface) {
         wl_resource_post_error(resource->handle, 0, "Invalid  surface");
         return;
     }
 
     wl_resource *exportedResource = wl_resource_create(resource->client(), &zxdg_exported_v2_interface, resource->version(), id);
     if (!exportedResource) {
         wl_client_post_no_memory(resource->client());
         return;
     }
 
     XdgExportedV2Interface *exported = new XdgExportedV2Interface(surface, exportedResource);
     addExported(exported);
 
     exported->send_handle(exported->handle());
 }
 
 XdgImporterV2Interface::XdgImporterV2Interface(Display *display, XdgForeignV2Interface *foreign)
     : QObject(foreign)
     , QtWaylandServer::zxdg_importer_v2(*display, s_importerVersion)
     , m_foreign(foreign)
 {
 }
 
 SurfaceInterface *XdgImporterV2Interface::transientFor(SurfaceInterface *surface)
 {
     auto it = m_parents.constFind(surface);
     if (it == m_parents.constEnd()) {
         return nullptr;
     }
     return (*it)->surface();
 }
 
 void XdgImporterV2Interface::zxdg_importer_v2_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void XdgImporterV2Interface::zxdg_importer_v2_import_toplevel(Resource *resource, uint32_t id, const QString &handle)
 {
     wl_resource *importedResource = wl_resource_create(resource->client(), &zxdg_imported_v2_interface, resource->version(), id);
     if (!importedResource) {
         wl_client_post_no_memory(resource->client());
         return;
     }
 
     // If there is no exported surface with the specified handle, we must still create an
     // inert xdg_imported object and send the destroyed event right afterwards.
     XdgExportedSurface *exported = m_foreign->d->exporter->exportedSurface(handle);
     if (!exported) {
         auto imported = new XdgDummyImportedV2Interface(importedResource);
         imported->send_destroyed();
         return;
     }
 
     XdgImportedV2Interface *imported = new XdgImportedV2Interface(exported, importedResource);
 
     connect(imported, &XdgImportedV2Interface::childChanged, this, [this, imported](SurfaceInterface *child) {
         link(imported, child);
 
         // child surface destroyed
         connect(child, &QObject::destroyed, this, [this, child]() {
             unlink(nullptr, child);
         });
     });
 
     // surface no longer imported
     connect(imported, &XdgImportedV2Interface::destroyed, this, [this, imported]() {
         unlink(imported, nullptr);
     });
 }
 
 void XdgImporterV2Interface::link(XdgImportedV2Interface *parent, SurfaceInterface *child)
 {
     // remove any previous association
     auto it = m_children.find(parent);
     if (it != m_children.end()) {
         m_parents.remove(*it);
         m_children.erase(it);
     }
 
     m_parents[child] = parent;
     m_children[parent] = child;
 
     Q_EMIT m_foreign->transientChanged(child, parent->surface());
 }
 
 void XdgImporterV2Interface::unlink(XdgImportedV2Interface *parent, SurfaceInterface *child)
 {
     if (parent) {
         // If the parent endpoint is unlinked, the transientChanged() signal will indicate
         // the orphaned child.
         auto it = m_children.find(parent);
         if (it != m_children.end()) {
             SurfaceInterface *child = *it;
             m_parents.remove(*it);
             m_children.erase(it);
             Q_EMIT m_foreign->transientChanged(child, nullptr);
         }
     } else if (child) {
         // If the child endpoint is unlinked, the transientChanged() signal will indicate
         // what parent has lost a child.
         auto it = m_parents.find(child);
         if (it != m_parents.end()) {
             XdgImportedV2Interface *parent = *it;
             m_children.remove(*it);
             m_parents.erase(it);
             Q_EMIT m_foreign->transientChanged(nullptr, parent->surface());
         }
     }
 }
 
 XdgExportedV2Interface::XdgExportedV2Interface(SurfaceInterface *surface, wl_resource *resource)
     : XdgExportedSurface(surface)
     , QtWaylandServer::zxdg_exported_v2(resource)
 {
 }
 
 void XdgExportedV2Interface::zxdg_exported_v2_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void XdgExportedV2Interface::zxdg_exported_v2_destroy_resource(Resource *resource)
 {
     delete this;
 }
 
 XdgDummyImportedV2Interface::XdgDummyImportedV2Interface(wl_resource *resource)
     : QtWaylandServer::zxdg_imported_v2(resource)
 {
 }
 
 void XdgDummyImportedV2Interface::zxdg_imported_v2_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void XdgDummyImportedV2Interface::zxdg_imported_v2_destroy_resource(Resource *resource)
 {
     delete this;
 }
 
 XdgImportedV2Interface::XdgImportedV2Interface(XdgExportedSurface *exported, wl_resource *resource)
     : QtWaylandServer::zxdg_imported_v2(resource)
     , m_exported(exported)
 {
     connect(exported, &XdgExportedSurface::destroyed, this, &XdgImportedV2Interface::handleExportedDestroyed);
 }
 
 SurfaceInterface *XdgImportedV2Interface::child() const
 {
     return m_child;
 }
 
 SurfaceInterface *XdgImportedV2Interface::surface() const
 {
     return m_exported->surface();
 }
 
 void XdgImportedV2Interface::zxdg_imported_v2_set_parent_of(Resource *resource, wl_resource *surface)
 {
     SurfaceInterface *surf = SurfaceInterface::get(surface);
 
     if (!surf) {
         return;
     }
 
     m_child = surf;
     Q_EMIT childChanged(surf);
 }
 
 void XdgImportedV2Interface::zxdg_imported_v2_destroy(Resource *resource)
 {
     wl_resource_destroy(resource->handle);
 }
 
 void XdgImportedV2Interface::zxdg_imported_v2_destroy_resource(Resource *resource)
 {
     delete this;
 }
 
 void XdgImportedV2Interface::handleExportedDestroyed()
 {
     send_destroyed();
     delete this;
 }
 
 }
 
 #include "moc_xdgforeign_v2.cpp"
 #include "moc_xdgforeign_v2_p.cpp"