#include <psd_additional_layer_info_block.h>

Public Member Functions
QDomDocument	getASLXML ()

QSharedPointer< KoShapeBackground >	getBackground (KisEmbeddedResourceStorageProxy &embeddedProxy)

QBrush	getBrush (KisEmbeddedResourceStorageProxy &embeddedProxy)

QDomDocument	getFillLayerConfig () const

bool	loadFromConfig (KisFilterConfigurationSP cfg)

void	loadPattern (KisEmbeddedResourceStorageProxy &embeddedProxy)

void	setAlignWithLayer (bool align)

void	setAngle (float Angl)

void	setOffset (QPointF phase)

void	setPatternRef (const QString Idnt, const QString name)

void	setScale (float Scl)

void	writeASL (KisAslXmlWriter &w)

Static Public Member Functions
static void	setupCatcher (const QString path, KisAslCallbackObjectCatcher &catcher, psd_layer_pattern_fill *data)

Public Attributes
bool	align_with_layer {false}

double	angle {0.0}

QPointF	offset

KoPatternSP	pattern

QString	patternID

QString	patternName

double	scale {100.0}

Detailed Description

Definition at line 636 of file psd_additional_layer_info_block.h.

Member Function Documentation

◆ getASLXML()

QDomDocument psd_layer_pattern_fill::getASLXML ( )

inline

Definition at line 724 of file psd_additional_layer_info_block.h.

                             {
        KisAslXmlWriter w;
        w.enterDescriptor("", "", "null");
 
        if (patternID.isEmpty()) {
            qWarning() << "This pattern cannot be saved: No pattern UUID available.";
            return QDomDocument();
        }
 
        writeASL(w);
 
        w.leaveDescriptor();
 
        return w.document();
    }

◆ getBackground()

QSharedPointer< KoShapeBackground > psd_layer_pattern_fill::getBackground ( KisEmbeddedResourceStorageProxy & embeddedProxy )

inline

Definition at line 765 of file psd_additional_layer_info_block.h.

                                                                                                    {
        QSharedPointer<KoPatternBackground> bg = QSharedPointer<KoPatternBackground>(new KoPatternBackground());
 
        loadPattern(embeddedProxy);
        if (pattern) {
            bg->setPattern(pattern->pattern());
        } else {
            KoResourceLoadResult res = KisGlobalResourcesInterface::instance()->source(ResourceType::Patterns).fallbackResource();
            bg->setPattern(res.resource<KoPattern>()->pattern());
        }
        QSizeF size = bg->patternOriginalSize();
        QPointF refPoint(offset.x()/size.width(), offset.y()/size.height());
        size = QSizeF(size.width() * (0.01*scale), size.height() * (0.01*scale));
        bg->setPatternDisplaySize(size);
        bg->setReferencePointOffset(refPoint);
        return bg;
    }

References KisGlobalResourcesInterface::instance(), KoPattern::pattern(), ResourceType::Patterns, and KoResourceLoadResult::resource().

◆ getBrush()

QBrush psd_layer_pattern_fill::getBrush ( KisEmbeddedResourceStorageProxy & embeddedProxy )

inline

Definition at line 783 of file psd_additional_layer_info_block.h.

                                                                    {
        QBrush brush;
        loadPattern(embeddedProxy);
        if (pattern) {
            brush.setTextureImage(pattern->pattern());
        } else {
            KoResourceLoadResult res = KisGlobalResourcesInterface::instance()->source(ResourceType::Patterns).fallbackResource();
            brush.setTextureImage(res.resource<KoPattern>()->pattern());
        }
        QTransform t = QTransform::fromScale(scale*0.01, scale*0.01);
        t.rotate(angle);
        brush.setTransform(t);
        return brush;
    }

References KisGlobalResourcesInterface::instance(), KoPattern::pattern(), ResourceType::Patterns, and KoResourceLoadResult::resource().

◆ getFillLayerConfig()

QDomDocument psd_layer_pattern_fill::getFillLayerConfig ( ) const

inline

Definition at line 672 of file psd_additional_layer_info_block.h.

                                            {
        KisFilterConfigurationSP cfg;
        cfg = KisGeneratorRegistry::instance()->value("pattern")->defaultConfiguration(KisGlobalResourcesInterface::instance());
 
        cfg->setProperty("pattern", patternName);
        cfg->setProperty("fileName", QString(patternID + ".pat"));
        cfg->setProperty("md5", ""); // Zero out MD5, PSD patterns are looked up by UUID in filename
 
        //angle is flipped for patterns in Krita.
        double fixedAngle = 360.0 - fmod(360.0 + angle, 360.0);
 
        cfg->setProperty("transform_scale_x", scale / 100);
        cfg->setProperty("transform_scale_y", scale / 100);
        cfg->setProperty("transform_rotation_z", fixedAngle);
 
        cfg->setProperty("transform_offset_x", offset.x());
        cfg->setProperty("transform_offset_y", offset.y());
        QDomDocument doc;
        doc.setContent(cfg->toXML());
        return doc;
    }

References KisBaseProcessor::defaultConfiguration(), KisGeneratorRegistry::instance(), KisGlobalResourcesInterface::instance(), and KoGenericRegistry< T >::value().

◆ loadFromConfig()

bool psd_layer_pattern_fill::loadFromConfig ( KisFilterConfigurationSP cfg )

