#include <kis_paintop_preset.h>

Inheritance diagram for KisPaintOpPreset:

Classes
class	UpdatedPostponer
	The UpdatedPostponer class. More...

struct	UpdateListener

Public Member Functions
KoCanvasResourcesInterfaceSP	canvasResourcesInterface () const

void	clearSideLoadedResources () override

KoResourceSP	clone () const override

KisPaintOpPresetSP	cloneWithResourcesSnapshot (KisResourcesInterfaceSP globalResourcesInterface, KoCanvasResourcesInterfaceSP canvasResourcesInterface, KoResourceCacheInterfaceSP cacheInterface) const

KisPaintOpPresetSP	createMaskingPreset () const

QString	defaultFileExtension () const override

QList< KoResourceLoadResult >	embeddedResources (KisResourcesInterfaceSP globalResourcesInterface) const override

void	fromXML (const QDomElement &elt, KisResourcesInterfaceSP resourcesInterface)

bool	hasLocalResourcesSnapshot () const

bool	hasMaskingPreset () const

	KisPaintOpPreset ()

	KisPaintOpPreset (const KisPaintOpPreset &rhs)

	KisPaintOpPreset (const QString &filename)

QList< KoResourceLoadResult >	linkedResources (KisResourcesInterfaceSP globalResourcesInterface) const override

bool	loadFromDevice (QIODevice *dev, KisResourcesInterfaceSP resourcesInterface) override

QString	name () const override

KisPaintOpPreset &	operator= (const KisPaintOpPreset &rhs)=delete

KoID	paintOp () const
	return the id of the paintop plugin

	Private (KisPaintOpPreset *q)

void	regenerateResourceCache (KoResourceCacheInterfaceSP cacheInterface)

bool	removable () const

QList< int >	requiredCanvasResources () const override

KoResourceCacheInterfaceSP	resourceCacheInterface () const

KisResourcesInterfaceSP	resourcesInterface () const

QPair< QString, QString >	resourceType () const override

bool	sanityCheckResourceCacheIsValid (KoResourceCacheInterfaceSP cacheInterface) const

bool	saveToDevice (QIODevice *dev) const override

void	setCanvasResourcesInterface (KoCanvasResourcesInterfaceSP canvasResourcesInterface)

void	setPaintOp (const KoID &paintOp)
	set the id of the paintop plugin

void	setResourceCacheInterface (KoResourceCacheInterfaceSP cacheInterface)

void	setResourcesInterface (KisResourcesInterfaceSP resourcesInterface)

void	setSettings (KisPaintOpSettingsSP settings)
	replace the current settings object with the specified settings

KisPaintOpSettingsSP	settings () const
	return the settings that define this paintop preset

QList< KoResourceLoadResult >	sideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface) const override

void	toXML (QDomDocument &doc, QDomElement &elt) const

QList< KisUniformPaintOpPropertySP >	uniformProperties ()

void	updateLinkedResourcesMetaData ()

QPointer< KisPaintOpPresetUpdateProxy >	updateProxy () const

QPointer< KisPaintOpPresetUpdateProxy >	updateProxyNoCreate () const

	~KisPaintOpPreset () override

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KoResource
bool	active () const

void	addMetaData (QString key, QVariant value)
	store the given key, value pair in the resource

QString	filename () const

QImage	image () const

bool	isDirty () const

virtual bool	isEphemeral () const

virtual bool	isSerializable () const

	KoResource ()

	KoResource (const KoResource &rhs)

	KoResource (const QString &filename)

bool	load (KisResourcesInterfaceSP resourcesInterface)

QString	md5Sum (bool generateIfEmpty=true) const

QMap< QString, QVariant >	metadata () const
	get a map with all the metadata

KoResource &	operator= (const KoResource &rhs)=delete

bool	permanent () const

QList< KoResourceLoadResult >	requiredResources (KisResourcesInterfaceSP globalResourcesInterface) const

int	resourceId () const

bool	save ()

void	setActive (bool active)

void	setDirty (bool value)
	Mark the preset as modified but not saved.

void	setFilename (const QString &filename)

void	setImage (const QImage &image)

void	setMD5Sum (const QString &md5sum)
	Set the md5sum of this resource. It must be in hex-encoded string format.

void	setName (const QString &name)

void	setPermanent (bool permanent)

void	setResourceId (int id)

void	setStorageLocation (const QString &location)

void	setValid (bool valid)

void	setVersion (int version)

KoResourceSignature	signature () const

QString	storageLocation () const

QList< KoResourceLoadResult >	takeSideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface)

virtual QImage	thumbnail () const
	thumbnail the thumbnail image to use in resource selectors

virtual QString	thumbnailPath () const
	thumbnailPath returns the path to a separate thumbnail image, outside the actual resource file itself. If the path is relative, it is supposed start in the same location as the resource itself. If it's absolute, that is, it starts with "/", it is from the root of the storage.

