Upgrade ECM and KF5 version requirements for 5.23.0 release.

6934d54417 added an optional dependency
on karchive. This also means that it doesn't merely depend on Qt and a
small number of third-party libs anymore and needs to moved to tier 2.

REVIEW: 127015

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 2.8.12)
 project(KImageFormats)
 
 include(FeatureSummary)
-find_package(ECM 5.14.0  NO_MODULE)
+find_package(ECM 5.23.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)
 
@@ -17,9 +17,15 @@ include(KDECMakeSettings)
 
 include(CheckIncludeFiles)
 
-set(REQUIRED_QT_VERSION 5.3.0)
+set(REQUIRED_QT_VERSION 5.4.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

autotests/readtest.cpp

@@ -129,7 +129,7 @@ int main(int argc, char ** argv)
     foreach (QFileInfo fi, imgdir.entryInfoList()) {
         int suffixPos = fi.filePath().count() - suffix.count();
         QString inputfile = fi.filePath();
-        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), "png");
+        QString expfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString expfilename = QFileInfo(expfile).fileName();
 
         QImageReader inputReader(inputfile, format.constData());

autotests/writetest.cpp

@@ -75,7 +75,7 @@ int main(int argc, char ** argv)
 
     foreach (QFileInfo fi, imgdir.entryInfoList()) {
         int suffixPos = fi.filePath().count() - suffix.count();
-        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), "png");
+        QString pngfile = fi.filePath().replace(suffixPos, suffix.count(), QStringLiteral("png"));
         QString pngfilename = QFileInfo(pngfile).fileName();
 
         QImageReader pngReader(pngfile, "png");

metainfo.yaml

@@ -1,6 +1,6 @@
 maintainer: alexmerry
 description: Image format plugins for Qt
-tier: 1
+tier: 2
 type: functional
 platforms:
     - name: Linux
@@ -10,3 +10,7 @@ platforms:
 portingAid: false
 deprecated: false
 release: true
+
+public_lib: true
+group: Frameworks
+subgroup: Tier 2

src/imageformats/CMakeLists.txt

@@ -89,3 +89,20 @@ target_link_libraries(kimg_xcf Qt5::Gui)
 install(TARGETS kimg_xcf  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
 install(FILES xcf.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
 
+##################################
+
+if (KF5Archive_FOUND)
+
+    add_library(kimg_kra MODULE kra.cpp)
+    target_link_libraries(kimg_kra Qt5::Gui KF5::Archive)
+
+    install(TARGETS kimg_kra  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES kra.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+    add_library(kimg_ora MODULE ora.cpp)
+    target_link_libraries(kimg_ora Qt5::Gui KF5::Archive)
+
+    install(TARGETS kimg_ora  DESTINATION ${KDE_INSTALL_QTPLUGINDIR}/imageformats/)
+    install(FILES ora.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR}/qimageioplugins/)
+
+endif()

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 0;
+    }
+    if (!device->isOpen()) {
+        return 0;
+    }
+
+    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,39 @@
+/* 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;
+    QImageIOHandler *create(QIODevice *device, const QByteArray &format = QByteArray()) const;
+};
+
+
+
+#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 0;
+    }
+    if (!device->isOpen()) {
+        return 0;
+    }
+
+    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/psd.desktop

@@ -2,6 +2,6 @@
 Type=Service
 X-KDE-ServiceTypes=QImageIOPlugins
 X-KDE-ImageFormat=psd
-X-KDE-MimeType=image/x-psd
+X-KDE-MimeType=image/vnd.adobe.photoshop
 X-KDE-Read=true
 X-KDE-Write=false

src/imageformats/psd.json

@@ -1,4 +1,4 @@
 {
     "Keys": [ "psd" ],
-    "MimeTypes": [ "image/x-psd" ]
+    "MimeTypes": [ "image/vnd.adobe.photoshop" ]
 }

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)
 {

tests/imageconverter.cpp

@@ -32,29 +32,29 @@
 int main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
-    QCoreApplication::addLibraryPath(QLatin1String(PLUGIN_DIR));
-    QCoreApplication::setApplicationName(QLatin1String("imageconverter"));
-    QCoreApplication::setApplicationVersion(QLatin1String("1.01.01.0"));
+    QCoreApplication::addLibraryPath(QStringLiteral(PLUGIN_DIR));
+    QCoreApplication::setApplicationName(QStringLiteral("imageconverter"));
+    QCoreApplication::setApplicationVersion(QStringLiteral("1.01.01.0"));
 
     QCommandLineParser parser;
-    parser.setApplicationDescription(QLatin1String("Converts images from one format to another"));
+    parser.setApplicationDescription(QStringLiteral("Converts images from one format to another"));
     parser.addHelpOption();
     parser.addVersionOption();
-    parser.addPositionalArgument(QLatin1String("in"), QLatin1String("input image file"));
-    parser.addPositionalArgument(QLatin1String("out"), QLatin1String("output image file"));
+    parser.addPositionalArgument(QStringLiteral("in"), QStringLiteral("input image file"));
+    parser.addPositionalArgument(QStringLiteral("out"), QStringLiteral("output image file"));
     QCommandLineOption informat(
-        QStringList() << QLatin1String("i") << QLatin1String("informat"),
-        QLatin1String("Image format for input file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("i") << QStringLiteral("informat"),
+        QStringLiteral("Image format for input file"),
+        QStringLiteral("format"));
     parser.addOption(informat);
     QCommandLineOption outformat(
-        QStringList() << QLatin1String("o") << QLatin1String("outformat"),
-        QLatin1String("Image format for output file"),
-        QLatin1String("format"));
+        QStringList() << QStringLiteral("o") << QStringLiteral("outformat"),
+        QStringLiteral("Image format for output file"),
+        QStringLiteral("format"));
     parser.addOption(outformat);
     QCommandLineOption listformats(
-        QStringList() << QLatin1String("l") << QLatin1String("list"),
-        QLatin1String("List supported image formats"));
+        QStringList() << QStringLiteral("l") << QStringLiteral("list"),
+        QStringLiteral("List supported image formats"));
     parser.addOption(listformats);
 
     parser.process(app);