KisLayerUtils Namespace Reference

Namespaces
namespace	Private

Classes
struct	ActivateSelectionMask
struct	AddNewFrame
struct	CleanUpNodes
struct	ConvertToPaintLayerInfo
struct	CreateMergedLayer
struct	CreateMergedLayerMultiple
struct	DisableColorizeKeyStrokes
struct	DisableExtraCompositing
struct	DisableOnionSkins
struct	DisablePassThroughForHeadsOnly
struct	EphemeralCommandsWrapper
struct	FillSelectionMasks
struct	InitSplitAlphaSelectionMask
struct	InsertNode
struct	KeepMergedNodesSelected
class	KeepNodesSelectedCommand
class	KisSimpleUpdateCommand
struct	MergeDownInfo
struct	MergeDownInfoBase
struct	MergeLayers
struct	MergeLayersMultiple
struct	MergeMetaData
struct	MergeMultipleInfo
struct	MergeSelectionMasks
struct	RefreshDelayedUpdateLayers
struct	RefreshHiddenAreas
class	RemoveNodeHelper
struct	SelectGlobalSelectionMask
struct	SimpleAddNode
struct	SimpleRemoveLayers
struct	SplitAlphaCommand
struct	SplitAlphaToMaskInfo
struct	SwitchFrameCommand
	The SwitchFrameCommand struct Switches to frame with undo/redo support. More...
struct	UndoEphemeralCommands
struct	UploadProjectionToFrameCommand

Typedefs
typedef QSharedPointer< ConvertToPaintLayerInfo >	ConvertToPaintLayerInfoSP
typedef QMap< int, QSet< KisNodeSP > >	FrameJobs
typedef QSharedPointer< MergeDownInfoBase >	MergeDownInfoBaseSP
typedef QSharedPointer< MergeDownInfo >	MergeDownInfoSP
typedef QSharedPointer< MergeMultipleInfo >	MergeMultipleInfoSP
typedef QSharedPointer< SplitAlphaToMaskInfo >	SplitAlphaToMaskInfoSP

Enumerations
enum	MergeFlag { None , SkipMergingFrames = 0x1 }

