Warning, file /frameworks/kwindowsystem/src/kwindowshadow.cpp was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 /*
     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()
 {
 }