Advance Wayland and KDE package bring-up

Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>

local/recipes/kde/kf6-kwindowsystem/source/src/kwindowshadow.cpp

@@ -0,0 +1,338 @@
+/*
+    SPDX-FileCopyrightText: 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
+
+    SPDX-License-Identifier: LGPL-2.1-or-later
+*/
+
+#include "kwindowshadow.h"
+#include "kwindowshadow_dummy_p.h"
+#include "kwindowshadow_p.h"
+#include "kwindowsystem_debug.h"
+#include "pluginwrapper_p.h"
+
+#include <array>
+
+KWindowShadowTile::KWindowShadowTile()
+    : d(KWindowSystemPluginWrapper::self().createWindowShadowTile())
+{
+}
+
+KWindowShadowTile::~KWindowShadowTile()
+{
+    if (d->isCreated) {
+        d->destroy();
+    }
+}
+
+QImage KWindowShadowTile::image() const
+{
+    return d->image;
+}
+
+void KWindowShadowTile::setImage(const QImage &image)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot change the image on a tile that already has native "
+                  "platform resources allocated.");
+        return;
+    }
+    d->image = image;
+}
+
+bool KWindowShadowTile::isCreated() const
+{
+    return d->isCreated;
+}
+
+bool KWindowShadowTile::create()
+{
+    if (d->isCreated) {
+        return true;
+    }
+    d->isCreated = d->create();
+    return d->isCreated;
+}
+
+KWindowShadow::KWindowShadow(QObject *parent)
+    : QObject(parent)
+    , d(KWindowSystemPluginWrapper::self().createWindowShadow())
+{
+}
+
+KWindowShadow::~KWindowShadow()
+{
+    destroy();
+}
+
+KWindowShadowTile::Ptr KWindowShadow::leftTile() const
+{
+    return d->leftTile;
+}
+
+void KWindowShadow::setLeftTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a left tile to a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setLeftTile() and create()");
+        return;
+    }
+    d->leftTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::topLeftTile() const
+{
+    return d->topLeftTile;
+}
+
+void KWindowShadow::setTopLeftTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a top-left tile to a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setTopLeftTile() and create()");
+        return;
+    }
+    d->topLeftTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::topTile() const
+{
+    return d->topTile;
+}
+
+void KWindowShadow::setTopTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a top tile to a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setTopTile() and create()");
+        return;
+    }
+    d->topTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::topRightTile() const
+{
+    return d->topRightTile;
+}
+
+void KWindowShadow::setTopRightTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a top-right tile to a shadow that already "
+                  "has native platform resources allocated. To do so, destroy() the shadow and "
+                  "then setTopRightTile() and create()");
+        return;
+    }
+    d->topRightTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::rightTile() const
+{
+    return d->rightTile;
+}
+
+void KWindowShadow::setRightTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a right tile to a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setRightTile() and create()");
+        return;
+    }
+    d->rightTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::bottomRightTile() const
+{
+    return d->bottomRightTile;
+}
+
+void KWindowShadow::setBottomRightTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a bottom-right tile to a shadow that already "
+                  "has native platform resources allocated. To do so, destroy() the shadow and "
+                  "then setBottomRightTile() and create()");
+        return;
+    }
+    d->bottomRightTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::bottomTile() const
+{
+    return d->bottomTile;
+}
+
+void KWindowShadow::setBottomTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a bottom tile to a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setBottomTile() and create()");
+        return;
+    }
+    d->bottomTile = tile;
+}
+
+KWindowShadowTile::Ptr KWindowShadow::bottomLeftTile() const
+{
+    return d->bottomLeftTile;
+}
+
+void KWindowShadow::setBottomLeftTile(KWindowShadowTile::Ptr tile)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot attach a bottom-left tile to a shadow that already "
+                  "has native platform resources allocated. To do so, destroy() the shadow and "
+                  "then setBottomLeftTile() and create()");
+        return;
+    }
+    d->bottomLeftTile = tile;
+}
+
+QMargins KWindowShadow::padding() const
+{
+    return d->padding;
+}
+
+void KWindowShadow::setPadding(const QMargins &padding)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot set the padding on a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and "
+                  "then setPadding() and create()");
+        return;
+    }
+    d->padding = padding;
+}
+
+QWindow *KWindowShadow::window() const
+{
+    return d->window;
+}
+
+void KWindowShadow::setWindow(QWindow *window)
+{
+    if (d->isCreated) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot set the target window on a shadow that already has "
+                  "native platform resources allocated. To do so, destroy() the shadow and then "
+                  "setWindow() and create()");
+        return;
+    }
+    d->window = window;
+}
+
+bool KWindowShadow::isCreated() const
+{
+    return d->isCreated;
+}
+
+bool KWindowShadow::create()
+{
+    if (d->isCreated) {
+        return true;
+    }
+    if (!d->window) {
+        qCWarning(LOG_KWINDOWSYSTEM,
+                  "Cannot allocate the native platform resources for the shadow "
+                  "because the target window is not specified.");
+        return false;
+    }
+    if (!d->prepareTiles()) {
+        return false;
+    }
+    d->isCreated = d->create();
+    return d->isCreated;
+}
+
+void KWindowShadow::destroy()
+{
+    if (!d->isCreated) {
+        return;
+    }
+    d->destroy();
+    d->isCreated = false;
+}
+
+KWindowShadowTilePrivate::~KWindowShadowTilePrivate()
+{
+}
+
+KWindowShadowTilePrivate *KWindowShadowTilePrivate::get(const KWindowShadowTile *tile)
+{
+    return tile->d.data();
+}
+
+KWindowShadowPrivate::~KWindowShadowPrivate()
+{
+}
+
+bool KWindowShadowPrivate::create()
+{
+    return false;
+}
+
+void KWindowShadowPrivate::destroy()
+{
+}
+
+bool KWindowShadowPrivate::prepareTiles()
+{
+    const std::array<KWindowShadowTile *, 8> tiles{
+        leftTile.data(),
+        topLeftTile.data(),
+        topTile.data(),
+        topRightTile.data(),
+        rightTile.data(),
+        bottomRightTile.data(),
+        bottomTile.data(),
+        bottomLeftTile.data(),
+    };
+
+    for (KWindowShadowTile *tile : tiles) {
+        if (!tile) {
+            continue;
+        }
+        if (tile->isCreated()) {
+            continue;
+        }
+        if (!tile->create()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool KWindowShadowTilePrivateDummy::create()
+{
+    return false;
+}
+
+void KWindowShadowTilePrivateDummy::destroy()
+{
+}
+
+bool KWindowShadowPrivateDummy::create()
+{
+    return false;
+}
+
+void KWindowShadowPrivateDummy::destroy()
+{
+}
+
+#include "moc_kwindowshadow.cpp"