virtual void	updateThumbnail ()
	updateThumbnail updates the thumbnail for this resource. Reimplement if your thumbnail is something else than the image set with setImage.

bool	valid () const

int	version () const
	Get the version of the resource.

virtual	~KoResource ()

Public Attributes
KisPaintOpSettingsSP	settings {0}

KisPaintOpSettings::UpdateListenerSP	settingsUpdateListener

QList< KoResourceLoadResult >	sideLoadedResources

QScopedPointer< KisPaintOpPresetUpdateProxy >	updateProxy

QString	version

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Public Attributes inherited from KoResource
bool	active {true}

QString	filename

QImage	image

QString	md5sum

QMap< QString, QVariant >	metadata

bool	modified {false}

QString	name

bool	permanent {false}

int	resourceId {-1}

QString	storageLocation

bool	valid {false}

int	version {-1}

Private Attributes
Private *const	d

Detailed Description

A KisPaintOpPreset contains a particular set of settings associated with a paintop, like brush, paintopsettings. A new property in this class is to make it dirty. That means the user can now temporarily save any tweaks in the Preset throughout the session. The Dirty Preset setting/unsetting is handled by KisPaintOpPresetSettings

KisPaintOpPreset is a serialized representation. That is, it stores only "metadata" needed to paint with a paintop. This metadata can be used to create painting c++-objects (e.g. brushes) or caches or embedded resources, but these objects are never stored inside the preset itself.

It is done intentionally, because our GUI elements work with "metadata" only. They just read/write strings into the XML document, they don't know anything about the internal structure of the preset's C++ object. Therefore, if we stored any caches/ resources inside the preset, they would become out-of-sync with the XML representation quite easily.

To overcome this issue, we use a set of provider-like interfaces to store caches/resources outside the preset:

1) KisResourcesInterface is the interface that lets the preset to fetch dependent resources from the centralized storage. Theoretically, the preset could create dependent resources from its XML representation internally all the time, but there are two reasons against that:

1) That is inefficient to load the brushes and/or textures for every stroke. It can create significant delay in the beginning of every stroke.

2) When we show an embedded resource in the GUI, it would be nice to know the resource's 'resourceId', so we could display it correctly. If we load the embedded resource every time, 'resourceId' field would be empty.

Abstract KisResourcesInterface also allows us to replace a link to the centralized storage with a snapshot of cloned resources, when we start rendering data in the non-gui thread.

2) KoCanvasResourcesInterface is the interface that lets the preset link to the global storage of "canvas resources", like current gradient, current fg color and current bg color.

When we start a stroke, we make a snapshot of the current state of the required canvas resources and replace the link to the global storage with the created local snapshot.

Please take it into account that some of the embedded/linked resources provided by KisResourcesInterface may change while cloning. It happens when these resources "bake" the state of canvas resources into themselves (e.g. gradient may change the "fg-stop" with real fg color).

3) KoResourceCacheInterface is an interface that provides a storage for the internal preset's caches (e.g. a brush with a pregenerated pyramid or a pregenerated template for a rotated pattern).

The cache interface link is reset when any change is made to the preset's metadata (which, effectively, resets all the caches).

The cache link should also be reset manually if the preset depends on some canvas resource (e.g. fg-color) and this canvas resource has changed. That is tracked by KisPresetShadowUpdater.

Definition at line 39 of file kis_paintop_preset.cpp.

Constructor & Destructor Documentation

◆ KisPaintOpPreset() [1/3]

KisPaintOpPreset::KisPaintOpPreset ( )

Definition at line 81 of file kis_paintop_preset.cpp.

    : KoResource(QString())
    , d(new Private(this))
{
}

◆ KisPaintOpPreset() [2/3]

KisPaintOpPreset::KisPaintOpPreset ( const QString & filename )

Definition at line 87 of file kis_paintop_preset.cpp.

    : KoResource(fileName)
    , d(new Private(this))
{
    setName(name().replace("_", " "));
}

References name(), and KoResource::setName().

◆ ~KisPaintOpPreset()

KisPaintOpPreset::~KisPaintOpPreset ( )

override

Definition at line 94 of file kis_paintop_preset.cpp.

{
    delete d;
}

References d.

◆ KisPaintOpPreset() [3/3]

KisPaintOpPreset::KisPaintOpPreset ( const KisPaintOpPreset & rhs )

Definition at line 99 of file kis_paintop_preset.cpp.

    : KoResource(rhs)
    , d(new Private(this))
{
    if (rhs.settings()) {
        setSettings(rhs.settings()); // the settings are cloned inside!
    }
    KIS_SAFE_ASSERT_RECOVER_NOOP(isDirty() == rhs.isDirty());
    // only valid if we could clone the settings
    setValid(rhs.settings());
 
    setName(rhs.name());
    setImage(rhs.image());
}

