KisImportExportManager Class Reference

The class managing all the filters. More...

#include <KisImportExportManager.h>

Inheritance diagram for KisImportExportManager:

Classes
struct	ConversionResult

Public Types
enum	Direction { Import = 1 , Export = 2 }

Public Member Functions
KisImportExportErrorCode	exportDocument (const QString &location, const QString &realLocation, const QByteArray &mimeType, bool showWarnings=true, KisPropertiesConfigurationSP exportConfiguration=0, bool isAdvancedExporting=false)
	Exports the given file/document to the specified URL/mimetype.
QFuture< KisImportExportErrorCode >	exportDocumentAsync (const QString &location, const QString &realLocation, const QByteArray &mimeType, KisImportExportErrorCode &status, bool showWarnings=true, KisPropertiesConfigurationSP exportConfiguration=0, bool isAdvancedExporting=false)
KisImportExportErrorCode	importDocument (const QString &location, const QString &mimeType)
	KisImportExportManager (KisDocument *document)
	~KisImportExportManager () override

Public Attributes
QSharedPointer< KisImportExportFilter >	cachedExportFilter
QString	cachedExportFilterMimeType
KoUpdaterPtr	updater

Static API
KisDocument *	m_document
Private *const	d
static QStringList	m_importMimeTypes
	A static cache for the availability checks of filters.
static QStringList	m_exportMimeTypes
bool	batchMode (void) const
void	setUpdater (KoUpdaterPtr updater)
static QStringList	supportedMimeTypes (Direction direction)
static KisImportExportFilter *	filterForMimeType (const QString &mimetype, Direction direction)
	filterForMimeType loads the relevant import/export plugin and returns it. The caller is responsible for deleting it!
static void	fillStaticExportConfigurationProperties (KisPropertiesConfigurationSP exportConfiguration, KisImageSP image)
static QString	askForAudioFileName (const QString &defaultDir, QWidget *parent)
static QString	getUriForAdditionalFile (const QString &defaultUri, QWidget *parent)
ConversionResult	convert (Direction direction, const QString &location, const QString &realLocation, const QString &mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync, bool isAdvancedExporting=false)
void	fillStaticExportConfigurationProperties (KisPropertiesConfigurationSP exportConfiguration)
bool	askUserAboutExportConfiguration (QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration, const QByteArray &from, const QByteArray &to, bool batchMode, const bool showWarnings, bool *alsoAsKra, bool isAdvancedExporting=false)
KisImportExportErrorCode	doImport (const QString &location, QSharedPointer< KisImportExportFilter > filter)
KisImportExportErrorCode	doExport (const QString &location, QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration, const QString alsoAsKraLocation)
KisImportExportErrorCode	doExportImpl (const QString &location, QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration)
QString	getAlsoAsKraLocation (const QString location) const
	KisImportExportManager (const KisImportExportManager &rhs)
KisImportExportManager &	operator= (const KisImportExportManager &rhs)

Additional Inherited Members
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

The class managing all the filters.

This class manages all filters for a Calligra application. Normally you will not have to use it, since KisMainWindow takes care of loading and saving documents.

KisFilter

Author

Kalle Dalheimer kalle.nosp@m.@kde.nosp@m..org

Torben Weis weis@.nosp@m.kde..nosp@m.org

Werner Trobin trobi.nosp@m.n@kd.nosp@m.e.org

Definition at line 96 of file KisImportExportManager.cpp.

Member Enumeration Documentation

Direction

enum KisImportExportManager::Direction

This enum is used to distinguish the import/export cases

Enumerator
Import
Export

Definition at line 45 of file KisImportExportManager.h.

{ Import = 1,  Export = 2 };

Constructor & Destructor Documentation

KisImportExportManager() [1/2]

KisImportExportManager::KisImportExportManager ( KisDocument * document )

explicit

Create a filter manager for a document

Definition at line 148 of file KisImportExportManager.cpp.

    : m_document(document)
    , d(new Private)
{
}

~KisImportExportManager()

KisImportExportManager::~KisImportExportManager ( )

override

Definition at line 154 of file KisImportExportManager.cpp.

{
    delete d;
}

References d.

KisImportExportManager() [2/2]

KisImportExportManager::KisImportExportManager ( const KisImportExportManager & rhs )

private

Member Function Documentation

askForAudioFileName()

QString KisImportExportManager::askForAudioFileName ( const QString & defaultDir, QWidget * parent )

static

Definition at line 287 of file KisImportExportManager.cpp.

{
    KoFileDialog dialog(parent, KoFileDialog::ImportFiles, "ImportAudio");
 
    if (!defaultDir.isEmpty()) {
        dialog.setDefaultDir(defaultDir);
    }
 
    QStringList mimeTypes;
    mimeTypes << "audio/mpeg";
    mimeTypes << "audio/ogg";
    mimeTypes << "audio/vorbis";
    mimeTypes << "audio/vnd.wave";
    mimeTypes << "audio/flac";
 
    dialog.setMimeTypeFilters(mimeTypes);
    dialog.setCaption(i18nc("@title:window", "Open Audio"));
 
    return dialog.filename();
}

References KoFileDialog::ImportFiles.

askUserAboutExportConfiguration()

bool KisImportExportManager::askUserAboutExportConfiguration ( QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration, const QByteArray & from, const QByteArray & to, bool batchMode, const bool showWarnings, bool * alsoAsKra, bool isAdvancedExporting = false )

