KisBrushExport Class Reference

#include <kis_brush_export.h>

Inheritance diagram for KisBrushExport:

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
	KisBrushExport (QObject *parent, const QVariantList &)
	~KisBrushExport () 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)
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
	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 19 of file kis_brush_export.h.

Constructor & Destructor Documentation

KisBrushExport()

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

Definition at line 47 of file kis_brush_export.cpp.

                                                                    : KisImportExportFilter(parent)
{
}

~KisBrushExport()

KisBrushExport::~KisBrushExport ( )

override

Definition at line 51 of file kis_brush_export.cpp.

{
}

Member Function Documentation

convert()

KisImportExportErrorCode KisBrushExport::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 55 of file kis_brush_export.cpp.

{
 
// XXX: Loading the parasite itself was commented out -- needs investigation
//    KisAnnotationSP annotation = document->savingImage()->annotation("ImagePipe Parasite");
//    KisPipeBrushParasite parasite;
//    if (annotation) {
//        QBuffer buf(const_cast<QByteArray*>(&annotation->annotation()));
//        buf.open(QBuffer::ReadOnly);
//        parasite.loadFromDevice(&buf);
//        buf.close();
//    }
 
    KisBrushExportOptions exportOptions;
 
    if (document->savingImage()->dynamicPropertyNames().contains("brushspacing")) {
        exportOptions.spacing = document->savingImage()->property("brushspacing").toFloat();
    } else {
        exportOptions.spacing = configuration->getDouble(KEY_SPACING);
    }
 
    if (!configuration->getString(KEY_NAME).isEmpty()) {
        exportOptions.name = configuration->getString(KEY_NAME);
    } else {
        exportOptions.name = document->savingImage()->objectName();
    }
 
    exportOptions.mask = configuration->getBool(KEY_MASK);
    exportOptions.preserveAlpha = configuration->getBool(KEY_PRESERVE_ALPHA);
    exportOptions.brushStyle = configuration->getInt(KEY_BRUSH_STYLE);
    exportOptions.dimensions = configuration->getInt(KEY_DIMENSIONS);
 
    for (int i = 0; i < KisPipeBrushParasite::MaxDim; ++i) {
        exportOptions.selectionModes[i] = configuration->getInt(KEY_SELECTION_MODE + QString::number(i));
        exportOptions.ranks[i] = configuration->getInt(KEY_RANK + QString::number(i));
    }
 
    KisGbrBrush *brush = 0;
    if (mimeType() == "image/x-gimp-brush") {
        brush = new KisGbrBrush(filename());
    } else if (mimeType() == "image/x-gimp-brush-animated") {
        brush = new KisImagePipeBrush(filename());
    } else {
        return ImportExportCodes::FileFormatIncorrect;
    }
 
    qApp->processEvents(); // For vector layers to be updated
 
    QRect rc = document->savingImage()->bounds();
 
    brush->setSpacing(exportOptions.spacing);
 
    KisImagePipeBrush *pipeBrush = dynamic_cast<KisImagePipeBrush*>(brush);
    if (pipeBrush) {
        // Create parasite.
        QVector< QVector<KisPaintDevice*> > devices;
        devices.append(QVector<KisPaintDevice*>());
 
        KoProperties properties;
        properties.setProperty("visible", true);
        QList<KisNodeSP> layers = document->savingImage()->root()->childNodes(QStringList("KisLayer"), properties);
        Q_FOREACH (KisNodeSP node, layers) {
            // push_front to behave exactly as gimp for gih creation
            devices[0].prepend(node->projection().data());
        }
 
        QVector<KisParasite::SelectionMode> modes;
        for (int i = 0; i < KisPipeBrushParasite::MaxDim; ++i) {
            modes.append((KisParasite::SelectionMode)exportOptions.selectionModes[i]);
        }
 
        KisPipeBrushParasite parasite;
        parasite.dim = exportOptions.dimensions;
        parasite.ncells = devices.at(0).count();
 
        int maxRanks = 0;
        for (int i = 0; i < KisPipeBrushParasite::MaxDim; ++i) {
            // ### This can mask some bugs, be careful here in the future
            parasite.rank[i] = exportOptions.ranks[i];
            parasite.selection[i] = modes.at(i);
            maxRanks += exportOptions.ranks[i];
        }
 
        if (maxRanks > layers.count()) {
            return ImportExportCodes::FileFormatIncorrect;
        }
        // XXX needs movement!
        parasite.setBrushesCount();
        pipeBrush->setParasite(parasite);
        pipeBrush->setDevices(devices, rc.width(), rc.height());
    } else {
        if (exportOptions.mask) {
            QImage image = document->savingImage()->projection()->convertToQImage(0, 0, 0, rc.width(), rc.height(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
            brush->setImage(image);
            brush->setBrushTipImage(image);
        } else {
            brush->initFromPaintDev(document->savingImage()->projection(),0,0,rc.width(), rc.height());
        }
    }
 
    brush->setName(exportOptions.name);
    // brushes are created after devices are loaded, call mask mode after that
    enumBrushApplication maskMode;
    if (exportOptions.mask) {
        brush->makeMaskImage(exportOptions.preserveAlpha);
        maskMode = exportOptions.preserveAlpha ? LIGHTNESSMAP : ALPHAMASK;
    } else {
        maskMode = IMAGESTAMP;
    }
    brush->setBrushApplication(maskMode);
    brush->setWidth(rc.width());
    brush->setHeight(rc.height());
 
    if (brush->saveToDevice(io)) {
        return ImportExportCodes::OK;
    } else {
        return ImportExportCodes::Failure;
    }
}

References ALPHAMASK, KisBrushExportOptions::brushStyle, KisSharedPtr< T >::data(), KisPipeBrushParasite::dim, KisBrushExportOptions::dimensions, ImportExportCodes::Failure, ImportExportCodes::FileFormatIncorrect, KisImportExportFilter::filename, IMAGESTAMP, KisGbrBrush::initFromPaintDev(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KEY_BRUSH_STYLE, KEY_DIMENSIONS, KEY_MASK, KEY_NAME, KEY_PRESERVE_ALPHA, KEY_RANK, KEY_SELECTION_MODE, KEY_SPACING, LIGHTNESSMAP, KisGbrBrush::makeMaskImage(), KisBrushExportOptions::mask, KisPipeBrushParasite::MaxDim, KisImportExportFilter::mimeType(), KisBrushExportOptions::name, KisPipeBrushParasite::ncells, ImportExportCodes::OK, KisBrushExportOptions::preserveAlpha, KisBaseNode::projection(), KisPipeBrushParasite::rank, KisBrushExportOptions::ranks, KisGbrBrush::saveToDevice(), KisPipeBrushParasite::selection, KisBrushExportOptions::selectionModes, KisBrush::setBrushApplication(), KisPipeBrushParasite::setBrushesCount(), KisGbrBrush::setBrushTipImage(), KisImagePipeBrush::setDevices(), KisBrush::setHeight(), KoResource::setImage(), KoResource::setName(), KisImagePipeBrush::setParasite(), KoProperties::setProperty(), KisBrush::setSpacing(), KisBrush::setWidth(), and KisBrushExportOptions::spacing.

createConfigurationWidget()

KisConfigWidget * KisBrushExport::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 192 of file kis_brush_export.cpp.

{
    KisWdgOptionsBrush *wdg = new KisWdgOptionsBrush(parent);
    if (to == "image/x-gimp-brush") {
        wdg->styleGroupBox->setVisible(false);
        wdg->animStyleGroup->setVisible(false);
    } else if (to == "image/x-gimp-brush-animated") {
        wdg->styleGroupBox->setVisible(true);
        wdg->animStyleGroup->setVisible(true);
    }
 
    wdg->setConfiguration(defaultConfiguration());
 
    // preload gih name with chosen filename
    QFileInfo fileLocation(filename());
    wdg->nameLineEdit->setText(fileLocation.completeBaseName());
    return wdg;
}

References defaultConfiguration(), KisImportExportFilter::filename, and KisWdgOptionsBrush::setConfiguration().

defaultConfiguration()

KisPropertiesConfigurationSP KisBrushExport::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 175 of file kis_brush_export.cpp.

{
    KisPropertiesConfigurationSP cfg = new KisPropertiesConfiguration();
    cfg->setProperty(KEY_SPACING, 1.0);
    cfg->setProperty(KEY_NAME, "");
    cfg->setProperty(KEY_MASK, true);
    cfg->setProperty(KEY_PRESERVE_ALPHA, false);
    cfg->setProperty(KEY_BRUSH_STYLE, 0);
    cfg->setProperty(KEY_DIMENSIONS, 1);
 
    for (int i = 0; i < KisPipeBrushParasite::MaxDim; ++i) {
        cfg->setProperty(KEY_SELECTION_MODE + QString::number(i), KisParasite::Incremental);
        cfg->getInt(KEY_RANK + QString::number(i), 0);
    }
    return cfg;
}

References KisParasite::Incremental, KEY_BRUSH_STYLE, KEY_DIMENSIONS, KEY_MASK, KEY_NAME, KEY_PRESERVE_ALPHA, KEY_RANK, KEY_SELECTION_MODE, KEY_SPACING, and KisPipeBrushParasite::MaxDim.

initializeCapabilities()

void KisBrushExport::initializeCapabilities ( )

overridevirtual

Reimplemented from KisImportExportFilter.

Definition at line 211 of file kis_brush_export.cpp.

{
    QList<QPair<KoID, KoID> > supportedColorModels;
    supportedColorModels << QPair<KoID, KoID>()
            << QPair<KoID, KoID>(RGBAColorModelID, Integer8BitsColorDepthID)
            << QPair<KoID, KoID>(GrayAColorModelID, Integer8BitsColorDepthID);
    addSupportedColorModels(supportedColorModels, "Gimp Brushes");
    if (mimeType() == "image/x-gimp-brush-animated") {
        addCapability(KisExportCheckRegistry::instance()->get("MultiLayerCheck")->create(KisExportCheckBase::SUPPORTED));
        addCapability(KisExportCheckRegistry::instance()->get("LayerOpacityCheck")->create(KisExportCheckBase::SUPPORTED));
    }
}

References KisImportExportFilter::addCapability(), KisImportExportFilter::addSupportedColorModels(), get(), GrayAColorModelID, KisExportCheckRegistry::instance(), Integer8BitsColorDepthID, KisImportExportFilter::mimeType(), RGBAColorModelID, and KisExportCheckBase::SUPPORTED.

---

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

• plugins/impex/brush/kis_brush_export.h
• plugins/impex/brush/kis_brush_export.cpp