Inheritance diagram for DuplicateLayers:

Public Types
enum	Mode { MOVE , COPY , ADD }

Public Member Functions
	DuplicateLayers (BatchMoveUpdateDataSP updateData, KisImageSP image, const KisNodeList &nodes, KisNodeSP dstParent, KisNodeSP dstAbove, KisNodeSP activeNode, Mode mode)

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 ()

Private Member Functions
QList< KisSelectionMaskSP >	findActiveSelectionMasks (KisNodeList nodes)

KisSelectionMaskSP	toActiveSelectionMask (KisNodeSP node)

Private Attributes
KisNodeSP	m_activeNode

KisNodeSP	m_dstAbove

KisNodeSP	m_dstParent

KisImageSP	m_image

Mode	m_mode

KisNodeList	m_nodes

BatchMoveUpdateDataSP	m_updateData

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

Detailed Description

Definition at line 469 of file kis_node_juggler_compressed.cpp.

Member Enumeration Documentation

◆ Mode

enum DuplicateLayers::Mode

Enumerator
MOVE
COPY
ADD

Definition at line 470 of file kis_node_juggler_compressed.cpp.

              {
        MOVE,
        COPY,
        ADD
    };

Constructor & Destructor Documentation

◆ DuplicateLayers()

DuplicateLayers::DuplicateLayers	(	BatchMoveUpdateDataSP	updateData,
		KisImageSP	image,
		const KisNodeList &	nodes,
		KisNodeSP	dstParent,
		KisNodeSP	dstAbove,
		KisNodeSP	activeNode,
		Mode	mode )

inline

Definition at line 476 of file kis_node_juggler_compressed.cpp.

        : m_updateData(updateData),
          m_image(image),
          m_nodes(nodes),
          m_dstParent(dstParent),
          m_dstAbove(dstAbove),
          m_activeNode(activeNode),
          m_mode(mode) {}

Member Function Documentation

◆ findActiveSelectionMasks()

QList< KisSelectionMaskSP > DuplicateLayers::findActiveSelectionMasks ( KisNodeList nodes )

inlineprivate

Definition at line 617 of file kis_node_juggler_compressed.cpp.

                                                                          {
        QList<KisSelectionMaskSP> masks;
        foreach (KisNodeSP node, nodes) {
            KisSelectionMaskSP mask = toActiveSelectionMask(node);
            if (mask) {
                masks << mask;
            }
        }
        return masks;
    }

References toActiveSelectionMask().

◆ populateChildCommands()

void DuplicateLayers::populateChildCommands ( )

inlineoverridevirtual

We should first disable the currently active masks, after the operation completed their cloned counterparts will be activated instead.

HINT: we should deactivate the masks before cloning, because otherwise KisGroupLayer::allowAsChild() will not let the second mask to be added to the list of child nodes. See bug 382315.

Activate the cloned counterparts of the masks after the operation is complete.

Implements KisCommandUtils::AggregateCommand.

Definition at line 491 of file kis_node_juggler_compressed.cpp.

                                          {
        KisNodeList filteredNodes = KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(m_nodes, m_image);
 
        if (filteredNodes.isEmpty()) return;
 
        KisNodeSP newAbove = filteredNodes.last();
 
        // make sure we don't add the new layer into a locked group
        while (newAbove->parent() && !newAbove->parent()->isEditable(false)) {
            newAbove = newAbove->parent();
        }
 
        KisNodeSP newParent = newAbove->parent();
 
        // override parent if provided externally
        if (m_dstParent) {
            newAbove = m_dstAbove;
            newParent = m_dstParent;
        }
 
        const int indexOfActiveNode = filteredNodes.indexOf(m_activeNode);
        QList<KisSelectionMaskSP> activeMasks = findActiveSelectionMasks(filteredNodes);
 
        // we will deactivate the masks before processing, so we should
        // save their list in a convenient form
        QSet<KisNodeSP> activeMaskNodes;
        Q_FOREACH (KisSelectionMaskSP mask, activeMasks) {
            activeMaskNodes.insert(mask);
        }
 
        const bool haveActiveMasks = !activeMasks.isEmpty();
 
        if (!newParent) return;
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(filteredNodes, KisNodeList(),
                                                               m_activeNode, KisNodeSP(),
                                                               m_image, false));
 
        if (haveActiveMasks) {
            addCommand(new ActivateSelectionMasksCommand(activeMasks,
                                                         QList<KisSelectionMaskSP>(),
                                                         false));
        }
 
        KisNodeList newNodes;
        QList<KisSelectionMaskSP> newActiveMasks;
        KisNodeSP currentAbove = newAbove;
        Q_FOREACH (KisNodeSP node, filteredNodes) {
            if (m_mode == COPY || m_mode == ADD) {
                KisNodeSP newNode;
 
                if (m_mode == COPY) {
                    newNode = node->clone();
                    KisLayerUtils::addCopyOfNameTag(newNode);
                } else {
                    newNode = node;
                }
 
                newNodes << newNode;
                if (haveActiveMasks && activeMaskNodes.contains(node)) {
                    KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(newNode.data());
                    newActiveMasks << mask;
                }
 
                MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, newNode, newParent, currentAbove));
                m_updateData->addInitialUpdate(moveStruct);
 
                addCommand(new KisImageLayerAddCommand(m_image, newNode,
                                                       newParent,
                                                       currentAbove,
                                                       false, false));
 
                currentAbove = newNode;
            } else if (m_mode == MOVE) {
                KisNodeSP newNode = node;
 
                newNodes << newNode;
                if (haveActiveMasks && activeMaskNodes.contains(node)) {
                    KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(newNode.data());
                    newActiveMasks << mask;
                }
 
                MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, newNode, newParent, currentAbove));
                m_updateData->addInitialUpdate(moveStruct);
 
                addCommand(new KisImageLayerMoveCommand(m_image, newNode,
                                                        newParent,
                                                        currentAbove,
                                                        false));
                currentAbove = newNode;
            }
        }
 
 
        if (haveActiveMasks) {
            addCommand(new ActivateSelectionMasksCommand(QList<KisSelectionMaskSP>(),
                                                         newActiveMasks,
                                                         true));
        }
 
        KisNodeSP newActiveNode = newNodes[qBound(0, indexOfActiveNode, newNodes.size() - 1)];
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(KisNodeList(), newNodes,
                                                               KisNodeSP(), newActiveNode,
                                                               m_image, true));
    }

References ADD, KisCommandUtils::AggregateCommand::addCommand(), KisLayerUtils::addCopyOfNameTag(), KisNode::clone(), COPY, KisSharedPtr< T >::data(), findActiveSelectionMasks(), KisBaseNode::isEditable(), m_activeNode, m_dstAbove, m_dstParent, m_image, m_mode, m_nodes, m_updateData, MOVE, KisNode::parent, KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(), and toQShared().

◆ toActiveSelectionMask()

KisSelectionMaskSP DuplicateLayers::toActiveSelectionMask ( KisNodeSP node )

inlineprivate

Definition at line 611 of file kis_node_juggler_compressed.cpp.

                                                             {
        KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(node.data());
        return mask && mask->active() ? mask : 0;
    }