private

Definition at line 523 of file KisImportExportManager.cpp.

{
 
    // prevents the animation renderer from running this code
 
 
    const QString mimeUserDescription = KisMimeDatabase::descriptionForMimeType(to);
 
    QStringList warnings;
    QStringList errors;
 
    {
        KisPreExportChecker checker;
        checker.check(m_document->image(), filter->exportChecks());
 
        warnings = checker.warnings();
        errors = checker.errors();
    }
 
    KisConfigWidget *wdg = 0;
 
    if (QThread::currentThread() == qApp->thread()) {
        wdg = filter->createConfigurationWidget(0, from, to);
 
        KisMainWindow *kisMain = KisPart::instance()->currentMainwindow();
        if (wdg && kisMain) {
            KisViewManager *manager = kisMain->viewManager();
            wdg->setView(manager);
        }
    }
 
    // Extra checks that cannot be done by the checker, because the checker only has access to the image.
    if (!m_document->assistants().isEmpty() && to != m_document->nativeFormatMimeType()) {
        warnings.append(i18nc("image conversion warning", "The image contains <b>assistants</b>. The assistants will not be saved."));
    }
    if (m_document->referenceImagesLayer() && m_document->referenceImagesLayer()->shapeCount() > 0 && to != m_document->nativeFormatMimeType()) {
        warnings.append(i18nc("image conversion warning", "The image contains <b>reference images</b>. The reference images will not be saved."));
    }
    if (m_document->guidesConfig().hasGuides() && !filter->exportSupportsGuides()) {
        warnings.append(i18nc("image conversion warning", "The image contains <b>guides</b>. The guides will not be saved."));
    }
    if (!m_document->gridConfig().isDefault() && to != m_document->nativeFormatMimeType()) {
        warnings.append(i18nc("image conversion warning", "The image contains a <b>custom grid configuration</b>. The configuration will not be saved."));
    }
 
    bool shouldFlattenTheImageBeforeScaling = false;
 
    if (isAdvancedExporting) {
        QMap<QString, KisExportCheckBase *> exportChecks = filter->exportChecks();
 
        const bool filterSupportsMultilayerExport =
                exportChecks.contains("MultiLayerCheck") &&
                exportChecks["MultiLayerCheck"]->checkNeeded(m_document->image()) &&
                exportChecks["MultiLayerCheck"]->check(m_document->image()) == KisExportCheckBase::SUPPORTED;
 
        if (!filterSupportsMultilayerExport) {
            shouldFlattenTheImageBeforeScaling = true;
        } else {
            if (KisLayerUtils::findNodeByType<KisAdjustmentLayer>(m_document->image()->root())) {
                shouldFlattenTheImageBeforeScaling = true;
                warnings.append(i18nc("image conversion warning", "Trying to perform an Advanced Export with the image containing a <b>filter layer</b>. The image will be <b>flattened</b> before resizing."));
            }
            if (KisLayerUtils::findNodeByType<KisFilterMask>(m_document->image()->root())) {
                shouldFlattenTheImageBeforeScaling = true;
                warnings.append(i18nc("image conversion warning", "Trying to perform an Advanced Export with the image containing a <b>filter mask</b>. The image will be <b>flattened</b> before resizing."));
            }
            bool hasLayerStyles =
                    KisLayerUtils::recursiveFindNode(m_document->image()->root(),
                                                     [] (KisNodeSP node) {
                    KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
                    return layer && layer->layerStyle();
        });
 
            if (hasLayerStyles) {
                shouldFlattenTheImageBeforeScaling = true;
                warnings.append(i18nc("image conversion warning", "Trying to perform an Advanced Export with the image containing a <b>layer style</b>. The image will be <b>flattened</b> before resizing."));
            }
        }
    }
 
    if (!batchMode && !errors.isEmpty()) {
        QString error =  "<html><body><p><b>"
                + i18n("Error: cannot save this image as a %1.", mimeUserDescription)
                + "</b> " + i18n("Reasons:") + "</p>"
                + "<p/><ul>";
        Q_FOREACH(const QString &w, errors) {
            error += "\n<li>" + w + "</li>";
        }
 
        error += "</ul>";
 
        QMessageBox::critical(KisPart::instance()->currentMainwindow(), i18nc("@title:window", "Krita: Export Error"), error);
        return false;
    }
 
    if (!batchMode && (wdg || !warnings.isEmpty() || isAdvancedExporting)) {
        QWidget *page = new QWidget();
        QVBoxLayout *layout = new QVBoxLayout(page);
 
        if (showWarnings && !warnings.isEmpty()) {
            QHBoxLayout *hLayout = new QHBoxLayout();
 
            QLabel *labelWarning = new QLabel();
            labelWarning->setPixmap(KisIconUtils::loadIcon("dialog-warning").pixmap(48, 48));
            hLayout->addWidget(labelWarning);
 
            KisPopupButton *bn = new KisPopupButton(0);
 
            bn->setText(i18nc("Keep the extra space at the end of the sentence, please", "Warning: saving as a %1 will lose information from your image.    ", mimeUserDescription));
            bn->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
            hLayout->addWidget(bn);
 
            layout->addLayout(hLayout);
 
            QTextBrowser *browser = new QTextBrowser();
            browser->setMinimumWidth(bn->width());
            bn->setPopupWidget(browser);
 
            QString warning = "<html><body><p><b>"
                    + i18n("You will lose information when saving this image as a %1.", mimeUserDescription);
 
            if (warnings.size() == 1) {
                warning += "</b> " + i18n("Reason:") + "</p>";
            }
            else {
                warning += "</b> " + i18n("Reasons:") + "</p>";
            }
            warning += "<p/><ul>";
 
            Q_FOREACH(const QString &w, warnings) {
                warning += "\n<li>" + w + "</li>";
            }
 
            warning += "</ul>";
            browser->setHtml(warning);
        }
 
        QTabWidget *box = new QTabWidget;
        if (wdg) {
            wdg->setConfiguration(exportConfiguration);
            box->addTab(wdg,i18n("Options"));
        }
 
        WdgImageSize *wdgImageSize = nullptr;
 
        if (isAdvancedExporting) {
            wdgImageSize = new WdgImageSize(box, m_document->image()->width(), m_document->image()->height(), m_document->image()->yRes());
 
            box->addTab(wdgImageSize,i18n("Resize"));
        }
        layout->addWidget(box);
 
        QCheckBox *chkAlsoAsKra = 0;
        if (showWarnings && !warnings.isEmpty()) {
            chkAlsoAsKra = new QCheckBox(i18n("Also save your image as a Krita file."));
            chkAlsoAsKra->setChecked(KisConfig(true).readEntry<bool>("AlsoSaveAsKra", false));
            layout->addWidget(chkAlsoAsKra);
        }
 
        KoDialog dlg(qApp->activeWindow());
        dlg.setMainWidget(page);
        page->setParent(&dlg);
        dlg.setButtons(KoDialog::Ok | KoDialog::Cancel);
        dlg.setWindowTitle(mimeUserDescription);
 
        if (showWarnings || wdg || isAdvancedExporting) {
            if (!dlg.exec()) {
                return false;
            }
        }
 
        *alsoAsKra = false;
        if (chkAlsoAsKra) {
            KisConfig(false).writeEntry<bool>("AlsoSaveAsKra", chkAlsoAsKra->isChecked());
            *alsoAsKra = chkAlsoAsKra->isChecked();
        }
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(bool(isAdvancedExporting) == bool(wdgImageSize));
 
        if (isAdvancedExporting && wdgImageSize) {
            if (shouldFlattenTheImageBeforeScaling) {
                m_document->savingImage()->flatten(KisNodeSP());
                m_document->savingImage()->waitForDone();
            }
 
            const QSize desiredSize(wdgImageSize->desiredWidth(), wdgImageSize->desiredHeight());
            double res = wdgImageSize->desiredResolution();
            m_document->savingImage()->scaleImage(desiredSize,res,res,wdgImageSize->filterType());
            m_document->savingImage()->waitForDone();
            KisLayerUtils::forceAllDelayedNodesUpdate(m_document->savingImage()->root());
            m_document->savingImage()->waitForDone();
        }
 
        if (wdg) {
            *exportConfiguration = *wdg->configuration();
        }
    }
 
    return true;
}

