kis_node_juggler_compressed.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2015 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_node_juggler_compressed.h"
 
#include <QHash>
#include <QSharedPointer>
#include <QPointer>
#include <QMutexLocker>
 
#include "kis_global.h"
#include "kis_image.h"
#include "kis_processing_applicator.h"
#include "commands/kis_image_layer_move_command.h"
#include "commands/kis_image_layer_add_command.h"
#include "kis_signal_compressor.h"
#include "kis_command_utils.h"
#include "kis_layer_utils.h"
#include "kis_node_manager.h"
#include "kis_layer.h"
#include "kis_generator_layer.h"
#include "kis_selection_mask.h"
 
 
struct MoveNodeStruct {
    MoveNodeStruct(KisImageSP _image, KisNodeSP _node, KisNodeSP _parent, KisNodeSP _above)
        : image(_image),
          node(_node),
          newParent(_parent),
          newAbove(_above),
          oldParent(_node->parent()),
          oldAbove(_node->prevSibling()),
          suppressNewParentRefresh(false),
          suppressOldParentRefresh(false)
    {
    }
 
    bool tryMerge(const MoveNodeStruct &rhs) {
        if (rhs.node != node) return false;
 
        bool result = true;
 
        if (newParent == rhs.oldParent) {
            // 'rhs' is newer
            newParent = rhs.newParent;
            newAbove = rhs.newAbove;
        } else if (oldParent == rhs.newParent) {
            // 'this' is newer
            oldParent = rhs.oldParent;
            oldAbove = rhs.oldAbove;
        } else {
            warnKrita << "MoveNodeStruct: Trying to merge unsequential moves!";
            result = false;
        }
 
        return result;
    }
 
    void doRedoUpdates() {
        if (oldParent && !suppressOldParentRefresh) {
            image->refreshGraphAsync(oldParent, KisProjectionUpdateFlag::NoFilthy);
        }
 
        if (newParent && oldParent != newParent) {
            node->setDirty(image->bounds());
        }
    }
 
    void doUndoUpdates() {
        if (newParent && !suppressNewParentRefresh) {
            image->refreshGraphAsync(newParent, KisProjectionUpdateFlag::NoFilthy);
        }
 
        if (oldParent && oldParent != newParent) {
            node->setDirty(image->bounds());
        }
    }
 
    KisImageSP image;
    KisNodeSP node;
    KisNodeSP newParent;
    KisNodeSP newAbove;
 
    KisNodeSP oldParent;
    KisNodeSP oldAbove;
    bool suppressNewParentRefresh;
    bool suppressOldParentRefresh;
};
 
typedef QSharedPointer<MoveNodeStruct> MoveNodeStructSP;
typedef QHash<KisNodeSP, MoveNodeStructSP> MovedNodesHash;
 
 
class BatchMoveUpdateData {
    MovedNodesHash m_movedNodesInitial;
    MovedNodesHash m_movedNodesUpdated;
 
    QMutex m_mutex;
 
    QPointer<KisNodeJugglerCompressed> m_parentJuggler;
 
public:
    BatchMoveUpdateData(KisNodeJugglerCompressed *parentJuggler)
        : m_parentJuggler(parentJuggler) {}
 
private:
 
    struct NewParentCollisionPolicy {
        static void setSuppressRefresh(MoveNodeStructSP update, bool value) {
            update->suppressNewParentRefresh = value;
        }
        static bool compare(MoveNodeStructSP lhs, MoveNodeStructSP rhs) {
            return lhs->newParent < rhs->newParent;
        }
    };
 
    struct OldParentCollisionPolicy {
        static void setSuppressRefresh(MoveNodeStructSP update, bool value) {
            update->suppressOldParentRefresh = value;
        }
        static bool compare(MoveNodeStructSP lhs, MoveNodeStructSP rhs) {
            return lhs->oldParent < rhs->oldParent;
        }
    };
 
