#include <KisMergeLabeledLayersCommand.h>

Inheritance diagram for KisMergeLabeledLayersCommand:

Classes
struct	ReferenceNodeInfo
	Basic info about a node. This is used to compare and see if the node changed. More...

Public Types
enum	GroupSelectionPolicy { GroupSelectionPolicy_SelectAlways , GroupSelectionPolicy_SelectIfColorLabeled , GroupSelectionPolicy_NeverSelect }
	Policies to stablish how the groups should be treated. More...

using	ReferenceNodeInfoList = QList<ReferenceNodeInfo>

using	ReferenceNodeInfoListSP = QSharedPointer<ReferenceNodeInfoList>

Public Member Functions
	KisMergeLabeledLayersCommand (KisImageSP image, KisPaintDeviceSP newRefPaintDevice, QList< int > selectedLabels, GroupSelectionPolicy groupSelectionPolicy=GroupSelectionPolicy_SelectAlways)
	Construct a new KisMergeLabeledLayersCommand that does not use a cache.

	KisMergeLabeledLayersCommand (KisImageSP image, ReferenceNodeInfoListSP prevRefNodeInfoList, ReferenceNodeInfoListSP newRefNodeInfoList, KisPaintDeviceSP prevRefPaintDevice, KisPaintDeviceSP newRefPaintDevice, QList< int > selectedLabels, GroupSelectionPolicy groupSelectionPolicy=GroupSelectionPolicy_SelectAlways, bool forceRegeneration=false, KisNodeSP activeNode=nullptr)
	Construct a new KisMergeLabeledLayersCommand that uses a cache.

void	redo () override

void	undo () override

	~KisMergeLabeledLayersCommand () 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 KisPaintDeviceSP	createRefPaintDevice (KisImageSP originalImage, QString name="Merge Labeled Layers Reference Paint Device")

Private Member Functions
QPair< KisNodeSP, QPair< bool, bool > >	collectNode (KisNodeSP node) const

bool	collectNodes (KisNodeSP node, QList< KisNodeSP > &nodeList, ReferenceNodeInfoList &nodeInfoList) const

bool	hasToCheckForChangesInNodes () const

void	mergeLabeledLayers ()

Detailed Description

Definition at line 22 of file KisMergeLabeledLayersCommand.h.

Member Typedef Documentation

◆ ReferenceNodeInfoList

using KisMergeLabeledLayersCommand::ReferenceNodeInfoList = QList<ReferenceNodeInfo>

Definition at line 65 of file KisMergeLabeledLayersCommand.h.

◆ ReferenceNodeInfoListSP

using KisMergeLabeledLayersCommand::ReferenceNodeInfoListSP = QSharedPointer<ReferenceNodeInfoList>

Definition at line 66 of file KisMergeLabeledLayersCommand.h.

Member Enumeration Documentation

◆ GroupSelectionPolicy

enum KisMergeLabeledLayersCommand::GroupSelectionPolicy

Policies to stablish how the groups should be treated.

Enumerator
GroupSelectionPolicy_SelectAlways	Groups will be taken into account if their color label matches one of the selected color labels, even when the group has "no-color-label" as label.
GroupSelectionPolicy_SelectIfColorLabeled	Groups will be taken into account only if they have set an explicit color label. This ignores groups that have "no-color-label" as color label and the "no-color-label" label is included in the selected labels list.
GroupSelectionPolicy_NeverSelect	Groups will not be taken into account.

Definition at line 28 of file KisMergeLabeledLayersCommand.h.

    {
        GroupSelectionPolicy_SelectAlways,
        GroupSelectionPolicy_SelectIfColorLabeled,
        GroupSelectionPolicy_NeverSelect
    };

Constructor & Destructor Documentation

◆ KisMergeLabeledLayersCommand() [1/2]

KisMergeLabeledLayersCommand::KisMergeLabeledLayersCommand	(	KisImageSP	image,
		KisPaintDeviceSP	newRefPaintDevice,
		QList< int >	selectedLabels,
		GroupSelectionPolicy	groupSelectionPolicy = GroupSelectionPolicy_SelectAlways )