Functions
void	addCopyOfNameTag (KisNodeSP node)
bool	canChangeImageProfileInvisibly (KisImageSP image)
void	changeImageDefaultProjectionColor (KisImageSP image, const KoColor &color)
bool	checkIsChildOf (KisNodeSP node, const KisNodeList &parents)
bool	checkIsCloneOf (KisNodeSP node, const KisNodeList &nodes)
template<typename T >
bool	checkNodesDiffer (KisNodeList nodes, std::function< T(KisNodeSP)> checkerFunc)
std::future< KisNodeSP >	convertToPaintLayer (KisImageSP image, KisNodeSP src)
int	fetchLayerActiveRasterFrameID (KisNodeSP node)
KisTimeSpan	fetchLayerActiveRasterFrameSpan (KisNodeSP node, const int time)
int	fetchLayerActiveRasterFrameTime (KisNodeSP node)
QSet< int >	fetchLayerFrames (KisNodeSP node)
QSet< int >	fetchLayerFramesRecursive (KisNodeSP rootNode)
QSet< int >	fetchLayerIdenticalRasterFrameTimes (KisNodeSP node, const int &frameTime)
QSet< int >	fetchLayerRasterFrameTimesMatchingID (KisNodeSP node, const int frameID)
QSet< int >	fetchLayerRasterIDsAtTimes (KisNodeSP node, const QSet< int > &times)
QSet< int >	fetchLayerUniqueRasterTimesMatchingIDs (KisNodeSP node, QSet< int > &frameIDs)
void	fetchSelectionMasks (KisNodeList mergedNodes, QVector< KisSelectionMaskSP > &selectionMasks)
QSet< int >	fetchUniqueFrameTimes (KisNodeSP node, QSet< int > selectedTimes, bool filterActiveFrameID)
KisNodeList	filterInvisibleNodes (const KisNodeList &nodes, KisNodeList *invisibleNodes, KisNodeSP *putAfter)
void	filterMergeableNodes (KisNodeList &nodes, bool allowMasks)
QSet< int >	filterTimesForOnlyRasterKeyedTimes (KisNodeSP node, const QSet< int > &times)
void	filterUnlockedNodes (KisNodeList &nodes)
KisImageSP	findImageByHierarchy (KisNodeSP node)
KisNodeSP	findIsolationRoot (KisNodeSP node)
KisNodeSP	findNodeByName (KisNodeSP root, const QString &name)
template<class T >
T *	findNodeByType (KisNodeSP root)
KisNodeSP	findNodeByUuid (KisNodeSP root, const QUuid &uuid)
QList< KisNodeSP >	findNodesByName (KisNodeSP root, const QString &name, bool recursive, bool partialMatch)
KisNodeList	findNodesWithProps (KisNodeSP root, const KoProperties &props, bool excludeRoot)
KisNodeSP	findRoot (KisNodeSP node)
void	flattenImage (KisImageSP image, KisNodeSP activeNode, MergeFlags flags)
void	flattenLayer (KisImageSP image, KisLayerSP layer, MergeFlags flags)
void	forceAllDelayedNodesUpdate (KisNodeSP root)
void	forceAllHiddenOriginalsUpdate (KisNodeSP root)
bool	hasDelayedNodeWithUpdates (KisNodeSP root)
void	mergeDown (KisImageSP image, KisLayerSP layer, const KisMetaData::MergeStrategy *strategy, MergeFlags flags)
void	mergeMultipleLayers (KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
void	mergeMultipleLayersImpl (KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, bool flattenSingleLayer, const KUndo2MagicString &actionName, bool cleanupNodes=true, const QString layerName=QString(), MergeFlags flags=None)
void	mergeMultipleNodes (KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter, MergeFlags flags)
void	newLayerFromVisible (KisImageSP image, KisNodeSP putAfter, MergeFlags flags)
template<typename NodePointer , typename Functor >
void	recursiveApplyNodes (NodePointer node, Functor func)
KisNodeSP	recursiveFindNode (KisNodeSP node, std::function< bool(KisNodeSP)> func)
QRect	recursiveTightNodeVisibleBounds (KisNodeSP rootNode)
void	refreshHiddenAreaAsync (KisImageSP image, KisNodeSP rootNode, const QRect &preparedArea)
KisNodeList	sortAndFilterAnyMergeableNodesSafe (const KisNodeList &nodes, KisImageSP image)
KisNodeList	sortAndFilterMergeableInternalNodes (KisNodeList nodes, bool allowMasks)
KisNodeList	sortMergeableInternalNodes (KisNodeList nodes)
void	sortMergeableNodes (KisNodeSP root, KisNodeList &inputNodes, KisNodeList &outputNodes)
KisNodeList	sortMergeableNodes (KisNodeSP root, KisNodeList nodes)
KRITAIMAGE_EXPORT void	sortMergeableNodes (KisNodeSP root, QList< KisNodeSP > &inputNodes, QList< KisNodeSP > &outputNodes)
void	splitAlphaToMask (KisImageSP image, KisNodeSP node, const QString &maskName)
void	splitNonRemovableNodes (KisNodeList &nodesToRemove, KisNodeList &_nodesToHide)
bool	tryMergeSelectionMasks (KisImageSP image, KisNodeList mergedNodes, KisNodeSP putAfter)
void	updateFrameJobs (FrameJobs *jobs, KisNodeSP node)
void	updateFrameJobsNonRecursive (FrameJobs *jobs, KisNodeSP rootNode, bool frameTimesRecursive=false)
	updateFrameJobsNonRecursive updates the frame jobs non-recursively, that is, on the rootNode only.
void	updateFrameJobsRecursive (FrameJobs *jobs, KisNodeSP rootNode)

Typedef Documentation

ConvertToPaintLayerInfoSP

typedef QSharedPointer<ConvertToPaintLayerInfo> KisLayerUtils::ConvertToPaintLayerInfoSP

Definition at line 365 of file kis_layer_utils.cpp.

FrameJobs

typedef QMap<int, QSet<KisNodeSP> > KisLayerUtils::FrameJobs

Definition at line 94 of file kis_layer_utils.h.

MergeDownInfoBaseSP

typedef QSharedPointer<MergeDownInfoBase> KisLayerUtils::MergeDownInfoBaseSP

Definition at line 361 of file kis_layer_utils.cpp.

MergeDownInfoSP

typedef QSharedPointer<MergeDownInfo> KisLayerUtils::MergeDownInfoSP

Definition at line 362 of file kis_layer_utils.cpp.

MergeMultipleInfoSP

typedef QSharedPointer<MergeMultipleInfo> KisLayerUtils::MergeMultipleInfoSP

Definition at line 363 of file kis_layer_utils.cpp.

SplitAlphaToMaskInfoSP

typedef QSharedPointer<SplitAlphaToMaskInfo> KisLayerUtils::SplitAlphaToMaskInfoSP

Definition at line 364 of file kis_layer_utils.cpp.

Enumeration Type Documentation

MergeFlag

enum KisLayerUtils::MergeFlag

Enumerator
None
SkipMergingFrames

Definition at line 31 of file kis_layer_utils.h.

                   {
        None,
        SkipMergingFrames = 0x1
    };

Function Documentation

addCopyOfNameTag()

KRITAIMAGE_EXPORT void KisLayerUtils::addCopyOfNameTag

(

KisNodeSP

node

)

Definition at line 1757 of file kis_layer_utils.cpp.

    {
        if (!KisImageConfig(true).renameDuplicatedLayers()) { return; }
 
        const QString prefix = i18n("Copy of");
        QString newName = node->name();
        if (!newName.startsWith(prefix)) {
            newName = QString("%1 %2").arg(prefix).arg(newName);
            node->setName(newName);
        }
    }

References KisBaseNode::name(), and KisBaseNode::setName().

canChangeImageProfileInvisibly()

KRITAIMAGE_EXPORT bool KisLayerUtils::canChangeImageProfileInvisibly

(

KisImageSP

image

)

Definition at line 2397 of file kis_layer_utils.cpp.

    {
        int numLayers = 0;
        bool hasNonNormalLayers = false;
        bool hasTransparentLayer = false;
 
 
        recursiveApplyNodes(image->root(),
            [&numLayers, &hasNonNormalLayers, &hasTransparentLayer, image] (KisNodeSP node) {
                if (!node->inherits("KisLayer")) return;
 
                numLayers++;
 
                if (node->exactBounds().isEmpty()) return;
 
                // this is only an approximation! it is not exact!
                if (!hasTransparentLayer &&
                    node->exactBounds() != image->bounds()) {
 
                    hasTransparentLayer = true;
                }
 
                if (!hasNonNormalLayers &&
                    node->compositeOpId() != COMPOSITE_OVER) {
 
                    hasNonNormalLayers = true;
                }
            });
 
        return numLayers == 1 || (!hasNonNormalLayers && !hasTransparentLayer);
    }

References COMPOSITE_OVER, KisBaseNode::compositeOpId(), recursiveApplyNodes(), and KisNodeFacade::root.

changeImageDefaultProjectionColor()

KRITAIMAGE_EXPORT void KisLayerUtils::changeImageDefaultProjectionColor	(	KisImageSP	image,
		const KoColor &	color )

Definition at line 1832 of file kis_layer_utils.cpp.

    {
        KisImageSignalVector emitSignals;
        KisProcessingApplicator applicator(image,
                                           image->root(),
                                           KisProcessingApplicator::RECURSIVE,
                                           emitSignals,
                                           kundo2_i18n("Change projection color"),
                                           0,
                                           KisCommandUtils::ChangeProjectionColorCommand);
        applicator.applyCommand(new KisChangeProjectionColorCommand(image, color), KisStrokeJobData::BARRIER, KisStrokeJobData::EXCLUSIVE);
        applicator.end();
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::BARRIER, KisCommandUtils::ChangeProjectionColorCommand, KisProcessingApplicator::end(), KisStrokeJobData::EXCLUSIVE, kundo2_i18n(), KisProcessingApplicator::RECURSIVE, and KisNodeFacade::root.

checkIsChildOf()

KRITAIMAGE_EXPORT bool KisLayerUtils::checkIsChildOf	(	KisNodeSP	node,
		const KisNodeList &	parents )

Definition at line 1593 of file kis_layer_utils.cpp.

    {
        KisNodeList nodeParents;
 
        KisNodeSP parent = node->parent();
        while (parent) {
            nodeParents << parent;
            parent = parent->parent();
        }
 
        foreach(KisNodeSP perspectiveParent, parents) {
            if (nodeParents.contains(perspectiveParent)) {
                return true;
            }
        }
 
        return false;
    }

References KisNode::parent.

checkIsCloneOf()

KRITAIMAGE_EXPORT bool KisLayerUtils::checkIsCloneOf	(	KisNodeSP	node,
		const KisNodeList &	nodes )

Returns true if: o node is a clone of some layer in nodes o node is a clone any child layer of any layer in nodes o node is a clone of a clone of a ..., that in the end points to any layer in nodes of their children.

Definition at line 1612 of file kis_layer_utils.cpp.

    {
        bool result = false;
 
        KisCloneLayer *clone = dynamic_cast<KisCloneLayer*>(node.data());
        if (clone) {
            KisNodeSP cloneSource = KisNodeSP(clone->copyFrom());
 
            Q_FOREACH(KisNodeSP subtree, nodes) {
                result =
                    recursiveFindNode(subtree,
                                      [cloneSource](KisNodeSP node) -> bool
                                      {
                                          return node == cloneSource;
                                      });
 
                if (!result) {
                    result = checkIsCloneOf(cloneSource, nodes);
                }
 
                if (result) {
                    break;
                }
            }
        }
 
        return result;
    }

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

checkNodesDiffer()

template<typename T >

bool KisLayerUtils::checkNodesDiffer	(	KisNodeList	nodes,
		std::function< T(KisNodeSP)>	checkerFunc )

Definition at line 220 of file kis_layer_utils.h.

    {
        bool valueDiffers = false;
        bool initialized = false;
        T currentValue = T();
        Q_FOREACH (KisNodeSP node, nodes) {
            if (!initialized) {
                currentValue = checkerFunc(node);
                initialized = true;
            } else if (currentValue != checkerFunc(node)) {
                valueDiffers = true;
                break;
            }
        }
        return valueDiffers;
    }

convertToPaintLayer()

KRITAIMAGE_EXPORT std::future< KisNodeSP > KisLayerUtils::convertToPaintLayer	(	KisImageSP	image,
		KisNodeSP	src )

Definition at line 2454 of file kis_layer_utils.cpp.

    {
        //Initialize all operation dependencies.
        ConvertToPaintLayerInfoSP info( new ConvertToPaintLayerInfo(image, src) );
 
        if (!info->hasTargetNode())
            return kismpl::make_ready_future(KisNodeSP());
 
        KisImageSignalVector emitSignals;
        KisProcessingApplicator applicator(image, 0, KisProcessingApplicator::NONE, emitSignals, kundo2_i18n("Convert to a Paint Layer"));
 
        applicator.applyCommand(new SimpleAddNode(info->image(), info->targetNode(), info->insertionParent(), info->insertionPutAfter()), KisStrokeJobData::BARRIER);
 
        if (info->frames().count() > 0) {
            Q_FOREACH(const int& frame, info->frames()) {
                applicator.applyCommand(new SwitchFrameCommand(info->image(), frame, false, info->storage));
                applicator.applyCommand(new RefreshDelayedUpdateLayers(info->sourceNodes()), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new RefreshHiddenAreas(info->image(), info->sourceNode()), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new AddNewFrame(info->targetNode(), frame, info->sourceNode()), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new UploadProjectionToFrameCommand(info->sourceNode(), info->targetNode(), frame));
                applicator.applyCommand(new SwitchFrameCommand(info->image(), frame, true, info->storage));
            }
        }
 
        applicator.applyCommand(new SimpleRemoveLayers(info->toRemove(), info->image()));
 
        applicator.end();
 
        return kismpl::then(applicator.successfullyCompletedFuture(),
            [node = info->targetNode()] (std::future<bool> completed) {
                return completed.get() ? node : KisNodeSP();
            });
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::BARRIER, KisProcessingApplicator::end(), kundo2_i18n(), kismpl::make_ready_future(), KisProcessingApplicator::NONE, KisProcessingApplicator::successfullyCompletedFuture(), and kismpl::then().

fetchLayerActiveRasterFrameID()

int KisLayerUtils::fetchLayerActiveRasterFrameID

(

KisNodeSP

node

)

Definition at line 2490 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  -1);
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, -1);
 
        if (!paintDevice->keyframeChannel()) {
            return -1;
        }
 
        const int activeTime = paintDevice->keyframeChannel()->activeKeyframeTime();
        KisRasterKeyframeSP keyframe = paintDevice->keyframeChannel()->activeKeyframeAt<KisRasterKeyframe>(activeTime);
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(keyframe, -1);
 
        return keyframe->frameID();
    }

