KraConverter Class Reference

#include <kra_converter.h>

Inheritance diagram for KraConverter:

Public Slots
virtual void	cancel ()

Public Member Functions
vKisNodeSP	activeNodes ()
QList< KisPaintingAssistantSP >	assistants ()
KisImportExportErrorCode	buildFile (QIODevice *io, const QString &filename, bool addMergedImage=true)
KisImportExportErrorCode	buildImage (QIODevice *io)
KisImageSP	image ()
	KraConverter (KisDocument *doc)
	KraConverter (KisDocument *doc, QPointer< KoUpdater > updater)
StoryboardCommentList	storyboardCommentList ()
StoryboardItemList	storyboardItemList ()
	~KraConverter () override

Private Member Functions
bool	completeLoading (KoStore *store)
QDomDocument	createDomDocument ()
KisImportExportErrorCode	loadXML (const QDomDocument &doc, KoStore *store)
KisImportExportErrorCode	oldLoadAndParse (KoStore *store, const QString &filename, QDomDocument &xmldoc)
KisImportExportErrorCode	savePreview (KoStore *store)
KisImportExportErrorCode	saveRootDocuments (KoStore *store)
bool	saveToStream (QIODevice *dev)
void	setProgress (int progress)

Private Attributes
vKisNodeSP	m_activeNodes
QList< KisPaintingAssistantSP >	m_assistants
KisDocument *	m_doc {0}
KisImageSP	m_image
KisKraLoader *	m_kraLoader {0}
KisKraSaver *	m_kraSaver {0}
bool	m_stop {false}
KoStore *	m_store {0}
StoryboardCommentList	m_storyboardCommentList
StoryboardItemList	m_storyboardItemList
QPointer< KoUpdater >	m_updater

Detailed Description

Definition at line 26 of file kra_converter.h.

Constructor & Destructor Documentation

KraConverter() [1/2]

KraConverter::KraConverter

(

KisDocument *

doc

)

Definition at line 28 of file kra_converter.cpp.

    : m_doc(doc)
    , m_image(doc->savingImage())
{
}

KraConverter() [2/2]

KraConverter::KraConverter	(	KisDocument *	doc,
		QPointer< KoUpdater >	updater )

Definition at line 34 of file kra_converter.cpp.

    : m_doc(doc)
    ,  m_image(doc->savingImage())
    ,  m_updater(updater)
{
}

~KraConverter()

KraConverter::~KraConverter ( )

override

Definition at line 41 of file kra_converter.cpp.

{
    delete m_store;
    delete m_kraSaver;
    delete m_kraLoader;
}

References m_kraLoader, m_kraSaver, and m_store.

Member Function Documentation

activeNodes()

vKisNodeSP KraConverter::activeNodes

(

)

Definition at line 115 of file kra_converter.cpp.

{
    return m_activeNodes;
}

References m_activeNodes.

assistants()

QList< KisPaintingAssistantSP > KraConverter::assistants

(

)

Definition at line 120 of file kra_converter.cpp.

{
    return m_assistants;
}

References m_assistants.

buildFile()

KisImportExportErrorCode KraConverter::buildFile	(	QIODevice *	io,
		const QString &	filename,
		bool	addMergedImage = true )

Definition at line 135 of file kra_converter.cpp.