References KoResource::image, KoResource::isDirty(), KIS_SAFE_ASSERT_RECOVER_NOOP, name(), KoResource::setImage(), KoResource::setName(), setSettings(), settings, and KoResource::setValid().

Member Function Documentation

◆ canvasResourcesInterface()

KoCanvasResourcesInterfaceSP KisPaintOpPreset::canvasResourcesInterface ( ) const

Returns canvas resources interface associated with the current preset.

In contrast to resourcesInterface() the canvas resources interface may be null, because the preset is created without any canvas resources. The resources are assigned to the preset only when the ser starts to paint with it.

The preset has no default canvas resources interface, because canvas resources are unique per-canvas, but the presets are unique per- application. Therefore association between the preset and canvas resources interface would be ambiguous.

Definition at line 494 of file kis_paintop_preset.cpp.

{
    return d->settings ? d->settings->canvasResourcesInterface() : nullptr;
}

References d.

◆ clearSideLoadedResources()

void KisPaintOpPreset::clearSideLoadedResources ( )

overridevirtual

Clears memory under side-loaded resources. The method is called by KisResourceLocator after the resources have been fetched and added to the global store.

Reimplemented from KoResource.

Definition at line 604 of file kis_paintop_preset.cpp.

{
    d->sideLoadedResources.clear();
}

References d.

◆ clone()

KoResourceSP KisPaintOpPreset::clone ( ) const

overridevirtual

Implements KoResource.

Definition at line 114 of file kis_paintop_preset.cpp.

{
    return KoResourceSP(new KisPaintOpPreset(*this));
}

References KisPaintOpPreset().

◆ cloneWithResourcesSnapshot()

KisPaintOpPresetSP KisPaintOpPreset::cloneWithResourcesSnapshot	(	KisResourcesInterfaceSP	globalResourcesInterface,
		KoCanvasResourcesInterfaceSP	canvasResourcesInterface,
		KoResourceCacheInterfaceSP	cacheInterface ) const

See also: KisRequiredResourcesOperators::cloneWithResourcesSnapshot

If the preset depends on any canvas resources, then we don't trust the caches that are stored inside. Instead we just reset them. If the preset is independent of the canvas resources, then its caches are, most probably valid and we can reuse them.

Definition at line 510 of file kis_paintop_preset.cpp.

{
    KisPaintOpPresetSP result =
            KisRequiredResourcesOperators::cloneWithResourcesSnapshot<KisPaintOpPresetSP>(this, globalResourcesInterface);
 
    const QList<int> canvasResources = result->requiredCanvasResources();
    if (!canvasResources.isEmpty()) {
        KoLocalStrokeCanvasResourcesSP storage(new KoLocalStrokeCanvasResources());
        Q_FOREACH (int key, canvasResources) {
            storage->storeResource(key, canvasResourcesInterface->resource(key));
        }
        result->setCanvasResourcesInterface(storage);
    }
 
    if (cacheInterface) {
        result->setResourceCacheInterface(cacheInterface);
    } else if (!canvasResources.isEmpty()) {
        result->setResourceCacheInterface(nullptr);
    }
 
    return result;
}

References canvasResourcesInterface().

◆ createMaskingPreset()

KisPaintOpPresetSP KisPaintOpPreset::createMaskingPreset ( ) const

Returns: a newly created preset of the masked brush that should be run alongside the current brush

Definition at line 468 of file kis_paintop_preset.cpp.

{
    KisPaintOpPresetSP result;
 
    if (d->settings && d->settings->hasMaskingSettings()) {
        result.reset(new KisPaintOpPreset());
        result->setSettings(d->settings->createMaskingSettings());
        if (!result->valid()) {
            result.clear();
        }
    }
 
    return result;
}

References d, and KisPaintOpPreset().

◆ defaultFileExtension()

QString KisPaintOpPreset::defaultFileExtension ( ) const

inlineoverridevirtual

Returns: the default file extension which should be used when saving the resource

Reimplemented from KoResource.

Definition at line 159 of file kis_paintop_preset.h.

                                                  {
        return ".kpp";
    }

◆ embeddedResources()

QList< KoResourceLoadResult > KisPaintOpPreset::embeddedResources ( KisResourcesInterfaceSP globalResourcesInterface ) const

overridevirtual

Returns: all the resources that were embedded into (*this) resource. If the resources were already added to the global database, then they are fetched from globalResourcesInterface to save time/memory.

These resources are embedded into the resource itself and are available throughout the entire lifetime of the resource.

Reimplemented from KoResource.

Definition at line 562 of file kis_paintop_preset.cpp.