Construct a new KisMergeLabeledLayersCommand that does not use a cache.

Parameters

image	The image with the reference layers
newRefPaintDevice	The resulting device that will contain the merged result
selectedLabels	The color labels of the reference layers
groupSelectionPolicy	How to treat groups

Definition at line 23 of file KisMergeLabeledLayersCommand.cpp.

    : KUndo2Command(kundo2_noi18n("MERGE_LABELED_LAYERS"))
    , m_refImage(new KisImage(new KisSurrogateUndoStore(), image->width(), image->height(), image->colorSpace(), "Merge Labeled Layers Reference Image"))
    , m_prevRefNodeInfoList(nullptr)
    , m_newRefNodeInfoList(nullptr)
    , m_prevRefPaintDevice(nullptr)
    , m_newRefPaintDevice(newRefPaintDevice)
    , m_currentRoot(image->root())
    , m_selectedLabels(selectedLabels)
    , m_groupSelectionPolicy(groupSelectionPolicy)
    , m_forceRegeneration(true)
    , m_activeNode(nullptr)
{
    KIS_ASSERT(newRefPaintDevice);
    if (image->animationInterface()->hasAnimation()) {
        m_refImage->animationInterface()->switchCurrentTimeAsync(image->animationInterface()->currentTime());
        m_refImage->waitForDone();
    }
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), KisImageAnimationInterface::hasAnimation(), KIS_ASSERT, m_refImage, KisImageAnimationInterface::switchCurrentTimeAsync(), and KisImage::waitForDone().

◆ KisMergeLabeledLayersCommand() [2/2]

KisMergeLabeledLayersCommand::KisMergeLabeledLayersCommand	(	KisImageSP	image,
		ReferenceNodeInfoListSP	prevRefNodeInfoList,
		ReferenceNodeInfoListSP	newRefNodeInfoList,
		KisPaintDeviceSP	prevRefPaintDevice,
		KisPaintDeviceSP	newRefPaintDevice,
		QList< int >	selectedLabels,
		GroupSelectionPolicy	groupSelectionPolicy = GroupSelectionPolicy_SelectAlways,
		bool	forceRegeneration = false,
		KisNodeSP	activeNode = nullptr )

Construct a new KisMergeLabeledLayersCommand that uses a cache.

Parameters

image	The image with the reference layers
prevRefNodeInfoList	The reference node info that is used to compare with the current one to see if the cache device can be used instead of generating a new one
newRefNodeInfoList	The resulting list of reference node info
prevRefPaintDevice	The device that is used as a cache if possible
newRefPaintDevice	The resulting device that will contain the merged result
selectedLabels	The color labels of the reference layers
groupSelectionPolicy	How to treat groups
forceRegeneration	If true, the cache is ignored and the merged result is regenerated
activeNode	The current node that is being edited.

Definition at line 46 of file KisMergeLabeledLayersCommand.cpp.

    : KUndo2Command(kundo2_noi18n("MERGE_LABELED_LAYERS"))
    , m_refImage(new KisImage(new KisSurrogateUndoStore(), image->width(), image->height(), image->colorSpace(), "Merge Labeled Layers Reference Image"))
    , m_prevRefNodeInfoList(prevRefNodeInfoList)
    , m_newRefNodeInfoList(newRefNodeInfoList)
    , m_prevRefPaintDevice(prevRefPaintDevice)
    , m_newRefPaintDevice(newRefPaintDevice)
    , m_currentRoot(image->root())
    , m_selectedLabels(selectedLabels)
    , m_groupSelectionPolicy(groupSelectionPolicy)
    , m_forceRegeneration(forceRegeneration)
    , m_activeNode(activeNode)
{
    KIS_SAFE_ASSERT_RECOVER_NOOP(prevRefNodeInfoList);
    KIS_SAFE_ASSERT_RECOVER_NOOP(newRefNodeInfoList);
    KIS_SAFE_ASSERT_RECOVER_NOOP(prevRefPaintDevice);
    KIS_ASSERT(newRefPaintDevice);
    if (image->animationInterface()->hasAnimation()) {
        m_refImage->animationInterface()->switchCurrentTimeAsync(image->animationInterface()->currentTime());
        m_refImage->waitForDone();
    }
}