    template <typename CollisionPolicy>
    static void resolveParentCollisionsImpl(MovedNodesHash *hash) {
        QVector<MoveNodeStructSP> updates;
        std::copy(hash->begin(), hash->end(), std::back_inserter(updates));
        std::sort(updates.begin(), updates.end(), CollisionPolicy::compare);
 
        auto rangeBegin = updates.begin();
 
        while (rangeBegin != updates.end()) {
            auto rangeEnd = std::upper_bound(rangeBegin, updates.end(), *rangeBegin, CollisionPolicy::compare);
 
            for (auto it = rangeBegin; it != std::prev(rangeEnd); ++it) {
                CollisionPolicy::setSuppressRefresh(*it, true);
            }
            CollisionPolicy::setSuppressRefresh(*std::prev(rangeEnd), false);
 
            rangeBegin = rangeEnd;
        }
    }
 
    static void resolveParentCollisions(MovedNodesHash *hash) {
        resolveParentCollisionsImpl<NewParentCollisionPolicy>(hash);
        resolveParentCollisionsImpl<OldParentCollisionPolicy>(hash);
    }
 
    static void addToHashLazy(MovedNodesHash *hash, MoveNodeStructSP moveStruct) {
        if (hash->contains(moveStruct->node)) {
            bool result = hash->value(moveStruct->node)->tryMerge(*moveStruct);
            KIS_ASSERT_RECOVER_NOOP(result);
        } else {
            hash->insert(moveStruct->node, moveStruct);
        }
    }
 
public:
 
    void processUnhandledUpdates() {
        QMutexLocker l(&m_mutex);
 
        if (m_movedNodesInitial.isEmpty()) return;
 
        MovedNodesHash::const_iterator it = m_movedNodesInitial.constBegin();
        MovedNodesHash::const_iterator end = m_movedNodesInitial.constEnd();
 
        for (; it != end; ++it) {
            it.value()->doRedoUpdates();
            addToHashLazy(&m_movedNodesUpdated, it.value());
        }
 
        resolveParentCollisions(&m_movedNodesUpdated);
 
        m_movedNodesInitial.clear();
    }
 
    void addInitialUpdate(MoveNodeStructSP moveStruct) {
        {
            QMutexLocker l(&m_mutex);
            addToHashLazy(&m_movedNodesInitial, moveStruct);
            resolveParentCollisions(&m_movedNodesInitial);
 
            // the juggler might directly forward the signal to processUnhandledUpdates,
            // which would also like to get a lock, so we should release it beforehand
        }
        if (m_parentJuggler) {
            Q_EMIT m_parentJuggler->requestUpdateAsyncFromCommand();
        }
    }
 
    void emitFinalUpdates(KisCommandUtils::FlipFlopCommand::State state) {
        QMutexLocker l(&m_mutex);
 
        if (m_movedNodesUpdated.isEmpty()) return;
 
        MovedNodesHash::const_iterator it = m_movedNodesUpdated.constBegin();
        MovedNodesHash::const_iterator end = m_movedNodesUpdated.constEnd();
 
        for (; it != end; ++it) {
            if (state == KisCommandUtils::FlipFlopCommand::State::FINALIZING) {
                it.value()->doRedoUpdates();
            } else {
                it.value()->doUndoUpdates();
            }
        }
    }
};
 
typedef QSharedPointer<BatchMoveUpdateData> BatchMoveUpdateDataSP;
 
class UpdateMovedNodesCommand : public KisCommandUtils::FlipFlopCommand
{
public:
    UpdateMovedNodesCommand(BatchMoveUpdateDataSP updateData, bool finalize, KUndo2Command *parent = 0)
        : FlipFlopCommand(finalize, parent),
          m_updateData(updateData)
    {
    }
 
    void partB() override {
        State currentState = getState();
 
        if (currentState == FINALIZING && isFirstRedo()) {
            m_updateData->processUnhandledUpdates();
        } else {
            m_updateData->emitFinalUpdates(currentState);
        }
    }
private:
    BatchMoveUpdateDataSP m_updateData;
};
 
class ActivateSelectionMasksCommand : public KisCommandUtils::FlipFlopCommand
{
public:
    ActivateSelectionMasksCommand(const QList<KisSelectionMaskSP> &activeBefore,
                                  const QList<KisSelectionMaskSP> &activeAfter,
                                  bool finalize, KUndo2Command *parent = 0)
        : FlipFlopCommand(finalize, parent),
          m_activeBefore(activeBefore),
          m_activeAfter(activeAfter)
    {
    }
 