References KisKeyframeChannel::activeKeyframeAt(), KisKeyframeChannel::activeKeyframeTime(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchLayerActiveRasterFrameSpan()

KRITAIMAGE_EXPORT KisTimeSpan KisLayerUtils::fetchLayerActiveRasterFrameSpan	(	KisNodeSP	node,
		const int	time )

Definition at line 2520 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  KisTimeSpan::infinite(0));
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, KisTimeSpan::infinite(0));
        if (!paintDevice->keyframeChannel()) {
            return KisTimeSpan::infinite(0);
        }
 
        return paintDevice->keyframeChannel()->affectedFrames(time);
    }

References KisKeyframeChannel::affectedFrames(), KisTimeSpan::infinite(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchLayerActiveRasterFrameTime()

KRITAIMAGE_EXPORT int KisLayerUtils::fetchLayerActiveRasterFrameTime

(

KisNodeSP

node

)

Definition at line 2507 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  -1);
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, -1);
 
        if (!paintDevice->keyframeChannel()) {
            return -1;
        }
 
        return paintDevice->keyframeChannel()->activeKeyframeTime();
    }

References KisKeyframeChannel::activeKeyframeTime(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchLayerFrames()

KRITAIMAGE_EXPORT QSet< int > KisLayerUtils::fetchLayerFrames

(

KisNodeSP

node

)

Definition at line 1375 of file kis_layer_utils.cpp.

                                               {
        QSet<int> frames;
        Q_FOREACH(KisKeyframeChannel *channel, node->keyframeChannels()) {
            if (!channel) {
                continue;
            }
 
            KisRasterKeyframeChannel *rasterChan = dynamic_cast<KisRasterKeyframeChannel*>(channel);
            if (rasterChan) {
                frames.unite(rasterChan->allKeyframeTimes());
                continue;
            }
 
            KisScalarKeyframeChannel *scalarChan = dynamic_cast<KisScalarKeyframeChannel*>(channel);
            if (scalarChan) {
                const int initialKeyframe = scalarChan->firstKeyframeTime();
 
                if (initialKeyframe == -1) {
                    continue;
                }
 
                const int lastKeyframe = scalarChan->lastKeyframeTime();
                KisTimeSpan currentSpan = scalarChan->identicalFrames(initialKeyframe);
                while (!currentSpan.isInfinite() && currentSpan.isValid() && currentSpan.start() < lastKeyframe) {
                    frames.insert(currentSpan.start());
                    currentSpan = scalarChan->identicalFrames(currentSpan.end() + 1);
                }
 
                frames.insert(lastKeyframe);
            }
 
        }
 
        return frames;
    }

References KisKeyframeChannel::allKeyframeTimes(), KisTimeSpan::end(), KisKeyframeChannel::firstKeyframeTime(), KisScalarKeyframeChannel::identicalFrames(), KisTimeSpan::isInfinite(), KisTimeSpan::isValid(), KisBaseNode::keyframeChannels, KisKeyframeChannel::lastKeyframeTime(), and KisTimeSpan::start().

fetchLayerFramesRecursive()

KRITAIMAGE_EXPORT QSet< int > KisLayerUtils::fetchLayerFramesRecursive

(

KisNodeSP

rootNode

)

Definition at line 1411 of file kis_layer_utils.cpp.

                                                            {
        if (!rootNode->visible()) return QSet<int>();
 
        QSet<int> frames = fetchLayerFrames(rootNode);
 
        KisNodeSP node = rootNode->firstChild();
        while(node) {
            frames |= fetchLayerFramesRecursive(node);
            node = node->nextSibling();
        }
 
        return frames;
    }

References fetchLayerFrames(), fetchLayerFramesRecursive(), KisNode::firstChild(), KisNode::nextSibling(), and KisBaseNode::visible().

fetchLayerIdenticalRasterFrameTimes()

KRITAIMAGE_EXPORT QSet< int > KisLayerUtils::fetchLayerIdenticalRasterFrameTimes	(	KisNodeSP	node,
		const int &	frameTime )

Definition at line 2532 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  QSet<int>());
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
        if (!paintDevice->keyframeChannel()) {
            return QSet<int>();
        }
 
        return paintDevice->keyframeChannel()->clonesOf(node.data(), frameTime);
    }

References KisRasterKeyframeChannel::clonesOf(), KisSharedPtr< T >::data(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchLayerRasterFrameTimesMatchingID()

QSet< int > KisLayerUtils::fetchLayerRasterFrameTimesMatchingID	(	KisNodeSP	node,
		const int	frameID )

Definition at line 2545 of file kis_layer_utils.cpp.

                                                                                      {
        KIS_ASSERT(node);
        KisRasterKeyframeChannel* rasterChannel = dynamic_cast<KisRasterKeyframeChannel*>(node->getKeyframeChannel(KisKeyframeChannel::Raster.id(), false));
 
        if (!rasterChannel) {
            return QSet<int>();
        }
 
        return rasterChannel->timesForFrameID(frameID);
    }

References KisBaseNode::getKeyframeChannel(), KIS_ASSERT, KisKeyframeChannel::Raster, and KisRasterKeyframeChannel::timesForFrameID().

fetchLayerRasterIDsAtTimes()

QSet< int > KisLayerUtils::fetchLayerRasterIDsAtTimes	(	KisNodeSP	node,
		const QSet< int > &	times )

Definition at line 2556 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  QSet<int>());
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
        if (!paintDevice->keyframeChannel()) {
            return QSet<int>();
        }
 
        QSet<int> frameIDs;
 
        Q_FOREACH( const int& frame, times ) {
            KisRasterKeyframeSP raster = paintDevice->keyframeChannel()->activeKeyframeAt<KisRasterKeyframe>(frame);
            frameIDs << raster->frameID();
        }
 
        return frameIDs;
    }

References KisKeyframeChannel::activeKeyframeAt(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchLayerUniqueRasterTimesMatchingIDs()

QSet< int > KisLayerUtils::fetchLayerUniqueRasterTimesMatchingIDs	(	KisNodeSP	node,
		QSet< int > &	frameIDs )

Definition at line 2587 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  QSet<int>());
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, QSet<int>());
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice->framesInterface(), QSet<int>());
 
        QSet<int> uniqueTimes;
 
        Q_FOREACH( const int& id, frameIDs) {
            QSet<int> times = fetchLayerRasterFrameTimesMatchingID(node, id);
            if (times.count() > 0) {
                uniqueTimes.insert(*times.begin());
            }
        }
 
        return uniqueTimes;
    }

