#include "psd_layer_section.h"
#include <QBuffer>
#include <QIODevice>
#include <KoColor.h>
#include <KoColorSpace.h>
#include <kis_debug.h>
#include <kis_effect_mask.h>
#include <kis_group_layer.h>
#include <kis_generator_layer.h>
#include <kis_image.h>
#include <kis_node.h>
#include <kis_paint_layer.h>
#include <kis_painter.h>
#include <kis_selection.h>
#include <kis_shape_selection.h>
#include <kis_transparency_mask.h>
#include <kis_shape_layer.h>
#include <KoSvgTextShape.h>
#include <KoShapeBackground.h>
#include <KoColorBackground.h>
#include <KoPatternBackground.h>
#include <KoGradientBackground.h>
#include <KoShapeStroke.h>
#include <KoPathShape.h>
#include <KoShapeGroup.h>
#include <KoShapeManager.h>
#include <KoSvgTextShapeMarkupConverter.h>
#include "kis_dom_utils.h"
#include "psd.h"
#include "psd_header.h"
#include "psd_utils.h"
#include "compression.h"
#include <asl/kis_asl_reader_utils.h>
#include <asl/kis_asl_writer_utils.h>
#include <asl/kis_offset_on_exit_verifier.h>
#include <kis_asl_layer_style_serializer.h>
#include <cos/kis_txt2_utls.h>
#include <cos/psd_text_data_converter.h>

Classes
struct	FlattenedNode

Functions
void	addBackgroundIfNeeded (KisNodeSP root, QList< FlattenedNode > &nodes)

QDomDocument	fetchLayerStyleXmlData (KisNodeSP node)

QDomNode	findNodeByKey (const QString &key, QDomNode parent)

KisNodeSP	findOnlyTransparencyMask (KisNodeSP node, FlattenedNode::Type type)

void	flattenNodes (KisNodeSP node, QList< FlattenedNode > &nodes)

void	flattenShapes (const KisShapeLayer parentShapeLayer, QList< KoShape > shapes, QList< FlattenedNode > &nodes)

void	mergePatternsXMLSection (const QDomDocument &src, QDomDocument &dst)

Function Documentation

◆ addBackgroundIfNeeded()

void addBackgroundIfNeeded	(	KisNodeSP	root,
		QList< FlattenedNode > &	nodes )

Definition at line 420 of file psd_layer_section.cpp.

{
    KisGroupLayer *group = dynamic_cast<KisGroupLayer *>(root.data());
    if (!group)
        return;
 
    KoColor projectionColor = group->defaultProjectionColor();
    if (projectionColor.opacityU8() == OPACITY_TRANSPARENT_U8)
        return;
 
    KisPaintLayerSP layer = new KisPaintLayer(group->image(), i18nc("Automatically created layer name when saving into PSD", "Background"), OPACITY_OPAQUE_U8);
 
    layer->paintDevice()->setDefaultPixel(projectionColor);
 
    {
        FlattenedNode item;
        item.node = layer;
        item.type = FlattenedNode::RASTER_LAYER;
        nodes << item;
    }
}

References KisSharedPtr< T >::data(), KisGroupLayer::defaultProjectionColor(), KisBaseNode::image, FlattenedNode::node, OPACITY_OPAQUE_U8, OPACITY_TRANSPARENT_U8, KoColor::opacityU8(), KisPaintLayer::paintDevice, FlattenedNode::RASTER_LAYER, KisPaintDevice::setDefaultPixel(), and FlattenedNode::type.

◆ fetchLayerStyleXmlData()

QDomDocument fetchLayerStyleXmlData ( KisNodeSP node )

Definition at line 565 of file psd_layer_section.cpp.

{
    const KisLayer *layer = qobject_cast<KisLayer *>(node.data());
    KisPSDLayerStyleSP layerStyle = layer->layerStyle();
 
    if (!layerStyle)
        return QDomDocument();
 
    KisAslLayerStyleSerializer serializer;
    serializer.setStyles(QVector<KisPSDLayerStyleSP>() << layerStyle);
    return serializer.formPsdXmlDocument();
}

