KisLayerUtils::CleanUpNodes Struct Reference

Inheritance diagram for KisLayerUtils::CleanUpNodes:

Public Member Functions
	CleanUpNodes (MergeDownInfoBaseSP info, KisNodeSP putAfter, bool relinkClones=false)
void	populateChildCommands () override
Public Member Functions inherited from KisCommandUtils::AggregateCommand
	AggregateCommand (const KUndo2MagicString &text, KUndo2Command *parent=0)
	AggregateCommand (KUndo2Command *parent=0)
void	redo () override
void	undo () override
Public Member Functions inherited from KUndo2Command
QString	actionText () const
virtual bool	canAnnihilateWith (const KUndo2Command *other) const
const KUndo2Command *	child (int index) const
int	childCount () const
virtual QTime	endTime () const
KUndo2CommandExtraData *	extraData () const
bool	hasParent () const
virtual int	id () const
virtual bool	isMerged () const
	KUndo2Command (const KUndo2MagicString &text, KUndo2Command *parent=0)
	KUndo2Command (KUndo2Command *parent=0)
virtual QVector< KUndo2Command * >	mergeCommandsVector () const
virtual bool	mergeWith (const KUndo2Command *other)
virtual void	redoMergedCommands ()
void	setEndTime ()
virtual void	setEndTime (const QTime &time)
void	setExtraData (KUndo2CommandExtraData *data)
void	setText (const KUndo2MagicString &text)
void	setTime ()
virtual void	setTime (const QTime &time)
virtual void	setTimedID (int timedID)
KUndo2MagicString	text () const
virtual QTime	time () const
virtual int	timedId () const
virtual bool	timedMergeWith (KUndo2Command *other)
virtual void	undoMergedCommands ()
virtual	~KUndo2Command ()

Static Public Member Functions
static void	findPerfectParent (KisNodeList nodesToDelete, KisNodeSP &putAfter, KisNodeSP &parent)

Private Member Functions
void	addCommandImpl (KUndo2Command *cmd) override
Private Member Functions inherited from KisLayerUtils::RemoveNodeHelper
virtual	~RemoveNodeHelper ()
void	safeRemoveMultipleNodes (KisNodeList nodes, KisImageSP image)
void	safeReplaceMultipleNodes (KisNodeList removedNodes, KisImageSP image, std::optional< ReplacementNode > replacementNode)

Private Attributes
MergeDownInfoBaseSP	m_info
KisNodeSP	m_putAfter
bool	m_relinkClones {false}

Additional Inherited Members
Protected Member Functions inherited from KisCommandUtils::AggregateCommand
void	addCommand (KUndo2Command *cmd)

Detailed Description

Definition at line 1154 of file kis_layer_utils.cpp.

Constructor & Destructor Documentation

CleanUpNodes()

KisLayerUtils::CleanUpNodes::CleanUpNodes ( MergeDownInfoBaseSP info, KisNodeSP putAfter, bool relinkClones = false )

inline

Definition at line 1155 of file kis_layer_utils.cpp.

            : m_info(info), m_putAfter(putAfter), m_relinkClones(relinkClones) {}

Member Function Documentation

addCommandImpl()

void KisLayerUtils::CleanUpNodes::addCommandImpl ( KUndo2Command * cmd )

inlineoverrideprivatevirtual

Implements KisLayerUtils::RemoveNodeHelper.

Definition at line 1260 of file kis_layer_utils.cpp.

                                                         {
            addCommand(cmd);
        }

findPerfectParent()

static void KisLayerUtils::CleanUpNodes::findPerfectParent ( KisNodeList nodesToDelete, KisNodeSP & putAfter, KisNodeSP & parent )

inlinestatic