References fetchLayerRasterFrameTimesMatchingID(), KisPaintDevice::framesInterface(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

fetchSelectionMasks()

void KisLayerUtils::fetchSelectionMasks	(	KisNodeList	mergedNodes,
		QVector< KisSelectionMaskSP > &	selectionMasks )

Definition at line 66 of file kis_layer_utils.cpp.

    {
        foreach (KisNodeSP node, mergedNodes) {
 
            Q_FOREACH(KisNodeSP child, node->childNodes(QStringList("KisSelectionMask"), KoProperties())) {
 
                KisSelectionMaskSP mask = qobject_cast<KisSelectionMask*>(child.data());
                if (mask) {
                    selectionMasks.append(mask);
                }
            }
        }
    }

References KisNode::childNodes(), and KisSharedPtr< T >::data().

fetchUniqueFrameTimes()

KRITAIMAGE_EXPORT QSet< int > KisLayerUtils::fetchUniqueFrameTimes	(	KisNodeSP	node,
		QSet< int >	selectedTimes,
		bool	filterActiveFrameID )

Definition at line 2606 of file kis_layer_utils.cpp.

    {
        if (selectedTimes.isEmpty() || !node->supportsKeyframeChannel(KisKeyframeChannel::Raster.id()))
            return selectedTimes;
 
        // Convert a set of selected keyframe times into set of selected "frameIDs"...
        QSet<int> selectedFrameIDs = KisLayerUtils::fetchLayerRasterIDsAtTimes(node, selectedTimes);
 
        if (filterActiveFrameID) {
            // Current frame was already filtered e.g. during filter preview in `KisFilterManager::apply`...
            // So let's remove it...
            const int currentActiveFrameID = KisLayerUtils::fetchLayerActiveRasterFrameID(node);
            selectedFrameIDs.remove(currentActiveFrameID);
        }
 
        // Convert frameIDs to any arbitrary frame time associated with the frameID...
        QSet<int> uniqueFrameTimes = node->paintDevice()->framesInterface() ? KisLayerUtils::fetchLayerUniqueRasterTimesMatchingIDs(node, selectedFrameIDs) : QSet<int>();
 
        return uniqueFrameTimes;
    }

References fetchLayerActiveRasterFrameID(), fetchLayerRasterIDsAtTimes(), fetchLayerUniqueRasterTimesMatchingIDs(), KisPaintDevice::framesInterface(), KoID::id(), KisBaseNode::paintDevice(), KisKeyframeChannel::Raster, and KisBaseNode::supportsKeyframeChannel().

filterInvisibleNodes()

KisNodeList KisLayerUtils::filterInvisibleNodes	(	const KisNodeList &	nodes,
		KisNodeList *	invisibleNodes,
		KisNodeSP *	putAfter )

When a layer is invisible and user-locked we should just skip it and do neither merge nor remove it.

Definition at line 1786 of file kis_layer_utils.cpp.

    {
        KIS_ASSERT_RECOVER(invisibleNodes) { return nodes; }
        KIS_ASSERT_RECOVER(putAfter) { return nodes; }
 
        KisNodeList visibleNodes;
        int putAfterIndex = -1;
 
        Q_FOREACH(KisNodeSP node, nodes) {
            if (node->visible()) {
                visibleNodes << node;
            } else if (node->userLocked()) {
            } else {
                *invisibleNodes << node;
 
                if (node == *putAfter) {
                    putAfterIndex = visibleNodes.size() - 1;
                }
            }
        }
 
        if (!visibleNodes.isEmpty() && putAfterIndex >= 0) {
            putAfterIndex = qBound(0, putAfterIndex, visibleNodes.size() - 1);
            *putAfter = visibleNodes[putAfterIndex];
        }
 
        return visibleNodes;
    }

References KIS_ASSERT_RECOVER, KisBaseNode::userLocked(), and KisBaseNode::visible().

filterMergeableNodes()

KRITAIMAGE_EXPORT void KisLayerUtils::filterMergeableNodes	(	KisNodeList &	nodes,
		bool	allowMasks )

Definition at line 1641 of file kis_layer_utils.cpp.

    {
        KisNodeList::iterator it = nodes.begin();
 
        while (it != nodes.end()) {
            if ((!allowMasks && !qobject_cast<KisLayer*>(it->data())) ||
                checkIsChildOf(*it, nodes)) {
                //qDebug() << "Skipping node" << ppVar((*it)->name());
                it = nodes.erase(it);
            } else {
                ++it;
            }
        }
    }

References checkIsChildOf().

filterTimesForOnlyRasterKeyedTimes()

KRITAIMAGE_EXPORT QSet< int > KisLayerUtils::filterTimesForOnlyRasterKeyedTimes	(	KisNodeSP	node,
		const QSet< int > &	times )

Definition at line 2575 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(node,  times);
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(paintDevice, times);
        if (!paintDevice->keyframeChannel()) {
            return times;
        }
 
        return paintDevice->keyframeChannel()->allKeyframeTimes().intersect(times);
    }