{
    QList<KoResourceLoadResult> resources;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(d->settings, resources);
 
    KisPaintOpFactory* f = KisPaintOpRegistry::instance()->value(paintOp().id());
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(f, resources);
    resources << f->prepareEmbeddedResources(d->settings, globalResourcesInterface);
 
    if (hasMaskingPreset()) {
        KisPaintOpPresetSP maskingPreset = createMaskingPreset();
        Q_ASSERT(maskingPreset);
        KisPaintOpFactory* f = KisPaintOpRegistry::instance()->value(maskingPreset->paintOp().id());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(f, resources);
        resources << f->prepareEmbeddedResources(maskingPreset->settings(), globalResourcesInterface);
 
    }
 
    return resources;
}

References createMaskingPreset(), d, hasMaskingPreset(), KisPaintOpRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, paintOp(), and KoGenericRegistry< T >::value().

◆ fromXML()

void KisPaintOpPreset::fromXML	(	const QDomElement &	elt,
		KisResourcesInterfaceSP	resourcesInterface )

Definition at line 323 of file kis_paintop_preset.cpp.

{
    setName(presetElt.attribute("name"));
    QString paintopid = presetElt.attribute("paintopid");
 
    if (!metadata().contains("paintopid")) {
        addMetaData("paintopid", paintopid);
    }
 
    if (paintopid.isEmpty()) {
        dbgImage << "No paintopid attribute";
        setValid(false);
        return;
    }
 
    if (KisPaintOpRegistry::instance()->get(paintopid) == 0) {
        dbgImage << "No paintop " << paintopid;
        setValid(false);
        return;
    }
 
    KoID id(paintopid, QString());
 
    KisPaintOpSettingsSP settings = KisPaintOpRegistry::instance()->createSettings(id, resourcesInterface);
    if (!settings) {
        setValid(false);
        warnKrita << "Could not load settings for preset" << paintopid;
        return;
    }
 
    settings->fromXML(presetElt);
 
    // sanitize the settings
    bool hasTexture = settings->getBool("Texture/Pattern/Enabled");
    if (!hasTexture) {
        Q_FOREACH (const QString & key, settings->getProperties().keys()) {
            if (key.startsWith("Texture") && key != "Texture/Pattern/Enabled") {
                settings->removeProperty(key);
            }
        }
    }
    setSettings(settings);
 
}

References KoResource::addMetaData(), KisPaintOpRegistry::createSettings(), dbgImage, get(), KisPaintOpRegistry::instance(), KoResource::metadata, resourcesInterface(), KoResource::setName(), setSettings(), settings, KoResource::setValid(), and warnKrita.

◆ hasLocalResourcesSnapshot()

bool KisPaintOpPreset::hasLocalResourcesSnapshot ( ) const

See also: KisRequiredResourcesOperators::hasLocalResourcesSnapshot

Definition at line 505 of file kis_paintop_preset.cpp.

{
    return KisRequiredResourcesOperators::hasLocalResourcesSnapshot(this);
}

References KisRequiredResourcesOperators::hasLocalResourcesSnapshot().

◆ hasMaskingPreset()

bool KisPaintOpPreset::hasMaskingPreset ( ) const

Returns: true if this preset demands a secondary masked brush running alongside it

Definition at line 463 of file kis_paintop_preset.cpp.

{
    return d->settings && d->settings->hasMaskingSettings();
}

References d.

◆ linkedResources()

QList< KoResourceLoadResult > KisPaintOpPreset::linkedResources ( KisResourcesInterfaceSP globalResourcesInterface ) const

overridevirtual

Returns: all the resources that are needed but (*this) resource and are not embedded into it. The resources are fetched from globalResourcesInterface. If fetching of some resources is failed, then (*this) resource is invalid.

Reimplemented from KoResource.

Definition at line 539 of file kis_paintop_preset.cpp.

{
    QList<KoResourceLoadResult> resources;
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(d->settings, resources);
 
    KisPaintOpFactory* f = KisPaintOpRegistry::instance()->value(paintOp().id());
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(f, resources);
    resources << f->prepareLinkedResources(d->settings, globalResourcesInterface);
 
    if (hasMaskingPreset()) {
        KisPaintOpPresetSP maskingPreset = createMaskingPreset();
        Q_ASSERT(maskingPreset);
 
        KisPaintOpFactory* f = KisPaintOpRegistry::instance()->value(maskingPreset->paintOp().id());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(f, resources);
        resources << f->prepareLinkedResources(maskingPreset->settings(), globalResourcesInterface);
 
    }
 
    return resources;
}

References createMaskingPreset(), d, hasMaskingPreset(), KisPaintOpRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, paintOp(), and KoGenericRegistry< T >::value().

◆ loadFromDevice()

bool KisPaintOpPreset::loadFromDevice	(	QIODevice *	dev,
		KisResourcesInterfaceSP	resourcesInterface )

overridevirtual

Implements KoResource.

Definition at line 168 of file kis_paintop_preset.cpp.