    void partA() override {
        QList<KisSelectionMaskSP> *newActiveMasks;
 
        if (getState() == FINALIZING) {
            newActiveMasks = &m_activeAfter;
        } else {
            newActiveMasks = &m_activeBefore;
        }
 
        Q_FOREACH (KisSelectionMaskSP mask, *newActiveMasks) {
            mask->setActive(false);
        }
    }
 
    void partB() override {
        QList<KisSelectionMaskSP> *newActiveMasks;
 
        if (getState() == FINALIZING) {
            newActiveMasks = &m_activeAfter;
        } else {
            newActiveMasks = &m_activeBefore;
        }
 
        Q_FOREACH (KisSelectionMaskSP mask, *newActiveMasks) {
            mask->setActive(true);
        }
    }
 
private:
    QList<KisSelectionMaskSP> m_activeBefore;
    QList<KisSelectionMaskSP> m_activeAfter;
};
 
 
struct LowerRaiseLayer : public KisCommandUtils::AggregateCommand {
    LowerRaiseLayer(BatchMoveUpdateDataSP updateData,
                    KisImageSP image,
                    const KisNodeList &nodes,
                    KisNodeSP activeNode,
                    bool lower)
        : m_updateData(updateData),
          m_image(image),
          m_nodes(nodes),
          m_activeNode(activeNode),
          m_lower (lower) {}
 
    enum NodesType {
        AllLayers,
        Mixed,
        AllMasks
    };
 
    NodesType getNodesType(KisNodeList nodes) {
        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;
    }
 
    bool allowsAsChildren(KisNodeSP parent, KisNodeList nodes) {
        if (!parent->isEditable(false)) return false;
 
        Q_FOREACH (KisNodeSP node, nodes) {
            if (!parent->allowAsChild(node)) return false;
        }
 
        return true;
    }
 
    void populateChildCommands() override {
        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));
    }
 
private:
    BatchMoveUpdateDataSP m_updateData;
    KisImageSP m_image;
    KisNodeList m_nodes;
    KisNodeSP m_activeNode;
    bool m_lower;
};
 
struct DuplicateLayers : public KisCommandUtils::AggregateCommand {
    enum Mode {
        MOVE,
        COPY,
        ADD
    };
 
    DuplicateLayers(BatchMoveUpdateDataSP updateData,
                    KisImageSP image,
                    const KisNodeList &nodes,
                    KisNodeSP dstParent,
                    KisNodeSP dstAbove,
                    KisNodeSP activeNode,
                    Mode mode)
        : m_updateData(updateData),
          m_image(image),
          m_nodes(nodes),
          m_dstParent(dstParent),
          m_dstAbove(dstAbove),
          m_activeNode(activeNode),
          m_mode(mode) {}
 
    void populateChildCommands() override {
        KisNodeList filteredNodes = KisLayerUtils::sortAndFilterAnyMergeableNodesSafe(m_nodes, m_image);
 
        if (filteredNodes.isEmpty()) return;
 
        KisNodeSP newAbove = filteredNodes.last();
 
        // make sure we don't add the new layer into a locked group
        while (newAbove->parent() && !newAbove->parent()->isEditable(false)) {
            newAbove = newAbove->parent();
        }
 
        KisNodeSP newParent = newAbove->parent();
 
        // override parent if provided externally
        if (m_dstParent) {
            newAbove = m_dstAbove;
            newParent = m_dstParent;
        }
 
        const int indexOfActiveNode = filteredNodes.indexOf(m_activeNode);
        QList<KisSelectionMaskSP> activeMasks = findActiveSelectionMasks(filteredNodes);
 
        // we will deactivate the masks before processing, so we should
        // save their list in a convenient form
        QSet<KisNodeSP> activeMaskNodes;
        Q_FOREACH (KisSelectionMaskSP mask, activeMasks) {
            activeMaskNodes.insert(mask);
        }
 
        const bool haveActiveMasks = !activeMasks.isEmpty();
 
        if (!newParent) return;
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(filteredNodes, KisNodeList(),
                                                               m_activeNode, KisNodeSP(),
                                                               m_image, false));
 
