GIT_SILENT Upgrade ECM and KF5 version requirements for 5.43.0 release.

Do this properly by defining a function (inspired by kcoreaddons_add_plugin)

.arcconfig

@@ -0,0 +1,3 @@
+{
+  "phabricator.uri" : "https://phabricator.kde.org/"
+}

.reviewboardrc

@@ -1,5 +0,0 @@
-REVIEWBOARD_URL = "https://git.reviewboard.kde.org"
-REPOSITORY = 'git://anongit.kde.org/kimageformats'
-BRANCH = 'master'
-TARGET_GROUPS = 'kdeframeworks'
-TARGET_PEOPLE = 'alexmerry'

CMakeLists.txt

@@ -1,9 +1,9 @@
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.0)
 
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.16.0  NO_MODULE)
+find_package(ECM 5.43.0  NO_MODULE)
 set_package_properties(ECM PROPERTIES TYPE REQUIRED DESCRIPTION "Extra CMake Modules." URL "https://projects.kde.org/projects/kdesupport/extra-cmake-modules")
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
@@ -11,15 +11,21 @@ feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND FATAL_ON_MISSING_REQUIRED_PACKA
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 include(KDEInstallDirs)
-include(KDEFrameworkCompilerSettings)
+include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(KDECMakeSettings)
 
 
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.3.0)
+set(REQUIRED_QT_VERSION 5.7.0)
 find_package(Qt5Gui ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 
+find_package(KF5Archive)
+set_package_properties(KF5Archive PROPERTIES
+    TYPE OPTIONAL
+    PURPOSE "Required for the QImage plugin for Krita and OpenRaster images"
+)
+
 # EPS support depends on the gs utility; non-UNIX systems are unlikely to have
 # this available in PATH
 set(BUILD_EPS_PLUGIN FALSE)

autotests/CMakeLists.txt

@@ -61,6 +61,14 @@ kimageformats_read_tests(
     rgb
     tga
 )
+
+if (KF5Archive_FOUND)
+    kimageformats_read_tests(
+        kra
+        ora
+    )
+endif()
+
 # Allow some fuzziness when reading this formats, to allow for
 # rounding errors (eg: in alpha blending).
 kimageformats_read_tests(FUZZ 1

metainfo.yaml

@@ -1,12 +1,18 @@
 maintainer: alexmerry
 description: Image format plugins for Qt
-tier: 1
+tier: 2
 type: functional
 platforms:
     - name: Linux
+    - name: FreeBSD
     - name: MacOSX
     - name: Windows
       note: No EPS support on Windows
+    - name: Android
 portingAid: false
 deprecated: false
 release: true
+
+public_lib: true
+group: Frameworks
+subgroup: Tier 2

src/imageformats/CMakeLists.txt

@@ -2,90 +2,101 @@
 
 ##################################
 
+function(kimageformats_add_plugin plugin)
+    set(options)
+    set(oneValueArgs JSON)
+    set(multiValueArgs SOURCES)
+    cmake_parse_arguments(KIF_ADD_PLUGIN "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if(NOT KIF_ADD_PLUGIN_SOURCES)
+        message(FATAL_ERROR "kimageformats_add_plugin called without SOURCES parameter")
+    endif()
+    get_filename_component(json "${KIF_ADD_PLUGIN_JSON}" REALPATH)
+    if(NOT KIF_ADD_PLUGIN_JSON OR NOT EXISTS ${json})
+        message(FATAL_ERROR "JSON file doesn't exist: ${json}")
+    endif()
+
+    set_property(SOURCE ${KIF_ADD_PLUGIN_SOURCES} APPEND PROPERTY OBJECT_DEPENDS ${json})
+    add_library(${plugin} MODULE ${KIF_ADD_PLUGIN_SOURCES})
+    set_property(TARGET ${plugin} APPEND PROPERTY AUTOGEN_TARGET_DEPENDS ${json})
+    set_target_properties(${plugin} PROPERTIES LIBRARY_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/imageformats")
+    target_link_libraries(${plugin} Qt5::Gui)
+    install(TARGETS ${plugin} DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats)
+endfunction()
+
+##################################
+
 install(FILES dds-qt.desktop RENAME dds.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if (BUILD_EPS_PLUGIN)
     if (Qt5PrintSupport_FOUND)
-        add_library(kimg_eps MODULE eps.cpp)
-        target_link_libraries(kimg_eps  Qt5::Gui Qt5::PrintSupport)
-
-        install(TARGETS kimg_eps  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+        kimageformats_add_plugin(kimg_eps JSON "eps.json" SOURCES eps.cpp)
+        target_link_libraries(kimg_eps Qt5::PrintSupport)
         install(FILES eps.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
     endif()
 endif()
 
 ##################################
 
-
 # need this for Qt's version of the plugin
 install(FILES jp2.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
 if(OpenEXR_FOUND)
-    add_library(kimg_exr MODULE exr.cpp)
-    target_link_libraries(kimg_exr Qt5::Gui OpenEXR::IlmImf)
+    kimageformats_add_plugin(kimg_exr JSON "exr.json" SOURCES exr.cpp)
+    target_link_libraries(kimg_exr OpenEXR::IlmImf)
     kde_target_enable_exceptions(kimg_exr PRIVATE)
 
-    install(TARGETS kimg_exr  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
     install(FILES exr.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 endif()
 
 ##################################
 
-add_library(kimg_pcx MODULE pcx.cpp)
-target_link_libraries(kimg_pcx  Qt5::Gui)
-
-install(TARGETS kimg_pcx  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_pcx JSON "pcx.json" SOURCES pcx.cpp)
 install(FILES pcx.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_pic MODULE pic.cpp)
-target_link_libraries(kimg_pic Qt5::Gui)
-
-install(TARGETS kimg_pic  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_pic JSON "pic.json" SOURCES pic.cpp)
 install(FILES pic.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_psd MODULE psd.cpp)
-target_link_libraries(kimg_psd Qt5::Gui)
-
-install(TARGETS kimg_psd  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_psd JSON "psd.json" SOURCES psd.cpp)
 install(FILES psd.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_ras MODULE ras.cpp)
-target_link_libraries(kimg_ras  Qt5::Gui)
-
-install(TARGETS kimg_ras  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_ras JSON "ras.json" SOURCES ras.cpp)
 install(FILES ras.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_rgb MODULE rgb.cpp)
-target_link_libraries(kimg_rgb  Qt5::Gui)
-
-install(TARGETS kimg_rgb  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_rgb JSON "rgb.json" SOURCES rgb.cpp)
 install(FILES rgb.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_tga MODULE tga.cpp)
-target_link_libraries(kimg_tga  Qt5::Gui)
-
-install(TARGETS kimg_tga  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_tga JSON "tga.json" SOURCES tga.cpp)
 install(FILES tga.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
 ##################################
 
-add_library(kimg_xcf MODULE xcf.cpp)
-target_link_libraries(kimg_xcf Qt5::Gui)
-
-install(TARGETS kimg_xcf  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+kimageformats_add_plugin(kimg_xcf JSON "xcf.json" SOURCES xcf.cpp)
 install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
+##################################
+
+if (KF5Archive_FOUND)
+
+    kimageformats_add_plugin(kimg_kra JSON "kra.json" SOURCES kra.cpp)
+    target_link_libraries(kimg_kra KF5::Archive)
+    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+    kimageformats_add_plugin(kimg_ora JSON "ora.json" SOURCES ora.cpp)
+    target_link_libraries(kimg_ora KF5::Archive)
+    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+endif()

src/imageformats/eps.cpp

@@ -15,12 +15,8 @@
 #include <QProcess>
 #include <QTemporaryFile>
 
-#if QT_VERSION >= QT_VERSION_CHECK(5, 4, 0)
 // logging category for this framework, default: log stuff >= warning
 Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin", QtWarningMsg)
-#else
-Q_LOGGING_CATEGORY(EPSPLUGIN, "epsplugin")
-#endif
 
 //#define EPS_PERFORMANCE_DEBUG 1
 
@@ -341,10 +337,10 @@ QImageIOPlugin::Capabilities EPSPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/exr.cpp

@@ -218,10 +218,10 @@ QImageIOPlugin::Capabilities EXRPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/kra.cpp

@@ -0,0 +1,88 @@
+/* This file is part of the KDE project
+   Copyright (C) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This code is based on Thacher Ulrich PSD loading code released
+   on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "kra.h"
+
+#include <kzip.h>
+
+#include <QImage>
+#include <QIODevice>
+#include <QFile>
+
+KraHandler::KraHandler()
+{
+}
+
+bool KraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("kra");
+        return true;
+    }
+    return false;
+}
+
+bool KraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QLatin1String("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool KraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("KraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[57];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return qstrcmp(buff + 0x26, "application/x-krita") == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities KraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "kra" || format == "KRA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && KraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *KraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new KraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/kra.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=QImageIOPlugins
+X-KDE-ImageFormat=kra
+X-KDE-MimeType=application/x-krita
+X-KDE-Read=true
+X-KDE-Write=false

src/imageformats/kra.h

@@ -0,0 +1,38 @@
+/* This file is part of the KDE project
+   Copyright (c) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+*/
+
+#ifndef KIMG_KRA_H
+#define KIMG_KRA_H
+
+#include <QImageIOPlugin>
+
+class KraHandler : public QImageIOHandler
+{
+public:
+    KraHandler();
+
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image)  Q_DECL_OVERRIDE;
+
+    static bool canRead(QIODevice *device);
+};
+
+class KraPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "kra.json")
+
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+};
+
+
+
+#endif

src/imageformats/kra.json

@@ -0,0 +1,5 @@
+{
+    "Keys": [ "kra" ],
+    "MimeTypes": [ "application/x-krita", "application/x-krita" ]
+}
+

src/imageformats/ora.cpp

@@ -0,0 +1,87 @@
+/* This file is part of the KDE project
+   Copyright (C) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This code is based on Thacher Ulrich PSD loading code released
+   on public domain. See: http://tulrich.com/geekstuff/
+*/
+
+#include "ora.h"
+
+#include <QImage>
+#include <QScopedPointer>
+
+#include <kzip.h>
+
+OraHandler::OraHandler()
+{
+}
+
+bool OraHandler::canRead() const
+{
+    if (canRead(device())) {
+        setFormat("ora");
+        return true;
+    }
+    return false;
+}
+
+bool OraHandler::read(QImage *image)
+{
+    KZip zip(device());
+    if (!zip.open(QIODevice::ReadOnly)) return false;
+
+    const KArchiveEntry *entry = zip.directory()->entry(QLatin1String("mergedimage.png"));
+    if (!entry || !entry->isFile()) return false;
+
+    const KZipFileEntry* fileZipEntry = static_cast<const KZipFileEntry*>(entry);
+
+    image->loadFromData(fileZipEntry->data(), "PNG");
+
+    return true;
+}
+
+bool OraHandler::canRead(QIODevice *device)
+{
+    if (!device) {
+        qWarning("OraHandler::canRead() called with no device");
+        return false;
+    }
+
+    char buff[54];
+    if (device->peek(buff, sizeof(buff)) == sizeof(buff))
+        return qstrcmp(buff + 0x26, "image/openraster") == 0;
+
+    return false;
+}
+
+QImageIOPlugin::Capabilities OraPlugin::capabilities(QIODevice *device, const QByteArray &format) const
+{
+    if (format == "ora" || format == "ORA") {
+        return Capabilities(CanRead);
+    }
+    if (!format.isEmpty()) {
+        return {};
+    }
+    if (!device->isOpen()) {
+        return {};
+    }
+
+    Capabilities cap;
+    if (device->isReadable() && OraHandler::canRead(device)) {
+        cap |= CanRead;
+    }
+    return cap;
+}
+
+QImageIOHandler *OraPlugin::create(QIODevice *device, const QByteArray &format) const
+{
+    QImageIOHandler *handler = new OraHandler;
+    handler->setDevice(device);
+    handler->setFormat(format);
+    return handler;
+}

src/imageformats/ora.desktop

@@ -0,0 +1,7 @@
+[Desktop Entry]
+Type=Service
+X-KDE-ServiceTypes=QImageIOPlugins
+X-KDE-ImageFormat=ora
+X-KDE-MimeType=image/openraster
+X-KDE-Read=true
+X-KDE-Write=false

src/imageformats/ora.h

@@ -0,0 +1,38 @@
+/* This file is part of the KDE project
+   Copyright (c) 2013 Boudewijn Rempt <boud@valdyas.org>
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the Lesser GNU General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+*/
+
+#ifndef KIMG_ORA_H
+#define KIMG_ORA_H
+
+#include <QImageIOPlugin>
+
+class OraHandler : public QImageIOHandler
+{
+public:
+    OraHandler();
+
+    bool canRead() const Q_DECL_OVERRIDE;
+    bool read(QImage *image)  Q_DECL_OVERRIDE;
+
+    static bool canRead(QIODevice *device);
+};
+
+
+class OraPlugin : public QImageIOPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QImageIOHandlerFactoryInterface" FILE "ora.json")
+public:
+    Capabilities capabilities(QIODevice *device, const QByteArray &format) const Q_DECL_OVERRIDE;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const Q_DECL_OVERRIDE;
+};
+
+
+#endif
+

src/imageformats/ora.json

@@ -0,0 +1,5 @@
+{
+    "Keys": [ "ora" ],
+    "MimeTypes": [ "image/openraster", "image/openraster" ]
+}
+

src/imageformats/pcx.cpp

@@ -667,10 +667,10 @@ QImageIOPlugin::Capabilities PCXPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/pic.cpp

@@ -449,10 +449,10 @@ QImageIOPlugin::Capabilities SoftimagePICPlugin::capabilities(QIODevice *device,
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/psd.cpp

@@ -120,19 +120,19 @@ static quint8 readPixel(QDataStream &stream) {
     quint8 pixel;
     stream >> pixel;
     return pixel;
-};
+}
 static QRgb updateRed(QRgb oldPixel, quint8 redPixel) {
     return qRgba(redPixel, qGreen(oldPixel), qBlue(oldPixel), qAlpha(oldPixel));
-};
+}
 static QRgb updateGreen(QRgb oldPixel, quint8 greenPixel) {
     return qRgba(qRed(oldPixel), greenPixel, qBlue(oldPixel), qAlpha(oldPixel));
-};
+}
 static QRgb updateBlue(QRgb oldPixel, quint8 bluePixel) {
     return qRgba(qRed(oldPixel), qGreen(oldPixel), bluePixel, qAlpha(oldPixel));
-};
+}
 static QRgb updateAlpha(QRgb oldPixel, quint8 alphaPixel) {
     return qRgba(qRed(oldPixel), qGreen(oldPixel), qBlue(oldPixel), alphaPixel);
-};
+}
 typedef QRgb(*channelUpdater)(QRgb,quint8);
 
 // Load the PSD image.
@@ -300,10 +300,10 @@ QImageIOPlugin::Capabilities PSDPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/ras.cpp

@@ -282,10 +282,10 @@ QImageIOPlugin::Capabilities RASPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/rgb.cpp

@@ -111,8 +111,8 @@ private:
 };
 
 SGIImage::SGIImage(QIODevice *io) :
-    _starttab(0),
-    _lengthtab(0)
+    _starttab(nullptr),
+    _lengthtab(nullptr)
 {
     _dev = io;
     _stream.setDevice(_dev);
@@ -714,10 +714,10 @@ QImageIOPlugin::Capabilities RGBPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/rle_p.h

@@ -75,7 +75,7 @@ template<typename Item, typename Func1, typename Func2>
 static inline bool decodeRLEData(RLEVariant variant,
                                  QDataStream &stream,
                                  Item *dest,
-                                 quint16 length,
+                                 quint32 length,
                                  Func1 readData,
                                  Func2 updateItem)
 {

src/imageformats/tga.cpp

@@ -145,6 +145,9 @@ struct TgaHeaderInfo {
         switch (tga.image_type) {
         case TGA_TYPE_RLE_INDEXED:
             rle = true;
+#if QT_VERSION >= QT_VERSION_CHECK(5,8,0)
+        Q_FALLTHROUGH();
+#endif
         // no break is intended!
         case TGA_TYPE_INDEXED:
             pal = true;
@@ -152,6 +155,9 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_RGB:
             rle = true;
+#if QT_VERSION >= QT_VERSION_CHECK(5,8,0)
+        Q_FALLTHROUGH();
+#endif
         // no break is intended!
         case TGA_TYPE_RGB:
             rgb = true;
@@ -159,6 +165,9 @@ struct TgaHeaderInfo {
 
         case TGA_TYPE_RLE_GREY:
             rle = true;
+#if QT_VERSION >= QT_VERSION_CHECK(5,8,0)
+        Q_FALLTHROUGH();
+#endif
         // no break is intended!
         case TGA_TYPE_GREY:
             grey = true;
@@ -414,10 +423,10 @@ QImageIOPlugin::Capabilities TGAPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead | CanWrite);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;

src/imageformats/xcf.cpp

@@ -107,7 +107,7 @@ private:
         //! copied in different ways.
         void (*assignBytes)(Layer &layer, uint i, uint j);
 
-        Layer(void) : name(0) {}
+        Layer(void) : name(nullptr) {}
         ~Layer(void)
         {
             delete[] name;
@@ -416,7 +416,7 @@ bool XCFImageFormat::loadImageProperties(QDataStream &xcf_io, XCFImage &xcf_imag
                 property.readBytes(tag, size);
 
                 quint32 flags;
-                char *data = 0;
+                char *data = nullptr;
                 property >> flags >> data;
 
                 if (tag && strncmp(tag, "gimp-comment", strlen("gimp-comment")) == 0) {
@@ -474,7 +474,7 @@ bool XCFImageFormat::loadProperty(QDataStream &xcf_io, PropType &type, QByteArra
     xcf_io >> foo;
     type = PropType(foo); // TODO urks
 
-    char *data = 0;
+    char *data = nullptr;
     quint32 size;
 
     // The colormap property size is not the correct number of bytes:
@@ -1323,7 +1323,9 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             image.fill(qRgb(255, 255, 255));
             break;
         } // else, fall through to 32-bit representation
-
+#if QT_VERSION >= QT_VERSION_CHECK(5,8,0)
+        Q_FALLTHROUGH();
+#endif
     case RGBA_GIMAGE:
         image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
         if (image.isNull()) {
@@ -1343,7 +1345,9 @@ bool XCFImageFormat::initializeImage(XCFImage &xcf_image)
             image.fill(255);
             break;
         } // else, fall through to 32-bit representation
-
+#if QT_VERSION >= QT_VERSION_CHECK(5,8,0)
+        Q_FALLTHROUGH();
+#endif
     case GRAYA_GIMAGE:
         image = QImage(xcf_image.width, xcf_image.height, QImage::Format_ARGB32);
         if (image.isNull()) {
@@ -1442,7 +1446,7 @@ void XCFImageFormat::copyLayerToImage(XCFImage &xcf_image)
 {
     Layer &layer(xcf_image.layer);
     QImage &image(xcf_image.image);
-    PixelCopyOperation copy = 0;
+    PixelCopyOperation copy = nullptr;
 
     switch (layer.type) {
     case RGB_GIMAGE:
@@ -1725,7 +1729,7 @@ void XCFImageFormat::mergeLayerIntoImage(XCFImage &xcf_image)
     Layer &layer(xcf_image.layer);
     QImage &image(xcf_image.image);
 
-    PixelMergeOperation merge = 0;
+    PixelMergeOperation merge = nullptr;
 
     if (!layer.opacity) {
         return;    // don't bother doing anything
@@ -2686,10 +2690,10 @@ QImageIOPlugin::Capabilities XCFPlugin::capabilities(QIODevice *device, const QB
         return Capabilities(CanRead);
     }
     if (!format.isEmpty()) {
-        return 0;
+        return {};
     }
     if (!device->isOpen()) {
-        return 0;
+        return {};
     }
 
     Capabilities cap;