Definition at line 1158 of file kis_layer_utils.cpp.

                                                                                                         {
            if (!putAfter) {
                putAfter = nodesToDelete.last();
            }
 
            // Add the new merged node on top of the active node
            // -- checking all parents if they are included in nodesToDelete
            // Not every descendant is included in nodesToDelete even if in fact
            //   they are going to be deleted, so we need to check it.
            // If we consider the path from root to the putAfter node,
            //    if there are any nodes marked for deletion, any node afterwards
            //    is going to be deleted, too.
            //   example:      root . . . . . ! ! . . ! ! ! ! . . . . putAfter
            //   it should be: root . . . . . ! ! ! ! ! ! ! ! ! ! ! ! !putAfter
            //   and here:     root . . . . X ! ! . . ! ! ! ! . . . . putAfter
            //   you can see which node is "the perfect ancestor"
            //   (marked X; called "parent" in the function arguments).
            //   and here:     root . . . . . O ! . . ! ! ! ! . . . . putAfter
            //   you can see which node is "the topmost deleted ancestor" (marked 'O')
 
            KisNodeSP node = putAfter->parent();
            bool foundDeletedAncestor = false;
            KisNodeSP topmostAncestorToDelete = nullptr;
 
            while (node) {
 
                if (nodesToDelete.contains(node)
                        && !nodesToDelete.contains(node->parent())) {
                    foundDeletedAncestor = true;
                    topmostAncestorToDelete = node;
                    // Here node is to be deleted and its parent is not,
                    // so its parent is the one of the first not deleted (="perfect") ancestors.
                    // We need the one that is closest to the top (root)
                }
 
                node = node->parent();
            }
 
            if (foundDeletedAncestor) {
                parent = topmostAncestorToDelete->parent();
                putAfter = topmostAncestorToDelete;
            }
            else {
                parent = putAfter->parent(); // putAfter (and none of its ancestors) is to be deleted, so its parent is the first not deleted ancestor
            }
 
        }

References KisNode::parent.

populateChildCommands()

void KisLayerUtils::CleanUpNodes::populateChildCommands ( )

inlineoverridevirtual

Implements KisCommandUtils::AggregateCommand.

Definition at line 1206 of file kis_layer_utils.cpp.

                                              {
            KisNodeList nodesToDelete = m_info->allSrcNodes();
 
            KisNodeSP parent;
            findPerfectParent(nodesToDelete, m_putAfter, parent);
 
            if (!parent) {
                KisNodeSP oldRoot = m_info->image->root();
                KisNodeSP newRoot(new KisGroupLayer(m_info->image, "root", OPACITY_OPAQUE_U8));
 
                // copy all fake nodes into the new image
                KisLayerUtils::recursiveApplyNodes(oldRoot, [this, oldRoot, newRoot] (KisNodeSP node) {
                    if (node->isFakeNode() && node->parent() == oldRoot) {
                        addCommand(new KisImageLayerAddCommand(m_info->image,
                                                               node->clone(),
                                                               newRoot,
                                                               KisNodeSP(),
                                                               false, false));
 
                    }
                });
 
                addCommand(new KisImageLayerAddCommand(m_info->image,
                                                       m_info->dstNode,
                                                       newRoot,
                                                       KisNodeSP(),
                                                       true, false));
                addCommand(new KisImageChangeLayersCommand(m_info->image, oldRoot, newRoot));
 
            }
            else {
                KisNodeList safeNodesToDelete = m_info->allSrcNodes();
                KisNodeList safeNodesToHide;
 
                splitNonRemovableNodes(safeNodesToDelete, safeNodesToHide);
 
                Q_FOREACH(KisNodeSP node, safeNodesToHide) {
                    addCommand(new KisImageChangeVisibilityCommand(false, node));
                }
 
                safeReplaceMultipleNodes(safeNodesToDelete, m_info->image,
                                         std::make_optional<ReplacementNode>(
                                             {m_info->dstNode,
                                             parent,
                                             m_putAfter,
                                             true, false,
                                             m_info->selectionMasks,
                                             m_relinkClones}));
            }
 
 
        }

References KisBaseNode::image, KisBaseNode::isFakeNode(), OPACITY_OPAQUE_U8, KisNode::parent, KisLayerUtils::recursiveApplyNodes(), KisNodeFacade::root, and KisLayerUtils::splitNonRemovableNodes().

Member Data Documentation

m_info

MergeDownInfoBaseSP KisLayerUtils::CleanUpNodes::m_info

private

Definition at line 1265 of file kis_layer_utils.cpp.

m_putAfter

KisNodeSP KisLayerUtils::CleanUpNodes::m_putAfter

private

Definition at line 1266 of file kis_layer_utils.cpp.

m_relinkClones

bool KisLayerUtils::CleanUpNodes::m_relinkClones {false}

private

Definition at line 1267 of file kis_layer_utils.cpp.

{false};

---

The documentation for this struct was generated from the following file:

• libs/image/kis_layer_utils.cpp