kis_stroke.cpp

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2011 Dmitry Kazakov <dimula73@gmail.com>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "kis_stroke.h"
 
#include "kis_stroke_strategy.h"
 
 
KisStroke::KisStroke(KisStrokeStrategy *strokeStrategy, Type type, int levelOfDetail)
    : m_strokeStrategy(strokeStrategy),
      m_strokeInitialized(false),
      m_strokeEnded(false),
      m_strokeSuspended(false),
      m_isCancelled(false),
      m_worksOnLevelOfDetail(levelOfDetail),
      m_type(type)
{
    m_initStrategy.reset(m_strokeStrategy->createInitStrategy());
    m_dabStrategy.reset(m_strokeStrategy->createDabStrategy());
    m_cancelStrategy.reset(m_strokeStrategy->createCancelStrategy());
    m_finishStrategy.reset(m_strokeStrategy->createFinishStrategy());
    m_suspendStrategy.reset(m_strokeStrategy->createSuspendStrategy());
    m_resumeStrategy.reset(m_strokeStrategy->createResumeStrategy());
 
    m_strokeStrategy->notifyUserStartedStroke();
 
    if(!m_initStrategy) {
        m_strokeInitialized = true;
    }
    else {
        enqueue(m_initStrategy.data(), m_strokeStrategy->createInitData());
    }
}
 
KisStroke::~KisStroke()
{
    Q_ASSERT(m_strokeEnded);
    Q_ASSERT(m_jobsQueue.isEmpty());
}
 
bool KisStroke::supportsSuspension()
{
    return !m_strokeInitialized || (m_suspendStrategy && m_resumeStrategy);
}
 
void KisStroke::suspendStroke(KisStrokeSP recipient)
{
    if (!m_strokeInitialized || m_strokeSuspended ||
        (m_strokeEnded && !hasJobs())) {
 
        return;
    }
 
    KIS_ASSERT_RECOVER_NOOP(m_suspendStrategy && m_resumeStrategy);
 
    prepend(m_resumeStrategy.data(),
            m_strokeStrategy->createResumeData(),
            worksOnLevelOfDetail(), false);
 
    recipient->prepend(m_suspendStrategy.data(),
                       m_strokeStrategy->createSuspendData(),
                       worksOnLevelOfDetail(), false);
 
    m_strokeSuspended = true;
}
 
void KisStroke::addJob(KisStrokeJobData *data)
{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!m_strokeEnded);
    enqueue(m_dabStrategy.data(), data);
}
 
void KisStroke::addMutatedJobs(const QVector<KisStrokeJobData *> list)
{
    // factory methods can return null, if no action is needed
    if (!m_dabStrategy) {
        qDeleteAll(list);
        return;
    }
 
    // Find first non-alien (non-suspend/non-resume) job
    //
    // Please note that this algorithm will stop working at the day we start
    // adding alien jobs not to the beginning of the stroke, but to other places.
    // Right now both suspend and resume jobs are added to the beginning of
    // the stroke.
 
    auto it = std::find_if(m_jobsQueue.begin(), m_jobsQueue.end(),
                           std::mem_fn(&KisStrokeJob::isOwnJob));
 
    Q_FOREACH (KisStrokeJobData *data, list) {
        it = m_jobsQueue.insert(it, new KisStrokeJob(m_dabStrategy.data(), data, worksOnLevelOfDetail(), true));
        ++it;
    }
}
 
KisStrokeJob* KisStroke::popOneJob()
{
    KisStrokeJob *job = dequeue();
 
    if(job) {
        m_strokeInitialized = true;
        m_strokeSuspended = false;
    }
 
    return job;
}
 
KUndo2MagicString KisStroke::name() const
{
    return m_strokeStrategy->name();
}
 
QString KisStroke::id() const
{
    return m_strokeStrategy->id();
}
 
bool KisStroke::hasJobs() const
{
    return !m_jobsQueue.isEmpty();
}
 
qint32 KisStroke::numJobs() const
{
    return m_jobsQueue.size();
}
 
void KisStroke::endStroke()
{
    KIS_SAFE_ASSERT_RECOVER_RETURN(!m_strokeEnded);
    m_strokeEnded = true;
 
    enqueue(m_finishStrategy.data(), m_strokeStrategy->createFinishData());
    m_strokeStrategy->notifyUserEndedStroke();
}
 