        if (haveActiveMasks) {
            addCommand(new ActivateSelectionMasksCommand(activeMasks,
                                                         QList<KisSelectionMaskSP>(),
                                                         false));
        }
 
        KisNodeList newNodes;
        QList<KisSelectionMaskSP> newActiveMasks;
        KisNodeSP currentAbove = newAbove;
        Q_FOREACH (KisNodeSP node, filteredNodes) {
            if (m_mode == COPY || m_mode == ADD) {
                KisNodeSP newNode;
 
                if (m_mode == COPY) {
                    newNode = node->clone();
                    KisLayerUtils::addCopyOfNameTag(newNode);
                } else {
                    newNode = node;
                }
 
                newNodes << newNode;
                if (haveActiveMasks && activeMaskNodes.contains(node)) {
                    KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(newNode.data());
                    newActiveMasks << mask;
                }
 
                MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, newNode, newParent, currentAbove));
                m_updateData->addInitialUpdate(moveStruct);
 
                addCommand(new KisImageLayerAddCommand(m_image, newNode,
                                                       newParent,
                                                       currentAbove,
                                                       false, false));
 
                currentAbove = newNode;
            } else if (m_mode == MOVE) {
                KisNodeSP newNode = node;
 
                newNodes << newNode;
                if (haveActiveMasks && activeMaskNodes.contains(node)) {
                    KisSelectionMaskSP mask = dynamic_cast<KisSelectionMask*>(newNode.data());
                    newActiveMasks << mask;
                }
 
                MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, newNode, newParent, currentAbove));
                m_updateData->addInitialUpdate(moveStruct);
 
                addCommand(new KisImageLayerMoveCommand(m_image, newNode,
                                                        newParent,
                                                        currentAbove,
                                                        false));
                currentAbove = newNode;
            }
        }
 
 
        if (haveActiveMasks) {
            addCommand(new ActivateSelectionMasksCommand(QList<KisSelectionMaskSP>(),
                                                         newActiveMasks,
                                                         true));
        }
 
        KisNodeSP newActiveNode = newNodes[qBound(0, indexOfActiveNode, newNodes.size() - 1)];
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(KisNodeList(), newNodes,
                                                               KisNodeSP(), newActiveNode,
                                                               m_image, true));
    }
private:
    KisSelectionMaskSP toActiveSelectionMask(KisNodeSP node) {
        KisSelectionMask *mask = dynamic_cast<KisSelectionMask*>(node.data());
        return mask && mask->active() ? mask : 0;
    }
 
 
    QList<KisSelectionMaskSP> findActiveSelectionMasks(KisNodeList nodes) {
        QList<KisSelectionMaskSP> masks;
        foreach (KisNodeSP node, nodes) {
            KisSelectionMaskSP mask = toActiveSelectionMask(node);
            if (mask) {
                masks << mask;
            }
        }
        return masks;
    }
private:
    BatchMoveUpdateDataSP m_updateData;
    KisImageSP m_image;
    KisNodeList m_nodes;
    KisNodeSP m_dstParent;
    KisNodeSP m_dstAbove;
    KisNodeSP m_activeNode;
    Mode m_mode;
};
 
struct RemoveLayers : private KisLayerUtils::RemoveNodeHelper, public KisCommandUtils::AggregateCommand {
    RemoveLayers(BatchMoveUpdateDataSP updateData,
                 KisImageSP image,
                 const KisNodeList &nodes,
                 KisNodeSP activeNode)
        : m_updateData(updateData),
          m_image(image),
          m_nodes(nodes),
          m_activeNode(activeNode){}
 
