Combine QImage::flip version checks

include/core/tile.h

@@ -18,6 +18,9 @@ public:
     uint16_t palette:4;
     uint16_t rawValue() const;
 
+    Qt::Orientations orientation() const;
+    void flip(QImage *image) const;
+
     static int getIndexInTileset(int);
 
     static const uint16_t maxValue;

include/ui/mapview.h

@@ -4,6 +4,7 @@
 #include <QJSValue>
 #include "graphicsview.h"
 #include "overlay.h"
+#include "tile.h"
 
 class Editor;
 
@@ -82,6 +83,7 @@ private:
     QMap<int, Overlay*> overlayMap;
 
     void updateScene();
+    void addTileImage(int x, int y, const Tile &tile, bool setTransparency, int layer = 0);
 };
 
 #endif // GRAPHICSVIEW_H

src/core/tile.cpp

@@ -41,6 +41,22 @@ uint16_t Tile::rawValue() const {
          | bitsPalette.pack(this->palette);
 }
 
+Qt::Orientations Tile::orientation() const {
+    return Util::getOrientation(this->xflip, this->yflip);
+}
+
+void Tile::flip(QImage *image) const {
+    if (!image) return;
+
+    // QImage::flip was introduced in 6.9.0 to replace QImage::mirrored.
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
+    image->flip(this->orientation());
+#else
+    *image = image->mirrored(this->xflip, this->yflip);
+#endif
+
+}
+
 int Tile::getIndexInTileset(int tileId) {
     if (tileId < Project::getNumTilesPrimary()) {
         return tileId;

src/scriptapi/apioverlay.cpp

@@ -270,29 +270,27 @@ void MapView::createImage(int x, int y, QString filepath, int width, int height,
 }
 
 void MapView::addTileImage(int x, int y, int tileId, bool xflip, bool yflip, int paletteId, bool setTransparency, int layer) {
-    if (!this->editor || !this->editor->layout || !this->editor->layout->tileset_primary || !this->editor->layout->tileset_secondary)
+    this->addTileImage(x, y, Tile(tileId, xflip, yflip, paletteId), setTransparency, layer);
+}
+
+void MapView::addTileImage(int x, int y, QJSValue tileObj, bool setTransparency, int layer) {
+    this->addTileImage(x, y, Scripting::toTile(tileObj), setTransparency, layer);
+}
+
+void MapView::addTileImage(int x, int y, const Tile &tile, bool setTransparency, int layer) {
+        if (!this->editor || !this->editor->layout || !this->editor->layout->tileset_primary || !this->editor->layout->tileset_secondary)
         return;
-    QImage image = getPalettedTileImage(tileId,
+    QImage image = getPalettedTileImage(tile.tileId,
                                         this->editor->layout->tileset_primary,
                                         this->editor->layout->tileset_secondary,
-                                        paletteId)
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
-                                        .flipped(Util::getOrientation(xflip, yflip));
-#else
-                                        .mirrored(xflip, yflip);
-#endif
-
+                                        tile.palette);
+    tile.flip(&image);
     if (setTransparency)
         image.setColor(0, qRgba(0, 0, 0, 0));
     if (this->getOverlay(layer)->addImage(x, y, image))
         this->updateScene();
 }
 
-void MapView::addTileImage(int x, int y, QJSValue tileObj, bool setTransparency, int layer) {
-    Tile tile = Scripting::toTile(tileObj);
-    this->addTileImage(x, y, tile.tileId, tile.xflip, tile.yflip, tile.palette, setTransparency, layer);
-}
-
 void MapView::addMetatileImage(int x, int y, int metatileId, bool setTransparency, int layer) {
     if (!this->editor || !this->editor->layout || !this->editor->layout->tileset_primary || !this->editor->layout->tileset_secondary)
         return;

src/ui/imageproviders.cpp

@@ -126,12 +126,7 @@ QImage getMetatileImage(
         QColor color(tile_image.color(0));
         color.setAlpha(0);
         tile_image.setColor(0, color.rgba());
-
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
-        tile_image.flip(Util::getOrientation(tile.xflip, tile.yflip));
-#else
-        tile_image = tile_image.mirrored(tile.xflip, tile.yflip);
-#endif
+        tile.flip(&tile_image);
         metatile_painter.drawImage(origin, tile_image);
     }
     metatile_painter.end();

src/ui/metatilelayersitem.cpp

@@ -1,7 +1,6 @@
 #include "config.h"
 #include "metatilelayersitem.h"
 #include "imageproviders.h"
-#include "utility.h"
 #include <QPainter>
 
 static const QList<QPoint> tilePositions = {
@@ -28,13 +27,8 @@ void MetatileLayersItem::draw() {
     int numTiles = qMin(projectConfig.getNumTilesInMetatile(), this->metatile ? this->metatile->tiles.length() : 0);
     for (int i = 0; i < numTiles; i++) {
         Tile tile = this->metatile->tiles.at(i);
-        QImage tileImage = getPalettedTileImage(tile.tileId, this->primaryTileset, this->secondaryTileset, tile.palette, true)
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
-                .flipped(Util::getOrientation(tile.xflip, tile.yflip))
-#else
-                .mirrored(tile.xflip, tile.yflip)
-#endif
-                .scaled(16, 16);
+        QImage tileImage = getPalettedTileImage(tile.tileId, this->primaryTileset, this->secondaryTileset, tile.palette, true).scaled(16, 16);
+        tile.flip(&tileImage);
         painter.drawImage(tilePositions.at(i) * 16, tileImage);
     }
     if (this->showGrid) {

src/ui/tilemaptileselector.cpp

@@ -93,11 +93,14 @@ QImage TilemapTileSelector::tileImg(shared_ptr<TilemapTile> tile) {
 
     // take a tile from the tileset
     QImage img = tilesetImage.copy(pos.x() * 8, pos.y() * 8, 8, 8);
+
+    // QImage::flip was introduced in 6.9.0 to replace QImage::mirrored.
 #if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
     img.flip(Util::getOrientation(tile->hFlip(), tile->vFlip()));
 #else
     img = img.mirrored(tile->hFlip(), tile->vFlip());
 #endif
+
     return img;
 }
 

src/ui/tileseteditor.cpp

@@ -383,13 +383,8 @@ void TilesetEditor::drawSelectedTiles() {
     for (int j = 0; j < dimensions.y(); j++) {
         for (int i = 0; i < dimensions.x(); i++) {
             auto tile = tiles.at(tileIndex);
-            QImage tileImage = getPalettedTileImage(tile.tileId, this->primaryTileset, this->secondaryTileset, tile.palette, true)
-#if (QT_VERSION >= QT_VERSION_CHECK(6, 9, 0))
-                    .flipped(Util::getOrientation(tile.xflip, tile.yflip))
-#else
-                    .mirrored(tile.xflip, tile.yflip)
-#endif
-                    .scaled(16, 16);
+            QImage tileImage = getPalettedTileImage(tile.tileId, this->primaryTileset, this->secondaryTileset, tile.palette, true).scaled(16, 16);
+            tile.flip(&tileImage);
             tileIndex++;
             painter.drawImage(i * 16, j * 16, tileImage);
         }