KisXCFImport Class Reference

#include <kis_xcf_import.h>

Inheritance diagram for KisXCFImport:

Public Member Functions
KisImportExportErrorCode	convert (KisDocument *document, QIODevice *io, KisPropertiesConfigurationSP configuration=0) override
	KisXCFImport (QObject *parent, const QVariantList &)
	~KisXCFImport () override
Public Member Functions inherited from KisImportExportFilter
virtual KisConfigWidget *	createConfigurationWidget (QWidget *parent, const QByteArray &from="", const QByteArray &to="") const
	createConfigurationWidget creates a widget that can be used to define the settings for a given import/export filter
virtual KisPropertiesConfigurationSP	defaultConfiguration (const QByteArray &from="", const QByteArray &to="") const
	defaultConfiguration defines the default settings for the given import export filter
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)
virtual bool	supportsIO () const
	Override and return false for the filters that use a library that cannot handle file handles, only file names.
QPointer< KoUpdater >	updater ()
virtual QString	verify (const QString &fileName) const
	Verify whether the given file is correct and readable.
	~KisImportExportFilter () override
	~Private ()

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
virtual void	initializeCapabilities ()
	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_xcf_import.h.

Constructor & Destructor Documentation

KisXCFImport()

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

Definition at line 134 of file kis_xcf_import.cpp.

                                                                : KisImportExportFilter(parent)
{
}

~KisXCFImport()

KisXCFImport::~KisXCFImport ( )

override

Definition at line 138 of file kis_xcf_import.cpp.

{
}

Member Function Documentation

convert()

KisImportExportErrorCode KisXCFImport::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 142 of file kis_xcf_import.cpp.

{
    int errorStatus;
 
    dbgFile << "Start decoding file";
    QByteArray data = io->readAll();
    xcf_file = (uint8_t*)data.data();
    xcf_length = data.size();
    io->close();
 
    // Decode the data
    if (getBasicXcfInfo() != XCF_OK) {
        if (XCF.version < 0 || XCF.version > 2) {
            document->setErrorMessage(i18n("This XCF file is too new; Krita cannot support XCF files written by GIMP 2.9 or newer."));
            return ImportExportCodes::FormatFeaturesUnsupported;
        }
        return ImportExportCodes::FileFormatIncorrect;
    }
 
    if(initColormap() != XCF_OK) {
        return ImportExportCodes::FileFormatIncorrect;
    }
 
    dbgFile << XCF.version << "width = " << XCF.width << "height = " << XCF.height << "layers = " << XCF.numLayers;
 
    // Create the image
    KisImageSP image = new KisImage(document->createUndoStore(), XCF.width, XCF.height, KoColorSpaceRegistry::instance()->rgb8(), "built image");
 
    QVector<Layer> layers;
    uint maxDepth = 0;
 
    // Read layers
    for (int i = 0; i < XCF.numLayers; ++i) {
 
        Layer layer;
 
        xcfLayer& xcflayer = XCF.layers[i];
        dbgFile << i << " name = " << xcflayer.name << " opacity = " << xcflayer.opacity << "group:" << xcflayer.isGroup << xcflayer.pathLength;
        dbgFile << ppVar(xcflayer.dim.width) << ppVar(xcflayer.dim.height) << ppVar(xcflayer.dim.tilesx) << ppVar(xcflayer.dim.tilesy) << ppVar(xcflayer.dim.ntiles) << ppVar(xcflayer.dim.c.t) << ppVar(xcflayer.dim.c.l) << ppVar(xcflayer.dim.c.r) << ppVar(xcflayer.dim.c.b);
 
        maxDepth = qMax(maxDepth, xcflayer.pathLength);
 
        bool isRgbA = false;
        // Select the color space
        const KoColorSpace* colorSpace = 0;
        switch (xcflayer.type) {
        case GIMP_INDEXED_IMAGE:
        case GIMP_INDEXEDA_IMAGE:
        case GIMP_RGB_IMAGE:
        case GIMP_RGBA_IMAGE:
            colorSpace = KoColorSpaceRegistry::instance()->rgb8();
            isRgbA = true;
            break;
        case GIMP_GRAY_IMAGE:
        case GIMP_GRAYA_IMAGE:
            colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), "");
            isRgbA = false;
            break;
        }
 
        // Create the layer
        KisLayerSP kisLayer;
        if (xcflayer.isGroup) {
            kisLayer = new KisGroupLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity);
        }
        else {
            kisLayer = new KisPaintLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity, colorSpace);
        }
 
        // Set some properties
        kisLayer->setCompositeOpId(layerModeG2K(xcflayer.mode));
        kisLayer->setVisible(xcflayer.isVisible);
        kisLayer->disableAlphaChannel(xcflayer.mode != GIMP_NORMAL_MODE);
 
        layer.layer = kisLayer;
        layer.depth = xcflayer.pathLength;
 
        // Copy the data in the image
        if ((errorStatus = initLayer(&xcflayer)) != XCF_OK) {
            return ImportExportCodes::FileFormatIncorrect;
        }
 
        int left = xcflayer.dim.c.l;
        int top = xcflayer.dim.c.t;
 
        if (!xcflayer.isGroup) {
 
            // Copy the data;
            for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
                for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
                    rect want;
                    want.l = x + left;
                    want.t = y + top;
                    want.b = want.t + TILE_HEIGHT;
                    want.r = want.l + TILE_WIDTH;
                    Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.pixels, want);
                    if (tile == XCF_PTR_EMPTY) {
                        return ImportExportCodes::FileFormatIncorrect;
                    }
                    KisHLineIteratorSP it = kisLayer->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
                    rgba* data = tile->pixels;
                    for (int v = 0; v < TILE_HEIGHT; ++v) {
                        if (isRgbA) {
                            // RGB image
                           do {
                                KoBgrTraits<quint8>::setRed(it->rawData(), GET_RED(*data));
                                KoBgrTraits<quint8>::setGreen(it->rawData(), GET_GREEN(*data));
                                KoBgrTraits<quint8>::setBlue(it->rawData(), GET_BLUE(*data));
                                KoBgrTraits<quint8>::setOpacity(it->rawData(), quint8(GET_ALPHA(*data)), 1);
                                ++data;
                            } while (it->nextPixel());
                        } else {
                            // Grayscale image
                            do {
                                it->rawData()[0] = GET_RED(*data);
                                it->rawData()[1] = GET_ALPHA(*data);
                                ++data;
                            } while (it->nextPixel());
                        }
                        it->nextRow();
                    }
                    freeTile(tile);
                }
            }
 
            // Move the layer to its position
            kisLayer->paintDevice()->setX(left);
            kisLayer->paintDevice()->setY(top);
        }
        // Create the mask
        if (xcflayer.hasMask) {
            KisTransparencyMaskSP mask = new KisTransparencyMask(image, i18n("Transparency Mask"));
            layer.mask = mask;
 
            mask->initSelection(kisLayer);
            for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
                for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
                    rect want;
                    want.l = x + left;
                    want.t = y + top;
                    want.b = want.t + TILE_HEIGHT;
                    want.r = want.l + TILE_WIDTH;
                    Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.mask, want);
                    if (tile == XCF_PTR_EMPTY) {
                        free(tile);
                        return ImportExportCodes::FileFormatIncorrect;
                    }
                    KisHLineIteratorSP it = mask->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
                    rgba* data = tile->pixels;
                    for (int v = 0; v < TILE_HEIGHT; ++v) {
                        do {
                            it->rawData()[0] = GET_ALPHA(*data);
                            ++data;
                        } while (it->nextPixel());
                        it->nextRow();
                    }
                    freeTile(tile);
                }
            }
            mask->paintDevice()->setX(left);
            mask->paintDevice()->setY(top);
        }
 
        dbgFile << xcflayer.pixels.tileptrs;
        layers.append(layer);
    }
 
    for (uint i = 0; i <= maxDepth; ++i) {
        addLayers(layers, image, i);
    }
 
    document->setCurrentImage(image);
    return ImportExportCodes::OK;
 
}