References KisDocument::assistants, batchMode(), KoDialog::Cancel, KisPreExportChecker::check(), KisConfigWidget::configuration(), KisPart::currentMainwindow(), KisMimeDatabase::descriptionForMimeType(), WdgImageSize::desiredHeight(), WdgImageSize::desiredResolution(), WdgImageSize::desiredWidth(), KisPreExportChecker::errors(), WdgImageSize::filterType(), KisImage::flatten(), KisLayerUtils::forceAllDelayedNodesUpdate(), KisDocument::gridConfig, KisDocument::guidesConfig, KisGuidesConfig::hasGuides(), KisImage::height(), KisDocument::image, KisPart::instance(), KisGridConfig::isDefault(), KIS_SAFE_ASSERT_RECOVER_NOOP, KisIconUtils::loadIcon(), m_document, KisDocument::nativeFormatMimeType(), KoDialog::Ok, KisLayerUtils::recursiveFindNode(), KisDocument::referenceImagesLayer(), KisNodeFacade::root, KisDocument::savingImage, KisImage::scaleImage(), KoDialog::setButtons(), KisConfigWidget::setConfiguration(), KoDialog::setMainWidget(), KisPopupButton::setPopupWidget(), KisConfigWidget::setView(), KoShapeContainer::shapeCount(), KisExportCheckBase::SUPPORTED, KisMainWindow::viewManager, KisImage::waitForDone(), KisPreExportChecker::warnings(), KisImage::width(), KisConfig::writeEntry(), and KisImage::yRes().

batchMode()

bool KisImportExportManager::batchMode

(

void

)

const

Get if the filter manager is batch mode (true) or in interactive mode (true)

Definition at line 277 of file KisImportExportManager.cpp.

{
    return m_document->fileBatchMode();
}

References KisDocument::fileBatchMode(), and m_document.

convert()

KisImportExportManager::ConversionResult KisImportExportManager::convert ( KisImportExportManager::Direction direction, const QString & location, const QString & realLocation, const QString & mimeType, bool showWarnings, KisPropertiesConfigurationSP exportConfiguration, bool isAsync, bool isAdvancedExporting = false )

private

Fetching a filter from the registry is a really expensive operation, because it blocks all the threads. Cache the filter if possible.

Definition at line 320 of file KisImportExportManager.cpp.

