KisTIFFExport Class Reference

#include <kis_tiff_export.h>

Inheritance diagram for KisTIFFExport:

Public Member Functions
KisImportExportErrorCode	convert (KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration=0) override
KisConfigWidget *	createConfigurationWidget (QWidget *parent, const QByteArray &from="", const QByteArray &to="") const override
	createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter
KisPropertiesConfigurationSP	defaultConfiguration (const QByteArray &from="", const QByteArray &to="") const override
	defaultConfiguration defines the default settings for the given import export filter
void	initializeCapabilities () override
	KisTIFFExport (QObject *parent, const QVariantList &)
bool	supportsIO () const override
	Override and return false for the filters that use a library that cannot handle file handles, only file names.
	~KisTIFFExport () override
Public Member Functions inherited from KisImportExportFilter
virtual QMap< QString, KisExportCheckBase * >	exportChecks ()
	generate and return the list of capabilities of this export filter. The list
virtual bool	exportSupportsGuides () const
	exportSupportsGuides Because guides are in the document and not the image, checking for guides cannot be made an exportCheck.
KisPropertiesConfigurationSP	lastSavedConfiguration (const QByteArray &from="", const QByteArray &to="") const
	lastSavedConfiguration return the last saved configuration for this filter
	Private ()
void	setBatchMode (bool batchmode)
void	setFilename (const QString &filename)
void	setImportUserFeedBackInterface (KisImportUserFeedbackInterface *interface)
void	setMimeType (const QString &mime)
void	setRealFilename (const QString &filename)
void	setUpdater (QPointer< KoUpdater > updater)
QPointer< KoUpdater >	updater ()
virtual QString	verify (const QString &fileName) const
	Verify whether the given file is correct and readable.
	~KisImportExportFilter () override
	~Private ()

Private Attributes
TIFFErrorHandler	oldErrHandler = nullptr
TIFFErrorHandler	oldWarnHandler = nullptr

Additional Inherited Members
Public Attributes inherited from KisImportExportFilter
bool	batchmode
QMap< QString, KisExportCheckBase * >	capabilities
QString	filename
KisImportUserFeedbackInterface *	importUserFeedBackInterface {nullptr}
QByteArray	mime
QString	realFilename
QPointer< KoUpdater >	updater
Static Public Attributes inherited from KisImportExportFilter
static const QString	CICPPrimariesTag = "CICPCompatiblePrimaries"
static const QString	CICPTransferCharacteristicsTag = "CICPCompatibleTransferFunction"
static const QString	ColorDepthIDTag = "ColorDepthID"
static const QString	ColorModelIDTag = "ColorModelID"
static const QString	HDRTag = "HDRSupported"
static const QString	ImageContainsTransparencyTag = "ImageContainsTransparency"
static const QString	sRGBTag = "sRGB"
Protected Member Functions inherited from KisImportExportFilter
void	addCapability (KisExportCheckBase *capability)
void	addSupportedColorModels (QList< QPair< KoID, KoID > > supportedColorModels, const QString &name, KisExportCheckBase::Level level=KisExportCheckBase::PARTIALLY)
bool	batchMode () const
QString	filename () const
KisImportUserFeedbackInterface *	importUserFeedBackInterface () const
	KisImportExportFilter (QObject *parent=0)
QByteArray	mimeType () const
QString	realFilename () const
void	setProgress (int value)
QString	verifyZiPBasedFiles (const QString &fileName, const QStringList &filesToCheck) const

Detailed Description

Definition at line 17 of file kis_tiff_export.h.

Constructor & Destructor Documentation

KisTIFFExport()

KisTIFFExport::KisTIFFExport	(	QObject *	parent,
		const QVariantList &	)

Definition at line 45 of file kis_tiff_export.cc.

    : KisImportExportFilter(parent)
    , oldErrHandler(TIFFSetErrorHandler(&KisTiffErrorHandler))
    , oldWarnHandler(TIFFSetWarningHandler(&KisTiffWarningHandler))
{
}

~KisTIFFExport()

KisTIFFExport::~KisTIFFExport ( )

override

Definition at line 52 of file kis_tiff_export.cc.

{
    TIFFSetErrorHandler(oldErrHandler);
    TIFFSetWarningHandler(oldWarnHandler);
}

References oldErrHandler, and oldWarnHandler.

Member Function Documentation

convert()

KisImportExportErrorCode KisTIFFExport::convert ( KisDocument * document, QIODevice * io, KisPropertiesConfigurationSP configuration = 0 )

overridevirtual