References KisKeyframeChannel::allKeyframeTimes(), KisPaintDevice::keyframeChannel(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and KisBaseNode::paintDevice().

filterUnlockedNodes()

KRITAIMAGE_EXPORT void KisLayerUtils::filterUnlockedNodes

(

KisNodeList &

nodes

)

Definition at line 1819 of file kis_layer_utils.cpp.

    {
        KisNodeList::iterator it = nodes.begin();
 
        while (it != nodes.end()) {
            if ((*it)->userLocked()) {
                it = nodes.erase(it);
            } else {
                ++it;
            }
        }
    }

findImageByHierarchy()

KRITAIMAGE_EXPORT KisImageSP KisLayerUtils::findImageByHierarchy

(

KisNodeSP

node

)

Definition at line 2319 of file kis_layer_utils.cpp.

    {
        while (node) {
            const KisLayer *layer = dynamic_cast<const KisLayer*>(node.data());
            if (layer) {
                return layer->image();
            }
 
            node = node->parent();
        }
 
        return 0;
    }

References KisSharedPtr< T >::data(), KisBaseNode::image, and KisNode::parent.

findIsolationRoot()

KRITAIMAGE_EXPORT KisNodeSP KisLayerUtils::findIsolationRoot

(

KisNodeSP

node

)

Definition at line 2276 of file kis_layer_utils.cpp.

    {
        KisImageSP image = node->image();
        if (image)
            return image->isolationRootNode();
        return nullptr;
    }

References KisBaseNode::image, and KisImage::isolationRootNode().

findNodeByName()

KRITAIMAGE_EXPORT KisNodeSP KisLayerUtils::findNodeByName	(	KisNodeSP	root,
		const QString &	name )

Definition at line 2268 of file kis_layer_utils.cpp.

    {
        return recursiveFindNode(root,
            [name] (KisNodeSP node) {
                return node->name() == name;
        });
    }

References KisBaseNode::name(), and recursiveFindNode().

findNodeByType()

template<class T >

T * KisLayerUtils::findNodeByType

(

KisNodeSP

root

)

Definition at line 275 of file kis_layer_utils.h.

                                      {
        return dynamic_cast<T*>(recursiveFindNode(root, [] (KisNodeSP node) {
            return bool(dynamic_cast<T*>(node.data()));
        }).data());
    }

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

findNodeByUuid()

KRITAIMAGE_EXPORT KisNodeSP KisLayerUtils::findNodeByUuid	(	KisNodeSP	root,
		const QUuid &	uuid )

Recursively searches for a node with specified Uuid

Definition at line 2242 of file kis_layer_utils.cpp.

    {
        return recursiveFindNode(root,
            [uuid] (KisNodeSP node) {
                return node->uuid() == uuid;
        });
    }

References recursiveFindNode(), and KisBaseNode::uuid().

findNodesByName()

KRITAIMAGE_EXPORT QList< KisNodeSP > KisLayerUtils::findNodesByName	(	KisNodeSP	root,
		const QString &	name,
		bool	recursive,
		bool	partialMatch )

Definition at line 2250 of file kis_layer_utils.cpp.

    {
        KisNodeList nodeList;
        KisNodeSP child = root->firstChild();
 
        while (child) {
            if (name.isEmpty() || (!partialMatch && child->name() == name) || (partialMatch && child->name().contains(name, Qt::CaseInsensitive))) {
                nodeList << child;
            }
            if (recursive && child->childCount() > 0) {
                nodeList << findNodesByName(child, name, recursive, partialMatch);
            }
            child = child->nextSibling();
        }
 
        return nodeList;
    }

References KisNode::childCount(), findNodesByName(), KisNode::firstChild(), KisBaseNode::name(), and KisNode::nextSibling().

findNodesWithProps()

KRITAIMAGE_EXPORT KisNodeList KisLayerUtils::findNodesWithProps	(	KisNodeSP	root,
		const KoProperties &	props,
		bool	excludeRoot )

Definition at line 1769 of file kis_layer_utils.cpp.

    {
        KisNodeList nodes;
 
        if ((!excludeRoot || root->parent()) && root->check(props)) {
            nodes << root;
        }
 
        KisNodeSP node = root->firstChild();
        while (node) {
            nodes += findNodesWithProps(node, props, excludeRoot);
            node = node->nextSibling();
        }
 
        return nodes;
    }

References KisBaseNode::check(), findNodesWithProps(), KisNode::firstChild(), KisNode::nextSibling(), and KisNode::parent.

findRoot()

KRITAIMAGE_EXPORT KisNodeSP KisLayerUtils::findRoot

(

KisNodeSP

node

)

Definition at line 2387 of file kis_layer_utils.cpp.

    {
        if (!node) return node;
 
        while (node->parent()) {
            node = node->parent();
        }
        return node;
    }

References KisNode::parent.

flattenImage()

KRITAIMAGE_EXPORT void KisLayerUtils::flattenImage	(	KisImageSP	image,
		KisNodeSP	activeNode,
		MergeFlags	flags )

Definition at line 2192 of file kis_layer_utils.cpp.

    {
        if (!activeNode) {
            activeNode = image->root()->lastChild();
        }
 
 
        KisNodeList mergedNodes;
        mergedNodes << image->root();
 
        mergeMultipleLayersImpl(image, mergedNodes, activeNode,
                                true, kundo2_i18n("Flatten Image"),
                                true, QString(),
                                flags);
    }

References kundo2_i18n(), KisNode::lastChild(), mergeMultipleLayersImpl(), and KisNodeFacade::root.

flattenLayer()

KRITAIMAGE_EXPORT void KisLayerUtils::flattenLayer	(	KisImageSP	image,
		KisLayerSP	layer,
		MergeFlags	flags )

Definition at line 2178 of file kis_layer_utils.cpp.

    {
        if (!layer->childCount() && !layer->layerStyle())
            return;
 
        KisNodeList mergedNodes;
        mergedNodes << layer;
 
        mergeMultipleLayersImpl(image, mergedNodes, layer,
                                true, kundo2_i18n("Flatten Layer"),
                                true, QString(),
                                flags);
    }

References KisNode::childCount(), kundo2_i18n(), KisLayer::layerStyle, and mergeMultipleLayersImpl().

forceAllDelayedNodesUpdate()

KRITAIMAGE_EXPORT void KisLayerUtils::forceAllDelayedNodesUpdate

(

KisNodeSP

root

)

Definition at line 2284 of file kis_layer_utils.cpp.

    {
        KisLayerUtils::recursiveApplyNodes(root,
        [] (KisNodeSP node) {
            KisDelayedUpdateNodeInterface *delayedUpdate =
                    dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
            if (delayedUpdate) {
                delayedUpdate->forceUpdateTimedNode();
            }
        });
    }

References KisSharedPtr< T >::data(), KisDelayedUpdateNodeInterface::forceUpdateTimedNode(), and recursiveApplyNodes().

forceAllHiddenOriginalsUpdate()

KRITAIMAGE_EXPORT void KisLayerUtils::forceAllHiddenOriginalsUpdate

(

KisNodeSP

root

)

Definition at line 2307 of file kis_layer_utils.cpp.

    {
        KisLayerUtils::recursiveApplyNodes(root,
        [] (KisNodeSP node) {
            KisCroppedOriginalLayerInterface *croppedUpdate =
                    dynamic_cast<KisCroppedOriginalLayerInterface*>(node.data());
            if (croppedUpdate) {
                croppedUpdate->forceUpdateHiddenAreaOnOriginal();
            }
        });
    }

References KisSharedPtr< T >::data(), KisCroppedOriginalLayerInterface::forceUpdateHiddenAreaOnOriginal(), and recursiveApplyNodes().

hasDelayedNodeWithUpdates()

KRITAIMAGE_EXPORT bool KisLayerUtils::hasDelayedNodeWithUpdates

(

KisNodeSP

root

)

Definition at line 2296 of file kis_layer_utils.cpp.

    {
        return recursiveFindNode(root,
            [] (KisNodeSP node) {
                KisDelayedUpdateNodeInterface *delayedUpdate =
                    dynamic_cast<KisDelayedUpdateNodeInterface*>(node.data());
 
                return delayedUpdate ? delayedUpdate->hasPendingTimedUpdates() : false;
            });
    }

References KisSharedPtr< T >::data(), KisDelayedUpdateNodeInterface::hasPendingTimedUpdates(), and recursiveFindNode().

mergeDown()

KRITAIMAGE_EXPORT void KisLayerUtils::mergeDown	(	KisImageSP	image,
		KisLayerSP	layer,
		const KisMetaData::MergeStrategy *	strategy,
		MergeFlags	flags )

See also

a comment in mergeMultipleLayersImpl()

Save the original time before we start switching is with asynchronous SwitchFrameCommand.

When switching frames we need to update the entire image, not only the new extent of the layer, hence we pass refresh_entire_image to the command to make sure that the entire image bounds rect is added to the update rect

If source layer is not animated, then just merge that into the current frame to avoid unintentional destruction of the animation on the layer below. To merge the source into all the frames, just make the source animated.

See https://bugs.kde.org/show_bug.cgi?id=475550

Definition at line 1468 of file kis_layer_utils.cpp.

    {
        if (!layer->prevSibling()) return;
 
        // XXX: this breaks if we allow free mixing of masks and layers
        KisLayerSP prevLayer = qobject_cast<KisLayer*>(layer->prevSibling().data());
 
        while (prevLayer && prevLayer->isFakeNode()) {
            prevLayer = qobject_cast<KisLayer*>(prevLayer->prevSibling().data());
        }
 
        if (!prevLayer) return;
 
        if (!layer->visible() && !prevLayer->visible()) {
            return;
        }
 
        KisImageSignalVector emitSignals;
        KisProcessingApplicator applicator(image, 0,
                                           KisProcessingApplicator::NONE,
                                           emitSignals,
                                           kundo2_i18n("Merge Down"));
 
        if (layer->visible() && prevLayer->visible()) {
            MergeDownInfoSP info(new MergeDownInfo(image, prevLayer, layer, flags));
 
            // disable key strokes on all colorize masks, all onion skins on
            // paint layers and wait until update is finished with a barrier
            applicator.applyCommand(new DisableColorizeKeyStrokes(info));
            applicator.applyCommand(new DisableOnionSkins(info));
            applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
            applicator.applyCommand(new KeepMergedNodesSelected(info, false));
            applicator.applyCommand(new FillSelectionMasks(info));
            applicator.applyCommand(new CreateMergedLayer(info), KisStrokeJobData::BARRIER);
 
            // NOTE: shape layer may have emitted spontaneous jobs during layer creation,
            //       wait for them to complete!
            applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
            applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
            // in two-layer mode we disable pass through only when the destination layer
            // is not a group layer
            applicator.applyCommand(new DisablePassThroughForHeadsOnly(info, true));
            applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
            if (info->frames.size() > 0) {
                const int currentTimeOnStart = info->image->animationInterface()->currentTime();
 
                foreach (int frame, info->frames) {
                    applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                    applicator.applyCommand(new AddNewFrame(info, frame));
                    applicator.applyCommand(new RefreshHiddenAreas(info, RefreshHiddenAreas::refresh_entire_image));
                    applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
 
                    const bool skipMergingSourceLayer = !layer->isAnimated() &&
                            frame != currentTimeOnStart;
 
                    applicator.applyCommand(new MergeLayers(info, skipMergingSourceLayer), KisStrokeJobData::BARRIER);
 
                    applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage), KisStrokeJobData::BARRIER);
                }
            } else {
                applicator.applyCommand(new RefreshHiddenAreas(info));
                applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new MergeLayers(info, false), KisStrokeJobData::BARRIER);
            }
 
            applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
            applicator.applyCommand(new CleanUpNodes(info, layer),
                                    KisStrokeJobData::SEQUENTIAL,
                                    KisStrokeJobData::EXCLUSIVE);
            applicator.applyCommand(new KeepMergedNodesSelected(info, true));
        } else if (layer->visible()) {
            applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                 layer, KisNodeSP(),
                                                                 image, false));
 
            applicator.applyCommand(
                new SimpleRemoveLayers(KisNodeList() << prevLayer,
                                       image),
                KisStrokeJobData::SEQUENTIAL,
                KisStrokeJobData::EXCLUSIVE);
 
            applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                 KisNodeSP(), layer,
                                                                 image, true));
        } else if (prevLayer->visible()) {
            applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                 layer, KisNodeSP(),
                                                                 image, false));
 
            applicator.applyCommand(
                new SimpleRemoveLayers(KisNodeList() << layer,
                                       image),
                KisStrokeJobData::SEQUENTIAL,
                KisStrokeJobData::EXCLUSIVE);
 
            applicator.applyCommand(new KeepNodesSelectedCommand(KisNodeList(), KisNodeList(),
                                                                 KisNodeSP(), prevLayer,
                                                                 image, true));
        }
 
        applicator.end();
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::BARRIER, KisSharedPtr< T >::data(), KisProcessingApplicator::end(), KisStrokeJobData::EXCLUSIVE, KisBaseNode::isAnimated(), KisBaseNode::isFakeNode(), kundo2_i18n(), KisProcessingApplicator::NONE, KisNode::prevSibling(), KisLayerUtils::RefreshHiddenAreas::refresh_entire_image, KisStrokeJobData::SEQUENTIAL, and KisBaseNode::visible().