inline

Definition at line 694 of file psd_additional_layer_info_block.h.

                                                      {
        if (cfg->name() != "pattern") {
            return false;
        }
 
        const QString patternMD5 = cfg->getString("md5", "");
        const QString patternNameTemp = cfg->getString("pattern", "Grid01.pat");
        const QString patternFileName = cfg->getString("fileName", "");
 
        KoResourceLoadResult res = KisGlobalResourcesInterface::instance()->source(ResourceType::Patterns).bestMatchLoadResult(patternMD5, patternFileName, patternNameTemp);
        pattern = res.resource<KoPattern>();
 
        patternName = cfg->getString("pattern", "");
 
        // Pattern ID needs the pattern to be saved first.
 
        align_with_layer = false;
 
        scale = cfg->getDouble("transform_scale_x", 1.0) * 100;
 
        angle = 360.0 - cfg->getDouble("transform_rotation_z", 0.0);
        if (angle > 180) {
            angle = (180.0 - angle);
        }
 
        offset  = QPointF(cfg->getInt("transform_offset_x", 0), cfg->getInt("transform_offset_y", 0));
 
        return true;
    }

References KisGlobalResourcesInterface::instance(), ResourceType::Patterns, and KoResourceLoadResult::resource().

◆ loadPattern()

void psd_layer_pattern_fill::loadPattern ( KisEmbeddedResourceStorageProxy & embeddedProxy )

inline

Definition at line 756 of file psd_additional_layer_info_block.h.

                                                                     {
        const QString patternMD5 = "";
        const QString patternNameTemp = patternName;
        const QString patternFileName = QString(patternID + ".pat");
 
        KoResourceLoadResult res = embeddedProxy.resourcesInterface()->source(ResourceType::Patterns).bestMatchLoadResult(patternMD5, patternFileName, patternNameTemp);
        pattern = res.resource<KoPattern>();
    }

References ResourceType::Patterns, KoResourceLoadResult::resource(), and KisEmbeddedResourceStorageProxy::resourcesInterface().

◆ setAlignWithLayer()

void psd_layer_pattern_fill::setAlignWithLayer ( bool align )

inline

Definition at line 660 of file psd_additional_layer_info_block.h.

                                       {
        align_with_layer = align;
    }

◆ setAngle()

void psd_layer_pattern_fill::setAngle ( float Angl )

inline

Definition at line 645 of file psd_additional_layer_info_block.h.

                              {
        angle = Angl;
    }

◆ setOffset()

void psd_layer_pattern_fill::setOffset ( QPointF phase )

inline

Definition at line 651 of file psd_additional_layer_info_block.h.

                                  {
        offset = phase;
    }

◆ setPatternRef()

void psd_layer_pattern_fill::setPatternRef	(	const QString	Idnt,
		const QString	name )

inline

Definition at line 655 of file psd_additional_layer_info_block.h.

                                                               {
        patternName = name;
        patternID = Idnt;
    }

◆ setScale()

void psd_layer_pattern_fill::setScale ( float Scl )

inline

Definition at line 648 of file psd_additional_layer_info_block.h.

                             {
        scale = Scl;
    }

◆ setupCatcher()

static void psd_layer_pattern_fill::setupCatcher	(	const QString	path,
		KisAslCallbackObjectCatcher &	catcher,
		psd_layer_pattern_fill *	data )

inlinestatic

Definition at line 664 of file psd_additional_layer_info_block.h.

                                                                                                                     {
        catcher.subscribeUnitFloat(path + "/Angl", "#Ang", std::bind(&psd_layer_pattern_fill::setAngle, data, std::placeholders::_1));
        catcher.subscribeUnitFloat(path + "/Scl ", "#Prc", std::bind(&psd_layer_pattern_fill::setScale, data, std::placeholders::_1));
        catcher.subscribeBoolean(path + "/Algn", std::bind(&psd_layer_pattern_fill::setAlignWithLayer, data, std::placeholders::_1));
        catcher.subscribePoint(path + "/phase", std::bind(&psd_layer_pattern_fill::setOffset, data, std::placeholders::_1));
        catcher.subscribePatternRef(path + "/Ptrn", std::bind(&psd_layer_pattern_fill::setPatternRef, data, std::placeholders::_1, std::placeholders::_2));
    }

References setAlignWithLayer(), setAngle(), setOffset(), setPatternRef(), setScale(), KisAslCallbackObjectCatcher::subscribeBoolean(), KisAslCallbackObjectCatcher::subscribePatternRef(), KisAslCallbackObjectCatcher::subscribePoint(), and KisAslCallbackObjectCatcher::subscribeUnitFloat().

◆ writeASL()

void psd_layer_pattern_fill::writeASL ( KisAslXmlWriter & w )

inline

Definition at line 740 of file psd_additional_layer_info_block.h.

                                      {
        // pattern ref
        w.enterDescriptor("Ptrn", "", "Ptrn");
 
        w.writeText("Nm  ", patternName);
        w.writeText("Idnt", patternID);
        w.leaveDescriptor();
 
        // end
 
        w.writeBoolean("Algn", align_with_layer);
        w.writeUnitFloat("Scl ", "#Prc", scale);
        w.writeUnitFloat("Angl", "#Ang", angle);
        w.writePoint("phase", offset);
    }