KisLayerUtils::RemoveNodeHelper Class Reference

#include <kis_layer_utils.h>

Inheritance diagram for KisLayerUtils::RemoveNodeHelper:

Classes
struct	ReplacementNode

Public Member Functions
virtual	~RemoveNodeHelper ()

Protected Member Functions
virtual void	addCommandImpl (KUndo2Command *cmd)=0
void	safeRemoveMultipleNodes (KisNodeList nodes, KisImageSP image)
void	safeReplaceMultipleNodes (KisNodeList removedNodes, KisImageSP image, std::optional< ReplacementNode > replacementNode)

Private Member Functions
bool	checkIsSourceForClone (KisNodeSP src, const KisNodeList &nodes)

Static Private Member Functions
static bool	scanForLastLayer (KisImageWSP image, KisNodeList nodesToRemove)

Detailed Description

Definition at line 162 of file kis_layer_utils.h.

Constructor & Destructor Documentation

~RemoveNodeHelper()

KisLayerUtils::RemoveNodeHelper::~RemoveNodeHelper ( )

virtual

Definition at line 920 of file kis_layer_utils.cpp.

    {
    }

Member Function Documentation

addCommandImpl()

virtual void KisLayerUtils::RemoveNodeHelper::addCommandImpl ( KUndo2Command * cmd )

protectedpure virtual

Implemented in KisLayerUtils::CleanUpNodes, KisLayerUtils::SimpleRemoveLayers, and RemoveLayers.

checkIsSourceForClone()

bool KisLayerUtils::RemoveNodeHelper::checkIsSourceForClone ( KisNodeSP src, const KisNodeList & nodes )

private

Definition at line 1025 of file kis_layer_utils.cpp.

                                                                                        {
        foreach (KisNodeSP node, nodes) {
            if (node == src) continue;
 
            KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
 
            if (clone && KisNodeSP(clone->copyFrom()) == src) {
                return true;
            }
        }
 
        return false;
    }

References KisCloneLayer::copyFrom, and KisSharedPtr< T >::data().

safeRemoveMultipleNodes()

void KisLayerUtils::RemoveNodeHelper::safeRemoveMultipleNodes ( KisNodeList nodes, KisImageSP image )

protected

The removal of two nodes in one go may be a bit tricky, because one of them may be the clone of another. If we remove the source of a clone layer, it will reincarnate into a paint layer. In this case the pointer to the second layer will be lost.

That's why we need to care about the order of the nodes removal: the clone — first, the source — last.

Definition at line 933 of file kis_layer_utils.cpp.

                                                                                      {
        safeReplaceMultipleNodes(nodes, image, std::nullopt);
    }

References safeReplaceMultipleNodes().

safeReplaceMultipleNodes()

void KisLayerUtils::RemoveNodeHelper::safeReplaceMultipleNodes ( KisNodeList removedNodes, KisImageSP image, std::optional< ReplacementNode > replacementNode )

protected