{
    QImageReader reader(dev, "PNG");
 
    d->version = reader.text("version");
    QString preset = reader.text("preset");
 
    if (!(d->version == "2.2" || d->version == "5.0")) {
        return false;
    }
 
    QImage img;
    if (!reader.read(&img)) {
        dbgImage << "Fail to decode PNG";
        return false;
    }
 
    //Workaround for broken presets
    //Presets was saved with nested cdata section
    preset.replace("<curve><![CDATA[", "<curve>");
    preset.replace("]]></curve>", "</curve>");
    //Presets with non-base64 pattern md5
    QRegularExpressionMatch patternMd5 = QRegularExpression("<param (?:type=\"string\" )?name=\"Texture/Pattern/PatternMD5\"(?: type=\"string\")?><!\\[CDATA\\[(.+?)\\]\\]></param>").match(preset);
    if (patternMd5.hasMatch() && patternMd5.captured(1).contains(QRegularExpression("[^a-zA-Z0-9+/=]"))) {
        preset.replace(patternMd5.captured(0), "");
    }
 
    QDomDocument doc;
    if (!doc.setContent(preset)) {
        return false;
    }
 
    QDomElement root = doc.documentElement();
 
    if (d->version == "5.0") {
        // Load any embedded resources
        QDomElement e = root.firstChildElement("resources");
        if (!e.isNull()) {
            for (e = e.firstChildElement("resource"); !e.isNull(); e = e.nextSiblingElement("resource")) {
                QString name = e.attribute("name");
                QString filename = e.attribute("filename");
                QString resourceType = e.attribute("type");
                QString md5sum = e.attribute("md5sum");
 
                KoResourceSP existingResource = resourcesInterface
                        ->source(resourceType)
                        .bestMatch(md5sum, filename, name);
 
                if (existingResource) {
                    continue;
                }
 
                QByteArray ba = QByteArray::fromBase64(e.text().toLatin1());
                QBuffer buf(&ba);
                buf.open(QBuffer::ReadOnly);
 
                d->sideLoadedResources.append(
                            KoEmbeddedResource(
                                KoResourceSignature(resourceType, md5sum, filename, name),
                                ba));
            }
        }
    }
 
    fromXML(root, resourcesInterface);
 
    if (!d->settings) {
        return false;
    }
 
    setValid(d->settings->isValid());
 
    if (!img.textKeys().isEmpty()) {
        QImage strippedImage(img.size(), img.format());
        memcpy(strippedImage.bits(), img.bits(), img.sizeInBytes());
 
        if (img.format() == QImage::Format_Indexed8) {
            strippedImage.setColorTable(img.colorTable());
        }
 
        setImage(strippedImage);
    } else {
        setImage(img);
    }
 
    updateLinkedResourcesMetaData();
 
    return true;
}

References d, dbgImage, KoResource::filename, fromXML(), KoResource::md5sum, name(), resourcesInterface(), resourceType(), KoResource::setImage(), KoResource::setValid(), and updateLinkedResourcesMetaData().

◆ name()

QString KisPaintOpPreset::name ( ) const

overridevirtual

Returns: the user-visible name of the resource

Reimplemented from KoResource.

Definition at line 131 of file kis_paintop_preset.cpp.

{
    return KoResource::name().replace("_", " ");
}

References KoResource::name.

◆ operator=()

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

delete

◆ paintOp()

KoID KisPaintOpPreset::paintOp ( ) const

return the id of the paintop plugin

Definition at line 125 of file kis_paintop_preset.cpp.

{
    Q_ASSERT(d->settings);
    return KoID(d->settings->getString("paintop"));
}

References d.

◆ Private()

KisPaintOpPreset::Private ( KisPaintOpPreset * q )

inline

Definition at line 67 of file kis_paintop_preset.cpp.

        : settingsUpdateListener(new UpdateListener(q)),
          version("5.0")
    {
    }

◆ regenerateResourceCache()

void KisPaintOpPreset::regenerateResourceCache ( KoResourceCacheInterfaceSP cacheInterface )

Recalculates all the internal caches and stores them in the cache interface.

Definition at line 625 of file kis_paintop_preset.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->settings);
 
    d->settings->regenerateResourceCache(cacheInterface);
    cacheInterface->setRelatedResourceCookie(d->settings->sanityVersionCookie());
}

References d, and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ removable()

bool KisPaintOpPreset::removable ( ) const

inline

Definition at line 155 of file kis_paintop_preset.h.

                           {
        return true;
    }

◆ requiredCanvasResources()

QList< int > KisPaintOpPreset::requiredCanvasResources ( ) const

overridevirtual

A list of per-canvas active resources that are needed for this resource to function properly. E.g. some gradients may require Fg/Bg colors and some presets would like to know about the current gradient selection.

Returns: a list of canvas resources needed for the current resource

Reimplemented from KoResource.