{
    if (m_image->size().isEmpty()) {
        return ImportExportCodes::Failure;
    }
    
    setProgress(5);
    m_store = KoStore::createStore(io, KoStore::Write, m_doc->nativeFormatMimeType(), KoStore::Zip);
 
    bool success = true;
 
    if (m_store->bad()) {
        m_doc->setErrorMessage(i18n("Could not create the file for saving"));
        return ImportExportCodes::CannotCreateFile;
    }
 
    setProgress(20);
 
    m_kraSaver = new KisKraSaver(m_doc, filename, addMergedImage);
 
    KisImportExportErrorCode resultCode = saveRootDocuments(m_store);
 
    if (!resultCode.isOk()) {
        return resultCode;
    }
 
    setProgress(40);
    bool result;
 
    result = m_kraSaver->saveKeyframes(m_store, m_doc->path(), true);
    if (!result) {
        success = false;
        qWarning() << "saving key frames failed";
    }
    setProgress(60);
    result = m_kraSaver->saveBinaryData(m_store, m_image, m_doc->path(), true, addMergedImage);
    if (!result) {
        success = false;
        qWarning() << "saving binary data failed";
    }
    setProgress(70);
    result = m_kraSaver->saveResources(m_store, m_image, m_doc->path());
    if (!result) {
        success = false;
        qWarning() << "saving resources data failed";
    }
 
    result = m_kraSaver->saveStoryboard(m_store, m_image, m_doc->path());
    if (!result) {
        success = false;
        qWarning() << "Saving storyboard data failed";
    }
 
    result = m_kraSaver->saveAnimationMetadata(m_store, m_image, m_doc->path());
    if (!result) {
        success = false;
        qWarning() << "Saving animation metadata failed";
    }
 
    result = m_kraSaver->saveAudio(m_store);
    if (!result) {
        success = false;
        qWarning() << "Saving audio data failed";
    }
 
    setProgress(80);
 
    if (!m_store->finalize()) {
        success = false;
    }
    if (!success || !m_kraSaver->errorMessages().isEmpty()) {
        m_doc->setErrorMessage(m_kraSaver->errorMessages().join(".\n"));
        return ImportExportCodes::Failure;
    }
 
    m_doc->setWarningMessage(m_kraSaver->warningMessages().join(".\n"));
 
    setProgress(90);
    return ImportExportCodes::OK;
}

References KoStore::bad(), ImportExportCodes::CannotCreateFile, KoStore::createStore(), KisKraSaver::errorMessages(), ImportExportCodes::Failure, KoStore::finalize(), KisImportExportErrorCode::isOk(), m_doc, m_image, m_kraSaver, m_store, KisDocument::nativeFormatMimeType(), ImportExportCodes::OK, KisDocument::path(), KisKraSaver::saveAnimationMetadata(), KisKraSaver::saveAudio(), KisKraSaver::saveBinaryData(), KisKraSaver::saveKeyframes(), KisKraSaver::saveResources(), saveRootDocuments(), KisKraSaver::saveStoryboard(), KisDocument::setErrorMessage(), setProgress(), KisDocument::setWarningMessage(), KisImage::size(), KisKraSaver::warningMessages(), KoStore::Write, and KoStore::Zip.

buildImage()

KisImportExportErrorCode KraConverter::buildImage

(

QIODevice *

io

)

Definition at line 68 of file kra_converter.cpp.

{
    m_store = KoStore::createStore(io, KoStore::Read, "", KoStore::Zip);
 
    if (m_store->bad()) {
        m_doc->setErrorMessage(i18n("Not a valid Krita file"));
        return ImportExportCodes::FileFormatIncorrect;
    }
 
    bool success = false;
    {
        if (m_store->hasFile("root") || m_store->hasFile("maindoc.xml")) {   // Fallback to "old" file format (maindoc.xml)
            QDomDocument doc;
 
            KisImportExportErrorCode res = oldLoadAndParse(m_store, "root", doc);
            if (res.isOk())
                res = loadXML(doc, m_store);
            if (!res.isOk()) {
                return res;
            }
 
        } else {
            errUI << "ERROR: No maindoc.xml" << Qt::endl;
            m_doc->setErrorMessage(i18n("Invalid document: no file 'maindoc.xml'."));
            return ImportExportCodes::FileFormatIncorrect;
        }
 
        if (m_store->hasFile("documentinfo.xml")) {
            QDomDocument doc;
            KisImportExportErrorCode resultHere = oldLoadAndParse(m_store, "documentinfo.xml", doc);
            if (resultHere.isOk()) {
                m_doc->documentInfo()->load(doc);
            }
        }
        success = completeLoading(m_store);
    }
 
    fixCloneLayers(m_image, m_image->root());
 
    return success ? ImportExportCodes::OK : ImportExportCodes::Failure;
}