{
    // export configuration is supported for export only
    KIS_SAFE_ASSERT_RECOVER_NOOP(direction == Export || !bool(exportConfiguration));
 
    QString typeName = mimeType;
    if (typeName.isEmpty()) {
        typeName = KisMimeDatabase::mimeTypeForFile(location, direction == KisImportExportManager::Export ? false : true);
    }
 
    QSharedPointer<KisImportExportFilter> filter;
 
    if (direction == KisImportExportManager::Export &&
            d->cachedExportFilter &&
            d->cachedExportFilterMimeType == typeName) {
 
        filter = d->cachedExportFilter;
    } else {
 
        filter = toQShared(filterForMimeType(typeName, direction));
 
        if (direction == Export) {
            d->cachedExportFilter = filter;
            d->cachedExportFilterMimeType = typeName;
        }
    }
 
    if (!filter) {
        return KisImportExportErrorCode(ImportExportCodes::FileFormatNotSupported);
    }
 
    filter->setFilename(location);
    filter->setRealFilename(realLocation);
    filter->setBatchMode(batchMode());
    filter->setMimeType(typeName);
 
    if (direction == Import) {
        KisMainWindow *kisMain = KisPart::instance()->currentMainwindow();
        filter->setImportUserFeedBackInterface(new SynchronousUserFeedbackInterface(kisMain, batchMode()));
    }
 
    if (!d->updater.isNull()) {
        // WARNING: The updater is not guaranteed to be persistent! If you ever want
        // to add progress reporting to "Save also as .kra", make sure you create
        // a separate KoProgressUpdater for that!
 
        // WARNING2: the failsafe completion of the updater happens in the destructor
        // the filter.
 
        filter->setUpdater(d->updater);
    }
 
    QByteArray from, to;
    if (direction == Export) {
        from = m_document->nativeFormatMimeType();
        to = typeName.toLatin1();
    }
    else {
        from = typeName.toLatin1();
        to = m_document->nativeFormatMimeType();
    }
 
    KIS_ASSERT_RECOVER_RETURN_VALUE(
                direction == Import || direction == Export,
                KisImportExportErrorCode(ImportExportCodes::InternalError)); // "bad conversion graph"
 
    ConversionResult result = KisImportExportErrorCode(ImportExportCodes::OK);
    if (direction == Import) {
 
        KisUsageLogger::log(QString("Importing %1 to %2. Location: %3. Real location: %4. Batchmode: %5")
                                .arg(QString::fromLatin1(from), QString::fromLatin1(to), location,
                                     realLocation, QString::number(batchMode())));
 
        // async importing is not yet supported!
        KIS_SAFE_ASSERT_RECOVER_NOOP(!isAsync);
 
        // FIXME: Dmitry says "this progress reporting code never worked. Initial idea was to implement it his way, but I stopped and didn't finish it"
        if (0 && !batchMode()) {
            KisAsyncActionFeedback f(i18n("Opening document..."), 0);
            result = f.runAction(std::bind(&KisImportExportManager::doImport, this, location, filter));
        } else {
            result = doImport(location, filter);
        }
        if (result.status().isOk()) {
            KisImageSP image = m_document->image().toStrongRef();
            if (image) {
                KIS_SAFE_ASSERT_RECOVER(image->colorSpace() != nullptr && image->colorSpace()->profile() != nullptr)
                {
                    qWarning() << "Loaded a profile-less file without a fallback. Rejecting image "
                                  "opening";
                    return KisImportExportErrorCode(ImportExportCodes::InternalError);
                }
                KisUsageLogger::log(QString("Loaded image from %1. Size: %2 * %3 pixels, %4 dpi. Color "
                                            "model: %6 %5 (%7). Layers: %8")
                                        .arg(QString::fromLatin1(from), QString::number(image->width()),
                                             QString::number(image->height()), QString::number(image->xRes()),
                                             image->colorSpace()->colorModelId().name(),
                                             image->colorSpace()->colorDepthId().name(),
                                             image->colorSpace()->profile()->name(),
                                             QString::number(image->nlayers())));
            } else {
                qWarning() << "The filter returned OK, but there is no image";
            }
 
        }
        else {
            KisUsageLogger::log(QString("Failed to load image from %1").arg(QString::fromLatin1(from)));
        }
 
    }
    else /* if (direction == Export) */ {
        if (!exportConfiguration) {
            exportConfiguration = filter->lastSavedConfiguration(from, to);
        }
 
        if (exportConfiguration) {
            fillStaticExportConfigurationProperties(exportConfiguration);
        }
 
        bool alsoAsKra = false;
        bool askUser = askUserAboutExportConfiguration(filter, exportConfiguration,
                                                       from, to,
                                                       batchMode(), showWarnings,
                                                       &alsoAsKra, isAdvancedExporting);
 
 
        if (!batchMode() && !askUser) {
            return KisImportExportErrorCode(ImportExportCodes::Cancelled);
        }
 
        KisUsageLogger::log(
            QString(
                "Converting from %1 to %2. Location: %3. Real location: %4. Batchmode: %5. Configuration: %6")
                .arg(QString::fromLatin1(from), QString::fromLatin1(to), location, realLocation,
                     QString::number(batchMode()),
                     (exportConfiguration ? exportConfiguration->toXML() : "none")));
 
        const QString alsoAsKraLocation = alsoAsKra ? getAlsoAsKraLocation(location) : QString();
        if (isAsync) {
            result = QtConcurrent::run(std::bind(&KisImportExportManager::doExport, this, location, filter,
                                                 exportConfiguration, alsoAsKraLocation));
 
            // we should explicitly report that the exporting has been initiated
            result.setStatus(ImportExportCodes::OK);
 
        } else if (!batchMode()) {
            KisAsyncActionFeedback f(i18n("Saving document..."), 0);
            result = f.runAction(std::bind(&KisImportExportManager::doExport, this, location, filter,
                                           exportConfiguration, alsoAsKraLocation));
        } else {
            result = doExport(location, filter, exportConfiguration, alsoAsKraLocation);
        }
 
        if (exportConfiguration && !batchMode()) {
            KisConfig(false).setExportConfiguration(typeName, exportConfiguration);
        }
    }
    return result;
}