Definition at line 609 of file kis_paintop_preset.cpp.

{
    return d->settings ? d->settings->requiredCanvasResources() : QList<int>();
}

References d.

◆ resourceCacheInterface()

KoResourceCacheInterfaceSP KisPaintOpPreset::resourceCacheInterface ( ) const

Return the saved cache interface or null if not available

Definition at line 620 of file kis_paintop_preset.cpp.

{
    return d->settings ? d->settings->resourceCacheInterface() : KoResourceCacheInterfaceSP();
}

References d.

◆ resourcesInterface()

KisResourcesInterfaceSP KisPaintOpPreset::resourcesInterface ( ) const

Returns: resource interface that is used by KisPaintOpSettings object for loading linked resources

Definition at line 483 of file kis_paintop_preset.cpp.

{
    return d->settings ? d->settings->resourcesInterface() : nullptr;
}

References d.

◆ resourceType()

QPair< QString, QString > KisPaintOpPreset::resourceType ( ) const

inlineoverridevirtual

Returns: the resource type

Implements KoResource.

Definition at line 144 of file kis_paintop_preset.h.

    {
        return QPair<QString, QString>(ResourceType::PaintOpPresets, "");
    }

References ResourceType::PaintOpPresets.

◆ sanityCheckResourceCacheIsValid()

bool KisPaintOpPreset::sanityCheckResourceCacheIsValid ( KoResourceCacheInterfaceSP cacheInterface ) const

Verifies if the cache object was actually created for this preset. It actually does anything only when a corresponding define is added in kis_paintop_settings.cpp. Otherwise it just returns true;

Definition at line 633 of file kis_paintop_preset.cpp.

{
    return d->settings->sanityVersionCookie() == cacheInterface->relatedResourceCookie();
}

References d.

◆ saveToDevice()

bool KisPaintOpPreset::saveToDevice ( QIODevice * dev ) const

overridevirtual

HACK ALERT: We update the version of the resource format on the first save operation, even though there is no guarantee that it was "save" operation, but not "export" operation.

The only point it affects now is whether we need to check for the presence of the linkedResources() in updateLinkedResourcesMetaData(). The new version of the preset format ("5.0") has all the linked resources embedded outside KisPaintOpSettings, which are automatically loaded on the resource activation. We we shouldn't add them into metaData()["dependent_resources_filenames"].

Reimplemented from KoResource.

Definition at line 368 of file kis_paintop_preset.cpp.

{
    QImageWriter writer(dev, "PNG");
 
    QDomDocument doc;
    QDomElement root = doc.createElement("Preset");
 
    toXML(doc, root);
 
    doc.appendChild(root);
 
    d->version = "5.0";
 
    const_cast<KisPaintOpPreset*>(this)->updateLinkedResourcesMetaData();
 
    writer.setText("version", d->version);
    writer.setText("preset", doc.toString());
 
    QImage img;
 
    if (image().isNull()) {
        img = QImage(1, 1, QImage::Format_RGB32);
    } else {
        img = image();
    }
 
    return writer.write(img);
}

References d, KoResource::image, toXML(), and updateLinkedResourcesMetaData().

◆ setCanvasResourcesInterface()

void KisPaintOpPreset::setCanvasResourcesInterface ( KoCanvasResourcesInterfaceSP canvasResourcesInterface )

Sets canvas resources interface used for initializing the preset

See also: canvasResourcesInterface()

Definition at line 499 of file kis_paintop_preset.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->settings);
    d->settings->setCanvasResourcesInterface(canvasResourcesInterface);
}

References canvasResourcesInterface(), d, and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ setPaintOp()

void KisPaintOpPreset::setPaintOp ( const KoID & paintOp )

set the id of the paintop plugin

Definition at line 119 of file kis_paintop_preset.cpp.

{
    Q_ASSERT(d->settings);
    d->settings->setProperty("paintop", paintOp.id());
}

References d, KoID::id(), and paintOp().

◆ setResourceCacheInterface()

void KisPaintOpPreset::setResourceCacheInterface ( KoResourceCacheInterfaceSP cacheInterface )

Set resource cache object generated for this preset (or its clone). After calling this method with non-null cache interface all the internal caches of this preset will be initialized. The cache interface itself will be stored inside the preset and will be preserved while cloning the preset.

Changing any property of the preset will reset both, internal caches and cache interface to null.

Calling this method with nullptr resets internal caches. It is needed, e.g. when some canvas resources have changed (

See also: requiredCanvasResources()).

Definition at line 614 of file kis_paintop_preset.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->settings);
    d->settings->setResourceCacheInterface(cacheInterface);
}

References d, and KIS_SAFE_ASSERT_RECOVER_RETURN.

◆ setResourcesInterface()

void KisPaintOpPreset::setResourcesInterface ( KisResourcesInterfaceSP resourcesInterface )