References KoStore::bad(), completeLoading(), KoStore::createStore(), KisDocument::documentInfo(), errUI, ImportExportCodes::Failure, ImportExportCodes::FileFormatIncorrect, fixCloneLayers(), KoStore::hasFile(), KisImportExportErrorCode::isOk(), KoDocumentInfo::load(), loadXML(), m_doc, m_image, m_store, ImportExportCodes::OK, oldLoadAndParse(), KoStore::Read, KisNodeFacade::root, KisDocument::setErrorMessage(), and KoStore::Zip.

cancel

void KraConverter::cancel ( )

virtualslot

Definition at line 465 of file kra_converter.cpp.

{
    m_stop = true;
}

References m_stop.

completeLoading()

bool KraConverter::completeLoading ( KoStore * store )

private

Definition at line 413 of file kra_converter.cpp.

{
    if (!m_image) {
        if (m_kraLoader->errorMessages().isEmpty()) {
           m_doc->setErrorMessage(i18n("Unknown error."));
        }
        else {
           m_doc->setErrorMessage(m_kraLoader->errorMessages().join("\n"));
        }
        return false;
    }
 
    m_image->disableDirtyRequests();
 
    QString layerPathName = m_kraLoader->imageName();
    if (!m_store->hasDirectory(layerPathName)) {
        // We might be hitting an encoding problem. Get the only folder in the toplevel
        Q_FOREACH (const QString &entry, m_store->directoryList()) {
            if (entry.contains("/layers/")) {
                layerPathName = entry.split("/layers/").first();
                m_store->setSubstitution(m_kraLoader->imageName(), layerPathName);
                break;
            }
        }
    }
 
    m_kraLoader->loadResources(store, m_doc);
    m_kraLoader->loadBinaryData(store, m_image, m_doc->localFilePath(), true);
    m_kraLoader->loadStoryboards(store, m_doc);
    m_kraLoader->loadAnimationMetadata(store, m_image);
    m_kraLoader->loadAudio(store, m_doc);
 
    if (!m_kraLoader->errorMessages().isEmpty()) {
        m_doc->setErrorMessage(m_kraLoader->errorMessages().join("\n"));
        return false;
    }
 
    m_image->enableDirtyRequests();
 
    if (!m_kraLoader->warningMessages().isEmpty()) {
        // warnings do not interrupt loading process, so we do not return here
        m_doc->setWarningMessage(m_kraLoader->warningMessages().join("\n"));
    }
 
    m_activeNodes = m_kraLoader->selectedNodes();
    m_assistants = m_kraLoader->assistants();
    m_storyboardItemList = m_kraLoader->storyboardItemList();
    m_storyboardCommentList = m_kraLoader->storyboardCommentList();
 
    return true;
}

References KisKraLoader::assistants(), KoStore::directoryList(), KisImage::disableDirtyRequests(), KisImage::enableDirtyRequests(), KisKraLoader::errorMessages(), KoStore::hasDirectory(), KisKraLoader::imageName(), KisKraLoader::loadAnimationMetadata(), KisKraLoader::loadAudio(), KisKraLoader::loadBinaryData(), KisKraLoader::loadResources(), KisKraLoader::loadStoryboards(), KisDocument::localFilePath(), m_activeNodes, m_assistants, m_doc, m_image, m_kraLoader, m_store, m_storyboardCommentList, m_storyboardItemList, KisKraLoader::selectedNodes(), KisDocument::setErrorMessage(), KoStore::setSubstitution(), KisDocument::setWarningMessage(), KisKraLoader::storyboardCommentList(), KisKraLoader::storyboardItemList(), and KisKraLoader::warningMessages().

createDomDocument()

QDomDocument KraConverter::createDomDocument ( )

private

Definition at line 273 of file kra_converter.cpp.

{
    QDomDocument doc = m_doc->createDomDocument("DOC", CURRENT_DTD_VERSION);
    QDomElement root = doc.documentElement();
 
    root.setAttribute("editor", "Krita");
    root.setAttribute("syntaxVersion", CURRENT_DTD_VERSION);
    root.setAttribute("kritaVersion", KritaVersionWrapper::versionString(false));
 
    root.appendChild(m_kraSaver->saveXML(doc, m_image));
 
    if (!m_kraSaver->errorMessages().isEmpty()) {
        m_doc->setErrorMessage(m_kraSaver->errorMessages().join(".\n"));
    }
    return doc;
}