void KisStroke::cancelStroke()
{
    // case 6
    if (m_isCancelled) return;
 
    const bool effectivelyInitialized =
        m_strokeInitialized || m_strokeStrategy->needsExplicitCancel();
 
    if(!effectivelyInitialized) {
        KIS_ASSERT_RECOVER_NOOP(type() == LODN ||
                                sanityCheckAllJobsAreCancellable());
        clearQueueOnCancel();
    }
    else if(effectivelyInitialized &&
            (!m_jobsQueue.isEmpty() || !m_strokeEnded)) {
 
        m_strokeStrategy->tryCancelCurrentStrokeJobAsync();
 
        clearQueueOnCancel();
        enqueue(m_cancelStrategy.data(),
                m_strokeStrategy->createCancelData());
    }
    // else {
    //     too late ...
    // }
 
    m_isCancelled = true;
    m_strokeEnded = true;
}
 
bool KisStroke::canCancel() const
{
    return m_isCancelled || !m_strokeInitialized ||
        !m_jobsQueue.isEmpty() || !m_strokeEnded;
}
 
bool KisStroke::sanityCheckAllJobsAreCancellable() const
{
    Q_FOREACH (KisStrokeJob *item, m_jobsQueue) {
        if (!item->isCancellable()) {
            return false;
        }
    }
    return true;
}
 
void KisStroke::clearQueueOnCancel()
{
    QQueue<KisStrokeJob*>::iterator it = m_jobsQueue.begin();
 
    while (it != m_jobsQueue.end()) {
        if ((*it)->isCancellable()) {
            delete (*it);
            it = m_jobsQueue.erase(it);
        } else {
            ++it;
        }
    }
}
 
bool KisStroke::isInitialized() const
{
    return m_strokeInitialized;
}
 
bool KisStroke::isEnded() const
{
    return m_strokeEnded;
}
 
bool KisStroke::isCancelled() const
{
    return m_isCancelled;
}
 
bool KisStroke::isExclusive() const
{
    return m_strokeStrategy->isExclusive();
}
 
bool KisStroke::supportsWrapAroundMode() const
{
    return m_strokeStrategy->supportsWrapAroundMode();
}
 
int KisStroke::worksOnLevelOfDetail() const
{
    return m_worksOnLevelOfDetail;
}
 
bool KisStroke::canForgetAboutMe() const
{
    return m_strokeStrategy->canForgetAboutMe();
}
 
bool KisStroke::isAsynchronouslyCancellable() const
{
    return m_strokeStrategy->isAsynchronouslyCancellable();
}
 
bool KisStroke::clearsRedoOnStart() const
{
    return m_strokeStrategy->clearsRedoOnStart();
}
 
qreal KisStroke::balancingRatioOverride() const
{
    return m_strokeStrategy->balancingRatioOverride();
}
 
KisStrokeJobData::Sequentiality KisStroke::nextJobSequentiality() const
{
    return !m_jobsQueue.isEmpty() ?
        m_jobsQueue.head()->sequentiality() : KisStrokeJobData::SEQUENTIAL;
}
 
int KisStroke::nextJobLevelOfDetail() const
{
    return !m_jobsQueue.isEmpty() ?
                m_jobsQueue.head()->levelOfDetail() : worksOnLevelOfDetail();
}
 
void KisStroke::enqueue(KisStrokeJobStrategy *strategy,
                        KisStrokeJobData *data)
{
    // factory methods can return null, if no action is needed
    if(!strategy) {
        delete data;
        return;
    }
 
    m_jobsQueue.enqueue(new KisStrokeJob(strategy, data, worksOnLevelOfDetail(), true));
}
 
void KisStroke::prepend(KisStrokeJobStrategy *strategy,
                        KisStrokeJobData *data,
                        int levelOfDetail,
                        bool isOwnJob)
{
    // factory methods can return null, if no action is needed
    if(!strategy) {
        delete data;
        return;
    }
 
    // LOG_MERGE_FIXME:
    Q_UNUSED(levelOfDetail);
 
    m_jobsQueue.prepend(new KisStrokeJob(strategy, data, worksOnLevelOfDetail(), isOwnJob));
}
 
KisStrokeJob* KisStroke::dequeue()
{
    return !m_jobsQueue.isEmpty() ? m_jobsQueue.dequeue() : 0;
}
 
void KisStroke::setLodBuddy(KisStrokeSP buddy)
{
    m_lodBuddy = buddy;
}
 
KisStrokeSP KisStroke::lodBuddy() const
{
    return m_lodBuddy;
}
 
KisStroke::Type KisStroke::type() const
{
    if (m_type == LOD0) {
        KIS_ASSERT_RECOVER_NOOP(m_lodBuddy && "LOD0 strokes must always have a buddy");
    } else if (m_type == LODN) {
        KIS_ASSERT_RECOVER_NOOP(m_worksOnLevelOfDetail > 0 && "LODN strokes must work on LOD > 0!");
    } else if (m_type == LEGACY) {
        KIS_ASSERT_RECOVER_NOOP(m_worksOnLevelOfDetail == 0 && "LEGACY strokes must work on LOD == 0!");
    }
 
    return m_type;
}