References askUserAboutExportConfiguration(), batchMode(), ImportExportCodes::Cancelled, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisImage::colorSpace(), KisPart::currentMainwindow(), d, doExport(), doImport(), Export, ImportExportCodes::FileFormatNotSupported, fillStaticExportConfigurationProperties(), filterForMimeType(), getAlsoAsKraLocation(), KisImage::height(), KisDocument::image, Import, KisPart::instance(), ImportExportCodes::InternalError, KisImportExportErrorCode::isOk(), KIS_ASSERT_RECOVER_RETURN_VALUE, KIS_SAFE_ASSERT_RECOVER, KIS_SAFE_ASSERT_RECOVER_NOOP, KisUsageLogger::log(), m_document, KisMimeDatabase::mimeTypeForFile(), KoID::name(), KoColorProfile::name, KisDocument::nativeFormatMimeType(), KisImage::nlayers(), ImportExportCodes::OK, KoColorSpace::profile(), KisConfig::setExportConfiguration(), KisImportExportManager::ConversionResult::setStatus(), KisImportExportManager::ConversionResult::status(), toQShared(), KisImage::width(), and KisImage::xRes().

doExport()

KisImportExportErrorCode KisImportExportManager::doExport ( const QString & location, QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration, const QString alsoAsKraLocation )

private

Definition at line 753 of file KisImportExportManager.cpp.

{
    KisImportExportErrorCode status =
            doExportImpl(location, filter, exportConfiguration);
 
    if (!alsoAsKraLocation.isNull() && status.isOk()) {
        QByteArray mime = m_document->nativeFormatMimeType();
        QSharedPointer<KisImportExportFilter> filter(
                    filterForMimeType(QString::fromLatin1(mime), Export));
 
        KIS_SAFE_ASSERT_RECOVER_NOOP(filter);
 
        if (filter) {
            filter->setFilename(alsoAsKraLocation);
 
            KisPropertiesConfigurationSP kraExportConfiguration =
                    filter->lastSavedConfiguration(mime, mime);
 
            status = doExportImpl(alsoAsKraLocation, filter, kraExportConfiguration);
        } else {
            status = ImportExportCodes::FileFormatIncorrect;
        }
    }
 
    return status;
}

