BatchMoveUpdateData Class Reference

Classes
struct	NewParentCollisionPolicy
struct	OldParentCollisionPolicy

Public Member Functions
void	addInitialUpdate (MoveNodeStructSP moveStruct)
	BatchMoveUpdateData (KisNodeJugglerCompressed *parentJuggler)
void	emitFinalUpdates (KisCommandUtils::FlipFlopCommand::State state)
void	processUnhandledUpdates ()

Static Private Member Functions
static void	addToHashLazy (MovedNodesHash *hash, MoveNodeStructSP moveStruct)
static void	resolveParentCollisions (MovedNodesHash *hash)
template<typename CollisionPolicy >
static void	resolveParentCollisionsImpl (MovedNodesHash *hash)

Private Attributes
MovedNodesHash	m_movedNodesInitial
MovedNodesHash	m_movedNodesUpdated
QMutex	m_mutex
QPointer< KisNodeJugglerCompressed >	m_parentJuggler

Detailed Description

All the commands executed by the stroke system are running in the background asynchronously. But, at the same time, they Q_EMIT updates in parallel to the ones emitted by the juggler. Therefore, the juggler and all its commands should share some data: which updates have been requested, but not yet dispatched (m_movedNodesInitial), and what updates have already been processed and executed (m_movedNodesUpdated). This object is shared via a shared pointer and guarantees safe (including thread-safe) access to the shared data.

Definition at line 120 of file kis_node_juggler_compressed.cpp.

Constructor & Destructor Documentation

BatchMoveUpdateData()

BatchMoveUpdateData::BatchMoveUpdateData ( KisNodeJugglerCompressed * parentJuggler )

inline

Definition at line 129 of file kis_node_juggler_compressed.cpp.

        : m_parentJuggler(parentJuggler) {}

Member Function Documentation

addInitialUpdate()

void BatchMoveUpdateData::addInitialUpdate ( MoveNodeStructSP moveStruct )

inline

Definition at line 206 of file kis_node_juggler_compressed.cpp.

                                                       {
        {
            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();
        }
    }

References addToHashLazy(), m_movedNodesInitial, m_mutex, m_parentJuggler, and resolveParentCollisions().

addToHashLazy()

static void BatchMoveUpdateData::addToHashLazy ( MovedNodesHash * hash, MoveNodeStructSP moveStruct )

inlinestaticprivate

Definition at line 177 of file kis_node_juggler_compressed.cpp.

                                                                                 {
        if (hash->contains(moveStruct->node)) {
            bool result = hash->value(moveStruct->node)->tryMerge(*moveStruct);
            KIS_ASSERT_RECOVER_NOOP(result);
        } else {
            hash->insert(moveStruct->node, moveStruct);
        }
    }

References KIS_ASSERT_RECOVER_NOOP.

emitFinalUpdates()

void BatchMoveUpdateData::emitFinalUpdates ( KisCommandUtils::FlipFlopCommand::State state )

inline

Definition at line 220 of file kis_node_juggler_compressed.cpp.

                                                                     {
        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();
            }
        }
    }

References KisCommandUtils::FlipFlopCommand::FINALIZING, m_movedNodesUpdated, and m_mutex.

processUnhandledUpdates()

void BatchMoveUpdateData::processUnhandledUpdates ( )

inline

Definition at line 188 of file kis_node_juggler_compressed.cpp.

                                   {
        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();
    }

References addToHashLazy(), m_movedNodesInitial, m_movedNodesUpdated, m_mutex, and resolveParentCollisions().

resolveParentCollisions()

static void BatchMoveUpdateData::resolveParentCollisions ( MovedNodesHash * hash )

inlinestaticprivate

Definition at line 172 of file kis_node_juggler_compressed.cpp.

                                                              {
        resolveParentCollisionsImpl<NewParentCollisionPolicy>(hash);
        resolveParentCollisionsImpl<OldParentCollisionPolicy>(hash);
    }

resolveParentCollisionsImpl()

template<typename CollisionPolicy >

static void BatchMoveUpdateData::resolveParentCollisionsImpl ( MovedNodesHash * hash )

inlinestaticprivate

Definition at line 153 of file kis_node_juggler_compressed.cpp.

                                                                  {
        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;
        }
    }

Member Data Documentation

m_movedNodesInitial

MovedNodesHash BatchMoveUpdateData::m_movedNodesInitial

private

Definition at line 121 of file kis_node_juggler_compressed.cpp.

m_movedNodesUpdated

MovedNodesHash BatchMoveUpdateData::m_movedNodesUpdated

private

Definition at line 122 of file kis_node_juggler_compressed.cpp.

m_mutex

QMutex BatchMoveUpdateData::m_mutex

private

Definition at line 124 of file kis_node_juggler_compressed.cpp.

m_parentJuggler

QPointer<KisNodeJugglerCompressed> BatchMoveUpdateData::m_parentJuggler

private

Definition at line 126 of file kis_node_juggler_compressed.cpp.

---

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

• libs/ui/kis_node_juggler_compressed.cpp