References KisSharedPtr< T >::data(), KisAslLayerStyleSerializer::formPsdXmlDocument(), KisLayer::layerStyle, and KisAslLayerStyleSerializer::setStyles().

◆ findNodeByKey()

QDomNode findNodeByKey	(	const QString &	key,
		QDomNode	parent )

inline

Definition at line 578 of file psd_layer_section.cpp.

{
    return KisDomUtils::findElementByAttribute(parent, "node", "key", key);
}

References KisDomUtils::findElementByAttribute().

◆ findOnlyTransparencyMask()

KisNodeSP findOnlyTransparencyMask	(	KisNodeSP	node,
		FlattenedNode::Type	type )

Definition at line 549 of file psd_layer_section.cpp.

{
    if (type != FlattenedNode::FOLDER_OPEN && type != FlattenedNode::FOLDER_CLOSED && type != FlattenedNode::RASTER_LAYER) {
        return 0;
    }
 
    KisLayer *layer = qobject_cast<KisLayer *>(node.data());
    QList<KisEffectMaskSP> masks = layer->effectMasks();
 
    if (masks.size() != 1)
        return 0;
 
    KisEffectMaskSP onlyMask = masks.first();
    return onlyMask->inherits("KisTransparencyMask") ? onlyMask : 0;
}

References KisSharedPtr< T >::data(), KisLayer::effectMasks(), FlattenedNode::FOLDER_CLOSED, FlattenedNode::FOLDER_OPEN, and FlattenedNode::RASTER_LAYER.

◆ flattenNodes()

void flattenNodes	(	KisNodeSP	node,
		QList< FlattenedNode > &	nodes )

Definition at line 489 of file psd_layer_section.cpp.

{
    KisNodeSP child = node->firstChild();
    while (child) {
        const bool isLayer = child->inherits("KisLayer");
        const bool isGroupLayer = child->inherits("KisGroupLayer");
        const KisShapeLayer *shapeLayer = qobject_cast<KisShapeLayer*>(child.data());
 
        if (isGroupLayer) {
            {
                FlattenedNode item;
                item.node = child;
                item.type = FlattenedNode::SECTION_DIVIDER;
                nodes << item;
            }
 
            flattenNodes(child, nodes);
 
            {
                FlattenedNode item;
                item.node = child;
                if (child->collapsed()) {
                    item.type = FlattenedNode::FOLDER_CLOSED;
                } else {
                    item.type = FlattenedNode::FOLDER_OPEN;
                }
                nodes << item;
            }
        } else if (shapeLayer) {
            if (shapeLayer->shapes().size() > 1) {
                {
                    FlattenedNode item;
                    item.node = child;
                    item.type = FlattenedNode::SECTION_DIVIDER;
                    nodes << item;
                }
                flattenShapes(shapeLayer, shapeLayer->shapes(), nodes);
                {
                    FlattenedNode item;
                    item.node = child;
                    item.type = FlattenedNode::FOLDER_CLOSED;
                    nodes << item;
                }
            } else {
                FlattenedNode item;
                item.node = child;
                item.type = FlattenedNode::RASTER_LAYER;
                nodes << item;
            }
        } else if (isLayer) {
            FlattenedNode item;
            item.node = child;
            item.type = FlattenedNode::RASTER_LAYER;
            nodes << item;
        }
 
        child = child->nextSibling();
    }
}

References KisBaseNode::collapsed, KisSharedPtr< T >::data(), KisNode::firstChild(), flattenNodes(), flattenShapes(), FlattenedNode::FOLDER_CLOSED, FlattenedNode::FOLDER_OPEN, isLayer(), KisNode::nextSibling(), FlattenedNode::node, FlattenedNode::RASTER_LAYER, FlattenedNode::SECTION_DIVIDER, KoShapeContainer::shapes(), and FlattenedNode::type.

◆ flattenShapes()