References KisImage::animationInterface(), KisImageAnimationInterface::currentTime(), KisImageAnimationInterface::hasAnimation(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, m_refImage, KisImageAnimationInterface::switchCurrentTimeAsync(), and KisImage::waitForDone().

◆ ~KisMergeLabeledLayersCommand()

KisMergeLabeledLayersCommand::~KisMergeLabeledLayersCommand ( )

override

Definition at line 77 of file KisMergeLabeledLayersCommand.cpp.

78{}

Member Function Documentation

◆ collectNode()

QPair< KisNodeSP, QPair< bool, bool > > KisMergeLabeledLayersCommand::collectNode ( KisNodeSP node ) const

private

Definition at line 98 of file KisMergeLabeledLayersCommand.cpp.

{
    if (!node->parent()) {
        // This is the root node. Do not use nor visit the siblings,
        // but always visit the children
        return {nullptr, {false, true}};
    }
 
    if (node->inherits("KisMask")) {
        // This is the a mask node. Do not use, nor visit the children,
        // but visit the siblings as they may be normal layers
        return {nullptr, {true, false}};
    }
 
    if (!node->visible()) {
        // Do not use the node and do not visit the children if the node is
        // hidden, but do visit the next sibling
        return {nullptr, {true, false}};
    }
 
    if (!m_selectedLabels.contains(node->colorLabelIndex())) {
        // Do not use this node if it is not labeled appropriately. The children
        // should still be visited if it is a group. The next sibling should
        // also be visited
        if (!(m_activeNode != nullptr && node->uuid() == m_activeNode->uuid())) {
            // If the active node has been passed and it is being considered,
            // it should be treated as if it is labeled to match.
            return {nullptr, {true, node->inherits("KisGroupLayer")}};
        }
    }
 
    if (node->inherits("KisCloneLayer")) {
        // Make a copy of the clone layer as a paint layer. The source layer
        // may not be color labeled and therefore not added to the temporary
        // image. So this ensures that the real contents are represented
        // in any case
        KisCloneLayerSP cloneLayer = dynamic_cast<KisCloneLayer*>(node.data());
        KisNodeSP transformedNode = cloneLayer->reincarnateAsPaintLayer();
        // Use the transformed node. The next sibling is visited, but not the
        // children, which may be some masks
        return {transformedNode, {true, false}};
    }
    
    if (node->inherits("KisAdjustmentLayer")) {
        // Similar to the clone layer case. The filter layer uses the
        // composition of the layers below as source to apply the effect
        // so we must use a paint layer representation of the result
        // because the next sibling nodes may not be color labeled and
        // therefore not added to the temporary image
        KisPaintDeviceSP proj = new KisPaintDevice(*(node->projection()));
        KisPaintLayerSP transformedNode = new KisPaintLayer(node->image(), node->name(), node->opacity(), proj);
        transformedNode->setX(transformedNode->x() + node->x());
        transformedNode->setY(transformedNode->y() + node->y());
        transformedNode->mergeNodeProperties(node->nodeProperties());
        // Use the transformed node. This new node already has the contents of
        // the next layers on the same level baked, so the next sibling nodes
        // are not visited. Do not visit the children, which may be some masks
        return {transformedNode, {false, false}};
    }
    
    if (node->inherits("KisGroupLayer")) {
        if (m_groupSelectionPolicy == GroupSelectionPolicy_NeverSelect ||
            (m_groupSelectionPolicy == GroupSelectionPolicy_SelectIfColorLabeled && node->colorLabelIndex() == 0)) {
            // If this group node should not be used (that is, the projection of
            // it's contents), it's children are always visited as well as
            // the next sibling
            return {nullptr, {true, true}};
        } else {
            // If this group node should be used (that is, the projection of
            // it's contents), just add the node, which adds
            // also all the children. This group node already has all the
            // children, so the child nodes are not visited.
            // The next sibling is visited
            return {node, {true, false}};
        }
    }
 
    // By default, visit the next sibling, but not the children
    return {node, {true, false}};
}

References KisBaseNode::colorLabelIndex(), KisSharedPtr< T >::data(), GroupSelectionPolicy_NeverSelect, GroupSelectionPolicy_SelectIfColorLabeled, KisBaseNode::image, m_activeNode, m_groupSelectionPolicy, m_selectedLabels, KisBaseNode::mergeNodeProperties(), KisBaseNode::name(), KisBaseNode::nodeProperties(), KisBaseNode::opacity(), KisNode::parent, KisBaseNode::projection(), KisLayer::setX(), KisLayer::setY(), KisBaseNode::uuid(), KisBaseNode::visible(), KisBaseNode::x(), KisLayer::x(), KisBaseNode::y(), and KisLayer::y().

◆ collectNodes()

bool KisMergeLabeledLayersCommand::collectNodes	(	KisNodeSP	node,
		QList< KisNodeSP > &	nodeList,
		ReferenceNodeInfoList &	nodeInfoList ) const

private

Definition at line 179 of file KisMergeLabeledLayersCommand.cpp.

{
    QPair<KisNodeSP, QPair<bool, bool>> result = collectNode(node);
    KisNodeSP collectedNode = result.first;
    const bool visitNextSibling = result.second.first;
    const bool visitChildren = result.second.second;
 
    if (collectedNode) {
        // If the node should be selected, it is added to the list
        nodeList << collectedNode;
        // Store additional info to check if the new list of reference nodes
        // is different. Use the original node to extract the info
        if (hasToCheckForChangesInNodes()) {
            const QUuid uuid = node->uuid();
            const int sequenceNumber = node->projection()->sequenceNumber();
            const int opacity = node->opacity();
            nodeInfoList.append({uuid, sequenceNumber, opacity});
        }
    }
 
    if (visitChildren) {
        node = node->lastChild();
        while (node) {
            const bool mustVisitNextSibling = collectNodes(node, nodeList, nodeInfoList);
            if (!mustVisitNextSibling) {
                break;
            }
            node = node->prevSibling();
        }
    }
 
    return visitNextSibling;
}

References collectNode(), collectNodes(), hasToCheckForChangesInNodes(), KisNode::lastChild(), KisBaseNode::opacity(), KisNode::prevSibling(), KisBaseNode::projection(), KisPaintDevice::sequenceNumber(), and KisBaseNode::uuid().

◆ createRefPaintDevice()

KisPaintDeviceSP KisMergeLabeledLayersCommand::createRefPaintDevice	(	KisImageSP	originalImage,
		QString	name = "Merge Labeled Layers Reference Paint Device" )

static

Definition at line 93 of file KisMergeLabeledLayersCommand.cpp.

{
    return KisPaintDeviceSP(new KisPaintDevice(originalImage->colorSpace(), name));
}

References KisImage::colorSpace().

◆ hasToCheckForChangesInNodes()

bool KisMergeLabeledLayersCommand::hasToCheckForChangesInNodes ( ) const

private

Definition at line 283 of file KisMergeLabeledLayersCommand.cpp.

{
    return m_prevRefNodeInfoList && m_newRefNodeInfoList && m_prevRefPaintDevice;
}

References m_newRefNodeInfoList, m_prevRefNodeInfoList, and m_prevRefPaintDevice.

◆ mergeLabeledLayers()

void KisMergeLabeledLayersCommand::mergeLabeledLayers ( )

private

Definition at line 213 of file KisMergeLabeledLayersCommand.cpp.

{
    QList<KisNodeSP> currentNodesList;
    ReferenceNodeInfoList currentNodeInfoList;
 
    collectNodes(m_currentRoot, currentNodesList, currentNodeInfoList);
 
    if (hasToCheckForChangesInNodes()) {
        *m_newRefNodeInfoList = currentNodeInfoList;
    }
 
    if (hasToCheckForChangesInNodes() && !m_forceRegeneration && (currentNodeInfoList == *m_prevRefNodeInfoList)) {
        m_newRefPaintDevice->prepareClone(m_prevRefPaintDevice);
        m_newRefPaintDevice->makeCloneFromRough(m_prevRefPaintDevice, m_prevRefPaintDevice->extent());
    } else {
        QList<KisNodeSP> currentNodesListCopy;
        for (KisNodeSP node : currentNodesList) {
            KisNodeSP copy = node->clone();
 
            if (copy.isNull()) {
                continue;
            }
 
            if (copy->inherits("KisLayer")) {
                KisLayer* layerCopy = dynamic_cast<KisLayer*>(copy.data());
                KIS_ASSERT(layerCopy);
                layerCopy->setChannelFlags(QBitArray());
            }
 
            copy->setCompositeOpId(COMPOSITE_OVER);
 
            bool success = m_refImage->addNode(copy, m_refImage->root(), 0);
 
            if (!success) {
                continue;
            }
 
            currentNodesListCopy << copy;
        }
 
        currentNodesListCopy = KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(currentNodesListCopy, m_refImage);
 
        m_refImage->initialRefreshGraph();
        KisLayerUtils::refreshHiddenAreaAsync(m_refImage, m_refImage->root(), m_refImage->bounds());
        m_refImage->waitForDone();
 
        if (m_refImage->root()->childCount() == 0) {
            return;
        }
 
        m_refImage->waitForDone();
        KisLayerUtils::mergeMultipleNodes(m_refImage, currentNodesListCopy, 0, KisLayerUtils::SkipMergingFrames);
        m_refImage->waitForDone();
 
        KisPainter::copyAreaOptimized(m_refImage->projection()->exactBounds().topLeft(), m_refImage->projection(), m_newRefPaintDevice, m_refImage->projection()->exactBounds());
    }
 
    // release resources: they are still owned by the caller
    // (or by some other object the caller passed them to)
    m_prevRefPaintDevice.clear();
    m_newRefPaintDevice.clear();
    m_currentRoot.clear();
    m_prevRefNodeInfoList.clear();
    m_newRefNodeInfoList.clear();
 
    // KisImage should be deleted only in the GUI thread (it has timers)
    makeKisDeleteLaterWrapper(m_refImage)->deleteLater();
    m_refImage.clear();
}

References KisNodeFacade::addNode(), KisImage::bounds(), KisNode::childCount(), KisSharedPtr< T >::clear(), KisNode::clone(), collectNodes(), COMPOSITE_OVER, KisPainter::copyAreaOptimized(), KisPaintDevice::exactBounds(), KisPaintDevice::extent(), hasToCheckForChangesInNodes(), KisImage::initialRefreshGraph(), KIS_ASSERT, m_currentRoot, m_forceRegeneration, m_newRefNodeInfoList, m_newRefPaintDevice, m_prevRefNodeInfoList, m_prevRefPaintDevice, m_refImage, KisPaintDevice::makeCloneFromRough(), makeKisDeleteLaterWrapper(), KisLayerUtils::mergeMultipleNodes(), KisPaintDevice::prepareClone(), KisImage::projection(), KisLayerUtils::refreshHiddenAreaAsync(), KisNodeFacade::root, KisLayer::setChannelFlags(), KisLayerUtils::SkipMergingFrames, KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(), and KisImage::waitForDone().

◆ redo()

void KisMergeLabeledLayersCommand::redo ( )

overridevirtual

Applies a change to the document. This function must be implemented in the derived class. Calling KUndo2QStack::push(), KUndo2QStack::undo() or KUndo2QStack::redo() from this function leads to undefined behavior.

The default implementation calls redo() on all child commands.

See also: undo()

Reimplemented from KUndo2Command.

Definition at line 85 of file KisMergeLabeledLayersCommand.cpp.

{
    if (m_refImage) {
        mergeLabeledLayers();
    }
    KUndo2Command::redo();
}

References m_refImage, mergeLabeledLayers(), and KUndo2Command::redo().

◆ undo()

void KisMergeLabeledLayersCommand::undo ( )

overridevirtual

Reverts a change to the document. After undo() is called, the state of the document should be the same as before redo() was called. This function must be implemented in the derived class. Calling KUndo2QStack::push(), KUndo2QStack::undo() or KUndo2QStack::redo() from this function leads to undefined behavior.

The default implementation calls undo() on all child commands in reverse order.

See also: redo()

Reimplemented from KUndo2Command.

Definition at line 80 of file KisMergeLabeledLayersCommand.cpp.

{
    KUndo2Command::undo();
}

References KUndo2Command::undo().

Member Data Documentation

◆ m_activeNode

KisNodeSP KisMergeLabeledLayersCommand::m_activeNode

private

Definition at line 132 of file KisMergeLabeledLayersCommand.h.

◆ m_currentRoot

KisNodeSP KisMergeLabeledLayersCommand::m_currentRoot

private

Definition at line 128 of file KisMergeLabeledLayersCommand.h.

◆ m_forceRegeneration

bool KisMergeLabeledLayersCommand::m_forceRegeneration

private

Definition at line 131 of file KisMergeLabeledLayersCommand.h.

◆ m_groupSelectionPolicy

GroupSelectionPolicy KisMergeLabeledLayersCommand::m_groupSelectionPolicy

private

Definition at line 130 of file KisMergeLabeledLayersCommand.h.

◆ m_newRefNodeInfoList

ReferenceNodeInfoListSP KisMergeLabeledLayersCommand::m_newRefNodeInfoList

private

Definition at line 125 of file KisMergeLabeledLayersCommand.h.

◆ m_newRefPaintDevice

KisPaintDeviceSP KisMergeLabeledLayersCommand::m_newRefPaintDevice

private

Definition at line 127 of file KisMergeLabeledLayersCommand.h.

◆ m_prevRefNodeInfoList

ReferenceNodeInfoListSP KisMergeLabeledLayersCommand::m_prevRefNodeInfoList

private

Definition at line 124 of file KisMergeLabeledLayersCommand.h.

◆ m_prevRefPaintDevice

KisPaintDeviceSP KisMergeLabeledLayersCommand::m_prevRefPaintDevice

private

Definition at line 126 of file KisMergeLabeledLayersCommand.h.

◆ m_refImage

KisImageSP KisMergeLabeledLayersCommand::m_refImage

private

Definition at line 123 of file KisMergeLabeledLayersCommand.h.

◆ m_selectedLabels

QList<int> KisMergeLabeledLayersCommand::m_selectedLabels

private

Definition at line 129 of file KisMergeLabeledLayersCommand.h.

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

libs/image/commands_new/KisMergeLabeledLayersCommand.h
libs/image/commands_new/KisMergeLabeledLayersCommand.cpp

Private Attributes
KisNodeSP	m_activeNode

KisNodeSP	m_currentRoot

bool	m_forceRegeneration

GroupSelectionPolicy	m_groupSelectionPolicy

ReferenceNodeInfoListSP	m_newRefNodeInfoList

KisPaintDeviceSP	m_newRefPaintDevice

ReferenceNodeInfoListSP	m_prevRefNodeInfoList

KisPaintDeviceSP	m_prevRefPaintDevice

KisImageSP	m_refImage

QList< int >	m_selectedLabels

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ReferenceNodeInfoList

◆ ReferenceNodeInfoListSP

Member Enumeration Documentation

◆ GroupSelectionPolicy

Constructor & Destructor Documentation

◆ KisMergeLabeledLayersCommand() [1/2]

◆ KisMergeLabeledLayersCommand() [2/2]

◆ ~KisMergeLabeledLayersCommand()

Member Function Documentation

◆ collectNode()

◆ collectNodes()

◆ createRefPaintDevice()

◆ hasToCheckForChangesInNodes()

◆ mergeLabeledLayers()

◆ redo()

◆ undo()

Member Data Documentation

◆ m_activeNode

◆ m_currentRoot

◆ m_forceRegeneration

◆ m_groupSelectionPolicy

◆ m_newRefNodeInfoList

◆ m_newRefPaintDevice

◆ m_prevRefNodeInfoList

◆ m_prevRefPaintDevice

◆ m_refImage

◆ m_selectedLabels