mergeMultipleLayers()

KRITAIMAGE_EXPORT void KisLayerUtils::mergeMultipleLayers	(	KisImageSP	image,
		KisNodeList	mergedNodes,
		KisNodeSP	putAfter,
		MergeFlags	flags )

Definition at line 2062 of file kis_layer_utils.cpp.

    {
        mergeMultipleLayersImpl(image, mergedNodes, putAfter,
                                false, kundo2_i18n("Merge Selected Nodes"),
                                true, QString(),
                                flags);
    }

References kundo2_i18n(), and mergeMultipleLayersImpl().

mergeMultipleLayersImpl()

void KisLayerUtils::mergeMultipleLayersImpl	(	KisImageSP	image,
		KisNodeList	mergedNodes,
		KisNodeSP	putAfter,
		bool	flattenSingleLayer,
		const KUndo2MagicString &	actionName,
		bool	cleanupNodes = true,
		const QString	layerName = QString(),
		MergeFlags	flags = None )

There might be two approaches for merging multiple layers:

1) Consider the selected nodes as a distinct "group" and merge them as if they were isolated from the rest of the image. The key point of this approach is that the look of the image will change, when merging "weird" layers, like adjustment layers or layers with non-normal blending mode.

2) Merge layers in a way to keep the look of the image as unchanged as possible. With this approach one uses a few heuristics:

• when merging multiple layers with non-normal (but equal) blending mode, first merge these layers together using Normal blending mode, then set blending mode of the result to the original blending mode
• when merging multiple layers with different blending modes or layer styles, they are first rasterized, and then laid over each other with their own composite op. The blending mode of the final layer is set to Normal, so the user could clearly see that he should choose the correct blending mode.

Krita uses the second approach: after merge operation, the image should look as if nothing has happened (if it is technically possible).

We have reached the root of the layer hierarchy and didn't manage to find a node that was editable enough for putting our merged result into it. That shouldn't happen in normal circumstances, unless the user chose to make the root layer visible and lock it manually.

When switching frames we need to update the entire image, not only the new extent of the layer, hence we pass refresh_entire_image to the command to make sure that the entire image bounds rect is added to the update rect