References KisDocument::createDomDocument(), CURRENT_DTD_VERSION, KisKraSaver::errorMessages(), m_doc, m_image, m_kraSaver, KisKraSaver::saveXML(), KisDocument::setErrorMessage(), and KritaVersionWrapper::versionString().

image()

KisImageSP KraConverter::image

(

)

Retrieve the constructed image

Definition at line 110 of file kra_converter.cpp.

{
    return m_image;
}

References m_image.

loadXML()

KisImportExportErrorCode KraConverter::loadXML ( const QDomDocument & doc, KoStore * store )

private

Definition at line 339 of file kra_converter.cpp.

{
    Q_UNUSED(store);
 
    QDomElement root;
    QDomNode node;
 
    if (doc.doctype().name() != "DOC") {
       errUI << "The format is not supported or the file is corrupted";
       m_doc->setErrorMessage(i18n("The format is not supported or the file is corrupted"));
       return ImportExportCodes::FileFormatIncorrect;
    }
    root = doc.documentElement();
    
    QString versionTag = root.attribute("syntaxVersion", "3.0");
    QVersionNumber parsedVersionNumber = QVersionNumber::fromString(versionTag);
    const int syntaxVersion = parsedVersionNumber.isNull() ? 3 : parsedVersionNumber.majorVersion();
    
    if (syntaxVersion > 2) {
        errUI << "The file is too new for this version of Krita:" << syntaxVersion;
        m_doc->setErrorMessage(i18n("The file is too new for this version of Krita (%1).", syntaxVersion));
        return ImportExportCodes::FormatFeaturesUnsupported;
    }
 
    if (!root.hasChildNodes()) {
        errUI << "The file has no layers.";
        m_doc->setErrorMessage(i18n("The file has no layers."));
        return ImportExportCodes::FileFormatIncorrect;
    }
 
    QString kritaVersionTag = root.attribute("kritaVersion", "6.0");
    QVersionNumber kritaVersionNumber = QVersionNumber::fromString(kritaVersionTag);
    if (kritaVersionNumber.isNull()) {
        kritaVersionNumber = QVersionNumber::fromString(KritaVersionWrapper::versionString(false));
    }
 
    m_kraLoader = new KisKraLoader(m_doc, syntaxVersion, kritaVersionNumber);
 
    // reset the old image before loading the next one
    m_doc->setCurrentImage(0, false);
 
    for (node = root.firstChild(); !node.isNull(); node = node.nextSibling()) {
        if (node.isElement()) {
            if (node.nodeName() == "IMAGE") {
                QDomElement elem = node.toElement();
                if (!(m_image = m_kraLoader->loadXML(elem))) {
 
                    if (m_kraLoader->errorMessages().isEmpty()) {
                        errUI << "Unknown error while opening the .kra file.";
                        m_doc->setErrorMessage(i18n("Unknown error."));
                    }
                    else {
                        m_doc->setErrorMessage(m_kraLoader->errorMessages().join("\n"));
                        errUI << m_kraLoader->errorMessages().join("\n");
                    }
                    return ImportExportCodes::Failure;
                }
 
                // HACK ALERT!
                m_doc->hackPreliminarySetImage(m_image);
 
                return ImportExportCodes::OK;
            }
            else {
                if (m_kraLoader->errorMessages().isEmpty()) {
                    m_doc->setErrorMessage(i18n("The file does not contain an image."));
                }
                return ImportExportCodes::FileFormatIncorrect;
            }
        }
    }
    return ImportExportCodes::Failure;
}

References KisKraLoader::errorMessages(), errUI, ImportExportCodes::Failure, ImportExportCodes::FileFormatIncorrect, ImportExportCodes::FormatFeaturesUnsupported, KisDocument::hackPreliminarySetImage(), KisKraLoader::loadXML(), m_doc, m_image, m_kraLoader, ImportExportCodes::OK, KisDocument::setCurrentImage(), KisDocument::setErrorMessage(), and KritaVersionWrapper::versionString().