The filter chain calls this method to perform the actual conversion. The passed mimetypes should be a pair of those you specified in your .desktop file. You have to implement this method to make the filter work.

Returns

The error status, see the #ConversionStatus enum. KisImportExportFilter::OK means that everything is alright.

Implements KisImportExportFilter.

Definition at line 58 of file kis_tiff_export.cc.

{
    // If a configuration object was passed to the convert method, we use that, otherwise we load from the settings
    KisPropertiesConfigurationSP cfg(new KisPropertiesConfiguration());
    if (configuration) {
        cfg->fromXML(configuration->toXML());
    }
    else {
        cfg = lastSavedConfiguration(KisDocument::nativeFormatMimeType(), "image/tiff");
    }
 
    KisTIFFOptions options;
    options.fromProperties(configuration);
 
    if (!options.flatten && !options.saveAsPhotoshop) {
        const bool hasGroupLayers =
            KisLayerUtils::recursiveFindNode(document->savingImage()->root(),
                [] (KisNodeSP node) {
                    return node->parent() && node->inherits("KisGroupLayer");
                });
        options.flatten = hasGroupLayers;
    }
 
    KisImageSP kisimage = [&]() {
        if (options.flatten) {
            KisImageSP image =
                new KisImage(nullptr,
                             document->savingImage()->width(),
                             document->savingImage()->height(),
                             document->savingImage()->colorSpace(),
                             "");
            image->setResolution(document->savingImage()->xRes(),
                                 document->savingImage()->yRes());
            KisPaintDeviceSP pd = KisPaintDeviceSP(
                new KisPaintDevice(*document->savingImage()->projection()));
            KisPaintLayerSP l =
                KisPaintLayerSP(new KisPaintLayer(image.data(),
                                                  "projection",
                                                  OPACITY_OPAQUE_U8,
                                                  pd));
            image->addNode(KisNodeSP(l.data()), image->rootLayer().data());
            return image;
        } else {
            return document->savingImage();
        }
    }();
 
    dbgFile << "Start writing TIFF File";
    KIS_ASSERT_RECOVER_RETURN_VALUE(kisimage, ImportExportCodes::InternalError);
 
    QFile file(filename());
    if (!file.open(QFile::ReadWrite | QFile::Truncate)) {
        return {KisImportExportErrorCannotRead(file.error())};
    }
 
    // Open file for writing
    const QByteArray encodedFilename = QFile::encodeName(filename());
 
    // https://gitlab.com/libtiff/libtiff/-/issues/173
#ifdef Q_OS_WIN
    const int handle = (int)(_get_osfhandle(file.handle()));
#else
    const int handle = file.handle();
#endif
 
    // NOLINTNEXTLINE(bugprone-narrowing-conversions, cppcoreguidelines-narrowing-conversions)
    std::unique_ptr<TIFF, decltype(&TIFFCleanup)> image(TIFFFdOpen(handle, encodedFilename.data(), "w"), &TIFFCleanup);
 
    if (!image) {
        dbgFile << "Could not open the file for writing" << filename();
        return ImportExportCodes::NoAccessToWrite;
    }
 
    // Set the document information
    KoDocumentInfo *info = document->documentInfo();
    QString title = info->aboutInfo("title");
    if (!title.isEmpty()) {
        if (!TIFFSetField(image.get(),
                          TIFFTAG_DOCUMENTNAME,
                          title.toLatin1().constData())) {
            return ImportExportCodes::ErrorWhileWriting;
        }
    }
    QString abstract = info->aboutInfo("description");
    if (!abstract.isEmpty()) {
        if (!TIFFSetField(image.get(),
                          TIFFTAG_IMAGEDESCRIPTION,
                          abstract.toLatin1().constData())) {
            return ImportExportCodes::ErrorWhileWriting;
        }
    }
    QString author = info->authorInfo("creator");
    if (!author.isEmpty()) {
        if (!TIFFSetField(image.get(),
                          TIFFTAG_ARTIST,
                          author.toLatin1().constData())) {
            return ImportExportCodes::ErrorWhileWriting;
        }
    }
 
    dbgFile << "xres: " << INCH_TO_POINT(kisimage->xRes())
            << " yres: " << INCH_TO_POINT(kisimage->yRes());
    if (!TIFFSetField(
            image.get(),
            TIFFTAG_XRESOLUTION,
            INCH_TO_POINT(kisimage->xRes()))) { // It is the "invert" macro
                                                // because we convert from
                                                // pointer-per-inch to points
        return ImportExportCodes::ErrorWhileWriting;
    }
    if (!TIFFSetField(image.get(),
                      TIFFTAG_YRESOLUTION,
                      INCH_TO_POINT(kisimage->yRes()))) {
        return ImportExportCodes::ErrorWhileWriting;
    }
 
    if (!TIFFSetField(image.get(), TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH)) {
        return ImportExportCodes::ErrorWhileWriting;
    }
 
    KisGroupLayer *root =
        dynamic_cast<KisGroupLayer *>(kisimage->rootLayer().data());
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(root,
                                         ImportExportCodes::InternalError);
 
#ifdef TIFF_CAN_WRITE_PSD_TAGS
    if (options.saveAsPhotoshop) {
        KisTiffPsdWriter writer(image.get(), &options);
        KisImportExportErrorCode result = writer.writeImage(root);
        if (!result.isOk()) {
            return result;
        }
    } else
#endif // TIFF_CAN_WRITE_PSD_TAGS
    {
        KisTIFFWriterVisitor visitor(image.get(), &options);
        if (!(visitor.visit(root))) {
            return ImportExportCodes::Failure;
        }
    }
 
    image.reset();
    file.close();
 
    if (!options.flatten && !options.saveAsPhotoshop) {
        // HACK!! Externally inject the Exif metadata
        // libtiff has no way to access the fields wholesale
        try {
            KisExiv2IODevice::ptr_type basicIoDevice(new KisExiv2IODevice(filename()));
 
#if EXIV2_TEST_VERSION(0,28,0)
            const std::unique_ptr<Exiv2::Image> img = Exiv2::ImageFactory::open(std::move(basicIoDevice));
#else
            const std::unique_ptr<Exiv2::Image> img(Exiv2::ImageFactory::open(basicIoDevice).release());
#endif
 
            img->readMetadata();
 
            Exiv2::ExifData &data = img->exifData();
 
            const KisMetaData::IOBackend *io =
                KisMetadataBackendRegistry::instance()->value("exif");
 
            // All IFDs are paint layer children of root
            KisNodeSP node = root->firstChild();
 
            QBuffer ioDevice;
 
            // Get layer
            KisLayer *layer = qobject_cast<KisLayer *>(node.data());
            Q_ASSERT(layer);
 
            // Inject the data as any other IOBackend
            io->saveTo(layer->metaData(), &ioDevice);
 
            Exiv2::ExifData dataToInject;
 
            // Reinterpret the blob we just got and inject its contents into
            // tempData
            Exiv2::ExifParser::decode(
                dataToInject,
                reinterpret_cast<const Exiv2::byte *>(ioDevice.data().data()),
                static_cast<uint32_t>(ioDevice.size()));
 
            for (const auto &v : dataToInject) {
                data[v.key()] = v.value();
            }
            // Write metadata
            img->writeMetadata();
#if EXIV2_TEST_VERSION(0,28,0)
        } catch (Exiv2::Error &e) {
            errFile << "Failed injecting TIFF metadata:" << Exiv2::Error(e.code()).what();
#else
        } catch (Exiv2::AnyError &e) {
            errFile << "Failed injecting TIFF metadata:" << e.code()
                    << e.what();
#endif
        }
    }
    return ImportExportCodes::OK;
}