Definition at line 937 of file kis_layer_utils.cpp.

                                                                                                  {
 
        const bool lastLayer = !replacementNode && scanForLastLayer(image, removedNodes);
 
        auto isNodeWeird = [] (KisNodeSP node) {
            const bool normalCompositeMode = node->compositeOpId() == COMPOSITE_OVER;
 
            KisLayer *layer = dynamic_cast<KisLayer*>(node.data());
            const bool hasInheritAlpha = layer && layer->alphaChannelDisabled();
            return !normalCompositeMode && !hasInheritAlpha;
        };
 
 
        using Recipe = KisBatchUpdateLayerModificationCommand::Recipe;
        using RecipeSP = KisBatchUpdateLayerModificationCommand::RecipeSP;
        RecipeSP updateRecipe(new Recipe());
 
        if (replacementNode) {
            updateRecipe->nodesToAdd.push_back({replacementNode->node,
                                                replacementNode->doRedoUpdates,
                                                replacementNode->doUndoUpdates});
        }
 
        Q_FOREACH (KisNodeSP node, removedNodes) {
            updateRecipe->nodesToRemove.push_back({node, !isNodeWeird(node), true});
        }
 
        addCommandImpl(new KisBatchUpdateLayerModificationCommand(image, updateRecipe, KisBatchUpdateLayerModificationCommand::INITIALIZING));
 
        if (replacementNode) {
            addCommandImpl(new KisImageLayerAddCommand(image,
                                                       replacementNode->node,
                                                       replacementNode->parent,
                                                       replacementNode->putAfter,
                                                       false, false));
 
            Q_FOREACH (KisSelectionMaskSP mask, replacementNode->selectionMasks) {
                addCommandImpl(new KisImageLayerMoveCommand(image, mask, replacementNode->node, replacementNode->node->lastChild(), false));
                addCommandImpl(new KisActivateSelectionMaskCommand(mask, false));
            }
 
            // relink all the clone layers onto the new replacement node
            if (replacementNode->relinkClones) {
                QList<KisCloneLayerWSP> clones;
 
                Q_FOREACH (KisNodeSP node, removedNodes) {
                    KisLayerSP originalSource = dynamic_cast<KisLayer*>(node.data());
                    if (originalSource) {
                        clones.append(originalSource->registeredClones());
                    }
                }
 
                KisLayerSP finalSource = dynamic_cast<KisLayer*>(replacementNode->node.data());
 
                if (finalSource && !clones.isEmpty()) {
                    addCommandImpl(new KisChangeCloneLayersCommand(implicitCastList<KisCloneLayerSP>(clones), finalSource));
                }
            }
        }
 
        while (!removedNodes.isEmpty()) {
            KisNodeList::iterator it = removedNodes.begin();
 
            while (it != removedNodes.end()) {
                if (!checkIsSourceForClone(*it, removedNodes)) {
                    KisNodeSP node = *it;
 
                    addCommandImpl(new KisImageLayerRemoveCommand(image, node, false, false));
                    it = removedNodes.erase(it);
                } else {
                    ++it;
                }
            }
        }
 
        addCommandImpl(new KisBatchUpdateLayerModificationCommand(image, updateRecipe, KisBatchUpdateLayerModificationCommand::FINALIZING));
 
        // Hint: we shouldn't include that into the batch update since this layer doesn't trigger any updates
        if (lastLayer) {
            KisLayerSP newLayer = new KisPaintLayer(image.data(), image->nextLayerName(), OPACITY_OPAQUE_U8, image->colorSpace());
            addCommandImpl(new KisImageLayerAddCommand(image, newLayer,
                                                       image->root(),
                                                       KisNodeSP(),
                                                       false, false));
        }
    }

References addCommandImpl(), KisLayer::alphaChannelDisabled(), checkIsSourceForClone(), KisImage::colorSpace(), COMPOSITE_OVER, KisSharedPtr< T >::data(), KisCommandUtils::FlipFlopCommand::FINALIZING, KisCommandUtils::FlipFlopCommand::INITIALIZING, KisNode::lastChild(), KisImage::nextLayerName(), OPACITY_OPAQUE_U8, KisLayer::registeredClones(), KisNodeFacade::root, and scanForLastLayer().

scanForLastLayer()

bool KisLayerUtils::RemoveNodeHelper::scanForLastLayer ( KisImageWSP image, KisNodeList nodesToRemove )

staticprivate

Definition at line 1039 of file kis_layer_utils.cpp.

                                                                                        {
        bool removeLayers = false;
        Q_FOREACH(KisNodeSP nodeToRemove, nodesToRemove) {
            if (qobject_cast<KisLayer*>(nodeToRemove.data())) {
                removeLayers = true;
                break;
            }
        }
        if (!removeLayers) return false;
 
        bool lastLayer = true;
        KisNodeSP node = image->root()->firstChild();
        while (node) {
            if (!nodesToRemove.contains(node) &&
                qobject_cast<KisLayer*>(node.data()) &&
                !node->isFakeNode()) {
 
                lastLayer = false;
                break;
            }
            node = node->nextSibling();
        }
 
        return lastLayer;
    }

References KisSharedPtr< T >::data(), KisNode::firstChild(), KisBaseNode::isFakeNode(), KisNode::nextSibling(), and KisNodeFacade::root.

---

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

• libs/image/kis_layer_utils.h
• libs/image/kis_layer_utils.cpp