oldLoadAndParse()

KisImportExportErrorCode KraConverter::oldLoadAndParse ( KoStore * store, const QString & filename, QDomDocument & xmldoc )

private

Definition at line 312 of file kra_converter.cpp.

{
    //dbgUI <<"Trying to open" << filename;
 
    if (!store->open(filename)) {
        warnUI << "Entry " << filename << " not found!";
        m_doc->setErrorMessage(i18n("Could not find %1", filename));
        return ImportExportCodes::FileNotExist;
    }
    // Error variables for QDomDocument::setContent
    QString errorMsg;
    int errorLine, errorColumn;
    bool ok = xmldoc.setContent(store->device(), &errorMsg, &errorLine, &errorColumn);
    store->close();
    if (!ok) {
        errUI << "Parsing error in " << filename << "! Aborting!" << Qt::endl
              << " In line: " << errorLine << ", column: " << errorColumn << Qt::endl
              << " Error message: " << errorMsg << Qt::endl;
        m_doc->setErrorMessage(i18n("Parsing error in %1 at line %2, column %3\nError message: %4",
                                    filename, errorLine, errorColumn,
                                    QCoreApplication::translate("QXml", errorMsg.toUtf8(), 0)));
        return ImportExportCodes::FileFormatIncorrect;
    }
    dbgUI << "File" << filename << " loaded and parsed";
    return ImportExportCodes::OK;
}

References KoStore::close(), dbgUI, KoStore::device(), errUI, ImportExportCodes::FileFormatIncorrect, ImportExportCodes::FileNotExist, m_doc, ImportExportCodes::OK, KoStore::open(), KisDocument::setErrorMessage(), and warnUI.

savePreview()

KisImportExportErrorCode KraConverter::savePreview ( KoStore * store )

private

Definition at line 290 of file kra_converter.cpp.

{
    QPixmap pix = m_doc->generatePreview(QSize(256, 256));
    QImage preview(pix.toImage().convertToFormat(QImage::Format_ARGB32, Qt::ColorOnly));
    if (preview.size().isEmpty()) {
        QSize newSize = m_doc->savingImage()->bounds().size();
        // make sure dimensions are at least one pixel, because extreme aspect ratios may cause rounding to zero
        newSize = newSize.scaled(QSize(256, 256), Qt::KeepAspectRatio).expandedTo({1, 1});
        preview = QImage(newSize, QImage::Format_ARGB32);
        preview.fill(QColor(0, 0, 0, 0));
    }
 
    KoStoreDevice io(store);
    if (!io.open(QIODevice::WriteOnly)) {
        return ImportExportCodes::NoAccessToWrite;
    }
    bool ret = preview.save(&io, "PNG");
    io.close();
    return ret ? ImportExportCodes::OK : ImportExportCodes::ErrorWhileWriting;
}

References KisImage::bounds(), KoStoreDevice::close(), ImportExportCodes::ErrorWhileWriting, KisDocument::generatePreview(), m_doc, ImportExportCodes::NoAccessToWrite, ImportExportCodes::OK, KoStoreDevice::open(), and KisDocument::savingImage.

saveRootDocuments()

KisImportExportErrorCode KraConverter::saveRootDocuments ( KoStore * store )

private

Definition at line 216 of file kra_converter.cpp.