Definition at line 1919 of file kis_layer_utils.cpp.

    {
        if (!putAfter) {
            putAfter = mergedNodes.first();
        }
 
        filterMergeableNodes(mergedNodes);
        {
            KisNodeList tempNodes;
            std::swap(mergedNodes, tempNodes);
            sortMergeableNodes(image->root(), tempNodes, mergedNodes);
        }
 
        if (mergedNodes.size() <= 1 &&
            (!flattenSingleLayer && mergedNodes.size() == 1)) return;
 
        KisImageSignalVector emitSignals;
        emitSignals << ComplexNodeReselectionSignal(KisNodeSP(), KisNodeList(), KisNodeSP(), mergedNodes);
 
 
 
        KisNodeList originalNodes = mergedNodes;
        KisNodeList invisibleNodes;
        mergedNodes = filterInvisibleNodes(originalNodes, &invisibleNodes, &putAfter);
 
        if (mergedNodes.isEmpty()) return;
 
 
        // make sure we don't add the new layer into a locked group
        KIS_SAFE_ASSERT_RECOVER_RETURN(putAfter->parent());
        while (putAfter->parent() && !putAfter->parent()->isEditable()) {
            putAfter = putAfter->parent();
        }
 
        if (!putAfter->parent()) {
            return;
        }
 
        KisProcessingApplicator applicator(image, 0,
                                           KisProcessingApplicator::NONE,
                                           emitSignals,
                                           actionName);
 
 
        if (!invisibleNodes.isEmpty() && cleanupNodes) {
 
            /* If the putAfter node is invisible,
             * we should instead pick one of the nodes
             * to be merged to avoid a null putAfter
             * after we remove all invisible layers from
             * the image.
             * (The assumption is that putAfter is among
             * the layers to merge, so if it's invisible,
             * it's going to be removed)
             */
            if (!putAfter->visible()){
                putAfter = mergedNodes.first();
            }
 
            applicator.applyCommand(
                new SimpleRemoveLayers(invisibleNodes,
                                       image),
                KisStrokeJobData::SEQUENTIAL,
                KisStrokeJobData::EXCLUSIVE);
        }
 
        if (mergedNodes.size() > 1 || invisibleNodes.isEmpty()) {
            MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes, flags));
 
            // disable key strokes on all colorize masks, all onion skins on
            // paint layers and wait until update is finished with a barrier
            //
            // when doing "new layer from visible" we should undo these changes
            // before the action stops, because the source layers are **not**
            // removed as a result of this action
            applicator.applyCommand(
                new EphemeralCommandsWrapper(info,
                                             {
                                              new DisableColorizeKeyStrokes(info),
                                              new DisableOnionSkins(info),
                                              new DisablePassThroughForHeadsOnly(info)
                                             },
                                             cleanupNodes));
            applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
            applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, false));
            applicator.applyCommand(new FillSelectionMasks(info));
            applicator.applyCommand(new CreateMergedLayerMultiple(info, layerName), KisStrokeJobData::BARRIER);
            applicator.applyCommand(new EphemeralCommandsWrapper(info, { new DisableExtraCompositing(info) } , cleanupNodes));
            applicator.applyCommand(new KUndo2Command(), KisStrokeJobData::BARRIER);
 
            if (!info->frames.isEmpty()) {
                foreach (int frame, info->frames) {
                    applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
 
                    applicator.applyCommand(new AddNewFrame(info, frame));
                    applicator.applyCommand(new RefreshHiddenAreas(info, RefreshHiddenAreas::refresh_entire_image));
                    applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                    applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
 
                    applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
                }
            } else {
                applicator.applyCommand(new RefreshHiddenAreas(info));
                applicator.applyCommand(new RefreshDelayedUpdateLayers(info), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new MergeLayersMultiple(info), KisStrokeJobData::BARRIER);
            }
 
            //applicator.applyCommand(new MergeMetaData(info, strategy), KisStrokeJobData::BARRIER);
            if (cleanupNodes){
                applicator.applyCommand(new CleanUpNodes(info, putAfter, flattenSingleLayer),
                                            KisStrokeJobData::SEQUENTIAL,
                                        KisStrokeJobData::EXCLUSIVE);
            } else {
                applicator.applyCommand(new UndoEphemeralCommands(info));
                applicator.applyCommand(new InsertNode(info, putAfter),
                                            KisStrokeJobData::SEQUENTIAL,
                                        KisStrokeJobData::EXCLUSIVE);
            }
 
            applicator.applyCommand(new KeepMergedNodesSelected(info, putAfter, true));
        }
 
        applicator.end();
 
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::BARRIER, KisProcessingApplicator::end(), KisStrokeJobData::EXCLUSIVE, filterInvisibleNodes(), filterMergeableNodes(), KisBaseNode::isEditable(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisProcessingApplicator::NONE, KisNode::parent, KisLayerUtils::RefreshHiddenAreas::refresh_entire_image, KisNodeFacade::root, KisStrokeJobData::SEQUENTIAL, sortMergeableNodes(), and KisBaseNode::visible().

mergeMultipleNodes()

KRITAIMAGE_EXPORT void KisLayerUtils::mergeMultipleNodes	(	KisImageSP	image,
		KisNodeList	mergedNodes,
		KisNodeSP	putAfter,
		MergeFlags	flags = None )

Same as mergeMultipleLayers() but tries to merge masks with tryMergeSelectionMasks() first.

Definition at line 2070 of file kis_layer_utils.cpp.

    {
        if (!tryMergeSelectionMasks(image, mergedNodes, putAfter)) {
            mergeMultipleLayers(image, mergedNodes, putAfter, flags);
        }
    }

References mergeMultipleLayers(), and tryMergeSelectionMasks().

newLayerFromVisible()

KRITAIMAGE_EXPORT void KisLayerUtils::newLayerFromVisible	(	KisImageSP	image,
		KisNodeSP	putAfter,
		MergeFlags	flags )

Definition at line 2077 of file kis_layer_utils.cpp.

    {
        KisNodeList mergedNodes;
        mergedNodes << image->root();
 
        mergeMultipleLayersImpl(image, mergedNodes, putAfter,
                                true, kundo2_i18n("New From Visible"),
                                false, i18nc("New layer created from all the visible layers", "Visible"),
                                flags);
    }

References kundo2_i18n(), mergeMultipleLayersImpl(), and KisNodeFacade::root.

recursiveApplyNodes()

template<typename NodePointer , typename Functor >

void KisLayerUtils::recursiveApplyNodes	(	NodePointer	node,
		Functor	func )

Applies func to node and all its children recursively

Definition at line 241 of file kis_layer_utils.h.

    {
        func(node);
 
        node = node->firstChild();
        while (node) {
            recursiveApplyNodes(node, func);
            node = node->nextSibling();
        }
    }

References recursiveApplyNodes().

recursiveFindNode()

KRITAIMAGE_EXPORT KisNodeSP KisLayerUtils::recursiveFindNode	(	KisNodeSP	node,
		std::function< bool(KisNodeSP)>	func )

Walks through node and all its children recursively until func returns true. When func returns true, the node is considered to be found, the search is stopped and the found node is returned to the caller.

Definition at line 2224 of file kis_layer_utils.cpp.

    {
        if (func(node)) {
            return node;
        }
 
        node = node->firstChild();
        while (node) {
            KisNodeSP resultNode = recursiveFindNode(node, func);
            if (resultNode) {
                return resultNode;
            }
            node = node->nextSibling();
        }
 
        return 0;
    }

References KisNode::firstChild(), KisNode::nextSibling(), and recursiveFindNode().

recursiveTightNodeVisibleBounds()

KRITAIMAGE_EXPORT QRect KisLayerUtils::recursiveTightNodeVisibleBounds

(

KisNodeSP

rootNode

)

Definition at line 2378 of file kis_layer_utils.cpp.

    {
        QRect exactBounds;
        recursiveApplyNodes(rootNode, [&exactBounds] (KisNodeSP node) {
            exactBounds |= node->projectionPlane()->tightUserVisibleBounds();
        });
        return exactBounds;
    }

References KisNode::projectionPlane(), and recursiveApplyNodes().

refreshHiddenAreaAsync()

KRITAIMAGE_EXPORT void KisLayerUtils::refreshHiddenAreaAsync	(	KisImageSP	image,
		KisNodeSP	rootNode,
		const QRect &	preparedArea )

Definition at line 2374 of file kis_layer_utils.cpp.

                                                                                                 {
        Private::refreshHiddenAreaAsync(image, rootNode, preparedArea, QRect());
    }

References KisLayerUtils::Private::refreshHiddenAreaAsync().

sortAndFilterAnyMergeableNodesSafe()

KRITAIMAGE_EXPORT KisNodeList KisLayerUtils::sortAndFilterAnyMergeableNodesSafe	(	const KisNodeList &	nodes,
		KisImageSP	image )

Definition at line 1733 of file kis_layer_utils.cpp.

                                                                                               {
        KisNodeList filteredNodes = nodes;
        KisNodeList sortedNodes;
 
        KisLayerUtils::filterMergeableNodes(filteredNodes, true);
 
        bool haveExternalNodes = false;
        Q_FOREACH (KisNodeSP node, nodes) {
            if (node->graphListener() != image->root()->graphListener()) {
                haveExternalNodes = true;
                break;
            }
        }
 
        if (!haveExternalNodes) {
            KisLayerUtils::sortMergeableNodes(image->root(), filteredNodes, sortedNodes);
        } else {
            sortedNodes = filteredNodes;
        }
 
        return sortedNodes;
    }

References filterMergeableNodes(), KisNode::graphListener, KisNodeFacade::root, and sortMergeableNodes().

sortAndFilterMergeableInternalNodes()

KRITAIMAGE_EXPORT KisNodeList KisLayerUtils::sortAndFilterMergeableInternalNodes	(	KisNodeList	nodes,
		bool	allowMasks )

Definition at line 1688 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
 
        KisNodeSP root;
        Q_FOREACH(KisNodeSP node, nodes) {
            KisNodeSP localRoot = node;
            while (localRoot->parent()) {
                localRoot = localRoot->parent();
            }
 
            if (!root) {
                root = localRoot;
            }
            KIS_SAFE_ASSERT_RECOVER(root == localRoot) { return nodes; }
        }
 
        KisNodeList result;
        sortMergeableNodes(root, nodes, result);
        filterMergeableNodes(result, allowMasks);
        return result;
    }

References filterMergeableNodes(), KIS_SAFE_ASSERT_RECOVER, KisNode::parent, and sortMergeableNodes().

sortMergeableInternalNodes()

KRITAIMAGE_EXPORT KisNodeList KisLayerUtils::sortMergeableInternalNodes

(

KisNodeList

nodes

)

Definition at line 1711 of file kis_layer_utils.cpp.

    {
        KIS_SAFE_ASSERT_RECOVER(!nodes.isEmpty()) { return nodes; }
 
        KisNodeSP root;
        Q_FOREACH(KisNodeSP node, nodes) {
            KisNodeSP localRoot = node;
            while (localRoot->parent()) {
                localRoot = localRoot->parent();
            }
 
            if (!root) {
                root = localRoot;
            }
            KIS_SAFE_ASSERT_RECOVER(root == localRoot) { return nodes; }
        }
 
        KisNodeList result;
        sortMergeableNodes(root, nodes, result);
        return result;
    }

References KIS_SAFE_ASSERT_RECOVER, KisNode::parent, and sortMergeableNodes().

sortMergeableNodes() [1/3]

void KisLayerUtils::sortMergeableNodes	(	KisNodeSP	root,
		KisNodeList &	inputNodes,
		KisNodeList &	outputNodes )

By the end of recursion inputNodes must be empty

Definition at line 1656 of file kis_layer_utils.cpp.

    {
        KisNodeList::iterator it = std::find(inputNodes.begin(), inputNodes.end(), root);
 
        if (it != inputNodes.end()) {
            outputNodes << *it;
            inputNodes.erase(it);
        }
 
        if (inputNodes.isEmpty()) {
            return;
        }
 
        KisNodeSP child = root->firstChild();
        while (child) {
            sortMergeableNodes(child, inputNodes, outputNodes);
            child = child->nextSibling();
        }
 
        KIS_ASSERT_RECOVER_NOOP(root->parent() || inputNodes.isEmpty());
    }

References KisNode::firstChild(), KIS_ASSERT_RECOVER_NOOP, KisNode::nextSibling(), KisNode::parent, and sortMergeableNodes().

sortMergeableNodes() [2/3]

KRITAIMAGE_EXPORT KisNodeList KisLayerUtils::sortMergeableNodes	(	KisNodeSP	root,
		KisNodeList	nodes )