References KoDocumentInfo::aboutInfo(), KisNodeFacade::addNode(), KoDocumentInfo::authorInfo(), KisSharedPtr< T >::data(), dbgFile, errFile, ImportExportCodes::ErrorWhileWriting, ImportExportCodes::Failure, KisImportExportFilter::filename, KisNode::firstChild(), KisTIFFOptions::flatten, KisTIFFOptions::fromProperties(), INCH_TO_POINT(), KisMetadataBackendRegistry::instance(), ImportExportCodes::InternalError, KisImportExportErrorCode::isOk(), KIS_ASSERT_RECOVER_RETURN_VALUE, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KisImportExportFilter::lastSavedConfiguration(), KisLayer::metaData(), KisDocument::nativeFormatMimeType(), ImportExportCodes::NoAccessToWrite, ImportExportCodes::OK, OPACITY_OPAQUE_U8, KisLayerUtils::recursiveFindNode(), KisImage::rootLayer(), KisTIFFOptions::saveAsPhotoshop, KisMetaData::IOBackend::saveTo(), KisImage::setResolution(), v, KoGenericRegistry< T >::value(), KisTIFFWriterVisitor::visit(), KisTiffPsdWriter::writeImage(), KisImage::xRes(), and KisImage::yRes().

createConfigurationWidget()

KisConfigWidget * KisTIFFExport::createConfigurationWidget ( QWidget * parent, const QByteArray & from = "", const QByteArray & to = "" ) const