{
    dbgFile << "Saving root";
    if (store->open("root")) {
        KoStoreDevice dev(store);
        if (!saveToStream(&dev) || !store->close()) {
            dbgUI << "saveToStream failed";
            return ImportExportCodes::NoAccessToWrite;
        }
    } else {
        m_doc->setErrorMessage(i18n("Not able to write '%1'. Partition full?", QString("maindoc.xml")));
        return ImportExportCodes::ErrorWhileWriting;
    }
 
    if (store->open("documentinfo.xml")) {
        QDomDocument doc = KisDocument::createDomDocument("document-info"
                                                          /*DTD name*/, "document-info" /*tag name*/, "1.1");
        doc = m_doc->documentInfo()->save(doc);
        KoStoreDevice dev(store);
        QByteArray s = doc.toByteArray(); // this is already Utf8!
        bool success = dev.write(s.data(), s.size());
        if (!success) {
            return ImportExportCodes::ErrorWhileWriting;
        }
        store->close();
    } else {
        return ImportExportCodes::Failure;
    }
 
    if (store->open("preview.png")) {
        // ### TODO: missing error checking (The partition could be full!)
        KisImportExportErrorCode result = savePreview(store);
        (void)store->close();
        if (!result.isOk()) {
            return result;
        }
    } else {
        return ImportExportCodes::Failure;
    }
 
    dbgUI << "Saving done of url:" << m_doc->path();
    return ImportExportCodes::OK;
}

References KoStore::close(), KisDocument::createDomDocument(), dbgFile, dbgUI, KisDocument::documentInfo(), ImportExportCodes::ErrorWhileWriting, ImportExportCodes::Failure, KisImportExportErrorCode::isOk(), m_doc, ImportExportCodes::NoAccessToWrite, ImportExportCodes::OK, KoStore::open(), KisDocument::path(), KoDocumentInfo::save(), savePreview(), saveToStream(), KisDocument::setErrorMessage(), and void().

saveToStream()

bool KraConverter::saveToStream ( QIODevice * dev )

private

Definition at line 260 of file kra_converter.cpp.

{
    QDomDocument doc = createDomDocument();
    // Save to buffer
    QByteArray s = doc.toByteArray(); // utf8 already
    dev->open(QIODevice::WriteOnly);
    int nwritten = dev->write(s.data(), s.size());
    if (nwritten != (int)s.size()) {
        warnUI << "wrote " << nwritten << "- expected" <<  s.size();
    }
    return nwritten == (int)s.size();
}

References createDomDocument(), and warnUI.

setProgress()

void KraConverter::setProgress ( int progress )

private

Definition at line 470 of file kra_converter.cpp.

{
    if (m_updater) {
        m_updater->setProgress(progress);
    }
}

References m_updater.

storyboardCommentList()

StoryboardCommentList KraConverter::storyboardCommentList

(

)

Definition at line 130 of file kra_converter.cpp.

{
    return m_storyboardCommentList;
}

References m_storyboardCommentList.

storyboardItemList()

StoryboardItemList KraConverter::storyboardItemList

(

)

Definition at line 125 of file kra_converter.cpp.

{
    return m_storyboardItemList;
}

References m_storyboardItemList.

Member Data Documentation

m_activeNodes

vKisNodeSP KraConverter::m_activeNodes

private

Definition at line 66 of file kra_converter.h.

m_assistants

QList<KisPaintingAssistantSP> KraConverter::m_assistants

private

Definition at line 67 of file kra_converter.h.

m_doc

KisDocument* KraConverter::m_doc {0}

private

Definition at line 63 of file kra_converter.h.

{0};

m_image

KisImageSP KraConverter::m_image

private

Definition at line 64 of file kra_converter.h.

m_kraLoader

KisKraLoader* KraConverter::m_kraLoader {0}

private

Definition at line 74 of file kra_converter.h.

{0};

m_kraSaver

KisKraSaver* KraConverter::m_kraSaver {0}

private

Definition at line 73 of file kra_converter.h.

{0};

m_stop

bool KraConverter::m_stop {false}

private

Definition at line 70 of file kra_converter.h.

{false};

m_store

KoStore* KraConverter::m_store {0}

private

Definition at line 72 of file kra_converter.h.

{0};

m_storyboardCommentList

StoryboardCommentList KraConverter::m_storyboardCommentList

private

Definition at line 69 of file kra_converter.h.

m_storyboardItemList

StoryboardItemList KraConverter::m_storyboardItemList

private

Definition at line 68 of file kra_converter.h.

m_updater

QPointer<KoUpdater> KraConverter::m_updater

private

Definition at line 75 of file kra_converter.h.

---

The documentation for this class was generated from the following files:

• plugins/impex/libkra/kra_converter.h
• plugins/impex/libkra/kra_converter.cpp