KisSafeDocumentLoader Class Reference

#include <kis_safe_document_loader.h>

Inheritance diagram for KisSafeDocumentLoader:

Classes
struct	Private

Signals
void	fileExistsStateChanged (bool fileExists)
void	loadingFailed ()
void	loadingFinished (KisPaintDeviceSP paintDevice, qreal xRes, qreal yRes, const QSize &size)

Public Member Functions
	KisSafeDocumentLoader (const QString &path="", QObject *parent=0)
void	reloadImage ()
void	setPath (const QString &path)
	~KisSafeDocumentLoader () override

Private Slots
void	delayedLoadStart ()
void	fileChanged (QString)
void	fileChangedCompressed (bool sync=false)
void	slotFileExistsStateChanged (const QString &path, bool fileExists)

Private Attributes
Private *const	m_d

Detailed Description

Definition at line 14 of file kis_safe_document_loader.h.

Constructor & Destructor Documentation

KisSafeDocumentLoader()

KisSafeDocumentLoader::KisSafeDocumentLoader	(	const QString &	path = "",
		QObject *	parent = 0 )

Definition at line 225 of file kis_safe_document_loader.cpp.

    : QObject(parent),
      m_d(new Private())
{
    connect(s_fileSystemWatcher, SIGNAL(fileChanged(QString)),
            SLOT(fileChanged(QString)));
 
    connect(s_fileSystemWatcher, SIGNAL(fileExistsStateChanged(QString, bool)),
            SLOT(slotFileExistsStateChanged(QString, bool)));
 
    connect(&m_d->fileChangedSignalCompressor, SIGNAL(timeout()),
            SLOT(fileChangedCompressed()));
 
    setPath(path);
}

References fileChanged(), fileChangedCompressed(), KisSafeDocumentLoader::Private::fileChangedSignalCompressor, fileExistsStateChanged(), m_d, setPath(), and slotFileExistsStateChanged().

~KisSafeDocumentLoader()

KisSafeDocumentLoader::~KisSafeDocumentLoader ( )

override

Definition at line 241 of file kis_safe_document_loader.cpp.

{
    if (!m_d->path.isEmpty()) {
        s_fileSystemWatcher->removePath(m_d->path);
    }
 
    delete m_d;
}

References m_d, and KisSafeDocumentLoader::Private::path.

Member Function Documentation

delayedLoadStart

void KisSafeDocumentLoader::delayedLoadStart ( )

privateslot

TODO: Ideally we should modify our KisDocument code to allow loading from a QIODevice, but currently it supports loading from a local file only. That is why we just extract the PNG into a temporary file and load it separately.

NOTE: we cannot use QImage for loading, since it strips the color profile attached to the PNG file

Definition at line 318 of file kis_safe_document_loader.cpp.