References addLayers(), rect::b, tileDimensions::c, KoColorSpaceRegistry::colorSpace(), KisPaintDevice::createHLineIteratorNG(), dbgFile, Layer::depth, xcfLayer::dim, KisLayer::disableAlphaChannel(), ImportExportCodes::FileFormatIncorrect, ImportExportCodes::FormatFeaturesUnsupported, freeTile(), GET_ALPHA, GET_BLUE, GET_GREEN, GET_RED, getBasicXcfInfo(), getMaskOrLayerTile(), GIMP_GRAY_IMAGE, GIMP_GRAYA_IMAGE, GIMP_INDEXED_IMAGE, GIMP_INDEXEDA_IMAGE, GIMP_NORMAL_MODE, GIMP_RGB_IMAGE, GIMP_RGBA_IMAGE, GrayAColorModelID, xcfLayer::hasMask, tileDimensions::height, xcfImage::height, KoID::id(), initColormap(), initLayer(), KisMask::initSelection(), KoColorSpaceRegistry::instance(), Integer8BitsColorDepthID, xcfLayer::isGroup, xcfLayer::isVisible, rect::l, Layer::layer, layerModeG2K(), xcfImage::layers, xcfLayer::mask, Layer::mask, xcfLayer::mode, xcfLayer::name, tileDimensions::ntiles, xcfImage::numLayers, ImportExportCodes::OK, xcfLayer::opacity, KisBaseNode::paintDevice(), KisMask::paintDevice(), xcfLayer::pathLength, Tile::pixels, xcfLayer::pixels, ppVar, rect::r, KoColorSpaceRegistry::rgb8(), KoBgrTraits< _channels_type_ >::setBlue(), KisBaseNode::setCompositeOpId(), KoBgrTraits< _channels_type_ >::setGreen(), KoColorSpaceTrait< _channels_type_, 4, 3 >::setOpacity(), KoBgrTraits< _channels_type_ >::setRed(), KisBaseNode::setVisible(), KisPaintDevice::setX(), KisPaintDevice::setY(), rect::t, TILE_HEIGHT, TILE_WIDTH, xcfTiles::tileptrs, tileDimensions::tilesx, tileDimensions::tilesy, xcfLayer::type, v, xcfImage::version, tileDimensions::width, xcfImage::width, XCF, xcf_file, xcf_length, XCF_OK, and XCF_PTR_EMPTY.

---

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

• plugins/impex/xcf/kis_xcf_import.h
• plugins/impex/xcf/kis_xcf_import.cpp