Inheritance diagram for LowerRaiseLayer:

Public Types
enum	NodesType { AllLayers , Mixed , AllMasks }

Public Member Functions
bool	allowsAsChildren (KisNodeSP parent, KisNodeList nodes)

NodesType	getNodesType (KisNodeList nodes)

	LowerRaiseLayer (BatchMoveUpdateDataSP updateData, KisImageSP image, const KisNodeList &nodes, KisNodeSP activeNode, bool lower)

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 Attributes
KisNodeSP	m_activeNode

KisImageSP	m_image

bool	m_lower

KisNodeList	m_nodes

BatchMoveUpdateDataSP	m_updateData

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

Detailed Description

A generalized command to move up/down a set of layer

Definition at line 329 of file kis_node_juggler_compressed.cpp.

Member Enumeration Documentation

◆ NodesType

enum LowerRaiseLayer::NodesType

Enumerator
AllLayers
Mixed
AllMasks

Definition at line 341 of file kis_node_juggler_compressed.cpp.

                   {
        AllLayers,
        Mixed,
        AllMasks
    };

Constructor & Destructor Documentation

◆ LowerRaiseLayer()

LowerRaiseLayer::LowerRaiseLayer	(	BatchMoveUpdateDataSP	updateData,
		KisImageSP	image,
		const KisNodeList &	nodes,
		KisNodeSP	activeNode,
		bool	lower )

inline

Definition at line 330 of file kis_node_juggler_compressed.cpp.

        : m_updateData(updateData),
          m_image(image),
          m_nodes(nodes),
          m_activeNode(activeNode),
          m_lower (lower) {}

Member Function Documentation

◆ allowsAsChildren()

bool LowerRaiseLayer::allowsAsChildren	(	KisNodeSP	parent,
		KisNodeList	nodes )

inline

Definition at line 361 of file kis_node_juggler_compressed.cpp.

                                                               {
        if (!parent->isEditable(false)) return false;
 
        Q_FOREACH (KisNodeSP node, nodes) {
            if (!parent->allowAsChild(node)) return false;
        }
 
        return true;
    }

◆ getNodesType()

NodesType LowerRaiseLayer::getNodesType ( KisNodeList nodes )

inline

Definition at line 347 of file kis_node_juggler_compressed.cpp.

                                              {
        bool hasLayers = false;
        bool hasMasks = false;
 
        Q_FOREACH (KisNodeSP node, nodes) {
            hasLayers |= bool(qobject_cast<KisLayer*>(node.data()));
            hasMasks |= bool(qobject_cast<KisMask*>(node.data()));
        }
 
        return hasLayers && hasMasks ? Mixed :
            hasLayers ? AllLayers :
            AllMasks;
    }

References AllLayers, AllMasks, KisSharedPtr< T >::data(), and Mixed.

◆ populateChildCommands()

void LowerRaiseLayer::populateChildCommands ( )

inlineoverridevirtual

Implements KisCommandUtils::AggregateCommand.

Definition at line 371 of file kis_node_juggler_compressed.cpp.

                                          {
        KisNodeList sortedNodes = KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(m_nodes, m_image);
        KisNodeSP headNode = m_lower ? sortedNodes.first() : sortedNodes.last();
        const NodesType nodesType = getNodesType(sortedNodes);
 
        KisNodeSP parent = headNode->parent();
        KisNodeSP grandParent = parent ? parent->parent() : 0;
 
        if (!parent->isEditable(false)) return;
 
        KisNodeSP newAbove;
        KisNodeSP newParent;
 
        if (m_lower) {
            KisNodeSP prevNode = headNode->prevSibling();
 
            if (prevNode) {
                if (allowsAsChildren(prevNode, sortedNodes) &&
                    !prevNode->collapsed()) {
 
                    newAbove = prevNode->lastChild();
                    newParent = prevNode;
                } else {
                    newAbove = prevNode->prevSibling();
                    newParent = parent;
                }
            } else if ((nodesType == AllLayers && grandParent) ||
                       (nodesType == AllMasks && grandParent && grandParent->parent())) {
                newAbove = parent->prevSibling();
                newParent = grandParent;
 
            } else if (nodesType == AllMasks &&
                       grandParent && !grandParent->parent() &&
                       (prevNode = parent->prevSibling()) &&
                       prevNode->inherits("KisLayer")) {
 
                newAbove = prevNode->lastChild();
                newParent = prevNode; // NOTE: this is an updated 'prevNode'!
            }
        } else {
            KisNodeSP nextNode = headNode->nextSibling();
 
            if (nextNode) {
                if (allowsAsChildren(nextNode, sortedNodes) &&
                        !nextNode->collapsed()) {
                    newAbove = 0;
                    newParent = nextNode;
                } else {
                    newAbove = nextNode;
                    newParent = parent;
                }
            } else if ((nodesType == AllLayers && grandParent) ||
                       (nodesType == AllMasks && grandParent && grandParent->parent())) {
                newAbove = parent;
                newParent = grandParent;
 
            } else if (nodesType == AllMasks &&
                       grandParent && !grandParent->parent() &&
                       (nextNode = parent->nextSibling()) &&
                       nextNode->inherits("KisLayer")) {
 
                newAbove = 0;
                newParent = nextNode; // NOTE: this is an updated 'nextNode'!
            }
        }
 
        if (!newParent ||
            !newParent->isEditable(false)) return;
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(sortedNodes, sortedNodes,
                                                               m_activeNode, m_activeNode,
                                                               m_image, false));
 
        KisNodeSP currentAbove = newAbove;
        Q_FOREACH (KisNodeSP node, sortedNodes) {
            if (node->parent() != newParent && !newParent->allowAsChild(node)) {
                continue;
            }
 
            MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, node, newParent, currentAbove));
            addCommand(new KisImageLayerMoveCommand(m_image, node, newParent, currentAbove, false));
            m_updateData->addInitialUpdate(moveStruct);
            currentAbove = node;
        }
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(sortedNodes, sortedNodes,
                                                               m_activeNode, m_activeNode,
                                                               m_image, true));
    }