{
    QFileInfo originalInfo(m_d->path);
    QFileInfo tempInfo(m_d->temporaryPath);
    bool successfullyLoaded = false;
 
    if (!m_d->fileChangedFlag &&
            originalInfo.size() == m_d->initialFileSize &&
            originalInfo.lastModified() == m_d->initialFileTimeStamp &&
            tempInfo.size() == m_d->initialFileSize) {
 
        m_d->doc.reset(KisPart::instance()->createTemporaryDocument());
        m_d->doc->setFileBatchMode(true);
 
        auto loadPathNatively = [&doc = m_d->doc](const QString &path) -> bool {
            const bool successfullyLoaded = doc->openPath(path, KisDocument::DontAddToRecent);
            if (successfullyLoaded) {
                // Wait for required updates, if any. BUG: 448256
                KisLayerUtils::forceAllDelayedNodesUpdate(doc->image()->root());
                doc->image()->waitForDone();
            }
            return successfullyLoaded;
        };
 
        if (m_d->path.toLower().endsWith("ora") || m_d->path.toLower().endsWith("kra")) {
            QScopedPointer<KoStore> store(KoStore::createStore(m_d->temporaryPath, KoStore::Read));
            if (store && !store->bad()) {
                if (store->open(QString("mergedimage.png"))) {
                    qint64 totalWritten = 0;
                    const qint64 expectedFileSize = store->size();
                    QTemporaryFile temporaryFile(QDir::tempPath() + QLatin1String("/krita_merged_image_XXXXXX.png"));
                    if (temporaryFile.open()) {
                        QByteArray buffer(BUFSIZ, 0);
 
                        while (true) {
                            qint64 read = store->read(buffer.data(), buffer.size());
                            if (read < 0) {
                                warnKrita << "Failed to read from mergedimage.png for the file layer's projection";
                                break;
                            } else if (read == 0) {
                                // End of file
                                break;
                            } else {
                                // Successful read, try to write it.
                                qint64 written = temporaryFile.write(buffer.constData(), read);
                                if (written < 0) {
                                    // Write error.
                                    warnKrita << "Failed to write mergedimage.png into a temporary file for the file layer's projection"
                                              << temporaryFile.fileName() << ":" << temporaryFile.errorString();
                                    break;
                                }
                                // We may not have written as much as we read, but we handle
                                // that at the end.
                                totalWritten += written;
                            }
                        }
 
                        temporaryFile.close();
                    } else {
                        warnKrita << "Failed to open temporary file for mergedimage.png for the file layer's projection"
                                  << temporaryFile.fileName() << ":" << temporaryFile.errorString();
                    }
                    store->close();
 
                    if (totalWritten == expectedFileSize) {
                        successfullyLoaded = loadPathNatively(temporaryFile.fileName());
                    } else {
                        successfullyLoaded = false;
                    }
                }
                else {
                    qWarning() << "delayedLoadStart: Could not open mergedimage.png";
                }
            }
            else {
                qWarning() << "delayedLoadStart: Store was bad";
            }
        }
        else {
            successfullyLoaded = loadPathNatively(m_d->temporaryPath);
        }
    } else {
        dbgKrita << "File was modified externally. Restarting.";
        dbgKrita << ppVar(m_d->fileChangedFlag);
        dbgKrita << ppVar(m_d->initialFileSize);
        dbgKrita << ppVar(m_d->initialFileTimeStamp);
        dbgKrita << ppVar(originalInfo.size());
        dbgKrita << ppVar(originalInfo.lastModified());
        dbgKrita << ppVar(tempInfo.size());
    }
 
    QFile::remove(m_d->temporaryPath);
    m_d->isLoading = false;
 
    if (!successfullyLoaded) {
        // Restart the attempt
        m_d->failureCount++;
        if (m_d->failureCount >= 3) {
            Q_EMIT loadingFailed();
        }
        else {
            m_d->fileChangedSignalCompressor.start();
        }
    }
    else {
        KisPaintDeviceSP paintDevice = new KisPaintDevice(m_d->doc->image()->colorSpace());
        KisPaintDeviceSP projection = m_d->doc->image()->projection();
        paintDevice->makeCloneFrom(projection, projection->extent());
        Q_EMIT loadingFinished(paintDevice,
                             m_d->doc->image()->xRes(),
                             m_d->doc->image()->yRes(),
                             m_d->doc->image()->size());
    }
 
    m_d->doc.reset();
}

References KoStore::createStore(), dbgKrita, KisSafeDocumentLoader::Private::doc, KisDocument::DontAddToRecent, KisPaintDevice::extent(), KisSafeDocumentLoader::Private::failureCount, KisSafeDocumentLoader::Private::fileChangedFlag, KisSafeDocumentLoader::Private::fileChangedSignalCompressor, KisLayerUtils::forceAllDelayedNodesUpdate(), KisSafeDocumentLoader::Private::initialFileSize, KisSafeDocumentLoader::Private::initialFileTimeStamp, KisPart::instance(), KisSafeDocumentLoader::Private::isLoading, loadingFailed(), loadingFinished(), m_d, KisPaintDevice::makeCloneFrom(), KisSafeDocumentLoader::Private::path, ppVar, KoStore::Read, KisSignalCompressor::start(), KisSafeDocumentLoader::Private::temporaryPath, and warnKrita.

fileChanged

void KisSafeDocumentLoader::fileChanged ( QString path )

