KoResourceBundle.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2014 Victor Lafon metabolic.ewilan @hotmail.fr
 *
 * SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
#include "KoResourceBundle.h"
 
#include <QBuffer>
#include <QByteArray>
#include <QCryptographicHash>
#include <QDate>
#include <QDir>
#include <QMessageBox>
#include <QPainter>
#include <QProcessEnvironment>
#include <QScopedPointer>
#include <QStringList>
 
#include <klocalizedstring.h>
 
#include <KisMimeDatabase.h>
#include "KoResourceBundleManifest.h"
#include <KoMD5Generator.h>
#include <KoResourcePaths.h>
#include <KoStore.h>
#include <KoXmlWriter.h>
#include "KisStoragePlugin.h"
#include "KisResourceLoaderRegistry.h"
#include <KisResourceModelProvider.h>
#include <KisResourceModel.h>
#include <KoMD5Generator.h>
 
#include <KritaVersionWrapper.h>
 
#include <kis_debug.h>
#include <KisGlobalResourcesInterface.h>
 
 
KoResourceBundle::KoResourceBundle(QString const& fileName)
    : m_filename(fileName),
      m_bundleVersion("1")
{
    m_metadata[KisResourceStorage::s_meta_generator] = "Krita (" + KritaVersionWrapper::versionString(true) + ")";
}
 
KoResourceBundle::~KoResourceBundle()
{
}
 
QString KoResourceBundle::defaultFileExtension() const
{
    return QString(".bundle");
}
 
