#include <kis_asl_layer_style_serializer.h>

Public Member Functions
void	assignAllLayerStylesToLayers (KisNodeSP root, const QString &storageLocation)

QDomDocument	formPsdXmlDocument () const

QDomDocument	formXmlDocument () const

QVector< KoAbstractGradientSP >	gradients () const

bool	isInitialized ()

bool	isValid ()

	KisAslLayerStyleSerializer ()

QHash< QString, KoPatternSP >	patterns () const

void	readFromDevice (QIODevice &device)

bool	readFromFile (const QString &filename)

void	readFromPSDXML (const QDomDocument &doc)

void	registerPSDPattern (const QDomDocument &doc)

void	saveToDevice (QIODevice &device)

bool	saveToFile (const QString &filename)

void	setStyles (const QVector< KisPSDLayerStyleSP > &styles)

QVector< KisPSDLayerStyleSP >	styles () const

QHash< QString, KisPSDLayerStyleSP >	stylesHash ()

	~KisAslLayerStyleSerializer ()

Static Public Member Functions
static QVector< KisPSDLayerStyleSP >	collectAllLayerStyles (KisNodeSP root)

static QVector< KoResourceSignature >	fetchLinkedResourceSignatures (const KisPSDLayerStyle *style)

static void	sideLoadLinkedResources (KisPSDLayerStyle *style, KisResourcesInterfaceSP resourcesInterface)

Private Member Functions
void	assignGradientObject (KoAbstractGradientSP gradient, std::function< void(KoAbstractGradientSP)> setGradient)

void	assignPatternObject (const QString &patternUuid, const QString &patternName, std::function< void(KoPatternSP)> setPattern)

void	connectCatcherToStyle (KisPSDLayerStyle *style, const QString &prefix)

void	newStyleStarted (bool isPsdStructure)

void	registerPatternObject (const KoPatternSP pattern, const QString &patternUuid)

Static Private Member Functions
static QVector< KoResourceSignature >	fetchAllPatternLinks (const KisPSDLayerStyle *style)

static QVector< KoPatternSP >	fetchAllPatterns (const KisPSDLayerStyle *style, KisResourcesInterfaceSP resourcesInterface)

Private Attributes
KisAslCallbackObjectCatcher	m_catcher

QVector< KoAbstractGradientSP >	m_gradientsStore

bool	m_initialized {false}

bool	m_isValid {true}

QSharedPointer< KisLocalStrokeResources >	m_localResourcesInterface

QHash< QString, KoPatternSP >	m_patternsStore

QHash< QString, KisPSDLayerStyleSP >	m_stylesHash

QVector< KisPSDLayerStyleSP >	m_stylesVector

Detailed Description

Definition at line 20 of file kis_asl_layer_style_serializer.h.

Constructor & Destructor Documentation

◆ KisAslLayerStyleSerializer()

KisAslLayerStyleSerializer::KisAslLayerStyleSerializer ( )

Definition at line 45 of file kis_asl_layer_style_serializer.cpp.

    : m_localResourcesInterface(new KisLocalStrokeResources())
{
}

◆ ~KisAslLayerStyleSerializer()

KisAslLayerStyleSerializer::~KisAslLayerStyleSerializer ( )

Definition at line 50 of file kis_asl_layer_style_serializer.cpp.

51{

52}

Member Function Documentation

◆ assignAllLayerStylesToLayers()

void KisAslLayerStyleSerializer::assignAllLayerStylesToLayers	(	KisNodeSP	root,
		const QString &	storageLocation )

Definition at line 1325 of file kis_asl_layer_style_serializer.cpp.

{
    if (!storageLocation.isEmpty()) {
        KisResourceModel stylesModel(ResourceType::LayerStyles);
        Q_FOREACH (KisPSDLayerStyleSP style, m_stylesVector) {
            KisPSDLayerStyleSP newStyle = style->clone().dynamicCast<KisPSDLayerStyle>();
            sideLoadLinkedResources(newStyle.data(), m_localResourcesInterface);
            style->setResourcesInterface(KisGlobalResourcesInterface::instance());
 
            stylesModel.addResourceDeduplicateFileName(newStyle, storageLocation);
        }
    }
 
    // we iterate over non-uploaded styles which store all the dependent resources
    // internally
    KisLayerUtils::recursiveApplyNodes(root, [styles = m_stylesVector] (KisNodeSP node) {
        KisLayer* layer = qobject_cast<KisLayer*>(node.data());
 
        if (layer && layer->layerStyle()) {
            QUuid uuid = layer->layerStyle()->uuid();
 
            bool found = false;
 
            Q_FOREACH (KisPSDLayerStyleSP style, styles) {
                if (style->uuid() == uuid) {
                    layer->setLayerStyle(style->cloneWithResourcesSnapshot(style->resourcesInterface(), 0));
                    found = true;
                    break;
                }
            }
 
            if (!found) {
                warnKrita << "WARNING: loading layer style for" << layer->name() << "failed! It requests inexistent style:" << uuid;
            }
        }
    });
}

References KisResourceModel::addResourceDeduplicateFileName(), KisSharedPtr< T >::data(), KisGlobalResourcesInterface::instance(), KisLayer::layerStyle, ResourceType::LayerStyles, m_localResourcesInterface, m_stylesVector, KisBaseNode::name(), KisLayerUtils::recursiveApplyNodes(), KisLayer::setLayerStyle(), sideLoadLinkedResources(), styles(), and warnKrita.

◆ assignGradientObject()

void KisAslLayerStyleSerializer::assignGradientObject	(	KoAbstractGradientSP	gradient,
		std::function< void(KoAbstractGradientSP)>	setGradient )

private

Definition at line 969 of file kis_asl_layer_style_serializer.cpp.

{
    m_gradientsStore.append(gradient);
    m_localResourcesInterface->addResource(gradient);
    setGradient(gradient);
}

References m_gradientsStore, and m_localResourcesInterface.

◆ assignPatternObject()

void KisAslLayerStyleSerializer::assignPatternObject	(	const QString &	patternUuid,
		const QString &	patternName,
		std::function< void(KoPatternSP)>	setPattern )

private

Definition at line 947 of file kis_asl_layer_style_serializer.cpp.

{
    Q_UNUSED(patternName);
 
    KoPatternSP pattern;
 
    if (!m_patternsStore.contains(patternUuid)) {
        warnKrita << "WARNING: ASL style contains non-existent pattern reference! Searching for uuid: "
                  << patternUuid << " (name: " << patternName << ")";
 
        QImage dumbImage(32, 32, QImage::Format_ARGB32);
        dumbImage.fill(Qt::red);
        KoPatternSP dumbPattern(new KoPattern(dumbImage, "invalid", ""));
        registerPatternObject(dumbPattern, patternUuid + QString("_invalid"));
        pattern = dumbPattern;
    } else {
        pattern = m_patternsStore[patternUuid];
    }
 
    setPattern(pattern);
}

References m_patternsStore, registerPatternObject(), and warnKrita.

◆ collectAllLayerStyles()

QVector< KisPSDLayerStyleSP > KisAslLayerStyleSerializer::collectAllLayerStyles ( KisNodeSP root )

static

Definition at line 1281 of file kis_asl_layer_style_serializer.cpp.

{
    KisLayer* layer = qobject_cast<KisLayer*>(root.data());
    QVector<KisPSDLayerStyleSP> layerStyles;
 
    if (layer && layer->layerStyle()) {
        KisPSDLayerStyleSP clone = layer->layerStyle()->clone().dynamicCast<KisPSDLayerStyle>();
        clone->setName(i18nc("Auto-generated layer style name for embedded styles (style itself)", "<%1> (embedded)", layer->name()));
        layerStyles << clone;
    }
 
    KisNodeSP child = root->firstChild();
    while (child) {
        layerStyles += collectAllLayerStyles(child);
        child = child->nextSibling();
    }
 
    return layerStyles;
}