overridevirtual

createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter

Parameters

parent	the owner of the widget; the caller is responsible for deleting
from	The mimetype of the source file/document
to	The mimetype of the destination file/document

Returns

the widget

Reimplemented from KisImportExportFilter.

Definition at line 266 of file kis_tiff_export.cc.

{
    return new KisTIFFOptionsWidget(parent);
}

defaultConfiguration()

KisPropertiesConfigurationSP KisTIFFExport::defaultConfiguration ( const QByteArray & from = "", const QByteArray & to = "" ) const

overridevirtual

defaultConfiguration defines the default settings for the given import export filter

Parameters

from	The mimetype of the source file/document
to	The mimetype of the destination file/document

Returns

a serializable KisPropertiesConfiguration object

Reimplemented from KisImportExportFilter.

Definition at line 260 of file kis_tiff_export.cc.

{
    KisTIFFOptions options;
    return options.toProperties();
}

References KisTIFFOptions::toProperties().

initializeCapabilities()

void KisTIFFExport::initializeCapabilities ( )

overridevirtual

Reimplemented from KisImportExportFilter.

Definition at line 271 of file kis_tiff_export.cc.

{
    addCapability(KisExportCheckRegistry::instance()->get("MultiLayerCheck")->create(KisExportCheckBase::SUPPORTED));
    addCapability(KisExportCheckRegistry::instance()->get("LayerOpacityCheck")->create(KisExportCheckBase::PARTIALLY));
    addCapability(KisExportCheckRegistry::instance()->get("sRGBProfileCheck")->create(KisExportCheckBase::SUPPORTED));
    addCapability(KisExportCheckRegistry::instance()->get("ExifCheck")->create(KisExportCheckBase::SUPPORTED));
    addCapability(KisExportCheckRegistry::instance()
                      ->get("TiffExifCheck")
                      ->create(KisExportCheckBase::PARTIALLY));
    addCapability(
        KisExportCheckRegistry::instance()->get("ColorModelHomogenousCheck")->create(KisExportCheckBase::SUPPORTED));
 
    QList<QPair<KoID, KoID>> supportedColorModels = {
        {},
        {RGBAColorModelID, Integer8BitsColorDepthID},
        {RGBAColorModelID, Integer16BitsColorDepthID},
        {RGBAColorModelID, Float16BitsColorDepthID},
        {RGBAColorModelID, Float32BitsColorDepthID},
        {GrayAColorModelID, Integer8BitsColorDepthID},
        {GrayAColorModelID, Integer16BitsColorDepthID},
        {CMYKAColorModelID, Integer8BitsColorDepthID},
        {CMYKAColorModelID, Integer16BitsColorDepthID},
        {YCbCrAColorModelID, Integer8BitsColorDepthID},
        {YCbCrAColorModelID, Integer16BitsColorDepthID},
        {YCbCrAColorModelID, Float16BitsColorDepthID},
        {YCbCrAColorModelID, Float32BitsColorDepthID},
        {LABAColorModelID, Integer8BitsColorDepthID},
        {LABAColorModelID, Integer16BitsColorDepthID},
        {LABAColorModelID, Float16BitsColorDepthID},
        {LABAColorModelID, Float32BitsColorDepthID}};
    addSupportedColorModels(supportedColorModels, "TIFF");
 
}

References KisImportExportFilter::addCapability(), KisImportExportFilter::addSupportedColorModels(), CMYKAColorModelID, Float16BitsColorDepthID, Float32BitsColorDepthID, get(), GrayAColorModelID, KisExportCheckRegistry::instance(), Integer16BitsColorDepthID, Integer8BitsColorDepthID, LABAColorModelID, KisExportCheckBase::PARTIALLY, RGBAColorModelID, KisExportCheckBase::SUPPORTED, and YCbCrAColorModelID.

supportsIO()

bool KisTIFFExport::supportsIO ( ) const

inlineoverridevirtual

Override and return false for the filters that use a library that cannot handle file handles, only file names.

Reimplemented from KisImportExportFilter.

Definition at line 23 of file kis_tiff_export.h.

{ return false; }

Member Data Documentation

oldErrHandler

TIFFErrorHandler KisTIFFExport::oldErrHandler = nullptr

private

Definition at line 30 of file kis_tiff_export.h.

oldWarnHandler

TIFFErrorHandler KisTIFFExport::oldWarnHandler = nullptr

private

Definition at line 31 of file kis_tiff_export.h.

---

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

• plugins/impex/tiff/kis_tiff_export.h
• plugins/impex/tiff/kis_tiff_export.cc