Set resource interface that will be used by KisPaintOpSettings object for loading linked resources

Definition at line 488 of file kis_paintop_preset.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(d->settings);
    d->settings->setResourcesInterface(resourcesInterface);
}

References d, KIS_SAFE_ASSERT_RECOVER_RETURN, and resourcesInterface().

◆ setSettings()

void KisPaintOpPreset::setSettings ( KisPaintOpSettingsSP settings )

replace the current settings object with the specified settings

Definition at line 136 of file kis_paintop_preset.cpp.

{
    Q_ASSERT(settings);
    Q_ASSERT(!settings->getString("paintop", QString()).isEmpty());
 
    KisDirtyStateSaver<KisPaintOpPreset*> dirtyStateSaver(this);
 
    if (d->settings) {
        d->settings->setUpdateListener(KisPaintOpSettings::UpdateListenerWSP());
        d->settings = 0;
    }
 
    if (settings) {
        d->settings = settings->clone();
        d->settings->setUpdateListener(d->settingsUpdateListener);
    }
 
    if (d->updateProxy) {
        d->updateProxy->notifyUniformPropertiesChanged();
        d->updateProxy->notifySettingsChanged();
    }
    setValid(true);
}

References d, settings, and KoResource::setValid().

◆ settings()

KisPaintOpSettingsSP KisPaintOpPreset::settings ( ) const

return the settings that define this paintop preset

◆ sideLoadedResources()

QList< KoResourceLoadResult > KisPaintOpPreset::sideLoadedResources ( KisResourcesInterfaceSP globalResourcesInterface ) const

overridevirtual

Side-loaded resources are the resources embedded into the file format and loaded alongside the main resource. After being loaded in loadFromDevice() they are stored separately and may be fetched by the resource locator.

After the locator has loaded them into the global storage, it can free the memory by calling clearSideLoadedResources().

Reimplemented from KoResource.

◆ toXML()

void KisPaintOpPreset::toXML	(	QDomDocument &	doc,
		QDomElement &	elt ) const

Definition at line 258 of file kis_paintop_preset.cpp.

{
    QString paintopid = d->settings->getString("paintop", QString());
 
    elt.setAttribute("paintopid", paintopid);
    elt.setAttribute("name", name());
 
 
    QList<KoResourceLoadResult> linkedResources = this->linkedResources(resourcesInterface());
 
    elt.setAttribute("embedded_resources", linkedResources.count());
 
    if (!linkedResources.isEmpty()) {
        QDomElement resourcesElement = doc.createElement("resources");
        elt.appendChild(resourcesElement);
        Q_FOREACH(KoResourceLoadResult linkedResource, linkedResources) {
            // we have requested linked resources, how can it be an embedded one?
            KIS_SAFE_ASSERT_RECOVER(linkedResource.type() != KoResourceLoadResult::EmbeddedResource) { continue; }
 
            KoResourceSP resource = linkedResource.resource();
 
            if (!resource) {
                qWarning() << "WARNING: KisPaintOpPreset::toXML couldn't fetch a linked resource" << linkedResource.signature();
                continue;
            }
 
            //KIS_SAFE_ASSERT_RECOVER_NOOP(resource->isSerializable() && "embedding non-serializable resources is not yet implemented");
            if (!resource->isSerializable()) {
                qWarning() << "embedding non-serializable resources is not yet implemented. Resource: " << filename() << name()
                           << "cannot embed" << resource->filename() << resource->name() << resource->resourceType().first << resource->resourceType().second;
                continue;
            }
 
            QBuffer buf;
            buf.open(QBuffer::WriteOnly);
            KisResourceModel model(resource->resourceType().first);
            bool r = model.exportResource(resource, &buf);
            buf.close();
            if (r) {
                QDomText text = doc.createCDATASection(QString::fromLatin1(buf.data().toBase64()));
                QDomElement e = doc.createElement("resource");
                e.setAttribute("type", resource->resourceType().first);
                e.setAttribute("md5sum", resource->md5Sum());
                e.setAttribute("name", resource->name());
                e.setAttribute("filename", resource->filename());
                e.appendChild(text);
                resourcesElement.appendChild(e);
 
            }
        }
    }
 
    // sanitize the settings
    bool hasTexture = d->settings->getBool("Texture/Pattern/Enabled");
    if (!hasTexture) {
        Q_FOREACH (const QString & key, d->settings->getProperties().keys()) {
            if (key.startsWith("Texture") && key != "Texture/Pattern/Enabled") {
                d->settings->removeProperty(key);
            }
        }
    }
 
    d->settings->toXML(doc, elt);
}

References d, KoResourceLoadResult::EmbeddedResource, KisResourceModel::exportResource(), KoResource::filename, KIS_SAFE_ASSERT_RECOVER, linkedResources(), name(), KoResourceLoadResult::resource(), resourcesInterface(), KoResourceLoadResult::signature(), and KoResourceLoadResult::type().