References doExportImpl(), Export, ImportExportCodes::FileFormatIncorrect, filterForMimeType(), KisImportExportErrorCode::isOk(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_document, and KisDocument::nativeFormatMimeType().

doExportImpl()

KisImportExportErrorCode KisImportExportManager::doExportImpl ( const QString & location, QSharedPointer< KisImportExportFilter > filter, KisPropertiesConfigurationSP exportConfiguration )

private

Definition at line 814 of file KisImportExportManager.cpp.

{
#ifdef USE_QSAVEFILE
    QSaveFile file(location);
    file.setDirectWriteFallback(true);
    if (filter->supportsIO() && !file.open(QFile::WriteOnly)) {
#else
    QFileInfo fi(location);
    QTemporaryFile file(QDir::tempPath() + "/.XXXXXX.kra");
    if (filter->supportsIO() && !file.open()) {
#endif
        KisImportExportErrorCannotWrite result(getFileOpenError(file));
#ifdef USE_QSAVEFILE
        file.cancelWriting();
#endif
        return result;
    }
 
    KisImportExportErrorCode status = filter->convert(m_document, &file, exportConfiguration);
 
    if (filter->supportsIO()) {
        if (!status.isOk()) {
#ifdef USE_QSAVEFILE
            file.cancelWriting();
#endif
        } else {
#ifdef USE_QSAVEFILE
            if (!file.commit()) {
                qWarning() << "Could not commit QSaveFile";
                status = KisImportExportErrorCannotWrite(file.error());
            }
#elif defined(Q_OS_ANDROID)
            // The Android file system is bananas, so it needs special handling.
 
            // If the temporary file is still open, ensure it's fully written.
            // If it got closed, open it again so that we can read from it.
            if(file.isOpen()) {
                if (!file.flush()) {
                    return KisImportExportErrorCannotWrite(file.error());
                }
            } else if (!file.open()) {
                return KisImportExportErrorCannotWrite(getFileOpenError(file));
            }
 
            // Grab the size we're expecting to write for later verification.
            qint64 expectedSize = file.size();
            if (expectedSize < 0 || !file.seek(0)) {
                return KisImportExportErrorCannotWrite(file.error());
            }
 
            // Open the target file. We have to explicitly tell the file to
            // truncate itself because unlike on every other system it doesn't
            // do that on its own when opening a file for writing, it just
            // leaves the old content laying around and you start overwriting
            // it, potentially leaving old garbage at the end of the file.
            QFile target(location);
            if (!target.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
                return KisImportExportErrorCannotWrite(getFileOpenError(target));
            }
 
            // QFile::copy also doesn't work, so we gotta do it manually by
            // alternately reading and writing BUFSIZ-sized chunks.
            QByteArray buf;
            buf.resize(BUFSIZ);
            qint64 totalWritten = 0;
            while (true) {
                qint64 read = file.read(buf.data(), BUFSIZ);
                if (read < 0) {
                    // Read error.
                    return KisImportExportErrorCannotWrite(file.error());
                } else if (read == 0) {
                    // End of file.
                    break;
                } else {
                    // Successful read, try to write it.
                    qint64 written = target.write(buf.constData(), read);
                    if (written < 0) {
                        // Write error.
                        return KisImportExportErrorCannotWrite(target.error());
                    }
                    // We may not have written as much as we read, but we handle
                    // that at the end.
                    totalWritten += written;
                }
            }
 
            // Finish up and make sure what we wrote is out to storage.
            file.close();
            if (!target.flush()) {
                return KisImportExportErrorCannotWrite(target.error());
            }
            target.close();
 
            // Now check if we actually wrote as much as we wanted to. If not,
            // raise an error. There's not much we can do about it though, since
            // we already truncated the original file at this point and don't
            // have permissions to create backup files in the sandbox.
            if (totalWritten != expectedSize) {
                return KisImportExportErrorCannotWrite(QFileDevice::CopyError);
            }
#else
            file.flush();
            file.close();
            QFile target(location);
            if (target.exists()) {
                // There should already be a .kra~ backup
                target.remove();
            }
            if (!file.copy(location)) {
                file.setAutoRemove(false);
                return KisImportExportErrorCannotWrite(file.error());
            }
#endif
        }
    }
 
    if (status.isOk()) {
        // Do some minimal verification
        QString verificationResult = filter->verify(location);
        if (!verificationResult.isEmpty()) {
            status = KisImportExportErrorCode(ImportExportCodes::ErrorWhileWriting);
            m_document->setErrorMessage(verificationResult);
        }
    }
 
    return status;
 
}

References ImportExportCodes::ErrorWhileWriting, KisImportExportErrorCode::isOk(), m_document, KisDocument::setErrorMessage(), and target().

doImport()

KisImportExportErrorCode KisImportExportManager::doImport ( const QString & location, QSharedPointer< KisImportExportFilter > filter )

private

Definition at line 733 of file KisImportExportManager.cpp.

{
    QFile file(location);
    if (!file.exists()) {
        return ImportExportCodes::FileNotExist;
    }
 
    if (filter->supportsIO() && !file.open(QFile::ReadOnly)) {
        return KisImportExportErrorCode(KisImportExportErrorCannotRead(file.error()));
    }
 
    KisImportExportErrorCode status = filter->convert(m_document, &file, KisPropertiesConfigurationSP());
 
    if (file.isOpen()) {
        file.close();
    }
 
    return status;
}

References ImportExportCodes::FileNotExist, and m_document.

exportDocument()

KisImportExportErrorCode KisImportExportManager::exportDocument	(	const QString &	location,
		const QString &	realLocation,
		const QByteArray &	mimeType,
		bool	showWarnings = true,
		KisPropertiesConfigurationSP	exportConfiguration = 0,
		bool	isAdvancedExporting = false )

Exports the given file/document to the specified URL/mimetype.

If mimeType is empty, then the closest matching Calligra part is searched and when the method returns mimeType contains this mimetype. Oh, well, export is a C++ keyword ;)

Definition at line 167 of file KisImportExportManager.cpp.

{
    ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, false, isAdvancedExporting);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), ImportExportCodes::InternalError);
 
    return result.status();
}