void flattenShapes	(	const KisShapeLayer *	parentShapeLayer,
		QList< KoShape * >	shapes,
		QList< FlattenedNode > &	nodes )

Definition at line 442 of file psd_layer_section.cpp.

                                                                                                               {
    Q_FOREACH (KoShape *shape, shapes) {
        const QString name = shape->name().isEmpty()? "shape "+QString::number(nodes.size()): shape->name();
        KoShapeGroup *group = dynamic_cast<KoShapeGroup*>(shape);
        if (group) {
            KisGroupLayerSP newGroup(new KisGroupLayer(parentShapeLayer->image(),
                                                       name,
                                                       (1.0-shape->transparency(false))*255,
                                                       parentShapeLayer->colorSpace()));
            newGroup->setVisible(shape->isVisible(false));
            newGroup->setOpacity(shape->transparency(false)*255);
            {
                FlattenedNode item;
                item.node = newGroup;
                item.type = FlattenedNode::SECTION_DIVIDER;
                nodes << item;
            }
            flattenShapes(parentShapeLayer, group->shapes(), nodes);
            {
                FlattenedNode item;
                item.node = newGroup;
                item.type = FlattenedNode::FOLDER_CLOSED;
                nodes << item;
            }
        } else {
            KisShapeLayerSP newLayer(new KisShapeLayer(nullptr,
                                                       parentShapeLayer->image(),
                                                       name,
                                                       (1.0-shape->transparency(false))*255));
            KoShape *newShape = shape->cloneShape();
            newShape->setTransparency(0.0);
            newShape->setTransformation(shape->absoluteTransformation());
            newLayer->setVisible(newShape->isVisible(false));
            newShape->setVisible(true);
            newLayer->shapeManager()->addShape(newShape, KoShapeManager::AddWithoutRepaint);
            newLayer->addShape(newShape);
 
            {
                FlattenedNode item;
                item.node = newLayer;
                item.type = FlattenedNode::RASTER_LAYER;
                nodes << item;
            }
        }
    }
}

References KoShape::absoluteTransformation(), KoShapeContainer::addShape(), KoShapeManager::addShape(), KoShapeManager::AddWithoutRepaint, KoShape::cloneShape(), KisLayer::colorSpace(), flattenShapes(), FlattenedNode::FOLDER_CLOSED, KisBaseNode::image, KoShape::isVisible(), KoShape::name(), FlattenedNode::node, FlattenedNode::RASTER_LAYER, FlattenedNode::SECTION_DIVIDER, KisBaseNode::setOpacity(), KoShape::setTransformation(), KoShape::setTransparency(), KoShape::setVisible(), KisShapeLayer::setVisible(), KisBaseNode::setVisible(), KisShapeLayer::shapeManager(), KoShapeContainer::shapes(), KoShape::transparency(), and FlattenedNode::type.

◆ mergePatternsXMLSection()

void mergePatternsXMLSection	(	const QDomDocument &	src,
		QDomDocument &	dst )

Definition at line 583 of file psd_layer_section.cpp.

{
    QDomNode srcPatternsNode = findNodeByKey(ResourceType::Patterns, src.documentElement());
    QDomNode dstPatternsNode = findNodeByKey(ResourceType::Patterns, dst.documentElement());
 
    if (srcPatternsNode.isNull())
        return;
    if (dstPatternsNode.isNull()) {
        dst = src;
        return;
    }
 
    KIS_ASSERT_RECOVER_RETURN(!srcPatternsNode.isNull());
    KIS_ASSERT_RECOVER_RETURN(!dstPatternsNode.isNull());
 
    QDomNode node = srcPatternsNode.firstChild();
    while (!node.isNull()) {
        QDomNode importedNode = dst.importNode(node, true);
        KIS_ASSERT_RECOVER_RETURN(!importedNode.isNull());
 
        dstPatternsNode.appendChild(importedNode);
        node = node.nextSibling();
    }
}

References findNodeByKey(), KIS_ASSERT_RECOVER_RETURN, and ResourceType::Patterns.

Classes

Functions