File indexing completed on 2024-11-10 04:57:24

 /*
     SPDX-FileCopyrightText: 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "xcursortheme.h"
 #include "3rdparty/xcursor.h"
 
 #include <KConfig>
 #include <KConfigGroup>
 
 #include <QDir>
 #include <QFile>
 #include <QSet>
 #include <QSharedData>
 #include <QStack>
 #include <QStandardPaths>
 
 namespace KWin
 {
 
 class KXcursorSpritePrivate : public QSharedData
 {
 public:
     QImage data;
     QPoint hotspot;
     std::chrono::milliseconds delay;
 };
 
 class KXcursorThemePrivate : public QSharedData
 {
 public:
     void load(const QString &themeName, int size, qreal devicePixelRatio);
     void loadCursors(const QString &packagePath, int size, qreal devicePixelRatio);
 
     QHash<QByteArray, QList<KXcursorSprite>> registry;
 };
 
 KXcursorSprite::KXcursorSprite()
     : d(new KXcursorSpritePrivate)
 {
 }
 
 KXcursorSprite::KXcursorSprite(const KXcursorSprite &other)
     : d(other.d)
 {
 }
 
 KXcursorSprite::~KXcursorSprite()
 {
 }
 
 KXcursorSprite &KXcursorSprite::operator=(const KXcursorSprite &other)
 {
     d = other.d;
     return *this;
 }
 
 KXcursorSprite::KXcursorSprite(const QImage &data, const QPoint &hotspot,
                                const std::chrono::milliseconds &delay)
     : d(new KXcursorSpritePrivate)
 {
     d->data = data;
     d->hotspot = hotspot;
     d->delay = delay;
 }
 
 QImage KXcursorSprite::data() const
 {
     return d->data;
 }
 
 QPoint KXcursorSprite::hotspot() const
 {
     return d->hotspot;
 }
 
 std::chrono::milliseconds KXcursorSprite::delay() const
 {
     return d->delay;
 }
 
 static QList<KXcursorSprite> loadCursor(const QString &filePath, int desiredSize, qreal devicePixelRatio)
 {
     XcursorImages *images = XcursorFileLoadImages(QFile::encodeName(filePath), desiredSize * devicePixelRatio);
     if (!images) {
         return {};
     }
 
     QList<KXcursorSprite> sprites;
     for (int i = 0; i < images->nimage; ++i) {
         const XcursorImage *nativeCursorImage = images->images[i];
         const qreal scale = std::max(qreal(1), qreal(nativeCursorImage->size) / desiredSize);
         const QPoint hotspot(nativeCursorImage->xhot, nativeCursorImage->yhot);
         const std::chrono::milliseconds delay(nativeCursorImage->delay);
 
         QImage data(nativeCursorImage->width, nativeCursorImage->height, QImage::Format_ARGB32_Premultiplied);
         data.setDevicePixelRatio(scale);
         memcpy(data.bits(), nativeCursorImage->pixels, data.sizeInBytes());
 
         sprites.append(KXcursorSprite(data, hotspot / scale, delay));
     }
 
     XcursorImagesDestroy(images);
     return sprites;
 }
 
 void KXcursorThemePrivate::loadCursors(const QString &packagePath, int size, qreal devicePixelRatio)
 {
     const QDir dir(packagePath);
     QFileInfoList entries = dir.entryInfoList(QDir::Files | QDir::NoDotAndDotDot);
     std::partition(entries.begin(), entries.end(), [](const QFileInfo &fileInfo) {
         return !fileInfo.isSymLink();
     });
 
     for (const QFileInfo &entry : std::as_const(entries)) {
         const QByteArray shape = QFile::encodeName(entry.fileName());
         if (registry.contains(shape)) {
             continue;
         }
         if (entry.isSymLink()) {
             const QFileInfo symLinkInfo(entry.symLinkTarget());
             if (symLinkInfo.absolutePath() == entry.absolutePath()) {
                 const auto sprites = registry.value(QFile::encodeName(symLinkInfo.fileName()));
                 if (!sprites.isEmpty()) {
                     registry.insert(shape, sprites);
                     continue;
                 }
             }
         }
         const QList<KXcursorSprite> sprites = loadCursor(entry.absoluteFilePath(), size, devicePixelRatio);
         if (!sprites.isEmpty()) {
             registry.insert(shape, sprites);
         }
     }
 }
 
 static QStringList searchPaths()
 {
     static QStringList paths;
     if (paths.isEmpty()) {
         if (const QString env = qEnvironmentVariable("XCURSOR_PATH"); !env.isEmpty()) {
             paths.append(env.split(':', Qt::SkipEmptyParts));
         } else {
             const QString home = QDir::homePath();
             if (!home.isEmpty()) {
                 paths.append(home + QLatin1String("/.icons"));
             }
             const QStringList dataDirs = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
             for (const QString &dataDir : dataDirs) {
                 paths.append(dataDir + QLatin1String("/icons"));
             }
         }
     }
     return paths;
 }
 
 void KXcursorThemePrivate::load(const QString &themeName, int size, qreal devicePixelRatio)
 {
     const QStringList paths = searchPaths();
 
     QStack<QString> stack;
     QSet<QString> loaded;
 
     stack.push(themeName);
 
     while (!stack.isEmpty()) {
         const QString themeName = stack.pop();
         if (loaded.contains(themeName)) {
             continue;
         }
 
         QStringList inherits;
 
         for (const QString &path : paths) {
             const QDir dir(path + QLatin1Char('/') + themeName);
             if (!dir.exists()) {
                 continue;
             }
             loadCursors(dir.filePath(QStringLiteral("cursors")), size, devicePixelRatio);
             if (inherits.isEmpty()) {
                 const KConfig config(dir.filePath(QStringLiteral("index.theme")), KConfig::NoGlobals);
                 inherits << KConfigGroup(&config, QStringLiteral("Icon Theme")).readEntry("Inherits", QStringList());
             }
         }
 
         loaded.insert(themeName);
         for (auto it = inherits.crbegin(); it != inherits.crend(); ++it) {
             stack.push(*it);
         }
     }
 }
 
 KXcursorTheme::KXcursorTheme()
     : d(new KXcursorThemePrivate)
 {
 }
 
 KXcursorTheme::KXcursorTheme(const QString &themeName, int size, qreal devicePixelRatio)
     : d(new KXcursorThemePrivate)
 {
     d->load(themeName, size, devicePixelRatio);
 }
 
 KXcursorTheme::KXcursorTheme(const KXcursorTheme &other)
     : d(other.d)
 {
 }
 
 KXcursorTheme::~KXcursorTheme()
 {
 }
 
 KXcursorTheme &KXcursorTheme::operator=(const KXcursorTheme &other)
 {
     d = other.d;
     return *this;
 }
 
 bool KXcursorTheme::operator==(const KXcursorTheme &other)
 {
     return d == other.d;
 }
 
 bool KXcursorTheme::operator!=(const KXcursorTheme &other)
 {
     return !(*this == other);
 }
 
 bool KXcursorTheme::isEmpty() const
 {
     return d->registry.isEmpty();
 }
 
 QList<KXcursorSprite> KXcursorTheme::shape(const QByteArray &name) const
 {
     return d->registry.value(name);
 }
 
 } // namespace KWin