privateslot

Definition at line 267 of file kis_safe_document_loader.cpp.

{
    if (FileSystemWatcherWrapper::unifyFilePath(m_d->path) == path) {
        m_d->fileChangedFlag = true;
        m_d->fileChangedSignalCompressor.start();
    }
}

References KisSafeDocumentLoader::Private::fileChangedFlag, KisSafeDocumentLoader::Private::fileChangedSignalCompressor, m_d, KisSafeDocumentLoader::Private::path, KisSignalCompressor::start(), and FileSystemWatcherWrapper::unifyFilePath().

fileChangedCompressed

void KisSafeDocumentLoader::fileChangedCompressed ( bool sync = false )

privateslot

Definition at line 285 of file kis_safe_document_loader.cpp.

{
    if (m_d->isLoading) return;
 
    QFileInfo initialFileInfo(m_d->path);
    m_d->initialFileSize = initialFileInfo.size();
    m_d->initialFileTimeStamp = initialFileInfo.lastModified();
 
    // it may happen when the file is flushed by
    // so other application
    if (!m_d->initialFileSize) return;
 
    m_d->isLoading = true;
    m_d->fileChangedFlag = false;
 
    m_d->temporaryPath =
            QDir::tempPath() + '/' +
            QString("krita_file_layer_copy_%1_%2.%3")
            .arg(QApplication::applicationPid())
            .arg(QRandomGenerator::global()->generate())
            .arg(initialFileInfo.suffix());
 
    QFile::copy(m_d->path, m_d->temporaryPath);
 
 
    if (!sync) {
        QTimer::singleShot(100, Qt::CoarseTimer, this, SLOT(delayedLoadStart()));
    } else {
        QApplication::processEvents();
        delayedLoadStart();
    }
}

References delayedLoadStart(), KisSafeDocumentLoader::Private::fileChangedFlag, KisSafeDocumentLoader::Private::initialFileSize, KisSafeDocumentLoader::Private::initialFileTimeStamp, KisSafeDocumentLoader::Private::isLoading, m_d, KisSafeDocumentLoader::Private::path, and KisSafeDocumentLoader::Private::temporaryPath.

fileExistsStateChanged

void KisSafeDocumentLoader::fileExistsStateChanged ( bool fileExists )

signal

loadingFailed

void KisSafeDocumentLoader::loadingFailed ( )

signal

loadingFinished

void KisSafeDocumentLoader::loadingFinished ( KisPaintDeviceSP paintDevice, qreal xRes, qreal yRes, const QSize & size )

signal

reloadImage()

void KisSafeDocumentLoader::reloadImage

(

)

Definition at line 262 of file kis_safe_document_loader.cpp.

{
    fileChangedCompressed(true);
}

References fileChangedCompressed().

setPath()

void KisSafeDocumentLoader::setPath

(

const QString &

path

)

Definition at line 250 of file kis_safe_document_loader.cpp.

{
    if (path.isEmpty()) return;
 
    if (!m_d->path.isEmpty()) {
        s_fileSystemWatcher->removePath(m_d->path);
    }
 
    m_d->path = path;
    s_fileSystemWatcher->addPath(m_d->path);
}

References m_d, and KisSafeDocumentLoader::Private::path.

slotFileExistsStateChanged

void KisSafeDocumentLoader::slotFileExistsStateChanged ( const QString & path, bool fileExists )

privateslot

Definition at line 275 of file kis_safe_document_loader.cpp.

{
    if (FileSystemWatcherWrapper::unifyFilePath(m_d->path) == path) {
        Q_EMIT fileExistsStateChanged(fileExists);
        if (fileExists) {
            fileChanged(path);
        }
    }
}

References fileChanged(), fileExistsStateChanged(), m_d, KisSafeDocumentLoader::Private::path, and FileSystemWatcherWrapper::unifyFilePath().

Member Data Documentation

m_d

Private* const KisSafeDocumentLoader::m_d

private

Definition at line 37 of file kis_safe_document_loader.h.

---

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

• libs/ui/kis_safe_document_loader.h
• libs/ui/kis_safe_document_loader.cpp