bool KoResourceBundle::load()
{
    if (m_filename.isEmpty()) return false;
    QScopedPointer<KoStore> resourceStore(KoStore::createStore(m_filename, KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
    if (!resourceStore || resourceStore->bad()) {
        qWarning() << "Could not open store on bundle" << m_filename;
        return false;
    }
 
    m_metadata.clear();
 
    if (resourceStore->open("META-INF/manifest.xml")) {
        if (!m_manifest.load(resourceStore->device())) {
            qWarning() << "Could not open manifest for bundle" << m_filename;
            return false;
        }
        resourceStore->close();
 
        Q_FOREACH (KoResourceBundleManifest::ResourceReference ref, m_manifest.files()) {
            if (!resourceStore->hasFile(ref.resourcePath)) {
                m_manifest.removeResource(ref);
                qWarning() << "Bundle" << filename() <<  "is broken. File" << ref.resourcePath << "is missing";
            }
        }
 
    } else {
        qWarning() << "Could not load META-INF/manifest.xml";
        return false;
    }
 
    bool versionFound = false;
    if (!readMetaData(resourceStore.data())) {
        qWarning() << "Could not load meta.xml";
        return false;
    }
 
    if (resourceStore->open("preview.png")) {
        // Workaround for some OS (Debian, Ubuntu), where loading directly from the QIODevice
        // fails with "libpng error: IDAT: CRC error"
        QByteArray data = resourceStore->device()->readAll();
        QBuffer buffer(&data);
        m_thumbnail.load(&buffer, "PNG");
        resourceStore->close();
    } else {
        qWarning() << "Could not open preview.png";
    }
 
    /*
     * If no version is found it's an old bundle with md5 hashes to fix, or if some manifest resource entry
     * doesn't not correspond to a file the bundle is "broken", in both cases we need to recreate the bundle.
     */
    if (!versionFound) {
        m_metadata.insert(KisResourceStorage::s_meta_version, "1");
    }
 
    return true;
}
 
bool KoResourceBundle::loadFromDevice(QIODevice *)
{
    return false;
}
 
bool saveResourceToStore(const QString &filename, KoResourceSP resource, KoStore *store, const QString &resType, KisResourceModel &model)
{
    if (!resource) {
        qWarning() << "No Resource";
        return false;
    }
 
    if (!resource->valid()) {
        qWarning() << "Resource is not valid";
        return false;
    }
    if (!store || store->bad()) {
        qWarning() << "No Store or Store is Bad";
        return false;
    }
 
    QBuffer buf;
    buf.open(QFile::WriteOnly);
 
    bool response = model.exportResource(resource, &buf);
    if (!response) {
        qWarning() << "Cannot save to device";
        return false;
    }
 
    if (!store->open(resType + "/" + filename)) {
        qWarning() << "Could not open file in store for resource";
        return false;
    }
 
    qint64 size = store->write(buf.data());
    store->close();
    buf.close();
    if (size != buf.size()) {
        qWarning() << "Cannot save resource to the store" << size << buf.size();
        return false;
    }
 
    if (!resource->thumbnailPath().isEmpty()) {
        // hack for MyPaint brush presets previews
        const QImage thumbnail = resource->thumbnail();
 
        // clone resource to find out the file path for its preview
        KoResourceSP clonedResource = resource->clone();
        clonedResource->setFilename(filename);
 
        if (!store->open(resType + "/" + clonedResource->thumbnailPath())) {
            qWarning() << "Could not open file in store for resource thumbnail";
            return false;
        }
        QBuffer buf;
        buf.open(QFile::ReadWrite);
        thumbnail.save(&buf, "PNG");
 
        int size2 = store->write(buf.data());
        if (size2 != buf.size()) {
            qWarning() << "Cannot save thumbnail to the store" << size << buf.size();
        }
        store->close();
        buf.close();
    }
 
 
    return size == buf.size();
}
 
bool KoResourceBundle::save()
{
    if (m_filename.isEmpty()) return false;
 
    if (metaData(KisResourceStorage::s_meta_creation_date, "").isEmpty()) {
        setMetaData(KisResourceStorage::s_meta_creation_date, QLocale::c().toString(QDate::currentDate(), QStringLiteral("dd/MM/yyyy")));
    }
    setMetaData(KisResourceStorage::s_meta_dc_date, QLocale::c().toString(QDate::currentDate(), QStringLiteral("dd/MM/yyyy")));
 
    QDir bundleDir = KoResourcePaths::saveLocation("data", "bundles");
    bundleDir.cdUp();
 
    QScopedPointer<KoStore> store(KoStore::createStore(m_filename, KoStore::Write, "application/x-krita-resourcebundle", KoStore::Zip));
 
    if (!store || store->bad()) return false;
 
    Q_FOREACH (const QString &resType, m_manifest.types()) {
        KisResourceModel model(resType);
        model.setResourceFilter(KisResourceModel::ShowAllResources);
        Q_FOREACH (const KoResourceBundleManifest::ResourceReference &ref, m_manifest.files(resType)) {
            KoResourceSP res;
            if (ref.resourceId >= 0) res = model.resourceForId(ref.resourceId);
            if (!res) res = model.resourcesForMD5(ref.md5sum).first();
            if (!res) res = model.resourcesForFilename(QFileInfo(ref.resourcePath).fileName()).first();
            if (!res) {
                qWarning() << "Could not find resource" << resType << ref.resourceId << ref.md5sum << ref.resourcePath;
                continue;
            }
 
            if (!saveResourceToStore(ref.filenameInBundle, res, store.data(), resType, model)) {
                qWarning() << "Could not save resource" << resType << res->name();
            }
        }
    }
 
    if (!m_thumbnail.isNull()) {
        QByteArray byteArray;
        QBuffer buffer(&byteArray);
        m_thumbnail.save(&buffer, "PNG");
        if (!store->open("preview.png")) qWarning() << "Could not open preview.png";
        if (store->write(byteArray) != buffer.size()) qWarning() << "Could not write preview.png";
        store->close();
    }
 
    saveManifest(store);
 
    saveMetadata(store);
 
    store->finalize();
 
    return true;
}
 
bool KoResourceBundle::saveToDevice(QIODevice */*dev*/) const
{
    return false;
}
 
void KoResourceBundle::setMetaData(const QString &key, const QString &value)
{
    m_metadata.insert(key, value);
}
 
const QString KoResourceBundle::metaData(const QString &key, const QString &defaultValue) const
{
    if (m_metadata.contains(key)) {
        return m_metadata[key];
    }
    else {
        return defaultValue;
    }
}
 
void KoResourceBundle::addResource(QString resourceType, QString filePath, QVector<KisTagSP> fileTagList, const QString md5sum, const int resourceId, const QString filenameInBundle)
{
    QStringList tags;
    Q_FOREACH(KisTagSP tag, fileTagList) {
        tags << tag->url();
    }
    m_manifest.addResource(resourceType, filePath, tags, md5sum, resourceId, filenameInBundle);
}
 
QList<QString> KoResourceBundle::getTagsList()
{
    return QList<QString>(m_bundletags.begin(), m_bundletags.end());
}
 
QStringList KoResourceBundle::resourceTypes() const
{
    return m_manifest.types();
}
 
void KoResourceBundle::setThumbnail(QImage image)
{
    if (!image.isNull()) {
        m_thumbnail = image;
        m_thumbnail = m_thumbnail.scaled(256, 256, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    }
    else {
        m_thumbnail = QImage(256, 256, QImage::Format_ARGB32);
        QPainter gc(&m_thumbnail);
        gc.fillRect(0, 0, 256, 256, Qt::red);
        gc.end();
    }
}
 
void KoResourceBundle::writeMeta(const QString &metaTag, KoXmlWriter *writer)
{
    if (m_metadata.contains(metaTag)) {
        QByteArray mt = metaTag.toUtf8();
        QByteArray tx = m_metadata[metaTag].toUtf8();
        writer->startElement(mt);
        writer->addTextNode(tx);
        writer->endElement();
    }
}
 
void KoResourceBundle::writeUserDefinedMeta(const QString &metaTag, KoXmlWriter *writer)
{
    if (m_metadata.contains(metaTag)) {
        writer->startElement("meta:meta-userdefined");
        writer->addAttribute("meta:name", metaTag);
        writer->addAttribute("meta:value", m_metadata[metaTag]);
        writer->endElement();
    }
}
 
bool KoResourceBundle::readMetaData(KoStore *resourceStore)
{
    if (!resourceStore->open("meta.xml")) {
        qWarning() << "Could not open meta.xml for" << m_filename;
        return false;
    }
 
    QDomDocument doc;
    if (!doc.setContent(resourceStore->device())) {
        qWarning() << "Could not parse meta.xml for" << m_filename;
        return false;
    }
 
    const QDomElement root = doc.documentElement();
    if (root.tagName() != "meta:meta") {
        qWarning() << "Expected meta:meta element root, but found"
                   << root.tagName();
        return false;
    }
 
    QDomElement e;
    for (e = root.firstChildElement(); !e.isNull(); e = e.nextSiblingElement()) {
        QString name  = e.tagName();
        QString value = e.text();
        if (name == "meta:meta-userdefined") {
            name  = e.attribute("meta:name");
            value = e.attribute("meta:value");
 
            if (name == "tag") {
                m_bundletags << value;
                continue;
            }
 
            if (name != "email"   &&
                name != "license" &&
                name != "website") {
                qWarning() << "Unrecognized metadata: "
                           << e.tagName()
                           << name
                           << value;
            }
 
            m_metadata.insert(name, value);
            name = "meta:" + name;
        } else if (name == "cd:creator") {
            // Bundles from some versions have prefix 'cd' instead of 'dc'.
            name = "dc:creator";
        }
 
        if (!m_metadata.contains(name)) {
            m_metadata.insert(name, value);
        }
    }
 
    resourceStore->close();
    return true;
}
 
void KoResourceBundle::saveMetadata(QScopedPointer<KoStore> &store)
{
    QBuffer buf;
 
    store->open("meta.xml");
    buf.open(QBuffer::WriteOnly);
 
    KoXmlWriter metaWriter(&buf);
    metaWriter.startDocument("office:document-meta");
    metaWriter.startElement("meta:meta");
    metaWriter.addAttribute("xmlns:meta", KisResourceStorage::s_xmlns_meta);
    metaWriter.addAttribute("xmlns:dc",   KisResourceStorage::s_xmlns_dc);
 
    writeMeta(KisResourceStorage::s_meta_generator, &metaWriter);
 
    QByteArray ba1 = KisResourceStorage::s_meta_version.toUtf8();
    metaWriter.startElement(ba1);
    QByteArray ba2  = m_bundleVersion.toUtf8();
    metaWriter.addTextNode(ba2);
    metaWriter.endElement();
 
    writeMeta(KisResourceStorage::s_meta_author, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_title,  &metaWriter);
    writeMeta(KisResourceStorage::s_meta_description, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_initial_creator,  &metaWriter);
    writeMeta(KisResourceStorage::s_meta_creator, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_creation_date, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_dc_date, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_email, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_license, &metaWriter);
    writeMeta(KisResourceStorage::s_meta_website, &metaWriter);
 
    // For compatibility
    writeUserDefinedMeta("email", &metaWriter);
    writeUserDefinedMeta("license", &metaWriter);
    writeUserDefinedMeta("website", &metaWriter);
 
 
    Q_FOREACH (const QString &tag, m_bundletags) {
        QByteArray ba1 = KisResourceStorage::s_meta_user_defined.toUtf8();
        QByteArray ba2 = KisResourceStorage::s_meta_name.toUtf8();
        QByteArray ba3 = KisResourceStorage::s_meta_value.toUtf8();
        metaWriter.startElement(ba1);
        metaWriter.addAttribute(ba2, "tag");
        metaWriter.addAttribute(ba3, tag);
        metaWriter.endElement();
    }
 
    metaWriter.endElement(); // meta:meta
    metaWriter.endDocument();
 
    buf.close();
    store->write(buf.data());
    store->close();
}
 
void KoResourceBundle::saveManifest(QScopedPointer<KoStore> &store)
{
    store->open("META-INF/manifest.xml");
    QBuffer buf;
    buf.open(QBuffer::WriteOnly);
    m_manifest.save(&buf);
    buf.close();
    store->write(buf.data());
    store->close();
}
 
int KoResourceBundle::resourceCount() const
{
    return m_manifest.files().count();
}
 
KoResourceBundleManifest &KoResourceBundle::manifest()
{
    return m_manifest;
}
 
KoResourceSP KoResourceBundle::resource(const QString &resourceType, const QString &filepath)
{
    QString mime = KisMimeDatabase::mimeTypeForSuffix(filepath);
    KisResourceLoaderBase *loader = KisResourceLoaderRegistry::instance()->loader(resourceType, mime);
    if (!loader) {
        qWarning() << "Could not create loader for" << resourceType << filepath << mime;
        return 0;
    }
 
    QStringList parts = filepath.split('/', Qt::SkipEmptyParts);
 
    Q_ASSERT(parts.size() == 2);
 
    KoResourceSP resource = loader->create(parts[1]);
    return loadResource(resource) ? resource : 0;
}
 
bool KoResourceBundle::exportResource(const QString &resourceType, const QString &fileName, QIODevice *device)
{
    if (m_filename.isEmpty()) return false;
 
    QScopedPointer<KoStore> resourceStore(KoStore::createStore(m_filename, KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
    if (!resourceStore || resourceStore->bad()) {
        qWarning() << "Could not open store on bundle" << m_filename;
        return false;
    }
    const QString filePath = QString("%1/%2").arg(resourceType).arg(fileName);
 
    if (!resourceStore->open(filePath)) {
        qWarning() << "Could not open file in bundle" << filePath;
        return false;
    }
 
    device->write(resourceStore->device()->readAll());
 
    return true;
}
 
bool KoResourceBundle::loadResource(KoResourceSP resource)
{
    if (m_filename.isEmpty()) return false;
 
    const QString resourceType = resource->resourceType().first;
 
    QScopedPointer<KoStore> resourceStore(KoStore::createStore(m_filename, KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
    if (!resourceStore || resourceStore->bad()) {
        qWarning() << "Could not open store on bundle" << m_filename;
        return false;
    }
    const QString fileName = QString("%1/%2").arg(resourceType).arg(resource->filename());
 
    if (!resourceStore->open(fileName)) {
        qWarning() << "Could not open file in bundle" << fileName;
        return false;
    }
 
    if (!resource->loadFromDevice(resourceStore->device(),
                                  KisGlobalResourcesInterface::instance())) {
        qWarning() << "Could not load the resource from the bundle" << resourceType << fileName << m_filename;
        return false;
    }
 
    resourceStore->close();
 
    if ((resource->image().isNull() || resource->thumbnail().isNull()) && !resource->thumbnailPath().isNull()) {
 
        if (!resourceStore->open(resourceType + '/' + resource->thumbnailPath())) {
            qWarning() << "Could not open thumbnail in bundle" << resource->thumbnailPath();
            return false;
        }
 
        QImage img;
        img.load(resourceStore->device(), QFileInfo(resource->thumbnailPath()).completeSuffix().toLatin1());
        resource->setImage(img);
        resource->updateThumbnail();
 
        resourceStore->close();
    }
 
    return true;
}
 
QString KoResourceBundle::resourceMd5(const QString &url)
{
    QString result;
 
    if (m_filename.isEmpty()) return result;
 
    QScopedPointer<KoStore> resourceStore(KoStore::createStore(m_filename, KoStore::Read, "application/x-krita-resourcebundle", KoStore::Zip));
 
    if (!resourceStore || resourceStore->bad()) {
        qWarning() << "Could not open store on bundle" << m_filename;
        return result;
    }
    if (!resourceStore->open(url)) {
        qWarning() << "Could not open file in bundle" << url;
        return result;
    }
 
    result = KoMD5Generator::generateHash(resourceStore->device());
    resourceStore->close();
 
    return result;
}
 
QImage KoResourceBundle::image() const
{
    return m_thumbnail;
}
 
QString KoResourceBundle::filename() const
{
    return m_filename;
}