References convert(), Export, ImportExportCodes::InternalError, KisImportExportManager::ConversionResult::isAsync(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisImportExportManager::ConversionResult::status().

exportDocumentAsync()

QFuture< KisImportExportErrorCode > KisImportExportManager::exportDocumentAsync	(	const QString &	location,
		const QString &	realLocation,
		const QByteArray &	mimeType,
		KisImportExportErrorCode &	status,
		bool	showWarnings = true,
		KisPropertiesConfigurationSP	exportConfiguration = 0,
		bool	isAdvancedExporting = false )

Definition at line 175 of file KisImportExportManager.cpp.

{
    ConversionResult result = convert(Export, location, realLocation, mimeType, showWarnings, exportConfiguration, true, isAdvancedExporting);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(result.isAsync() ||
                                         !result.status().isOk(), QFuture<KisImportExportErrorCode>());
 
    status = result.status();
    return result.futureStatus();
}

References convert(), Export, KisImportExportManager::ConversionResult::futureStatus(), KisImportExportManager::ConversionResult::isAsync(), KisImportExportErrorCode::isOk(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisImportExportManager::ConversionResult::status().

fillStaticExportConfigurationProperties() [1/2]

void KisImportExportManager::fillStaticExportConfigurationProperties ( KisPropertiesConfigurationSP exportConfiguration )

private

Definition at line 518 of file KisImportExportManager.cpp.

{
    return fillStaticExportConfigurationProperties(exportConfiguration, m_document->image());
}

References fillStaticExportConfigurationProperties(), KisDocument::image, and m_document.

fillStaticExportConfigurationProperties() [2/2]

void KisImportExportManager::fillStaticExportConfigurationProperties ( KisPropertiesConfigurationSP exportConfiguration, KisImageSP image )

static

Fill necessary information for the export filter into the properties, e.g. if the image has transparency or has sRGB profile.

Definition at line 484 of file KisImportExportManager.cpp.

{
    KisPaintDeviceSP dev = image->projection();
    const KoColorSpace* cs = dev->colorSpace();
    const bool isThereAlpha =
            KisPainter::checkDeviceHasTransparency(image->projection());
 
    exportConfiguration->setProperty(KisImportExportFilter::ImageContainsTransparencyTag, isThereAlpha);
    exportConfiguration->setProperty(KisImportExportFilter::ColorModelIDTag, cs->colorModelId().id());
    exportConfiguration->setProperty(KisImportExportFilter::ColorDepthIDTag, cs->colorDepthId().id());
 
    const bool sRGB =
            (cs->profile()->name().contains(QLatin1String("srgb"), Qt::CaseInsensitive) &&
             !cs->profile()->name().contains(QLatin1String("g10")));
    exportConfiguration->setProperty(KisImportExportFilter::sRGBTag, sRGB);
 
    ColorPrimaries primaries = cs->profile()->getColorPrimaries();
    if (primaries >= PRIMARIES_ADOBE_RGB_1998) {
        primaries = PRIMARIES_UNSPECIFIED;
    }
    TransferCharacteristics transferFunction =
        cs->profile()->getTransferCharacteristics();
    if (transferFunction >= TRC_GAMMA_1_8) {
        transferFunction = TRC_UNSPECIFIED;
    }
    exportConfiguration->setProperty(KisImportExportFilter::CICPPrimariesTag,
                                     static_cast<int>(primaries));
    exportConfiguration->setProperty(
        KisImportExportFilter::CICPTransferCharacteristicsTag,
        static_cast<int>(transferFunction));
    exportConfiguration->setProperty(KisImportExportFilter::HDRTag, cs->hasHighDynamicRange());
}

References KisPainter::checkDeviceHasTransparency(), KisImportExportFilter::CICPPrimariesTag, KisImportExportFilter::CICPTransferCharacteristicsTag, KoColorSpace::colorDepthId(), KisImportExportFilter::ColorDepthIDTag, KoColorSpace::colorModelId(), KisImportExportFilter::ColorModelIDTag, KisPaintDevice::colorSpace(), KoColorProfile::getColorPrimaries(), KoColorProfile::getTransferCharacteristics(), KoColorSpace::hasHighDynamicRange(), KisImportExportFilter::HDRTag, KoID::id(), KisImportExportFilter::ImageContainsTransparencyTag, KoColorProfile::name, PRIMARIES_ADOBE_RGB_1998, PRIMARIES_UNSPECIFIED, KoColorSpace::profile(), KisImage::projection(), KisImportExportFilter::sRGBTag, TRC_GAMMA_1_8, and TRC_UNSPECIFIED.

filterForMimeType()

KisImportExportFilter * KisImportExportManager::filterForMimeType ( const QString & mimetype, KisImportExportManager::Direction direction )

static

filterForMimeType loads the relevant import/export plugin and returns it. The caller is responsible for deleting it!

Parameters

mimetype	the mimetype we want to import/export. If there's more than one plugin, the one with the highest weight as defined in the json description will be taken
direction	import or export

Returns

a pointer to the filter plugin or 0 if none could be found

Definition at line 227 of file KisImportExportManager.cpp.

{
    int weight = -1;
    KisImportExportFilter *filter = 0;
    QList<KoJsonTrader::Plugin>list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
 
    Q_FOREACH(const KoJsonTrader::Plugin &loader, list) {
        QJsonObject json = loader.metaData().value("MetaData").toObject();
        QString directionKey = direction == Export ? "X-KDE-Export" : "X-KDE-Import";
 
        if (json.value(directionKey).toString().split(",", Qt::SkipEmptyParts).contains(mimetype)) {
 
            KPluginFactory *factory = qobject_cast<KPluginFactory *>(loader.instance());
 
            if (!factory) {
                warnUI << loader.errorString();
                continue;
            }
 
            QObject* obj = factory->create<KisImportExportFilter>(0);
            if (!obj || !obj->inherits("KisImportExportFilter")) {
                delete obj;
                continue;
            }
 
            KisImportExportFilter *f = qobject_cast<KisImportExportFilter*>(obj);
            if (!f) {
                delete obj;
                continue;
            }
 
            KIS_ASSERT_RECOVER_NOOP(json.value("X-KDE-Weight").isDouble());
 
            int w = json.value("X-KDE-Weight").toInt();
 
            if (w > weight) {
                delete filter;
                filter = f;
                f->setObjectName(loader.fileName());
                weight = w;
            }
        }
    }
 
    if (filter) {
        filter->setMimeType(mimetype);
    }
    return filter;
}

References KoJsonTrader::Plugin::errorString(), Export, KoJsonTrader::Plugin::fileName(), KoJsonTrader::instance(), KoJsonTrader::Plugin::instance(), KIS_ASSERT_RECOVER_NOOP, KoJsonTrader::Plugin::metaData(), KoJsonTrader::query(), KisImportExportFilter::setMimeType(), and warnUI.

getAlsoAsKraLocation()

QString KisImportExportManager::getAlsoAsKraLocation ( const QString location ) const

private

Definition at line 943 of file KisImportExportManager.cpp.

{
#ifdef Q_OS_ANDROID
    return getUriForAdditionalFile(location, nullptr);
#else
    return location + ".kra";
#endif
}

References getUriForAdditionalFile().

getUriForAdditionalFile()

QString KisImportExportManager::getUriForAdditionalFile ( const QString & defaultUri, QWidget * parent )

static

Definition at line 308 of file KisImportExportManager.cpp.

{
    KoFileDialog dialog(parent, KoFileDialog::SaveFile, "Save Kra");
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(!defaultUri.isEmpty());
 
    dialog.setDirectoryUrl(QUrl(defaultUri));
    dialog.setMimeTypeFilters(QStringList("application/x-krita"));
 
    return dialog.filename();
}

References KIS_SAFE_ASSERT_RECOVER_NOOP, and KoFileDialog::SaveFile.

importDocument()

KisImportExportErrorCode KisImportExportManager::importDocument	(	const QString &	location,
		const QString &	mimeType )

Imports the specified document and returns the resultant filename (most likely some file in /tmp). path can be either a URL or a filename. documentMimeType gives importDocument a hint about what type the document may be. It can be left empty.

Returns

status signals the success/error of the conversion. If the QString which is returned isEmpty() and the status is OK, then we imported the file directly into the document.

Definition at line 159 of file KisImportExportManager.cpp.

{
    ConversionResult result = convert(Import, location, location, mimeType, false, 0, false);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(!result.isAsync(), ImportExportCodes::InternalError);
 
    return result.status();
}

References convert(), Import, ImportExportCodes::InternalError, KisImportExportManager::ConversionResult::isAsync(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisImportExportManager::ConversionResult::status().

operator=()

KisImportExportManager & KisImportExportManager::operator= ( const KisImportExportManager & rhs )

private

setUpdater()

void KisImportExportManager::setUpdater

(

KoUpdaterPtr

updater

)

Definition at line 282 of file KisImportExportManager.cpp.

{
    d->updater = updater;
}

References d, and updater.

supportedMimeTypes()

QStringList KisImportExportManager::supportedMimeTypes ( Direction direction )

static

Suitable for passing to KoFileDialog::setMimeTypeFilters. The default mime gets set by the "users" of this method, as we do not have enough information here. Optionally, extraNativeMimeTypes are added after the native mimetype.

Definition at line 188 of file KisImportExportManager.cpp.

{
    // Find the right mimetype by the extension
    QSet<QString> mimeTypes;
    //    mimeTypes << KisDocument::nativeFormatMimeType() << "application/x-krita-paintoppreset" << "image/openraster";
 
    if (direction == KisImportExportManager::Import) {
        if (m_importMimeTypes.isEmpty()) {
            QList<KoJsonTrader::Plugin> list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
            Q_FOREACH(const KoJsonTrader::Plugin &loader, list) {
                QJsonObject json = loader.metaData().value("MetaData").toObject();
                Q_FOREACH(const QString &mimetype, json.value("X-KDE-Import").toString().split(",", Qt::SkipEmptyParts)) {
 
                    //qDebug() << "Adding  import mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                    mimeTypes << mimetype;
                }
            }
            m_importMimeTypes = QList<QString>(mimeTypes.begin(), mimeTypes.end());
        }
        return m_importMimeTypes;
    }
    else if (direction == KisImportExportManager::Export) {
        if (m_exportMimeTypes.isEmpty()) {
            QList<KoJsonTrader::Plugin> list = KoJsonTrader::instance()->query("Krita/FileFilter", "");
            Q_FOREACH(const KoJsonTrader::Plugin &loader, list) {
                QJsonObject json = loader.metaData().value("MetaData").toObject();
                Q_FOREACH(const QString &mimetype, json.value("X-KDE-Export").toString().split(",", Qt::SkipEmptyParts)) {
 
                    //qDebug() << "Adding  export mimetype" << mimetype << KisMimeDatabase::descriptionForMimeType(mimetype) << "from plugin" << loader;
                    mimeTypes << mimetype;
                }
            }
            m_exportMimeTypes = QList<QString>(mimeTypes.begin(), mimeTypes.end());
        }
        return m_exportMimeTypes;
    }
    return QStringList();
}

References Export, Import, KoJsonTrader::instance(), m_exportMimeTypes, m_importMimeTypes, KoJsonTrader::Plugin::metaData(), and KoJsonTrader::query().

Member Data Documentation

cachedExportFilter

QSharedPointer<KisImportExportFilter> KisImportExportManager::cachedExportFilter

Definition at line 102 of file KisImportExportManager.cpp.

cachedExportFilterMimeType

QString KisImportExportManager::cachedExportFilterMimeType

Definition at line 101 of file KisImportExportManager.cpp.

d

Private* const KisImportExportManager::d

private

Definition at line 146 of file KisImportExportManager.h.

m_document

KisDocument* KisImportExportManager::m_document

private

Definition at line 139 of file KisImportExportManager.h.

m_exportMimeTypes

QStringList KisImportExportManager::m_exportMimeTypes

staticprivate

Definition at line 143 of file KisImportExportManager.h.

m_importMimeTypes

QStringList KisImportExportManager::m_importMimeTypes

staticprivate

A static cache for the availability checks of filters.

Definition at line 142 of file KisImportExportManager.h.

updater

KoUpdaterPtr KisImportExportManager::updater

Definition at line 99 of file KisImportExportManager.cpp.

---

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

• libs/ui/KisImportExportManager.cpp
• libs/ui/KisImportExportManager.h