◆ uniformProperties()

QList< KisUniformPaintOpPropertySP > KisPaintOpPreset::uniformProperties ( )

we pass a shared pointer to settings explicitly, because the settings will not be able to wrap itself into a shared pointer

Definition at line 455 of file kis_paintop_preset.cpp.

{
    return d->settings->uniformProperties(d->settings, updateProxy());
}

References d, and updateProxy.

◆ updateLinkedResourcesMetaData()

void KisPaintOpPreset::updateLinkedResourcesMetaData ( )

The new preset format embeds all the linked resources outside KisPaintOpSettings and loads them on activation, therefore we shouldn't add them into "dependent_resources_filenames".

Definition at line 410 of file kis_paintop_preset.cpp.

{
    if (d->version == "2.2") {
        KisResourcesInterfaceSP fakeResourcesInterface(new KisLocalStrokeResources());
        QList<KoResourceLoadResult> dependentResources = this->linkedResources(fakeResourcesInterface);
 
        QStringList resourceFileNames;
 
        Q_FOREACH (KoResourceLoadResult resource, dependentResources) {
            const QString filename = resource.signature().filename;
 
            if (!filename.isEmpty()) {
                resourceFileNames.append(filename);
            }
        }
 
        KritaUtils::makeContainerUnique(resourceFileNames);
 
        if (!resourceFileNames.isEmpty()) {
            addMetaData("dependent_resources_filenames", resourceFileNames);
        }
    } else {
        addMetaData("dependent_resources_filenames", QStringList());
    }
}

References KoResource::addMetaData(), d, KoResource::filename, KoResourceSignature::filename, linkedResources(), KritaUtils::makeContainerUnique(), and KoResourceLoadResult::signature().

◆ updateProxy()

QPointer< KisPaintOpPresetUpdateProxy > KisPaintOpPreset::updateProxy ( ) const

◆ updateProxyNoCreate()

QPointer< KisPaintOpPresetUpdateProxy > KisPaintOpPreset::updateProxyNoCreate ( ) const

Definition at line 450 of file kis_paintop_preset.cpp.

{
    return d->updateProxy.data();
}

References d.

Member Data Documentation

◆ d

Private* const KisPaintOpPreset::d

private

Definition at line 271 of file kis_paintop_preset.h.

◆ settings

KisPaintOpSettingsSP KisPaintOpPreset::settings {0}

Definition at line 73 of file kis_paintop_preset.cpp.

73{0};

◆ settingsUpdateListener

KisPaintOpSettings::UpdateListenerSP KisPaintOpPreset::settingsUpdateListener

Definition at line 75 of file kis_paintop_preset.cpp.

◆ sideLoadedResources

QList< KoResourceLoadResult > KisPaintOpPreset::sideLoadedResources

Do not load the existing resources. There is no use for it.

Definition at line 77 of file kis_paintop_preset.cpp.

◆ updateProxy

QPointer< KisPaintOpPresetUpdateProxy > KisPaintOpPreset::updateProxy

Definition at line 74 of file kis_paintop_preset.cpp.

◆ version

QString KisPaintOpPreset::version

Definition at line 76 of file kis_paintop_preset.cpp.

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

libs/image/brushengine/kis_paintop_preset.cpp
libs/image/brushengine/kis_paintop_preset.h

Classes

Public Member Functions

Public Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisPaintOpPreset() [1/3]

◆ KisPaintOpPreset() [2/3]

◆ ~KisPaintOpPreset()

◆ KisPaintOpPreset() [3/3]

Member Function Documentation

◆ canvasResourcesInterface()

◆ clearSideLoadedResources()

◆ clone()

◆ cloneWithResourcesSnapshot()

◆ createMaskingPreset()

◆ defaultFileExtension()

◆ embeddedResources()

◆ fromXML()

◆ hasLocalResourcesSnapshot()

◆ hasMaskingPreset()

◆ linkedResources()

◆ loadFromDevice()

◆ name()

◆ operator=()

◆ paintOp()

◆ Private()

◆ regenerateResourceCache()

◆ removable()

◆ requiredCanvasResources()

◆ resourceCacheInterface()

◆ resourcesInterface()

◆ resourceType()

◆ sanityCheckResourceCacheIsValid()

◆ saveToDevice()

◆ setCanvasResourcesInterface()

◆ setPaintOp()

◆ setResourceCacheInterface()

◆ setResourcesInterface()

◆ setSettings()

◆ settings()

◆ sideLoadedResources()

◆ toXML()

◆ uniformProperties()

◆ updateLinkedResourcesMetaData()

◆ updateProxy()

◆ updateProxyNoCreate()

Member Data Documentation

◆ d

◆ settings

◆ settingsUpdateListener

◆ sideLoadedResources

◆ updateProxy

◆ version