References collectAllLayerStyles(), KisSharedPtr< T >::data(), KisNode::firstChild(), KisLayer::layerStyle, KisBaseNode::name(), and KisNode::nextSibling().

◆ connectCatcherToStyle()

void KisAslLayerStyleSerializer::connectCatcherToStyle	(	KisPSDLayerStyle *	style,
		const QString &	prefix )

private

Definition at line 1008 of file kis_asl_layer_style_serializer.cpp.

{
    CONN_TEXT_RADDR("/null/Nm  ", setName, style, KisPSDLayerStyle);
    CONN_TEXT_RADDR("/null/Idnt", setPsdUuid, style, KisPSDLayerStyle);
 
    CONN_BOOL("/masterFXSwitch", setEnabled, style, KisPSDLayerStyle, prefix);
 
    psd_layer_effects_drop_shadow *dropShadow = style->dropShadow();
 
    CONN_COMPOSITE_OP("/DrSh/Md  ", setBlendMode, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_COLOR("/DrSh/Clr ", setColor, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/Opct", "#Prc", setOpacity, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/lagl", "#Ang", setAngle, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/Dstn", "#Pxl", setDistance, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/Ckmt", "#Pxl", setSpread, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/blur", "#Pxl", setSize, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_UNITF("/DrSh/Nose", "#Prc", setNoise, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_BOOL("/DrSh/enab", setEffectEnabled, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_BOOL("/DrSh/uglg", setUseGlobalLight, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_BOOL("/DrSh/AntA", setAntiAliased, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_BOOL("/DrSh/layerConceals", setKnocksOut, dropShadow, psd_layer_effects_drop_shadow, prefix);
    CONN_CURVE("/DrSh/TrnS", setContourLookupTable, dropShadow, psd_layer_effects_drop_shadow, prefix);
 
    psd_layer_effects_inner_shadow *innerShadow = style->innerShadow();
 
    CONN_COMPOSITE_OP("/IrSh/Md  ", setBlendMode, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_COLOR("/IrSh/Clr ", setColor, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/Opct", "#Prc", setOpacity, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/lagl", "#Ang", setAngle, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/Dstn", "#Pxl", setDistance, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/Ckmt", "#Pxl", setSpread, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/blur", "#Pxl", setSize, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_UNITF("/IrSh/Nose", "#Prc", setNoise, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_BOOL("/IrSh/enab", setEffectEnabled, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_BOOL("/IrSh/uglg", setUseGlobalLight, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_BOOL("/IrSh/AntA", setAntiAliased, innerShadow, psd_layer_effects_inner_shadow, prefix);
    CONN_CURVE("/IrSh/TrnS", setContourLookupTable, innerShadow, psd_layer_effects_inner_shadow, prefix);
 
    psd_layer_effects_outer_glow *outerGlow = style->outerGlow();
 
    CONN_COMPOSITE_OP("/OrGl/Md  ", setBlendMode, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_COLOR("/OrGl/Clr ", setColor, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_UNITF("/OrGl/Opct", "#Prc", setOpacity, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_UNITF("/OrGl/Ckmt", "#Pxl", setSpread, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_UNITF("/OrGl/blur", "#Pxl", setSize, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_UNITF("/OrGl/Nose", "#Prc", setNoise, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_BOOL("/OrGl/enab", setEffectEnabled, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_BOOL("/OrGl/AntA", setAntiAliased, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_CURVE("/OrGl/TrnS", setContourLookupTable, outerGlow, psd_layer_effects_outer_glow, prefix);
 
    QMap<QString, psd_technique_type> fillTechniqueMap;
    fillTechniqueMap.insert("PrBL", psd_technique_precise);
    fillTechniqueMap.insert("SfBL", psd_technique_softer);
    CONN_ENUM("/OrGl/GlwT", "BETE", setTechnique, fillTechniqueMap, psd_technique_type, outerGlow, psd_layer_effects_outer_glow, prefix);
 
    CONN_GRADIENT("/OrGl/Grad", setGradient, outerGlow, psd_layer_effects_outer_glow, prefix);
 
    CONN_UNITF("/OrGl/Inpr", "#Prc", setRange, outerGlow, psd_layer_effects_outer_glow, prefix);
    CONN_UNITF("/OrGl/ShdN", "#Prc", setJitter, outerGlow, psd_layer_effects_outer_glow, prefix);
 
 
    psd_layer_effects_inner_glow *innerGlow = style->innerGlow();
 
    CONN_COMPOSITE_OP("/IrGl/Md  ", setBlendMode, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_COLOR("/IrGl/Clr ", setColor, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_UNITF("/IrGl/Opct", "#Prc", setOpacity, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_UNITF("/IrGl/Ckmt", "#Pxl", setSpread, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_UNITF("/IrGl/blur", "#Pxl", setSize, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_UNITF("/IrGl/Nose", "#Prc", setNoise, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_BOOL("/IrGl/enab", setEffectEnabled, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_BOOL("/IrGl/AntA", setAntiAliased, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_CURVE("/IrGl/TrnS", setContourLookupTable, innerGlow, psd_layer_effects_inner_glow, prefix);
 
    CONN_ENUM("/IrGl/GlwT", "BETE", setTechnique, fillTechniqueMap, psd_technique_type, innerGlow, psd_layer_effects_inner_glow, prefix);
 
    CONN_GRADIENT("/IrGl/Grad", setGradient, innerGlow, psd_layer_effects_inner_glow, prefix);
 
    CONN_UNITF("/IrGl/Inpr", "#Prc", setRange, innerGlow, psd_layer_effects_inner_glow, prefix);
    CONN_UNITF("/IrGl/ShdN", "#Prc", setJitter, innerGlow, psd_layer_effects_inner_glow, prefix);
 
    QMap<QString, psd_glow_source> glowSourceMap;
    glowSourceMap.insert("SrcC", psd_glow_center);
    glowSourceMap.insert("SrcE", psd_glow_edge);
    CONN_ENUM("/IrGl/glwS", "IGSr", setSource, glowSourceMap, psd_glow_source, innerGlow, psd_layer_effects_inner_glow, prefix);
 
 
    psd_layer_effects_satin *satin = style->satin();
 
    CONN_COMPOSITE_OP("/ChFX/Md  ", setBlendMode, satin, psd_layer_effects_satin, prefix);
    CONN_COLOR("/ChFX/Clr ", setColor, satin, psd_layer_effects_satin, prefix);
 
    CONN_UNITF("/ChFX/Opct", "#Prc", setOpacity, satin, psd_layer_effects_satin, prefix);
    CONN_UNITF("/ChFX/lagl", "#Ang", setAngle, satin, psd_layer_effects_satin, prefix);
    CONN_UNITF("/ChFX/Dstn", "#Pxl", setDistance, satin, psd_layer_effects_satin, prefix);
    CONN_UNITF("/ChFX/blur", "#Pxl", setSize, satin, psd_layer_effects_satin, prefix);
 
    CONN_BOOL("/ChFX/enab", setEffectEnabled, satin, psd_layer_effects_satin, prefix);
    CONN_BOOL("/ChFX/AntA", setAntiAliased, satin, psd_layer_effects_satin, prefix);
    CONN_BOOL("/ChFX/Invr", setInvert, satin, psd_layer_effects_satin, prefix);
    CONN_CURVE("/ChFX/MpgS", setContourLookupTable, satin, psd_layer_effects_satin, prefix);
 
    psd_layer_effects_color_overlay *colorOverlay = style->colorOverlay();
 
    CONN_COMPOSITE_OP("/SoFi/Md  ", setBlendMode, colorOverlay, psd_layer_effects_color_overlay, prefix);
    CONN_COLOR("/SoFi/Clr ", setColor, colorOverlay, psd_layer_effects_color_overlay, prefix);
    CONN_UNITF("/SoFi/Opct", "#Prc", setOpacity, colorOverlay, psd_layer_effects_color_overlay, prefix);
    CONN_BOOL("/SoFi/enab", setEffectEnabled, colorOverlay, psd_layer_effects_color_overlay, prefix);
 
    psd_layer_effects_gradient_overlay *gradientOverlay = style->gradientOverlay();
 
    CONN_COMPOSITE_OP("/GrFl/Md  ", setBlendMode, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_UNITF("/GrFl/Opct", "#Prc", setOpacity, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_UNITF("/GrFl/Scl ", "#Prc", setScale, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_UNITF("/GrFl/Angl", "#Ang", setAngle, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_BOOL("/GrFl/enab", setEffectEnabled, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_BOOL("/GrFl/Dthr", setDither, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_BOOL("/GrFl/Rvrs", setReverse, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_BOOL("/GrFl/Algn", setAlignWithLayer, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_POINT("/GrFl/Ofst", setGradientOffset, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
    CONN_GRADIENT("/GrFl/Grad", setGradient, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
 
 
    QMap<QString, psd_gradient_style> gradientStyleMap;
    gradientStyleMap.insert("Lnr ", psd_gradient_style_linear);
    gradientStyleMap.insert("Rdl ", psd_gradient_style_radial);
    gradientStyleMap.insert("Angl", psd_gradient_style_angle);
    gradientStyleMap.insert("Rflc", psd_gradient_style_reflected);
    gradientStyleMap.insert("Dmnd", psd_gradient_style_diamond);
    CONN_ENUM("/GrFl/Type", "GrdT", setStyle, gradientStyleMap, psd_gradient_style, gradientOverlay, psd_layer_effects_gradient_overlay, prefix);
 
    psd_layer_effects_pattern_overlay *patternOverlay = style->patternOverlay();
 
    CONN_BOOL("/patternFill/enab", setEffectEnabled, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_COMPOSITE_OP("/patternFill/Md  ", setBlendMode, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_UNITF("/patternFill/Opct", "#Prc", setOpacity, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_PATTERN("/patternFill/Ptrn", setPattern, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_UNITF("/patternFill/Scl ", "#Prc", setScale, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_BOOL("/patternFill/Algn", setAlignWithLayer, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
    CONN_POINT("/patternFill/phase", setPatternPhase, patternOverlay, psd_layer_effects_pattern_overlay, prefix);
 
    psd_layer_effects_stroke *stroke = style->stroke();
 
    CONN_COMPOSITE_OP("/FrFX/Md  ", setBlendMode, stroke, psd_layer_effects_stroke, prefix);
    CONN_BOOL("/FrFX/enab", setEffectEnabled, stroke, psd_layer_effects_stroke, prefix);
    CONN_UNITF("/FrFX/Opct", "#Prc", setOpacity, stroke, psd_layer_effects_stroke, prefix);
    CONN_UNITF("/FrFX/Sz  ", "#Pxl", setSize, stroke, psd_layer_effects_stroke, prefix);
 
    QMap<QString, psd_stroke_position> strokeStyleMap;
    strokeStyleMap.insert("OutF", psd_stroke_outside);
    strokeStyleMap.insert("InsF", psd_stroke_inside);
    strokeStyleMap.insert("CtrF", psd_stroke_center);
    CONN_ENUM("/FrFX/Styl", "FStl", setPosition, strokeStyleMap, psd_stroke_position, stroke, psd_layer_effects_stroke, prefix);
 
    QMap<QString, psd_fill_type> strokeFillType;
    strokeFillType.insert("SClr", psd_fill_solid_color);
    strokeFillType.insert("GrFl", psd_fill_gradient);
    strokeFillType.insert("Ptrn", psd_fill_pattern);
    CONN_ENUM("/FrFX/PntT", "FrFl", setFillType, strokeFillType, psd_fill_type, stroke, psd_layer_effects_stroke, prefix);
 
    // Color type
    CONN_COLOR("/FrFX/Clr ", setColor, stroke, psd_layer_effects_stroke, prefix);
 
    // Gradient Type
    CONN_GRADIENT("/FrFX/Grad", setGradient, stroke, psd_layer_effects_stroke, prefix);
    CONN_UNITF("/FrFX/Angl", "#Ang", setAngle, stroke, psd_layer_effects_stroke, prefix);
    CONN_UNITF("/FrFX/Scl ", "#Prc", setScale, stroke, psd_layer_effects_stroke, prefix);
    CONN_ENUM("/FrFX/Type", "GrdT", setStyle, gradientStyleMap, psd_gradient_style, stroke, psd_layer_effects_stroke, prefix);
    CONN_BOOL("/FrFX/Rvrs", setReverse, stroke, psd_layer_effects_stroke, prefix);
    CONN_BOOL("/FrFX/Algn", setAlignWithLayer, stroke, psd_layer_effects_stroke, prefix);
    CONN_POINT("/FrFX/Ofst", setGradientOffset, stroke, psd_layer_effects_stroke, prefix);
    CONN_BOOL("/FrFX/Dthr", setDither, stroke, psd_layer_effects_stroke, prefix);
 
    // Pattern type
 
    CONN_PATTERN("/FrFX/Ptrn", setPattern, stroke, psd_layer_effects_stroke, prefix);
    CONN_BOOL("/FrFX/Lnkd", setAlignWithLayer, stroke, psd_layer_effects_stroke, prefix); // yes, we share the params...
    CONN_POINT("/FrFX/phase", setPatternPhase, stroke, psd_layer_effects_stroke, prefix);
 
 
    psd_layer_effects_bevel_emboss *bevelAndEmboss = style->bevelAndEmboss();
 
    CONN_BOOL("/ebbl/enab", setEffectEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_COMPOSITE_OP("/ebbl/hglM", setHighlightBlendMode, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_COLOR("/ebbl/hglC", setHighlightColor, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/hglO", "#Prc", setHighlightOpacity, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_COMPOSITE_OP("/ebbl/sdwM", setShadowBlendMode, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_COLOR("/ebbl/sdwC", setShadowColor, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/sdwO", "#Prc", setShadowOpacity, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    QMap<QString, psd_technique_type> bevelTechniqueMap;
    bevelTechniqueMap.insert("PrBL", psd_technique_precise);
    bevelTechniqueMap.insert("SfBL", psd_technique_softer);
    bevelTechniqueMap.insert("Slmt", psd_technique_slope_limit);
    CONN_ENUM("/ebbl/bvlT", "bvlT", setTechnique, bevelTechniqueMap, psd_technique_type, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    QMap<QString, psd_bevel_style> bevelStyleMap;
    bevelStyleMap.insert("OtrB", psd_bevel_outer_bevel);
    bevelStyleMap.insert("InrB", psd_bevel_inner_bevel);
    bevelStyleMap.insert("Embs", psd_bevel_emboss);
    bevelStyleMap.insert("PlEb", psd_bevel_pillow_emboss);
    bevelStyleMap.insert("strokeEmboss", psd_bevel_stroke_emboss);
    CONN_ENUM("/ebbl/bvlS", "BESl", setStyle, bevelStyleMap, psd_bevel_style, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_BOOL("/ebbl/uglg", setUseGlobalLight, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_UNITF("/ebbl/lagl", "#Ang", setAngle, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/Lald", "#Ang", setAltitude, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_UNITF("/ebbl/srgR", "#Prc", setDepth, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_UNITF("/ebbl/blur", "#Pxl", setSize, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
 
    QMap<QString, psd_direction> bevelDirectionMap;
    bevelDirectionMap.insert("In  ", psd_direction_up);
    bevelDirectionMap.insert("Out ", psd_direction_down);
    CONN_ENUM("/ebbl/bvlD", "BESs", setDirection, bevelDirectionMap, psd_direction, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_CURVE("/ebbl/TrnS", setContourLookupTable, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_BOOL("/ebbl/antialiasGloss", setGlossAntiAliased, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    CONN_UNITF("/ebbl/Sftn", "#Pxl", setSoften, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    // Use shape mode
 
    CONN_BOOL("/ebbl/useShape", setContourEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_CURVE("/ebbl/MpgS", setGlossContourLookupTable, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_BOOL("/ebbl/AntA", setAntiAliased, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/Inpr", "#Prc", setContourRange, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
 
    // Use texture mode
 
    CONN_BOOL("/ebbl/useTexture", setTextureEnabled, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_BOOL("/ebbl/InvT", setTextureInvert, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_BOOL("/ebbl/Algn", setTextureAlignWithLayer, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/Scl ", "#Prc", setTextureScale, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_UNITF("/ebbl/textureDepth ", "#Prc", setTextureDepth, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_PATTERN("/ebbl/Ptrn", setTexturePattern, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
    CONN_POINT("/ebbl/phase", setTexturePhase, bevelAndEmboss, psd_layer_effects_bevel_emboss, prefix);
}

◆ fetchAllPatternLinks()

QVector< KoResourceSignature > KisAslLayerStyleSerializer::fetchAllPatternLinks ( const KisPSDLayerStyle * style )

staticprivate

Definition at line 265 of file kis_asl_layer_style_serializer.cpp.

{
    QVector<KoResourceSignature> allPatternLinks;
 
    if (style->patternOverlay()->effectEnabled()) {
        allPatternLinks << style->patternOverlay()->patternLink();
    }
 
    if (style->stroke()->effectEnabled() &&
        style->stroke()->fillType() == psd_fill_pattern) {
 
        allPatternLinks << style->stroke()->patternLink();
    }
 
    if(style->bevelAndEmboss()->effectEnabled() &&
       style->bevelAndEmboss()->textureEnabled()) {
 
        allPatternLinks << style->bevelAndEmboss()->texturePatternLink();
    }
 
    return allPatternLinks;
}

References KisPSDLayerStyle::bevelAndEmboss(), psd_layer_effects_shadow_base::effectEnabled(), psd_layer_effects_shadow_base::fillType(), psd_layer_effects_overlay_base::patternLink(), KisPSDLayerStyle::patternOverlay(), psd_fill_pattern, KisPSDLayerStyle::stroke, psd_layer_effects_bevel_emboss::textureEnabled(), and psd_layer_effects_bevel_emboss::texturePatternLink().

◆ fetchAllPatterns()

QVector< KoPatternSP > KisAslLayerStyleSerializer::fetchAllPatterns	(	const KisPSDLayerStyle *	style,
		KisResourcesInterfaceSP	resourcesInterface )

staticprivate

Definition at line 287 of file kis_asl_layer_style_serializer.cpp.

{
    const auto allPatternLinks = fetchAllPatternLinks(style);
    QVector <KoPatternSP> allPatterns;
 
    Q_FOREACH(const KoResourceSignature &sig, allPatternLinks) {
        KoPatternSP pattern = resourcesInterface->source<KoPattern>(sig.type).bestMatch(sig.md5sum, sig.filename, sig.name);
        if (pattern) {
            allPatterns << pattern;
        } else {
            warnKrita << "WARNING: failed to fetch a pattern for a layer style" << sig;
        }
    }
 
    return allPatterns;
}

References fetchAllPatternLinks(), KoResourceSignature::filename, KoResourceSignature::md5sum, KoResourceSignature::name, KoResourceSignature::type, and warnKrita.

◆ fetchLinkedResourceSignatures()

QVector< KoResourceSignature > KisAslLayerStyleSerializer::fetchLinkedResourceSignatures ( const KisPSDLayerStyle * style )

static

Definition at line 764 of file kis_asl_layer_style_serializer.cpp.

{
    QVector<KoResourceSignature> embeddedResourceLinks = fetchAllPatternLinks(style);
 
    if (style->gradientOverlay()->effectEnabled()) {
        embeddedResourceLinks << style->gradientOverlay()->gradientLink();
    }
 
    if (style->innerGlow()->effectEnabled() && style->innerGlow()->fillType() == psd_fill_gradient) {
        embeddedResourceLinks << style->innerGlow()->gradientLink();
    }
 
    if (style->outerGlow()->effectEnabled() && style->outerGlow()->fillType() == psd_fill_gradient) {
        embeddedResourceLinks << style->outerGlow()->gradientLink();
    }
 
    if (style->stroke()->effectEnabled() && style->stroke()->fillType() == psd_fill_gradient) {
        embeddedResourceLinks << style->stroke()->gradientLink();
    }
 
    return embeddedResourceLinks;
}

References psd_layer_effects_shadow_base::effectEnabled(), fetchAllPatternLinks(), psd_layer_effects_shadow_base::fillType(), psd_layer_effects_shadow_base::gradientLink(), KisPSDLayerStyle::gradientOverlay(), KisPSDLayerStyle::innerGlow(), KisPSDLayerStyle::outerGlow(), psd_fill_gradient, and KisPSDLayerStyle::stroke.

◆ formPsdXmlDocument()

QDomDocument KisAslLayerStyleSerializer::formPsdXmlDocument ( ) const

Definition at line 751 of file kis_asl_layer_style_serializer.cpp.

{
    QDomDocument doc = formXmlDocument();
 
    QDomNode nullNode = findNodeByClassId("null", doc.documentElement());
    QDomNode stylNode = findNodeByClassId("Styl", doc.documentElement());
    QDomNode lefxNode = findNodeByClassId("Lefx", stylNode);
 
    replaceAllChildren(lefxNode, nullNode);
 
    return doc;
}

References findNodeByClassId(), formXmlDocument(), and replaceAllChildren().

◆ formXmlDocument()

QDomDocument KisAslLayerStyleSerializer::formXmlDocument ( ) const

the duplicated patterns will be resolved later at the uuid generation stage

Definition at line 314 of file kis_asl_layer_style_serializer.cpp.

{
    KIS_ASSERT_RECOVER(!m_stylesVector.isEmpty()) { return QDomDocument(); }
 
    QVector<KoPatternSP> allPatterns;
 
    Q_FOREACH (KisPSDLayerStyleSP style, m_stylesVector) {
        allPatterns += fetchAllPatterns(style.data(), style->resourcesInterface());
    }
 
    QHash<KoPatternSP, QString> patternToUuidMap;
 
    KisAslXmlWriter w;
 
    if (!allPatterns.isEmpty()) {
        w.enterList(ResourceType::Patterns);
 
        Q_FOREACH (KoPatternSP pattern, allPatterns) {
            if (pattern) {
                if (!patternToUuidMap.contains(pattern)) {
                    QString uuid = w.writePattern("", pattern);
                    patternToUuidMap.insert(pattern, uuid);
                }
            } else {
                warnKrita << "WARNING: KisAslLayerStyleSerializer::saveToDevice: saved pattern is null!";
            }
        }
 
        w.leaveList();
    }
 
    Q_FOREACH (KisPSDLayerStyleSP style, m_stylesVector) {
 
        w.enterDescriptor("", "", "null");
        w.writeText("Nm  ", style->name());
        w.writeText("Idnt", style->psdUuid());
        w.leaveDescriptor();
 
        w.enterDescriptor("", "", "Styl");
 
        w.enterDescriptor("documentMode", "", "documentMode");
        w.leaveDescriptor();
 
        w.enterDescriptor("Lefx", "", "Lefx");
 
        w.writeUnitFloat("Scl ", "#Prc", 100);
        w.writeBoolean("masterFXSwitch", style->isEnabled());
 
 
        // Drop Shadow
        const psd_layer_effects_drop_shadow *dropShadow = style->dropShadow();
        if (dropShadow->effectEnabled()) {
            w.enterDescriptor("DrSh", "", "DrSh");
 
            w.writeBoolean("enab", dropShadow->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(dropShadow->blendMode()));
            w.writeColor("Clr ", dropShadow->color());
 
            w.writeUnitFloat("Opct", "#Prc", dropShadow->opacity());
            w.writeBoolean("uglg", dropShadow->useGlobalLight());
            w.writeUnitFloat("lagl", "#Ang", dropShadow->angle());
            w.writeUnitFloat("Dstn", "#Pxl", dropShadow->distance());
            w.writeUnitFloat("Ckmt", "#Pxl", dropShadow->spread());
            w.writeUnitFloat("blur", "#Pxl", dropShadow->size());
            w.writeUnitFloat("Nose", "#Prc", dropShadow->noise());
 
            w.writeBoolean("AntA", dropShadow->antiAliased());
 
            // FIXME: save curves
            w.writeCurve("TrnS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.writeBoolean("layerConceals", dropShadow->knocksOut());
            w.leaveDescriptor();
        }
 
        // Inner Shadow
        const psd_layer_effects_inner_shadow *innerShadow = style->innerShadow();
        if (innerShadow->effectEnabled()) {
            w.enterDescriptor("IrSh", "", "IrSh");
 
            w.writeBoolean("enab", innerShadow->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(innerShadow->blendMode()));
            w.writeColor("Clr ", innerShadow->color());
 
            w.writeUnitFloat("Opct", "#Prc", innerShadow->opacity());
            w.writeBoolean("uglg", innerShadow->useGlobalLight());
            w.writeUnitFloat("lagl", "#Ang", innerShadow->angle());
            w.writeUnitFloat("Dstn", "#Pxl", innerShadow->distance());
            w.writeUnitFloat("Ckmt", "#Pxl", innerShadow->spread());
            w.writeUnitFloat("blur", "#Pxl", innerShadow->size());
            w.writeUnitFloat("Nose", "#Prc", innerShadow->noise());
 
            w.writeBoolean("AntA", innerShadow->antiAliased());
 
            // FIXME: save curves
            w.writeCurve("TrnS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.leaveDescriptor();
        }
 
        // Outer Glow
        const psd_layer_effects_outer_glow *outerGlow = style->outerGlow();
        if (outerGlow->effectEnabled()) {
            w.enterDescriptor("OrGl", "", "OrGl");
 
            w.writeBoolean("enab", outerGlow->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(outerGlow->blendMode()));
 
            if (outerGlow->fillType() == psd_fill_gradient && outerGlow->gradient(style->resourcesInterface())) {
                KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(outerGlow->gradient(style->resourcesInterface()).data());
                KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(outerGlow->gradient(style->resourcesInterface()).data());
 
                if (segmentGradient && segmentGradient->valid()) {
                    w.writeSegmentGradient("Grad", *segmentGradient);
                } else if (stopGradient  && stopGradient->valid()) {
                    w.writeStopGradient("Grad", *stopGradient);
                } else {
                    warnKrita << "WARNING: OG: Unknown gradient type!";
                    w.writeColor("Clr ", outerGlow->color());
                }
 
            } else {
                w.writeColor("Clr ", outerGlow->color());
            }
 
            w.writeUnitFloat("Opct", "#Prc", outerGlow->opacity());
 
            w.writeEnum("GlwT", "BETE", techniqueToString(outerGlow->technique(), "BETE"));
 
            w.writeUnitFloat("Ckmt", "#Pxl", outerGlow->spread());
            w.writeUnitFloat("blur", "#Pxl", outerGlow->size());
            w.writeUnitFloat("Nose", "#Prc", outerGlow->noise());
 
            w.writeUnitFloat("ShdN", "#Prc", outerGlow->jitter());
 
            w.writeBoolean("AntA", outerGlow->antiAliased());
 
            // FIXME: save curves
            w.writeCurve("TrnS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.writeUnitFloat("Inpr", "#Prc", outerGlow->range());
 
            w.leaveDescriptor();
        }
 
        // Inner Glow
        const psd_layer_effects_inner_glow *innerGlow = style->innerGlow();
        if (innerGlow->effectEnabled()) {
            w.enterDescriptor("IrGl", "", "IrGl");
 
            w.writeBoolean("enab", innerGlow->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(innerGlow->blendMode()));
 
            if (innerGlow->fillType() == psd_fill_gradient && innerGlow->gradient(style->resourcesInterface())) {
                KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(innerGlow->gradient(style->resourcesInterface()).data());
                KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(innerGlow->gradient(style->resourcesInterface()).data());
 
                if (segmentGradient  && innerGlow->gradient(style->resourcesInterface())->valid()) {
                    w.writeSegmentGradient("Grad", *segmentGradient);
                } else if (stopGradient  && innerGlow->gradient(style->resourcesInterface())->valid()) {
                    w.writeStopGradient("Grad", *stopGradient);
                } else {
                    warnKrita << "WARNING: IG: Unknown gradient type!";
                    w.writeColor("Clr ", innerGlow->color());
                }
 
            } else {
                w.writeColor("Clr ", innerGlow->color());
            }
 
            w.writeUnitFloat("Opct", "#Prc", innerGlow->opacity());
 
            w.writeEnum("GlwT", "BETE", techniqueToString(innerGlow->technique(), "BETE"));
 
            w.writeUnitFloat("Ckmt", "#Pxl", innerGlow->spread());
            w.writeUnitFloat("blur", "#Pxl", innerGlow->size());
 
            // NOTE: order is swapped in ASL!
            w.writeUnitFloat("ShdN", "#Prc", innerGlow->jitter());
            w.writeUnitFloat("Nose", "#Prc", innerGlow->noise());
 
            w.writeBoolean("AntA", innerGlow->antiAliased());
 
            w.writeEnum("glwS", "IGSr", innerGlow->source() == psd_glow_center ? "SrcC" : "SrcE");
 
            // FIXME: save curves
            w.writeCurve("TrnS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.writeUnitFloat("Inpr", "#Prc", innerGlow->range());
 
            w.leaveDescriptor();
        }
 
        // Bevel and Emboss
        const psd_layer_effects_bevel_emboss *bevelAndEmboss = style->bevelAndEmboss();
        if (bevelAndEmboss->effectEnabled()) {
            w.enterDescriptor("ebbl", "", "ebbl");
 
            w.writeBoolean("enab", bevelAndEmboss->effectEnabled());
 
            w.writeEnum("hglM", "BlnM", compositeOpToBlendMode(bevelAndEmboss->highlightBlendMode()));
            w.writeColor("hglC", bevelAndEmboss->highlightColor());
            w.writeUnitFloat("hglO", "#Prc", bevelAndEmboss->highlightOpacity());
 
            w.writeEnum("sdwM", "BlnM", compositeOpToBlendMode(bevelAndEmboss->shadowBlendMode()));
            w.writeColor("sdwC", bevelAndEmboss->shadowColor());
            w.writeUnitFloat("sdwO", "#Prc", bevelAndEmboss->shadowOpacity());
 
            w.writeEnum("bvlT", "bvlT", techniqueToString(bevelAndEmboss->technique(), "bvlT"));
            w.writeEnum("bvlS", "BESl", bevelStyleToString(bevelAndEmboss->style()));
 
            w.writeBoolean("uglg", bevelAndEmboss->useGlobalLight());
            w.writeUnitFloat("lagl", "#Ang", bevelAndEmboss->angle());
            w.writeUnitFloat("Lald", "#Ang", bevelAndEmboss->altitude());
 
            w.writeUnitFloat("srgR", "#Prc", bevelAndEmboss->depth());
            w.writeUnitFloat("blur", "#Pxl", bevelAndEmboss->size());
            w.writeEnum("bvlD", "BESs", bevelAndEmboss->direction() == psd_direction_up ? "In  " : "Out ");
 
            // FIXME: save curves
            w.writeCurve("TrnS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.writeBoolean("antialiasGloss", bevelAndEmboss->glossAntiAliased());
 
            w.writeUnitFloat("Sftn", "#Pxl", bevelAndEmboss->soften());
 
            if (bevelAndEmboss->contourEnabled()) {
                w.writeBoolean("useShape", bevelAndEmboss->contourEnabled());
 
                // FIXME: save curves
                w.writeCurve("MpgS",
                             "Linear",
                             QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
                w.writeBoolean("AntA", bevelAndEmboss->antiAliased());
                w.writeUnitFloat("Inpr", "#Prc", bevelAndEmboss->contourRange());
            }
 
            w.writeBoolean("useTexture", bevelAndEmboss->textureEnabled());
 
            if (bevelAndEmboss->textureEnabled()) {
                w.writeBoolean("InvT", bevelAndEmboss->textureInvert());
                w.writeBoolean("Algn", bevelAndEmboss->textureAlignWithLayer());
                w.writeUnitFloat("Scl ", "#Prc", bevelAndEmboss->textureScale());
                w.writeUnitFloat("textureDepth ", "#Prc", bevelAndEmboss->textureDepth());
 
                KoPatternSP pattern = bevelAndEmboss->texturePattern(style->resourcesInterface());
                w.writePatternRef("Ptrn", pattern, fetchPatternUuidSafe(pattern, patternToUuidMap));
                w.writePhasePoint("phase", bevelAndEmboss->texturePhase());
            }
 
            w.leaveDescriptor();
        }
 
        // Satin
        const psd_layer_effects_satin *satin = style->satin();
        if (satin->effectEnabled()) {
            w.enterDescriptor("ChFX", "", "ChFX");
 
            w.writeBoolean("enab", satin->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(satin->blendMode()));
            w.writeColor("Clr ", satin->color());
 
            w.writeBoolean("AntA", satin->antiAliased());
            w.writeBoolean("Invr", satin->invert());
            w.writeUnitFloat("Opct", "#Prc", satin->opacity());
            w.writeUnitFloat("lagl", "#Ang", satin->angle());
            w.writeUnitFloat("Dstn", "#Pxl", satin->distance());
            w.writeUnitFloat("blur", "#Pxl", satin->size());
 
            // FIXME: save curves
            w.writeCurve("MpgS",
                         "Linear",
                         QVector<QPointF>() << QPointF() << QPointF(255, 255));
 
            w.leaveDescriptor();
        }
 
        const psd_layer_effects_color_overlay *colorOverlay = style->colorOverlay();
        if (colorOverlay->effectEnabled()) {
            w.enterDescriptor("SoFi", "", "SoFi");
 
            w.writeBoolean("enab", colorOverlay->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(colorOverlay->blendMode()));
            w.writeUnitFloat("Opct", "#Prc", colorOverlay->opacity());
            w.writeColor("Clr ", colorOverlay->color());
 
            w.leaveDescriptor();
        }
 
        // Gradient Overlay
        const psd_layer_effects_gradient_overlay *gradientOverlay = style->gradientOverlay();
        KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(gradientOverlay->gradient(style->resourcesInterface()).data());
        KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(gradientOverlay->gradient(style->resourcesInterface()).data());
 
        if (gradientOverlay->effectEnabled() && ((segmentGradient && segmentGradient->valid()) || (stopGradient && stopGradient->valid()))) {
            w.enterDescriptor("GrFl", "", "GrFl");
 
            w.writeBoolean("enab", gradientOverlay->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(gradientOverlay->blendMode()));
            w.writeUnitFloat("Opct", "#Prc", gradientOverlay->opacity());
 
            if (segmentGradient && segmentGradient->valid()) {
                w.writeSegmentGradient("Grad", *segmentGradient);
            } else if (stopGradient && stopGradient->valid()) {
                w.writeStopGradient("Grad", *stopGradient);
            }
 
            w.writeUnitFloat("Angl", "#Ang", gradientOverlay->angle());
 
            w.writeEnum("Type", "GrdT", gradientTypeToString(gradientOverlay->style()));
 
            w.writeBoolean("Rvrs", gradientOverlay->reverse());
            w.writeBoolean("Algn", gradientOverlay->alignWithLayer());
            w.writeUnitFloat("Scl ", "#Prc", gradientOverlay->scale());
 
            w.writeOffsetPoint("Ofst", gradientOverlay->gradientOffset());
 
            w.writeBoolean("Dthr", gradientOverlay->dither());
 
            w.leaveDescriptor();
        }
 
        // Pattern Overlay
        const psd_layer_effects_pattern_overlay *patternOverlay = style->patternOverlay();
        if (patternOverlay->effectEnabled()) {
            w.enterDescriptor("patternFill", "", "patternFill");
 
            w.writeBoolean("enab", patternOverlay->effectEnabled());
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(patternOverlay->blendMode()));
            w.writeUnitFloat("Opct", "#Prc", patternOverlay->opacity());
 
            KoPatternSP pattern = patternOverlay->pattern(style->resourcesInterface());
            w.writePatternRef("Ptrn", pattern, fetchPatternUuidSafe(pattern, patternToUuidMap));
 
            w.writeUnitFloat("Scl ", "#Prc", patternOverlay->scale());
            w.writeBoolean("Algn", patternOverlay->alignWithLayer());
            w.writePhasePoint("phase", patternOverlay->patternPhase());
 
            w.leaveDescriptor();
        }
 
        const psd_layer_effects_stroke *stroke = style->stroke();
        if (stroke->effectEnabled()) {
            w.enterDescriptor("FrFX", "", "FrFX");
 
            w.writeBoolean("enab", stroke->effectEnabled());
 
            w.writeEnum("Styl", "FStl", strokePositionToString(stroke->position()));
            w.writeEnum("PntT", "FrFl", strokeFillTypeToString(stroke->fillType()));
 
            w.writeEnum("Md  ", "BlnM", compositeOpToBlendMode(stroke->blendMode()));
            w.writeUnitFloat("Opct", "#Prc", stroke->opacity());
 
            w.writeUnitFloat("Sz  ", "#Pxl", stroke->size());
 
            if (stroke->fillType() == psd_fill_solid_color) {
                w.writeColor("Clr ", stroke->color());
            }
            else if (stroke->fillType() == psd_fill_gradient) {
                KoSegmentGradient *segmentGradient = dynamic_cast<KoSegmentGradient*>(stroke->gradient(style->resourcesInterface()).data());
                KoStopGradient *stopGradient = dynamic_cast<KoStopGradient*>(stroke->gradient(style->resourcesInterface()).data());
 
                if (segmentGradient && segmentGradient->valid()) {
                    w.writeSegmentGradient("Grad", *segmentGradient);
                } else if (stopGradient && stopGradient->valid()) {
                    w.writeStopGradient("Grad", *stopGradient);
                } else {
                    warnKrita << "WARNING: Stroke: Unknown gradient type!";
                    w.writeColor("Clr ", stroke->color());
                }
 
                w.writeUnitFloat("Angl", "#Ang", stroke->angle());
                w.writeEnum("Type", "GrdT", gradientTypeToString(stroke->style()));
 
                w.writeBoolean("Rvrs", stroke->reverse());
                w.writeUnitFloat("Scl ", "#Prc", stroke->scale());
                w.writeBoolean("Algn", stroke->alignWithLayer());
                w.writeOffsetPoint("Ofst", stroke->gradientOffset());
 
                w.writeBoolean("Dthr", stroke->dither());
 
            } else if (stroke->fillType() == psd_fill_pattern) {
 
                KoPatternSP pattern = stroke->pattern(style->resourcesInterface());
                w.writePatternRef("Ptrn", pattern, fetchPatternUuidSafe(pattern, patternToUuidMap));
                w.writeUnitFloat("Scl ", "#Prc", stroke->scale());
                w.writeBoolean("Lnkd", stroke->alignWithLayer());
                w.writePhasePoint("phase", stroke->patternPhase());
            }
 
            w.leaveDescriptor();
        }
 
        w.leaveDescriptor();
        w.leaveDescriptor();
    }
 
    return w.document();
}

◆ gradients()

QVector< KoAbstractGradientSP > KisAslLayerStyleSerializer::gradients ( ) const

Definition at line 73 of file kis_asl_layer_style_serializer.cpp.

{
    return m_gradientsStore;
}

References m_gradientsStore.

◆ isInitialized()

bool KisAslLayerStyleSerializer::isInitialized ( )

inline

Definition at line 48 of file kis_asl_layer_style_serializer.h.

                         {
        return m_initialized;
    }

◆ isValid()

bool KisAslLayerStyleSerializer::isValid ( )

inline

Definition at line 52 of file kis_asl_layer_style_serializer.h.

                   {
        return isInitialized() && m_isValid;
    }

◆ newStyleStarted()

void KisAslLayerStyleSerializer::newStyleStarted ( bool isPsdStructure )

private

Definition at line 1252 of file kis_asl_layer_style_serializer.cpp.

{
    m_stylesVector.append(toQShared(new KisPSDLayerStyle("", m_localResourcesInterface)));
    KisPSDLayerStyleSP currentStyleSP = m_stylesVector.last();
    KisPSDLayerStyle *currentStyle = currentStyleSP.data();
 
    psd_layer_effects_context *context = currentStyleSP->context();
    context->keep_original = 0;
 
    QString prefix = isPsdStructure ? "/null" : "/Styl/Lefx";
    connectCatcherToStyle(currentStyle, prefix);
}

References connectCatcherToStyle(), psd_layer_effects_context::keep_original, m_localResourcesInterface, m_stylesVector, and toQShared().

◆ patterns()

QHash< QString, KoPatternSP > KisAslLayerStyleSerializer::patterns ( ) const

Definition at line 68 of file kis_asl_layer_style_serializer.cpp.

{
    return m_patternsStore;
}

References m_patternsStore.

◆ readFromDevice()

void KisAslLayerStyleSerializer::readFromDevice ( QIODevice & device )

Definition at line 1363 of file kis_asl_layer_style_serializer.cpp.

{
    m_catcher.subscribePattern("/patterns/KisPattern", std::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1, _2));
    m_catcher.subscribePattern("/Patterns/KisPattern", std::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1, _2));
    m_catcher.subscribeNewStyleStarted(std::bind(&KisAslLayerStyleSerializer::newStyleStarted, this, false));
 
    KisAslReader reader;
    const QDomDocument doc = reader.readFile(device);
 
    if (doc.isNull()) {
        m_initialized = false;
        return;
    }
 
    //dbgKrita << ppVar(doc.toString());
 
    //KisAslObjectCatcher c2;
    KisAslXmlParser parser;
    parser.parseXML(doc, m_catcher);
 
    QMultiHash<QString, KisPSDLayerStyleSP> allStyles;
    QHash<QString, KisPSDLayerStyleSP> cleanedStyles;
 
    for(const auto &style : m_stylesVector)
        allStyles.insert(style->psdUuid(), style);
 
    // correct all the layer styles
    for (const auto &style : allStyles) {
        FillStylesCorrector::correct(style.data());
 
        if (allStyles.count(style->psdUuid()) > 1) {
            const auto &existingStyle = cleanedStyles.find(style->psdUuid());
 
            if (existingStyle != cleanedStyles.end()) {
                if (existingStyle.value()->name() != style->name()) {
                    qWarning() << "Duplicated UUID" << style->psdUuid() << "for styles" << style->name() << "and"
                               << existingStyle.value()->name();
                    style->setMD5Sum("");
                    style->setUuid(QUuid::createUuid());
                } else {
                    qWarning() << "Duplicated style" << style->name();
                    continue;
                }
            }
        }
 
        style->setValid(!style->isEmpty());
 
        style->setFilename(style->uuid().toString());
 
        cleanedStyles.insert(style->psdUuid(), style);
    }
 
    m_stylesVector = cleanedStyles.values().toVector();
 
    m_initialized = true;
}

References FillStylesCorrector::correct(), m_catcher, m_initialized, m_stylesVector, newStyleStarted(), KisAslXmlParser::parseXML(), KisAslReader::readFile(), registerPatternObject(), KisAslCallbackObjectCatcher::subscribeNewStyleStarted(), and KisAslCallbackObjectCatcher::subscribePattern().

◆ readFromFile()

bool KisAslLayerStyleSerializer::readFromFile ( const QString & filename )

Definition at line 1265 of file kis_asl_layer_style_serializer.cpp.

{
    QFile file(filename);
    if (file.size() == 0) return false;
 
    if (!file.open(QIODevice::ReadOnly)) {
        dbgKrita << "Can't open file " << filename;
        return false;
    }
 
    readFromDevice(file);
    file.close();
 
    return m_initialized;
}

References dbgKrita, m_initialized, and readFromDevice().

◆ readFromPSDXML()

void KisAslLayerStyleSerializer::readFromPSDXML ( const QDomDocument & doc )

Definition at line 1432 of file kis_asl_layer_style_serializer.cpp.

{
    // The caller prepares the document using the following code
    //
    // KisAslReader reader;
    // QDomDocument doc = reader.readLfx2PsdSection(device);
 
    m_stylesVector.clear();
 
    //m_catcher.subscribePattern("/Patterns/KisPattern", std::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1));
    m_catcher.subscribeNewStyleStarted(std::bind(&KisAslLayerStyleSerializer::newStyleStarted, this, true));
 
    //KisAslObjectCatcher c2;
    KisAslXmlParser parser;
    parser.parseXML(doc, m_catcher);
 
    // correct all the layer styles
    Q_FOREACH (KisPSDLayerStyleSP style, m_stylesVector) {
        FillStylesCorrector::correct(style.data());
    }
}

References FillStylesCorrector::correct(), m_catcher, m_stylesVector, newStyleStarted(), KisAslXmlParser::parseXML(), and KisAslCallbackObjectCatcher::subscribeNewStyleStarted().

◆ registerPatternObject()

void KisAslLayerStyleSerializer::registerPatternObject	(	const KoPatternSP	pattern,
		const QString &	patternUuid )

private

Definition at line 931 of file kis_asl_layer_style_serializer.cpp.

                                                                                                            {
 
    if (!pattern) {
        warnKrita << "WARNING: got an empty pattern:" << patternUuid;
        return;
    }
 
    if (m_patternsStore.contains(patternUuid)) {
        warnKrita << "WARNING: ASL style contains a duplicated pattern!" << ppVar(pattern->name()) << ppVar(m_patternsStore[patternUuid]->name());
    } else {
        pattern->setFilename(patternUuid + QString(".pat"));
        m_patternsStore.insert(patternUuid, pattern);
        m_localResourcesInterface->addResource(pattern);
    }
}

References m_localResourcesInterface, m_patternsStore, ppVar, and warnKrita.

◆ registerPSDPattern()

void KisAslLayerStyleSerializer::registerPSDPattern ( const QDomDocument & doc )

Definition at line 1421 of file kis_asl_layer_style_serializer.cpp.

{
    KisAslCallbackObjectCatcher catcher;
    catcher.subscribePattern("/Patterns/KisPattern", std::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1, _2));
    catcher.subscribePattern("/patterns/KisPattern", std::bind(&KisAslLayerStyleSerializer::registerPatternObject, this, _1, _2));
 
    //KisAslObjectCatcher c2;
    KisAslXmlParser parser;
    parser.parseXML(doc, catcher);
}

References KisAslXmlParser::parseXML(), registerPatternObject(), and KisAslCallbackObjectCatcher::subscribePattern().

◆ saveToDevice()

void KisAslLayerStyleSerializer::saveToDevice ( QIODevice & device )

Definition at line 787 of file kis_asl_layer_style_serializer.cpp.

{
    QDomDocument doc = formXmlDocument();
    KIS_ASSERT(!doc.isNull());
 
    KisAslWriter writer;
    writer.writeFile(device, doc);
}

References formXmlDocument(), KIS_ASSERT, and KisAslWriter::writeFile().

◆ saveToFile()

bool KisAslLayerStyleSerializer::saveToFile ( const QString & filename )

Definition at line 796 of file kis_asl_layer_style_serializer.cpp.

{
    QFile file(filename);
 
    if (!file.open(QIODevice::WriteOnly)) {
        dbgKrita << "Can't open file " << filename;
        return false;
    }
    saveToDevice(file);
    file.close();
 
    return true;
}

References dbgKrita, and saveToDevice().

◆ setStyles()

void KisAslLayerStyleSerializer::setStyles ( const QVector< KisPSDLayerStyleSP > & styles )

Definition at line 59 of file kis_asl_layer_style_serializer.cpp.

{
    m_stylesVector = styles;
    Q_FOREACH(const KisPSDLayerStyleSP style, styles) {
        m_stylesHash.insert(style->psdUuid(), style);
    }
    m_initialized = true;
}

References m_initialized, m_stylesHash, m_stylesVector, and styles().

◆ sideLoadLinkedResources()

void KisAslLayerStyleSerializer::sideLoadLinkedResources	(	KisPSDLayerStyle *	style,
		KisResourcesInterfaceSP	resourcesInterface )

static

Definition at line 1301 of file kis_asl_layer_style_serializer.cpp.

{
    const QList<KoResourceLoadResult> linkedResources = style->linkedResources(resourcesInterface);
    QList<KoEmbeddedResource> sideLoadedResourcesStorage;
    Q_FOREACH (const KoResourceLoadResult &res, linkedResources) {
        if (res.type() != KoResourceLoadResult::ExistingResource) {
            qWarning() << "WARNING: failed to load layer style's embedded resource into the database"
                       << res.signature();
            continue;
        }
 
        QBuffer buffer;
        buffer.open(QIODevice::WriteOnly);
        bool result = res.resource()->saveToDevice(&buffer);
        buffer.close();
        KIS_SAFE_ASSERT_RECOVER(result) { continue; }
        KIS_SAFE_ASSERT_RECOVER(res.resource()->md5Sum() == KoMD5Generator::generateHash(buffer.data())) { continue; }
 
        sideLoadedResourcesStorage.append(KoEmbeddedResource(res.signature(), buffer.data()));
    }
    style->setSideLoadedResources(sideLoadedResourcesStorage);
}

References KoResourceLoadResult::ExistingResource, KoMD5Generator::generateHash(), KIS_SAFE_ASSERT_RECOVER, KisPSDLayerStyle::linkedResources(), KoResourceLoadResult::resource(), KisPSDLayerStyle::setSideLoadedResources(), KoResourceLoadResult::signature(), and KoResourceLoadResult::type().

◆ styles()

QVector< KisPSDLayerStyleSP > KisAslLayerStyleSerializer::styles ( ) const

Definition at line 54 of file kis_asl_layer_style_serializer.cpp.

{
    return m_stylesVector;
}

References m_stylesVector.

◆ stylesHash()

QHash< QString, KisPSDLayerStyleSP > KisAslLayerStyleSerializer::stylesHash ( )

Definition at line 78 of file kis_asl_layer_style_serializer.cpp.

{
    if (m_stylesHash.count() == 0 && m_stylesVector.count() != 0) {
        // build the hash
        Q_FOREACH(KisPSDLayerStyleSP style, m_stylesVector) {
            m_stylesHash.insert(style->psdUuid(), style);
        }
    }
    return m_stylesHash;
}

References m_stylesHash, and m_stylesVector.

Member Data Documentation

◆ m_catcher

KisAslCallbackObjectCatcher KisAslLayerStyleSerializer::m_catcher

private

Definition at line 74 of file kis_asl_layer_style_serializer.h.

◆ m_gradientsStore

QVector<KoAbstractGradientSP> KisAslLayerStyleSerializer::m_gradientsStore

private

Definition at line 76 of file kis_asl_layer_style_serializer.h.

◆ m_initialized

bool KisAslLayerStyleSerializer::m_initialized {false}

private

Definition at line 78 of file kis_asl_layer_style_serializer.h.

78{false};

◆ m_isValid

bool KisAslLayerStyleSerializer::m_isValid {true}

private

Definition at line 79 of file kis_asl_layer_style_serializer.h.

79{true};

◆ m_localResourcesInterface

QSharedPointer<KisLocalStrokeResources> KisAslLayerStyleSerializer::m_localResourcesInterface

private

Definition at line 80 of file kis_asl_layer_style_serializer.h.

◆ m_patternsStore

QHash<QString, KoPatternSP> KisAslLayerStyleSerializer::m_patternsStore

private

Definition at line 72 of file kis_asl_layer_style_serializer.h.

◆ m_stylesHash

QHash<QString, KisPSDLayerStyleSP> KisAslLayerStyleSerializer::m_stylesHash

private

Definition at line 77 of file kis_asl_layer_style_serializer.h.

◆ m_stylesVector

QVector<KisPSDLayerStyleSP> KisAslLayerStyleSerializer::m_stylesVector

private

Definition at line 75 of file kis_asl_layer_style_serializer.h.

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

libs/image/kis_asl_layer_style_serializer.h
libs/image/kis_asl_layer_style_serializer.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisAslLayerStyleSerializer()

◆ ~KisAslLayerStyleSerializer()

Member Function Documentation

◆ assignAllLayerStylesToLayers()

◆ assignGradientObject()

◆ assignPatternObject()

◆ collectAllLayerStyles()

◆ connectCatcherToStyle()

◆ fetchAllPatternLinks()

◆ fetchAllPatterns()

◆ fetchLinkedResourceSignatures()

◆ formPsdXmlDocument()

◆ formXmlDocument()

◆ gradients()

◆ isInitialized()

◆ isValid()

◆ newStyleStarted()

◆ patterns()

◆ readFromDevice()

◆ readFromFile()

◆ readFromPSDXML()

◆ registerPatternObject()

◆ registerPSDPattern()

◆ saveToDevice()

◆ saveToFile()

◆ setStyles()

◆ sideLoadLinkedResources()

◆ styles()

◆ stylesHash()

Member Data Documentation

◆ m_catcher

◆ m_gradientsStore

◆ m_initialized

◆ m_isValid

◆ m_localResourcesInterface

◆ m_patternsStore

◆ m_stylesHash

◆ m_stylesVector