Definition at line 1681 of file kis_layer_utils.cpp.

    {
        KisNodeList result;
        sortMergeableNodes(root, nodes, result);
        return result;
    }

References sortMergeableNodes().

sortMergeableNodes() [3/3]

KRITAIMAGE_EXPORT void KisLayerUtils::sortMergeableNodes	(	KisNodeSP	root,
		QList< KisNodeSP > &	inputNodes,
		QList< KisNodeSP > &	outputNodes )

splitAlphaToMask()

KRITAIMAGE_EXPORT void KisLayerUtils::splitAlphaToMask	(	KisImageSP	image,
		KisNodeSP	node,
		const QString &	maskName )

Definition at line 2429 of file kis_layer_utils.cpp.

    {
        SplitAlphaToMaskInfoSP info( new SplitAlphaToMaskInfo(node->image(), node, maskName) );
 
        KisImageSignalVector emitSignals;
        KisProcessingApplicator applicator(image, 0,
                                           KisProcessingApplicator::NONE,
                                           emitSignals,
                                           kundo2_i18n("Split Alpha into a Mask"));
 
        applicator.applyCommand(new SimpleAddNode(info->image, info->getMask(), info->node), KisStrokeJobData::BARRIER);
        applicator.applyCommand(new InitSplitAlphaSelectionMask(info));
        if (info->frames.count() > 0) {
            Q_FOREACH(const int& frame, info->frames) {
                applicator.applyCommand(new SwitchFrameCommand(info->image, frame, false, info->storage));
                applicator.applyCommand(new AddNewFrame(info->getMask(), frame, info->node));
                applicator.applyCommand(new SplitAlphaCommand(info), KisStrokeJobData::BARRIER);
                applicator.applyCommand(new SwitchFrameCommand(info->image, frame, true, info->storage));
            }
        } else {
            applicator.applyCommand(new SplitAlphaCommand(info), KisStrokeJobData::BARRIER);
        }
        applicator.end();
    }

References KisProcessingApplicator::applyCommand(), KisStrokeJobData::BARRIER, KisProcessingApplicator::end(), KisBaseNode::image, kundo2_i18n(), and KisProcessingApplicator::NONE.

splitNonRemovableNodes()

void KisLayerUtils::splitNonRemovableNodes	(	KisNodeList &	nodesToRemove,
		KisNodeList &	_nodesToHide )

Definition at line 1142 of file kis_layer_utils.cpp.

    {
        QSet<KisNodeSP> nodesToHide;
        QSet<KisNodeSP> extraNodesToRemove;
 
        for (auto it = nodesToRemove.begin(); it != nodesToRemove.end(); ++it) {
            KisNodeSP root = *it;
            KIS_SAFE_ASSERT_RECOVER_NOOP(root->visible());
 
            if (!root->isEditable(false)) {
                nodesToHide.insert(root);
            } else {
                bool rootNeedsCarefulRemoval = false;
 
                recursiveApplyNodes(root,
                                    [root, &nodesToHide, &rootNeedsCarefulRemoval] (KisNodeSP node) {
                                        if (!node->isEditable(false)) {
                                            while (node != root) {
                                                nodesToHide.insert(node);
                                                node = node->parent();
                                                KIS_SAFE_ASSERT_RECOVER_BREAK(node);
                                            }
                                            nodesToHide.insert(root);
                                            rootNeedsCarefulRemoval = true;
                                        }
                                    });
 
                if (rootNeedsCarefulRemoval) {
                    recursiveApplyNodes(root,
                                        [&extraNodesToRemove] (KisNodeSP node) {
                                            extraNodesToRemove.insert(node);
                                        });
                }
            }
        }
        nodesToRemove += KisNodeList(extraNodesToRemove.begin(), extraNodesToRemove.end());
        KritaUtils::filterContainer<KisNodeList>(nodesToRemove,
                                                 [nodesToHide](KisNodeSP node) {
                                                     return !nodesToHide.contains(node);
                                                 });
        _nodesToHide = KisNodeList(nodesToHide.begin(), nodesToHide.end());
    }

References KisBaseNode::isEditable(), KIS_SAFE_ASSERT_RECOVER_NOOP, recursiveApplyNodes(), and KisBaseNode::visible().

tryMergeSelectionMasks()

KRITAIMAGE_EXPORT bool KisLayerUtils::tryMergeSelectionMasks	(	KisImageSP	image,
		KisNodeList	mergedNodes,
		KisNodeSP	putAfter )

Definition at line 2139 of file kis_layer_utils.cpp.

    {
        QList<KisSelectionMaskSP> selectionMasks;
 
        for (auto it = mergedNodes.begin(); it != mergedNodes.end(); /*noop*/) {
            KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(it->data());
            if (!mask) {
                it = mergedNodes.erase(it);
            } else {
                selectionMasks.append(mask);
                ++it;
            }
        }
 
        if (mergedNodes.isEmpty()) return false;
 
        KisLayerSP parentLayer = qobject_cast<KisLayer*>(selectionMasks.first()->parent().data());
        KIS_ASSERT_RECOVER(parentLayer) { return 0; }
 
        KisImageSignalVector emitSignals;
 
        KisProcessingApplicator applicator(image, 0,
                                           KisProcessingApplicator::NONE,
                                           emitSignals,
                                           kundo2_i18n("Merge Selection Masks"));
 
        MergeMultipleInfoSP info(new MergeMultipleInfo(image, mergedNodes, None));
 
 
        applicator.applyCommand(new MergeSelectionMasks(info, putAfter));
        applicator.applyCommand(new CleanUpNodes(info, putAfter),
                                KisStrokeJobData::SEQUENTIAL,
                                KisStrokeJobData::EXCLUSIVE);
        applicator.applyCommand(new ActivateSelectionMask(info));
        applicator.end();
 
        return true;
    }

References KisProcessingApplicator::applyCommand(), KisProcessingApplicator::end(), KisStrokeJobData::EXCLUSIVE, KIS_ASSERT_RECOVER, kundo2_i18n(), None, KisProcessingApplicator::NONE, and KisStrokeJobData::SEQUENTIAL.

updateFrameJobs()

void KisLayerUtils::updateFrameJobs	(	FrameJobs *	jobs,
		KisNodeSP	node )

Definition at line 1425 of file kis_layer_utils.cpp.

                                                          {
        QSet<int> frames = fetchLayerFrames(node);
        frames = fetchUniqueFrameTimes(node, frames, false);
 
        if (frames.isEmpty()) {
            (*jobs)[0].insert(node);
        } else {
            foreach (int frame, frames) {
                (*jobs)[frame].insert(node);
            }
        }
    }

References fetchLayerFrames(), and fetchUniqueFrameTimes().

updateFrameJobsNonRecursive()

void KisLayerUtils::updateFrameJobsNonRecursive	(	FrameJobs *	jobs,
		KisNodeSP	rootNode,
		bool	frameTimesRecursive = false )

updateFrameJobsNonRecursive updates the frame jobs non-recursively, that is, on the rootNode only.

Parameters

frameTimesRecursive

– whether to make the frame times themselves recursive, or to only use the frames on the root node.

Definition at line 1448 of file kis_layer_utils.cpp.

    {
        if (frameTimesRecursive) {
            QSet<int> frames = fetchLayerFramesRecursive(rootNode);
 
            if (frames.isEmpty()) {
                (*jobs)[0].insert(rootNode);
            } else {
                foreach (int frame, frames) {
                    (*jobs)[frame].insert(rootNode);
                }
            }
        } else {
            updateFrameJobs(jobs, rootNode);
        }
    }

References fetchLayerFramesRecursive(), and updateFrameJobs().

updateFrameJobsRecursive()

void KisLayerUtils::updateFrameJobsRecursive	(	FrameJobs *	jobs,
		KisNodeSP	rootNode )

Definition at line 1438 of file kis_layer_utils.cpp.

                                                                       {
        updateFrameJobs(jobs, rootNode);
 
        KisNodeSP node = rootNode->firstChild();
        while(node) {
            updateFrameJobsRecursive(jobs, node);
            node = node->nextSibling();
        }
    }

References KisNode::firstChild(), KisNode::nextSibling(), updateFrameJobs(), and updateFrameJobsRecursive().