File indexing completed on 2024-04-21 07:52:37

 /*
     SPDX-FileCopyrightText: 1997 Mathias Mueller <in5y158@public.uni-hamburg.de>
     SPDX-FileCopyrightText: 2006 Mauricio Piacentini <mauricio@tabuleiro.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 // own
 #include "kmahjonggtileset.h"
 
 // STL
 #include <cstdlib>
 
 // Qt
 #include <QFile>
 #include <QGuiApplication>
 #include <QPainter>
 #include <QPixmapCache>
 #include <QStandardPaths>
 #include <QSvgRenderer>
 
 // KF
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 
 // LibKMahjongg
 #include "libkmahjongg_debug.h"
 
 class KMahjonggTilesetMetricsData
 {
 public:
     short lvloffx = 0; // used for 3D indentation, x value
     short lvloffy = 0; // used for 3D indentation, y value
     short w = 0; // tile width ( +border +shadow)
     short h = 0; // tile height ( +border +shadow)
     short fw = 0; // face width
     short fh = 0; // face height
 
     KMahjonggTilesetMetricsData() = default;
 };
 
 class KMahjonggTilesetPrivate
 {
 public:
     KMahjonggTilesetPrivate() = default;
 
     void updateScaleInfo(short tilew, short tileh);
     void buildElementIdTable();
     QString pixmapCacheNameFromElementId(const QString &elementid, short width, short height) const;
     QPixmap renderElement(short width, short height, const QString &elementid) const;
 
 public:
     QList<QString> elementIdTable;
 
     QString name;
     QString description;
     QString license;
     QString copyrightText;
     QString version;
     QString website;
     QString bugReportUrl;
     QString authorName;
     QString authorEmailAddress;
 
     KMahjonggTilesetMetricsData originaldata;
     KMahjonggTilesetMetricsData scaleddata;
     QString filename; // cache the last file loaded to save reloading it
     QString graphicspath;
 
     mutable QSvgRenderer svg; // render() is non-const
     bool isSVG = false;
     bool graphicsLoaded = false;
 };
 
 // ---------------------------------------------------------
 
 KMahjonggTileset::KMahjonggTileset()
     : d_ptr(new KMahjonggTilesetPrivate)
 {
     Q_D(KMahjonggTileset);
 
     d->buildElementIdTable();
 }
 
 // ---------------------------------------------------------
 
 KMahjonggTileset::~KMahjonggTileset() = default;
 
 void KMahjonggTilesetPrivate::updateScaleInfo(short tilew, short tileh)
 {
     scaleddata.w = tilew;
     scaleddata.h = tileh;
     const double ratio = (static_cast<qreal>(scaleddata.w)) / (static_cast<qreal>(originaldata.w));
     scaleddata.lvloffx = static_cast<short>(originaldata.lvloffx * ratio);
     scaleddata.lvloffy = static_cast<short>(originaldata.lvloffy * ratio);
     scaleddata.fw = static_cast<short>(originaldata.fw * ratio);
     scaleddata.fh = static_cast<short>(originaldata.fh * ratio);
 }
 
 QSize KMahjonggTileset::preferredTileSize(QSize boardsize, int horizontalCells, int verticalCells) const
 {
     Q_D(const KMahjonggTileset);
 
     // calculate our best tile size to fit the boardsize passed to us
     qreal newtilew, newtileh, aspectratio;
     qreal bw = boardsize.width();
     qreal bh = boardsize.height();
 
     // use tileface for calculation, with one complete tile in the sum for extra margin
     qreal fullh = (d->originaldata.fh * verticalCells) + d->originaldata.h;
     qreal fullw = (d->originaldata.fw * horizontalCells) + d->originaldata.w;
     qreal floatw = d->originaldata.w;
     qreal floath = d->originaldata.h;
 
     if ((fullw / fullh) > (bw / bh)) {
         // space will be left on height, use width as limit
         aspectratio = bw / fullw;
     } else {
         aspectratio = bh / fullh;
     }
     newtilew = aspectratio * floatw;
     newtileh = aspectratio * floath;
     return QSize(static_cast<short>(newtilew), static_cast<short>(newtileh));
 }
 
 bool KMahjonggTileset::loadDefault()
 {
     Q_D(KMahjonggTileset);
 
     const QString tilesetPath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kmahjongglib/tilesets/default.desktop"));
     qCDebug(LIBKMAHJONGG_LOG) << "Inside LoadDefault(), located path at" << tilesetPath;
     if (tilesetPath.isEmpty()) {
         return false;
     }
     return loadTileset(tilesetPath);
 }
 
 QString KMahjonggTileset::name() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->name;
 }
 
 QString KMahjonggTileset::description() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->description;
 }
 
 QString KMahjonggTileset::license() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->license;
 }
 
 QString KMahjonggTileset::copyrightText() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->copyrightText;
 }
 
 QString KMahjonggTileset::version() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->version;
 }
 
 QString KMahjonggTileset::website() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->website;
 }
 
 QString KMahjonggTileset::bugReportUrl() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->bugReportUrl;
 }
 
 QString KMahjonggTileset::authorName() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->authorName;
 }
 
 QString KMahjonggTileset::authorEmailAddress() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->authorEmailAddress;
 }
 
 short KMahjonggTileset::width() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->scaleddata.w;
 }
 
 short KMahjonggTileset::height() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->scaleddata.h;
 }
 
 short KMahjonggTileset::levelOffsetX() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->scaleddata.lvloffx;
 }
 
 short KMahjonggTileset::levelOffsetY() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->scaleddata.lvloffy;
 }
 
 short KMahjonggTileset::qWidth() const
 {
     Q_D(const KMahjonggTileset);
 
     return static_cast<short>(d->scaleddata.fw / 2.0);
 }
 
 short KMahjonggTileset::qHeight() const
 {
     Q_D(const KMahjonggTileset);
 
     return static_cast<short>(d->scaleddata.fh / 2.0);
 }
 
 QString KMahjonggTileset::path() const
 {
     Q_D(const KMahjonggTileset);
 
     return d->filename;
 }
 
 #define kTilesetVersionFormat 1
 
 // ---------------------------------------------------------
 bool KMahjonggTileset::loadTileset(const QString &tilesetPath)
 {
     Q_D(KMahjonggTileset);
 
     // qCDebug(LIBKMAHJONGG_LOG) << "Attempting to load .desktop at" << tilesetPath;
 
     // verify if it is a valid file first and if we can open it
     QFile tilesetfile(tilesetPath);
     if (!tilesetfile.open(QIODevice::ReadOnly)) {
         d->name.clear();
         d->description.clear();
         d->license.clear();
         d->copyrightText.clear();
         d->version.clear();
         d->website.clear();
         d->bugReportUrl.clear();
         d->authorName.clear();
         d->authorEmailAddress.clear();
         return false;
     }
     tilesetfile.close();
 
     KConfig tileconfig(tilesetPath, KConfig::SimpleConfig);
     KConfigGroup group = tileconfig.group(QStringLiteral("KMahjonggTileset"));
 
     d->name = group.readEntry("Name"); // Returns translated data
     d->description = group.readEntry("Description");
     d->license = group.readEntry("License");
     d->copyrightText = group.readEntry("Copyright");
     d->version = group.readEntry("Version");
     d->website = group.readEntry("Website");
     d->bugReportUrl = group.readEntry("BugReportUrl");
     d->authorName = group.readEntry("Author");
     d->authorEmailAddress = group.readEntry("AuthorEmail");
 
     // Version control
     int tileversion = group.readEntry("VersionFormat", 0);
     // Format is increased when we have incompatible changes, meaning that older clients are not able to use the remaining information safely
     if (tileversion > kTilesetVersionFormat) {
         return false;
     }
 
     QString graphName = group.readEntry("FileName");
 
     d->graphicspath = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kmahjongglib/tilesets/") + graphName);
     // qCDebug(LIBKMAHJONGG_LOG) << "Using tileset at" << d->graphicspath;
 
     // only SVG for now
     d->isSVG = true;
     if (d->graphicspath.isEmpty()) {
         return false;
     }
 
     d->originaldata.w = group.readEntry("TileWidth", 30);
     d->originaldata.h = group.readEntry("TileHeight", 50);
     d->originaldata.fw = group.readEntry("TileFaceWidth", 30);
     d->originaldata.fh = group.readEntry("TileFaceHeight", 50);
     d->originaldata.lvloffx = group.readEntry("LevelOffsetX", 10);
     d->originaldata.lvloffy = group.readEntry("LevelOffsetY", 10);
 
     // client application needs to call loadGraphics()
     d->graphicsLoaded = false;
     d->filename = tilesetPath;
 
     return true;
 }
 
 // ---------------------------------------------------------
 bool KMahjonggTileset::loadGraphics()
 {
     Q_D(KMahjonggTileset);
 
     if (d->graphicsLoaded) {
         return true;
     }
     if (d->isSVG) {
         // really?
         d->svg.load(d->graphicspath);
         if (d->svg.isValid()) {
             // invalidate our global cache
             QPixmapCache::clear();
             d->graphicsLoaded = true;
             reloadTileset(QSize(d->originaldata.w, d->originaldata.h));
         } else {
             return false;
         }
     } else {
         // TODO add support for png??
         return false;
     }
 
     return true;
 }
 
 // ---------------------------------------------------------
 bool KMahjonggTileset::reloadTileset(QSize newTilesize)
 {
     Q_D(KMahjonggTileset);
 
     if (QSize(d->scaleddata.w, d->scaleddata.h) == newTilesize) {
         return false;
     }
 
     if (d->isSVG) {
         if (d->svg.isValid()) {
             d->updateScaleInfo(newTilesize.width(), newTilesize.height());
             // rendering will be done when needed, automatically using the global cache
         } else {
             return false;
         }
     } else {
         // TODO add support for png???
         return false;
     }
 
     return true;
 }
 
 void KMahjonggTilesetPrivate::buildElementIdTable()
 {
     constexpr int tileCount = 4;
     constexpr int characterCount = 9;
     constexpr int bambooCount = 9;
     constexpr int rodCount = 9;
     constexpr int seasonCount = 4;
     constexpr int windCount = 4;
     constexpr int dragonCount = 3;
     constexpr int flowerCount = 4;
 
     elementIdTable.reserve(2 * tileCount + characterCount + bambooCount + rodCount + seasonCount + windCount + dragonCount + flowerCount);
 
     // Build a list for faster lookup of element ids, mapped to the enumeration used by GameData and BoardWidget
     // Unselected tiles
     for (short idx = 1; idx <= tileCount; idx++) {
         elementIdTable.append(QStringLiteral("TILE_%1").arg(idx));
     }
     // Selected tiles
     for (short idx = 1; idx <= tileCount; idx++) {
         elementIdTable.append(QStringLiteral("TILE_%1_SEL").arg(idx));
     }
     // now faces
     for (short idx = 1; idx <= characterCount; idx++) {
         elementIdTable.append(QStringLiteral("CHARACTER_%1").arg(idx));
     }
     for (short idx = 1; idx <= bambooCount; idx++) {
         elementIdTable.append(QStringLiteral("BAMBOO_%1").arg(idx));
     }
     for (short idx = 1; idx <= rodCount; idx++) {
         elementIdTable.append(QStringLiteral("ROD_%1").arg(idx));
     }
     for (short idx = 1; idx <= seasonCount; idx++) {
         elementIdTable.append(QStringLiteral("SEASON_%1").arg(idx));
     }
     for (short idx = 1; idx <= windCount; idx++) {
         elementIdTable.append(QStringLiteral("WIND_%1").arg(idx));
     }
     for (short idx = 1; idx <= dragonCount; idx++) {
         elementIdTable.append(QStringLiteral("DRAGON_%1").arg(idx));
     }
     for (short idx = 1; idx <= flowerCount; idx++) {
         elementIdTable.append(QStringLiteral("FLOWER_%1").arg(idx));
     }
 }
 
 QString KMahjonggTilesetPrivate::pixmapCacheNameFromElementId(const QString &elementid, short width, short height) const
 {
     return name + elementid + QStringLiteral("W%1H%2").arg(width).arg(height);
 }
 
 QPixmap KMahjonggTilesetPrivate::renderElement(short width, short height, const QString &elementid) const
 {
     // qCDebug(LIBKMAHJONGG_LOG) << "render element" << elementid << width << height;
     QPixmap qiRend(width, height);
     qiRend.fill(Qt::transparent);
 
     if (svg.isValid()) {
         QPainter p(&qiRend);
         svg.render(&p, elementid);
     }
     return qiRend;
 }
 
 QPixmap KMahjonggTileset::selectedTile(int num) const
 {
     Q_D(const KMahjonggTileset);
 
     QPixmap pm;
 
     const qreal dpr = qApp->devicePixelRatio();
     // use tile size
     const short width = d->scaleddata.w * dpr;
     const short height = d->scaleddata.h * dpr;
     QString elemId = d->elementIdTable.at(num + 4); // selected offset in our idtable;
     // using raw pixmap size with cache id, as the rendering is done dpr-ignorant
     const  QString pixmapCacheName = d->pixmapCacheNameFromElementId(elemId, width, height);
     if (!QPixmapCache::find(pixmapCacheName, &pm)) {
         pm = d->renderElement(width, height, elemId);
         pm.setDevicePixelRatio(dpr);
         QPixmapCache::insert(pixmapCacheName, pm);
     }
     return pm;
 }
 
 QPixmap KMahjonggTileset::unselectedTile(int num) const
 {
     Q_D(const KMahjonggTileset);
 
     QPixmap pm;
 
     const qreal dpr = qApp->devicePixelRatio();
     // use tile size
     const short width = d->scaleddata.w * dpr;
     const short height = d->scaleddata.h * dpr;
     QString elemId = d->elementIdTable.at(num);
     // using raw pixmap size with cache id, as the rendering is done dpr-ignorant
     const  QString pixmapCacheName = d->pixmapCacheNameFromElementId(elemId, width, height);
     if (!QPixmapCache::find(pixmapCacheName, &pm)) {
         pm = d->renderElement(width, height, elemId);
         pm.setDevicePixelRatio(dpr);
         QPixmapCache::insert(pixmapCacheName, pm);
     }
     return pm;
 }
 
 QPixmap KMahjonggTileset::tileface(int num) const
 {
     Q_D(const KMahjonggTileset);
 
     QPixmap pm;
     if ((num + 8) >= d->elementIdTable.count()) {
         // qCDebug(LIBKMAHJONGG_LOG) << "Client asked for invalid tileface id";
         return pm;
     }
 
     const qreal dpr = qApp->devicePixelRatio();
     // use face size
     const short width = d->scaleddata.fw * dpr;
     const short height = d->scaleddata.fh * dpr;
     QString elemId = d->elementIdTable.at(num + 8); // tileface offset in our idtable;
     // using raw pixmap size with cache id, as the rendering is done dpr-ignorant
     const  QString pixmapCacheName = d->pixmapCacheNameFromElementId(elemId, width, height);
     if (!QPixmapCache::find(pixmapCacheName, &pm)) {
         pm = d->renderElement(width, height, elemId);
         pm.setDevicePixelRatio(dpr);
         QPixmapCache::insert(pixmapCacheName, pm);
     }
     return pm;
 }