    void populateChildCommands() override {
        KisNodeList filteredNodes = m_nodes;
        KisLayerUtils::filterMergeableNodes(filteredNodes, true);
        KisLayerUtils::filterUnlockedNodes(filteredNodes);
 
        if (filteredNodes.isEmpty()) return;
 
        Q_FOREACH (KisNodeSP node, filteredNodes) {
            MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_image, node, KisNodeSP(), KisNodeSP()));
            m_updateData->addInitialUpdate(moveStruct);
        }
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(filteredNodes, KisNodeList(),
                                                               m_activeNode, KisNodeSP(),
                                                               m_image, false));
 
        safeRemoveMultipleNodes(filteredNodes, m_image);
 
        addCommand(new KisLayerUtils::KeepNodesSelectedCommand(filteredNodes, KisNodeList(),
                                                               m_activeNode, KisNodeSP(),
                                                               m_image, true));
    }
protected:
    void addCommandImpl(KUndo2Command *cmd) override {
        addCommand(cmd);
    }
 
private:
    BatchMoveUpdateDataSP m_updateData;
    KisImageSP m_image;
    KisNodeList m_nodes;
    KisNodeSP m_activeNode;
};
 
struct KisNodeJugglerCompressed::Private
{
    Private(KisNodeJugglerCompressed *juggler, const KUndo2MagicString &_actionName, KisImageSP _image, KisNodeManager *_nodeManager, int _timeout)
        : actionName(_actionName),
          image(_image),
          nodeManager(_nodeManager),
          compressor(_timeout, KisSignalCompressor::FIRST_ACTIVE_POSTPONE_NEXT),
          selfDestructionCompressor(3 * _timeout, KisSignalCompressor::POSTPONE),
          updateData(new BatchMoveUpdateData(juggler)),
          autoDelete(false),
          isStarted(false)
    {}
 
    KUndo2MagicString actionName;
    KisImageSP image;
    KisNodeManager *nodeManager;
    QScopedPointer<KisProcessingApplicator> applicator;
 
    KisSignalCompressor compressor;
    KisSignalCompressor selfDestructionCompressor;
 
    BatchMoveUpdateDataSP updateData;
 
    bool autoDelete;
    bool isStarted;
};
 
KisNodeJugglerCompressed::KisNodeJugglerCompressed(const KUndo2MagicString &actionName, KisImageSP image, KisNodeManager *nodeManager, int timeout)
    : m_d(new Private(this, actionName, image, nodeManager, timeout))
{
 
    KisImageSignalVector emitSignals;
 
    m_d->applicator.reset(
        new KisProcessingApplicator(m_d->image, 0,
                                    KisProcessingApplicator::NONE,
                                    emitSignals,
                                    actionName));
    connect(this, SIGNAL(requestUpdateAsyncFromCommand()), SLOT(startTimers()));
    connect(&m_d->compressor, SIGNAL(timeout()), SLOT(slotUpdateTimeout()));
 
    connect(m_d->image, SIGNAL(sigStrokeCancellationRequested()), SLOT(slotEndStrokeRequested()));
    connect(m_d->image, SIGNAL(sigUndoDuringStrokeRequested()), SLOT(slotUndoDuringStrokeRequested()));
    connect(m_d->image, SIGNAL(sigStrokeEndRequestedActiveNodeFiltered()), SLOT(slotEndStrokeRequested()));
    connect(m_d->image, SIGNAL(sigAboutToBeDeleted()), SLOT(slotImageAboutToBeDeleted()));
 
    m_d->applicator->applyCommand(
        new UpdateMovedNodesCommand(m_d->updateData, false));
    m_d->isStarted = true;
}
 
KisNodeJugglerCompressed::~KisNodeJugglerCompressed()
{
    KIS_ASSERT_RECOVER(!m_d->applicator) {
        m_d->applicator->end();
        m_d->applicator.reset();
    }
}
 
bool KisNodeJugglerCompressed::canMergeAction(const KUndo2MagicString &actionName)
{
    return actionName == m_d->actionName;
}
 
void KisNodeJugglerCompressed::lowerNode(const KisNodeList &nodes)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new LowerRaiseLayer(m_d->updateData,
                            m_d->image,
                            nodes, activeNode, true),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
}
 
void KisNodeJugglerCompressed::raiseNode(const KisNodeList &nodes)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new LowerRaiseLayer(m_d->updateData,
                            m_d->image,
                            nodes, activeNode, false),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::removeNode(const KisNodeList &nodes)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new RemoveLayers(m_d->updateData,
                         m_d->image,
                         nodes, activeNode),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::duplicateNode(const KisNodeList &nodes)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new DuplicateLayers(m_d->updateData,
                            m_d->image,
                            nodes,
                            KisNodeSP(), KisNodeSP(),
                            activeNode,
                            DuplicateLayers::COPY),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::copyNode(const KisNodeList &nodes, KisNodeSP dstParent, KisNodeSP dstAbove)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new DuplicateLayers(m_d->updateData,
                            m_d->image,
                            nodes,
                            dstParent, dstAbove,
                            activeNode,
                            DuplicateLayers::COPY),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::moveNode(const KisNodeList &nodes, KisNodeSP dstParent, KisNodeSP dstAbove)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new DuplicateLayers(m_d->updateData,
                            m_d->image,
                            nodes,
                            dstParent, dstAbove,
                            activeNode,
                            DuplicateLayers::MOVE),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::addNode(const KisNodeList &nodes, KisNodeSP dstParent, KisNodeSP dstAbove)
{
    KisNodeSP activeNode = m_d->nodeManager ? m_d->nodeManager->activeNode() : 0;
 
    m_d->applicator->applyCommand(
        new DuplicateLayers(m_d->updateData,
                            m_d->image,
                            nodes,
                            dstParent, dstAbove,
                            activeNode,
                            DuplicateLayers::ADD),
                KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
}
 
void KisNodeJugglerCompressed::moveNode(KisNodeSP node, KisNodeSP parent, KisNodeSP above)
{
    m_d->applicator->applyCommand(new KisImageLayerMoveCommand(m_d->image, node, parent, above, false),
                                  KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
    MoveNodeStructSP moveStruct = toQShared(new MoveNodeStruct(m_d->image, node, parent, above));
 
    m_d->updateData->addInitialUpdate(moveStruct);
}
 
void KisNodeJugglerCompressed::startTimers()
{
    m_d->compressor.start();
 
    if (m_d->autoDelete) {
        m_d->selfDestructionCompressor.start();
    }
}
 
void KisNodeJugglerCompressed::slotUpdateTimeout()
{
    // The juggler could have been already finished explicitly
    // by slotEndStrokeRequested(). In such a case the final updates
    // will be issued by the last command of the stroke.
 
    if (!m_d->updateData || !m_d->isStarted) return;
 
    BatchMoveUpdateDataSP updateData = m_d->updateData;
 
    m_d->applicator->applyCommand(
        new KisCommandUtils::LambdaCommand(
            [updateData] () {
                updateData->processUnhandledUpdates();
                return nullptr;
            }));
}
 
void KisNodeJugglerCompressed::end()
{
    if (!m_d->isStarted) return;
 
    m_d->applicator->applyCommand(
        new UpdateMovedNodesCommand(m_d->updateData, true));
 
    m_d->applicator->end();
    cleanup();
}
 
void KisNodeJugglerCompressed::cleanup()
{
    m_d->applicator.reset();
    m_d->compressor.stop();
    m_d->image.clear();
    m_d->updateData.clear();
    m_d->isStarted = false;
 
    if (m_d->autoDelete) {
        m_d->selfDestructionCompressor.stop();
        this->deleteLater();
    }
}
 
void KisNodeJugglerCompressed::setAutoDelete(bool value)
{
    m_d->autoDelete = value;
    connect(&m_d->selfDestructionCompressor, SIGNAL(timeout()), SLOT(end()));
}
 
void KisNodeJugglerCompressed::slotEndStrokeRequested()
{
    if (!m_d->isStarted) return;
    end();
}
 
void KisNodeJugglerCompressed::slotUndoDuringStrokeRequested()
{
    if (!m_d->isStarted) return;
 
    KisImageSP image = m_d->image;
    end();
    image->waitForDone();
}
 
void KisNodeJugglerCompressed::slotImageAboutToBeDeleted()
{
    if (!m_d->isStarted) return;
 
    end();
}
 
bool KisNodeJugglerCompressed::isEnded() const
{
    return !m_d->isStarted;
}