#include <kis_painter_based_stroke_strategy.h>

Inheritance diagram for KisPainterBasedStrokeStrategy:

Classes
struct	FakeUndoData

Public Member Functions
void	cancelStrokeCallback () override

void	finishStrokeCallback () override

void	initStrokeCallback () override

	KisPainterBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name, KisResourcesSnapshotSP resources, KisFreehandStrokeInfo *strokeInfo)

	KisPainterBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name, KisResourcesSnapshotSP resources, QVector< KisFreehandStrokeInfo * > strokeInfos)

void	resumeStrokeCallback () override

void	suspendStrokeCallback () override

	~KisPainterBasedStrokeStrategy ()

Public Member Functions inherited from KisRunnableBasedStrokeStrategy
void	doStrokeCallback (KisStrokeJobData *data) override

	KisRunnableBasedStrokeStrategy (const KisRunnableBasedStrokeStrategy &rhs)

	KisRunnableBasedStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KisRunnableStrokeJobsInterface *	runnableJobsInterface () const

	~KisRunnableBasedStrokeStrategy ()

Public Member Functions inherited from KisSimpleStrokeStrategy
KisStrokeJobData *	createCancelData () override

KisStrokeJobStrategy *	createCancelStrategy () override

KisStrokeJobStrategy *	createDabStrategy () override

KisStrokeJobData *	createFinishData () override

KisStrokeJobStrategy *	createFinishStrategy () override

KisStrokeJobData *	createInitData () override

KisStrokeJobStrategy *	createInitStrategy () override

KisStrokeJobData *	createResumeData () override

KisStrokeJobStrategy *	createResumeStrategy () override

KisStrokeJobData *	createSuspendData () override

KisStrokeJobStrategy *	createSuspendStrategy () override

	KisSimpleStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

Public Member Functions inherited from KisStrokeStrategy
qreal	balancingRatioOverride () const

bool	canForgetAboutMe () const

bool	clearsRedoOnStart () const

virtual KisStrokeStrategy *	createLodClone (int levelOfDetail)

KisLodPreferences	currentLodPreferences () const

bool	forceLodModeIfPossible () const

QString	id () const

bool	isAsynchronouslyCancellable () const

bool	isExclusive () const

	KisStrokeStrategy (const QLatin1String &id, const KUndo2MagicString &name=KUndo2MagicString())

KUndo2MagicString	name () const

bool	needsExplicitCancel () const

virtual void	notifyUserEndedStroke ()

virtual void	notifyUserStartedStroke ()

bool	requestsOtherStrokesToEnd () const

void	setForceLodModeIfPossible (bool forceLodModeIfPossible)

void	setMutatedJobsInterface (KisStrokesQueueMutatedJobInterface *mutatedJobsInterface, KisStrokeId strokeId)

bool	supportsWrapAroundMode () const

virtual void	tryCancelCurrentStrokeJobAsync ()
	tryCancelCurrentStrokeJobAsync is called by the strokes queue when the stroke is being cancelled. The stroke strategy may or may not handle this request and cancel the currently running long action.

virtual	~KisStrokeStrategy ()

Protected Member Functions
KisSelectionSP	activeSelection () const

QVector< KisRunnableStrokeJobData * >	doMaskingBrushUpdates (const QVector< QRect > &rects)

	KisPainterBasedStrokeStrategy (const KisPainterBasedStrokeStrategy &rhs, int levelOfDetail)

KisMaskedFreehandStrokePainter *	maskedPainter (int strokeInfoId)

bool	needsMaskingUpdates () const

int	numMaskedPainters () const

void	setSupportsContinuedInterstrokeData (bool value)

void	setSupportsIndirectPainting (bool value)

void	setSupportsMaskingBrush (bool value)

void	setSupportsTimedMergeId (bool value)

void	setUndoEnabled (bool value)

bool	supportsContinuedInterstrokeData () const

bool	supportsIndirectPainting () const

bool	supportsMaskingBrush () const

bool	supportsTimedMergeId () const

KisPaintDeviceSP	targetDevice () const

KisNodeSP	targetNode () const

Protected Member Functions inherited from KisSimpleStrokeStrategy
void	enableJob (JobType type, bool enable=true, KisStrokeJobData::Sequentiality sequentiality=KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::Exclusivity exclusivity=KisStrokeJobData::NORMAL)

	KisSimpleStrokeStrategy (const KisSimpleStrokeStrategy &rhs)

Protected Member Functions inherited from KisStrokeStrategy
void	addMutatedJob (KisStrokeJobData *data)

void	addMutatedJobs (const QVector< KisStrokeJobData * > list)

	KisStrokeStrategy (const KisStrokeStrategy &rhs)

void	setAsynchronouslyCancellable (bool value)

void	setBalancingRatioOverride (qreal value)

void	setCanForgetAboutMe (bool value)

void	setClearsRedoOnStart (bool value)

void	setExclusive (bool value)

void	setNeedsExplicitCancel (bool value)

void	setRequestsOtherStrokesToEnd (bool value)

void	setSupportsWrapAroundMode (bool value)

Private Member Functions
void	deletePainters ()

void	init ()

void	initPainters (KisPaintDeviceSP targetDevice, KisPaintDeviceSP maskingDevice, KisSelectionSP selection, bool hasIndirectPainting, const QString &indirectPaintingCompositeOp)

int	timedID (const QString &id)

Private Attributes
KisSelectionSP	m_activeSelection

QScopedPointer< KUndo2Command >	m_autokeyCommand

QScopedPointer< FakeUndoData >	m_fakeUndoData

KisIndirectPaintingSupport::FinalMergeSuspenderSP	m_finalMergeSuspender

QVector< KisMaskedFreehandStrokePainter * >	m_maskedPainters

QScopedPointer< KisMaskingBrushRenderer >	m_maskingBrushRenderer

QVector< KisFreehandStrokeInfo * >	m_maskStrokeInfos

KisResourcesSnapshotSP	m_resources

QVector< KisFreehandStrokeInfo * >	m_strokeInfos

bool	m_supportsContinuedInterstrokeData {false}

bool	m_supportsIndirectPainting {false}

bool	m_supportsMaskingBrush {false}

KisPaintDeviceSP	m_targetDevice

QScopedPointer< KisTransaction >	m_transaction

bool	m_useMergeID {false}

Additional Inherited Members
Public Types inherited from KisSimpleStrokeStrategy
enum	JobType { JOB_INIT = 0 , JOB_CANCEL , JOB_FINISH , JOB_DOSTROKE , JOB_SUSPEND , JOB_RESUME , NJOBS }

Static Public Member Functions inherited from KisSimpleStrokeStrategy
static QLatin1String	jobTypeToString (JobType type)

Detailed Description

Definition at line 26 of file kis_painter_based_stroke_strategy.h.

Constructor & Destructor Documentation

◆ KisPainterBasedStrokeStrategy() [1/3]

KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy	(	const QLatin1String &	id,
		const KUndo2MagicString &	name,
		KisResourcesSnapshotSP	resources,
		QVector< KisFreehandStrokeInfo * >	strokeInfos )

Definition at line 41 of file kis_painter_based_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(id, name),
      m_resources(resources),
      m_strokeInfos(strokeInfos),
      m_transaction(0),
      m_useMergeID(false),
      m_supportsMaskingBrush(false),
      m_supportsIndirectPainting(false)
{
    init();
}

References init().

◆ KisPainterBasedStrokeStrategy() [2/3]

KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy	(	const QLatin1String &	id,
		const KUndo2MagicString &	name,
		KisResourcesSnapshotSP	resources,
		KisFreehandStrokeInfo *	strokeInfo )

Definition at line 56 of file kis_painter_based_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(id, name),
      m_resources(resources),
      m_strokeInfos(QVector<KisFreehandStrokeInfo*>() <<  strokeInfo),
      m_transaction(0),
      m_useMergeID(false),
      m_supportsMaskingBrush(false),
      m_supportsIndirectPainting(false)
{
    init();
}

References init().

◆ ~KisPainterBasedStrokeStrategy()

KisPainterBasedStrokeStrategy::~KisPainterBasedStrokeStrategy ( )

Definition at line 71 of file kis_painter_based_stroke_strategy.cpp.

72{

73}

◆ KisPainterBasedStrokeStrategy() [3/3]

KisPainterBasedStrokeStrategy::KisPainterBasedStrokeStrategy	(	const KisPainterBasedStrokeStrategy &	rhs,
		int	levelOfDetail )

protected

Definition at line 85 of file kis_painter_based_stroke_strategy.cpp.

    : KisRunnableBasedStrokeStrategy(rhs),
      m_resources(rhs.m_resources),
      m_useMergeID(rhs.m_useMergeID),
      m_supportsMaskingBrush(rhs.m_supportsMaskingBrush),
      m_supportsIndirectPainting(rhs.m_supportsIndirectPainting),
      m_supportsContinuedInterstrokeData(rhs.m_supportsContinuedInterstrokeData)
{
    Q_FOREACH (KisFreehandStrokeInfo *info, rhs.m_strokeInfos) {
        m_strokeInfos.append(new KisFreehandStrokeInfo(info, levelOfDetail));
    }
 
    KIS_ASSERT_RECOVER_NOOP(
        rhs.m_maskStrokeInfos.isEmpty() &&
        !rhs.m_transaction &&
        !rhs.m_targetDevice &&
        !rhs.m_activeSelection &&
        "After the stroke has been started, no copying must happen");
}

References KIS_ASSERT_RECOVER_NOOP, m_activeSelection, m_maskStrokeInfos, m_strokeInfos, m_targetDevice, and m_transaction.

Member Function Documentation

◆ activeSelection()

KisSelectionSP KisPainterBasedStrokeStrategy::activeSelection ( ) const

protected

Definition at line 110 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_activeSelection;
}

References m_activeSelection.

◆ cancelStrokeCallback()

void KisPainterBasedStrokeStrategy::cancelStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 471 of file kis_painter_based_stroke_strategy.cpp.

{
    if (!m_transaction) return;
 
    if (m_autokeyCommand) {
        m_autokeyCommand->undo();
    }
 
    KisNodeSP node = m_resources->currentNode();
    KisIndirectPaintingSupport *indirect =
        dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
    bool revert = true;
    if (indirect) {
        KisPaintDeviceSP t = indirect->temporaryTarget();
        if (t) {
            m_transaction.reset();
            deletePainters();
 
            KisRegion region = t->region();
            indirect->setTemporaryTarget(nullptr);
            node->setDirty(region);
            revert = false;
        }
    }
 
    if (revert) {
        m_transaction->revert();
        m_transaction.reset();
        deletePainters();
    }
}

References KisResourcesSnapshot::currentNode(), KisSharedPtr< T >::data(), deletePainters(), m_autokeyCommand, m_resources, m_transaction, KisPaintDevice::region(), KisNode::setDirty(), KisIndirectPaintingSupport::setTemporaryTarget(), and KisIndirectPaintingSupport::temporaryTarget.

◆ deletePainters()

void KisPainterBasedStrokeStrategy::deletePainters ( )

private

Definition at line 229 of file kis_painter_based_stroke_strategy.cpp.

{
    Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
        delete info;
    }
 
    m_strokeInfos.clear();
 
    Q_FOREACH (KisFreehandStrokeInfo *info, m_maskStrokeInfos) {
        delete info;
    }
 
    m_maskStrokeInfos.clear();
 
    Q_FOREACH (KisMaskedFreehandStrokePainter *info, m_maskedPainters) {
        delete info;
    }
 
    m_maskedPainters.clear();
}

References m_maskedPainters, m_maskStrokeInfos, and m_strokeInfos.

◆ doMaskingBrushUpdates()

QVector< KisRunnableStrokeJobData * > KisPainterBasedStrokeStrategy::doMaskingBrushUpdates ( const QVector< QRect > & rects )

protected

Create a list of update jobs that should be run before issuing the setDirty() call on the node

See also: needsMaskingUpdates()

Definition at line 130 of file kis_painter_based_stroke_strategy.cpp.

{
    QVector<KisRunnableStrokeJobData *> jobs;
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_maskingBrushRenderer, jobs);
 
    Q_FOREACH (const QRect &rc, rects) {
        KritaUtils::addJobConcurrent(jobs,
            [this, rc] () {
                this->m_maskingBrushRenderer->updateProjection(rc);
            }
        );
    }
 
    return jobs;
}

References KritaUtils::addJobConcurrent(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, and m_maskingBrushRenderer.

◆ finishStrokeCallback()

void KisPainterBasedStrokeStrategy::finishStrokeCallback ( )

overridevirtual

When the transaction is reset to zero, cancel job does nothing. Therefore, we should ensure that the merging jobs are never cancelled.

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 389 of file kis_painter_based_stroke_strategy.cpp.

{
    KisNodeSP node = m_resources->currentNode();
    KisIndirectPaintingSupport *indirect =
        dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
    KisPostExecutionUndoAdapter *undoAdapter =
        m_resources->postExecutionUndoAdapter();
 
 
    if (!undoAdapter) {
        m_fakeUndoData.reset(new FakeUndoData());
        undoAdapter = m_fakeUndoData->undoAdapter.data();
    }
 
    QSharedPointer<KUndo2Command> parentCommand;
 
    if (!m_useMergeID) {
        parentCommand.reset(new KUndo2Command());
    } else {
        parentCommand.reset(new MergeableStrokeUndoCommand(m_resources));
        parentCommand->setTimedID(timedID(this->id()));
    }
 
    parentCommand->setText(name());
    parentCommand->setTime(m_transaction->undoCommand()->time());
    parentCommand->setEndTime(QTime::currentTime());
 
    if (m_autokeyCommand) {
        KisCommandUtils::CompositeCommand *wrapper = new KisCommandUtils::CompositeCommand(parentCommand.data());
        wrapper->addCommand(m_autokeyCommand.take());
    }
 
    if (indirect && indirect->hasTemporaryTarget()) {
        KUndo2MagicString transactionText = m_transaction->text();
        m_transaction->end();
        m_transaction.reset();
        deletePainters();
 
        QVector<KisRunnableStrokeJobData*> jobs;
 
        indirect->mergeToLayerThreaded(node,
                               parentCommand.data(),
                               KUndo2MagicString(),
                               -1,
                               &jobs);
 
        KritaUtils::addJobBarrier(jobs,
            [parentCommand, undoAdapter] () {
                parentCommand->redo();
 
                if (undoAdapter) {
                    undoAdapter->addCommand(parentCommand);
                }
            });
 
 
        Q_FOREACH (KisRunnableStrokeJobData *job, jobs) {
            job->setCancellable(false);
        }
 
        runnableJobsInterface()->addRunnableJobs(jobs);
    }
    else {
        KisCommandUtils::CompositeCommand *wrapper = new KisCommandUtils::CompositeCommand(parentCommand.data());
        wrapper->addCommand(m_transaction->endAndTake());
 
        m_transaction.reset();
        deletePainters();
 
        if (undoAdapter) {
            parentCommand->redo();
            undoAdapter->addCommand(parentCommand);
        }
 
    }
 
}

References KisCommandUtils::CompositeCommand::addCommand(), KisPostExecutionUndoAdapter::addCommand(), KritaUtils::addJobBarrier(), KisRunnableStrokeJobsInterface::addRunnableJobs(), KisResourcesSnapshot::currentNode(), KisSharedPtr< T >::data(), deletePainters(), KisIndirectPaintingSupport::hasTemporaryTarget(), m_autokeyCommand, m_fakeUndoData, m_resources, m_transaction, m_useMergeID, KisIndirectPaintingSupport::mergeToLayerThreaded(), KisStrokeStrategy::name(), KisResourcesSnapshot::postExecutionUndoAdapter(), KisRunnableBasedStrokeStrategy::runnableJobsInterface(), KisStrokeJobData::setCancellable(), and timedID().

◆ init()

void KisPainterBasedStrokeStrategy::init ( )

private

Definition at line 75 of file kis_painter_based_stroke_strategy.cpp.

{
    enableJob(KisSimpleStrokeStrategy::JOB_INIT);
    enableJob(KisSimpleStrokeStrategy::JOB_FINISH);
    enableJob(KisSimpleStrokeStrategy::JOB_CANCEL, true, KisStrokeJobData::SEQUENTIAL, KisStrokeJobData::EXCLUSIVE);
 
    enableJob(KisSimpleStrokeStrategy::JOB_SUSPEND);
    enableJob(KisSimpleStrokeStrategy::JOB_RESUME);
}

References KisSimpleStrokeStrategy::enableJob(), KisStrokeJobData::EXCLUSIVE, KisSimpleStrokeStrategy::JOB_CANCEL, KisSimpleStrokeStrategy::JOB_FINISH, KisSimpleStrokeStrategy::JOB_INIT, KisSimpleStrokeStrategy::JOB_RESUME, KisSimpleStrokeStrategy::JOB_SUSPEND, and KisStrokeJobData::SEQUENTIAL.

◆ initPainters()

void KisPainterBasedStrokeStrategy::initPainters	(	KisPaintDeviceSP	targetDevice,
		KisPaintDeviceSP	maskingDevice,
		KisSelectionSP	selection,
		bool	hasIndirectPainting,
		const QString &	indirectPaintingCompositeOp )

private

Definition at line 186 of file kis_painter_based_stroke_strategy.cpp.

{
    Q_FOREACH (KisFreehandStrokeInfo *info, m_strokeInfos) {
        KisPainter *painter = info->painter;
 
        painter->begin(targetDevice, !hasIndirectPainting ? selection : nullptr);
        painter->setRunnableStrokeJobsInterface(runnableJobsInterface());
        m_resources->setupPainter(painter);
 
        if(hasIndirectPainting) {
            painter->setCompositeOpId(indirectPaintingCompositeOp);
            painter->setOpacityToUnit();
            painter->setChannelFlags(QBitArray());
        }
    }
 
    if (maskingDevice) {
        for (int i = 0; i < m_strokeInfos.size(); i++) {
            KisFreehandStrokeInfo *maskingInfo =
                new KisFreehandStrokeInfo(*m_strokeInfos[i]->dragDistance);
 
            KisPainter *painter = maskingInfo->painter;
 
            painter->begin(maskingDevice, nullptr);
            m_resources->setupMaskingBrushPainter(painter);
 
            KIS_SAFE_ASSERT_RECOVER_NOOP(hasIndirectPainting);
            m_maskStrokeInfos.append(maskingInfo);
        }
    }
 
    for (int i = 0; i < m_strokeInfos.size(); i++) {
        m_maskedPainters.append(
            new KisMaskedFreehandStrokePainter(m_strokeInfos[i],
                                               !m_maskStrokeInfos.isEmpty() ?
                                                   m_maskStrokeInfos[i] : nullptr));
    }
}

References KisPainter::begin(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_maskedPainters, m_maskStrokeInfos, m_resources, m_strokeInfos, KisFreehandStrokeInfo::painter, KisRunnableBasedStrokeStrategy::runnableJobsInterface(), KisPainter::setChannelFlags(), KisPainter::setCompositeOpId(), KisPainter::setOpacityToUnit(), KisPainter::setRunnableStrokeJobsInterface(), KisResourcesSnapshot::setupMaskingBrushPainter(), KisResourcesSnapshot::setupPainter(), and targetDevice().

◆ initStrokeCallback()

void KisPainterBasedStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 250 of file kis_painter_based_stroke_strategy.cpp.

{
    QVector<KisRunnableStrokeJobData*> jobs;
 
    KritaUtils::addJobSequential(jobs, [this] () {
        KisNodeSP node = m_resources->currentNode();
 
        KUndo2Command *autoKeyframeCommand =
            KisAutoKey::tryAutoCreateDuplicatedFrame(node->paintDevice(),
                                                     KisAutoKey::AllowBlankMode |
                                                         KisAutoKey::SupportsLod);
        if (autoKeyframeCommand) {
            m_autokeyCommand.reset(autoKeyframeCommand);
        }
    });
 
    KritaUtils::addJobSequential(jobs, [this] () mutable {
        KisNodeSP node = m_resources->currentNode();
        KisPaintDeviceSP paintDevice = node->paintDevice();
        KisPaintDeviceSP targetDevice = paintDevice;
        KisSelectionSP selection =  m_resources->activeSelection();
        bool hasIndirectPainting = supportsIndirectPainting() && m_resources->needsIndirectPainting();
        const QString indirectCompositeOp = m_resources->indirectPaintingCompositeOp();
 
        if (hasIndirectPainting) {
            KisIndirectPaintingSupport *indirect =
                dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
            if (indirect) {
                targetDevice = paintDevice->createCompositionSourceDevice();
                targetDevice->setParentNode(node);
                indirect->setCurrentColor(m_resources->currentFgColor());
                indirect->setTemporaryTarget(targetDevice);
 
                indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
                indirect->setTemporaryOpacity(m_resources->opacity());
                indirect->setTemporarySelection(selection);
 
                QBitArray channelLockFlags = m_resources->channelLockFlags();
                indirect->setTemporaryChannelFlags(channelLockFlags);
            }
            else {
                hasIndirectPainting = false;
            }
        }
 
        QScopedPointer<KisInterstrokeDataFactory> interstrokeDataFactory(
            KisPaintOpRegistry::instance()->createInterstrokeDataFactory(m_resources->currentPaintOpPreset()));
 
        KIS_SAFE_ASSERT_RECOVER(!interstrokeDataFactory || !hasIndirectPainting) {
            interstrokeDataFactory.reset();
        }
 
        QScopedPointer<KisInterstrokeDataTransactionWrapperFactory> wrapper;
 
        if (interstrokeDataFactory) {
            wrapper.reset(new KisInterstrokeDataTransactionWrapperFactory(
                              interstrokeDataFactory.take(),
                              supportsContinuedInterstrokeData()));
        }
 
        m_transaction.reset(new KisTransaction(KUndo2MagicString(), targetDevice, nullptr,
                                               -1,
                                               wrapper.take()));
 
        // WARNING: masked brush cannot work without indirect painting mode!
        KIS_SAFE_ASSERT_RECOVER_NOOP(!(supportsMaskingBrush() &&
                                       m_resources->needsMaskingBrushRendering()) || hasIndirectPainting);
 
        if (hasIndirectPainting &&
            supportsMaskingBrush() &&
            m_resources->needsMaskingBrushRendering()) {
 
            const QString compositeOpId =
                m_resources->currentPaintOpPreset()->settings()->maskingBrushCompositeOp();
 
            m_maskingBrushRenderer.reset(new KisMaskingBrushRenderer(targetDevice, compositeOpId));
 
            initPainters(m_maskingBrushRenderer->strokeDevice(),
                         m_maskingBrushRenderer->maskDevice(),
                         selection,
                         hasIndirectPainting,
                         indirectCompositeOp);
 
        } else {
            initPainters(targetDevice, nullptr, selection, hasIndirectPainting, indirectCompositeOp);
        }
 
        m_targetDevice = targetDevice;
        m_activeSelection = selection;
 
        // sanity check: selection should be applied only once
        if (selection && !m_strokeInfos.isEmpty()) {
            KisIndirectPaintingSupport *indirect =
                dynamic_cast<KisIndirectPaintingSupport*>(node.data());
            KIS_ASSERT_RECOVER_RETURN(hasIndirectPainting || m_strokeInfos.first()->painter->selection());
            // when hasIndirectPainting is true, indirect cannot be null
            KIS_ASSERT_RECOVER_RETURN(!hasIndirectPainting || indirect);
            KIS_ASSERT_RECOVER_RETURN(!hasIndirectPainting || !indirect->temporarySelection() || !m_strokeInfos.first()->painter->selection());
        }
    });
 
    runnableJobsInterface()->addRunnableJobs(jobs);
}

◆ maskedPainter()

KisMaskedFreehandStrokePainter * KisPainterBasedStrokeStrategy::maskedPainter ( int strokeInfoId )

protected

Definition at line 115 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_maskedPainters[strokeInfoId];
}

References m_maskedPainters.

◆ needsMaskingUpdates()

bool KisPainterBasedStrokeStrategy::needsMaskingUpdates ( ) const

protected

Return true if the descendant should execute a few more jobs before issuing setDirty() call on the layer.

If the returned value is true, then the stroke actually paints not on the layer's paint device, but on some intermediate device owned by KisPainterBasedStrokeStrategy and one should merge it first before asking the update.

The value can be true only when the stroke is declared to support masked brush!

See also: supportsMaskingBrush()

Definition at line 125 of file kis_painter_based_stroke_strategy.cpp.

{
    return bool(m_maskingBrushRenderer);
}

References m_maskingBrushRenderer.

◆ numMaskedPainters()

int KisPainterBasedStrokeStrategy::numMaskedPainters ( ) const

protected

Definition at line 120 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_maskedPainters.size();
}

References m_maskedPainters.

◆ resumeStrokeCallback()

void KisPainterBasedStrokeStrategy::resumeStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 516 of file kis_painter_based_stroke_strategy.cpp.

{
    KisNodeSP node = m_resources->currentNode();
    KisIndirectPaintingSupport *indirect =
        dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
    if(indirect) {
        // todo: don't ask about paint device
        // todo:change to an assert
        if (node->paintDevice() != m_targetDevice) {
            indirect->setTemporaryTarget(m_targetDevice);
            indirect->setTemporaryCompositeOp(m_resources->compositeOpId());
            indirect->setTemporaryOpacity(m_resources->opacity());
            indirect->setTemporarySelection(m_activeSelection);
 
            QBitArray channelLockFlags = m_resources->channelLockFlags();
            indirect->setTemporaryChannelFlags(channelLockFlags);
        }
    }
 
    m_finalMergeSuspender.clear();
}

References KisResourcesSnapshot::channelLockFlags(), KisResourcesSnapshot::compositeOpId(), KisResourcesSnapshot::currentNode(), KisSharedPtr< T >::data(), m_activeSelection, m_finalMergeSuspender, m_resources, m_targetDevice, KisResourcesSnapshot::opacity(), KisBaseNode::paintDevice(), KisIndirectPaintingSupport::setTemporaryChannelFlags(), KisIndirectPaintingSupport::setTemporaryCompositeOp(), KisIndirectPaintingSupport::setTemporaryOpacity(), KisIndirectPaintingSupport::setTemporarySelection(), and KisIndirectPaintingSupport::setTemporaryTarget().

◆ setSupportsContinuedInterstrokeData()

void KisPainterBasedStrokeStrategy::setSupportsContinuedInterstrokeData ( bool value )

protected

Definition at line 171 of file kis_painter_based_stroke_strategy.cpp.

{
    m_supportsContinuedInterstrokeData = value;
}

References m_supportsContinuedInterstrokeData, and value().

◆ setSupportsIndirectPainting()

void KisPainterBasedStrokeStrategy::setSupportsIndirectPainting ( bool value )

protected

Definition at line 156 of file kis_painter_based_stroke_strategy.cpp.

{
    m_supportsIndirectPainting = value;
}

References m_supportsIndirectPainting, and value().

◆ setSupportsMaskingBrush()

void KisPainterBasedStrokeStrategy::setSupportsMaskingBrush ( bool value )

protected

The descendants may declare if this stroke should support auto-creation of the masked brush. Default value: false

Definition at line 146 of file kis_painter_based_stroke_strategy.cpp.

{
    m_supportsMaskingBrush = value;
}

References m_supportsMaskingBrush, and value().

◆ setSupportsTimedMergeId()

void KisPainterBasedStrokeStrategy::setSupportsTimedMergeId ( bool value )

protected

Definition at line 181 of file kis_painter_based_stroke_strategy.cpp.

{
    m_useMergeID = value;
}

References m_useMergeID, and value().

◆ setUndoEnabled()

void KisPainterBasedStrokeStrategy::setUndoEnabled ( bool value )

protected

◆ supportsContinuedInterstrokeData()

bool KisPainterBasedStrokeStrategy::supportsContinuedInterstrokeData ( ) const

protected

Definition at line 166 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_supportsContinuedInterstrokeData;
}

References m_supportsContinuedInterstrokeData.

◆ supportsIndirectPainting()

bool KisPainterBasedStrokeStrategy::supportsIndirectPainting ( ) const

protected

Definition at line 161 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_supportsIndirectPainting;
}

References m_supportsIndirectPainting.

◆ supportsMaskingBrush()

bool KisPainterBasedStrokeStrategy::supportsMaskingBrush ( ) const

protected

Return if the stroke should auto-create a masked brush from the provided paintop preset or not

Definition at line 151 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_supportsMaskingBrush;
}

References m_supportsMaskingBrush.

◆ supportsTimedMergeId()

bool KisPainterBasedStrokeStrategy::supportsTimedMergeId ( ) const

protected

Definition at line 176 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_useMergeID;
}

References m_useMergeID.

◆ suspendStrokeCallback()

void KisPainterBasedStrokeStrategy::suspendStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 504 of file kis_painter_based_stroke_strategy.cpp.

{
    KisNodeSP node = m_resources->currentNode();
    KisIndirectPaintingSupport *indirect =
        dynamic_cast<KisIndirectPaintingSupport*>(node.data());
 
    if(indirect && indirect->hasTemporaryTarget()) {
        m_finalMergeSuspender = indirect->trySuspendFinalMerge();
        indirect->setTemporaryTarget(nullptr);
    }
}

References KisResourcesSnapshot::currentNode(), KisSharedPtr< T >::data(), KisIndirectPaintingSupport::hasTemporaryTarget(), m_finalMergeSuspender, m_resources, KisIndirectPaintingSupport::setTemporaryTarget(), and KisIndirectPaintingSupport::trySuspendFinalMerge().

◆ targetDevice()

KisPaintDeviceSP KisPainterBasedStrokeStrategy::targetDevice ( ) const

protected

Definition at line 105 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_targetDevice;
}

References m_targetDevice.

◆ targetNode()

KisNodeSP KisPainterBasedStrokeStrategy::targetNode ( ) const

protected

Definition at line 539 of file kis_painter_based_stroke_strategy.cpp.

{
    return m_resources->currentNode();
}

References KisResourcesSnapshot::currentNode(), and m_resources.

◆ timedID()

int KisPainterBasedStrokeStrategy::timedID ( const QString & id )

inlineprivate

Definition at line 113 of file kis_painter_based_stroke_strategy.h.

                                         {
        return int(qHash(id));
    }

References qHash().

Member Data Documentation

◆ m_activeSelection

KisSelectionSP KisPainterBasedStrokeStrategy::m_activeSelection

private

Definition at line 128 of file kis_painter_based_stroke_strategy.h.

◆ m_autokeyCommand

QScopedPointer<KUndo2Command> KisPainterBasedStrokeStrategy::m_autokeyCommand

private

Definition at line 130 of file kis_painter_based_stroke_strategy.h.

◆ m_fakeUndoData

QScopedPointer<FakeUndoData> KisPainterBasedStrokeStrategy::m_fakeUndoData

private

Definition at line 146 of file kis_painter_based_stroke_strategy.h.

◆ m_finalMergeSuspender

KisIndirectPaintingSupport::FinalMergeSuspenderSP KisPainterBasedStrokeStrategy::m_finalMergeSuspender

private

Definition at line 138 of file kis_painter_based_stroke_strategy.h.

◆ m_maskedPainters

QVector<KisMaskedFreehandStrokePainter*> KisPainterBasedStrokeStrategy::m_maskedPainters

private

Definition at line 121 of file kis_painter_based_stroke_strategy.h.

◆ m_maskingBrushRenderer

QScopedPointer<KisMaskingBrushRenderer> KisPainterBasedStrokeStrategy::m_maskingBrushRenderer

private

Definition at line 125 of file kis_painter_based_stroke_strategy.h.

◆ m_maskStrokeInfos

QVector<KisFreehandStrokeInfo*> KisPainterBasedStrokeStrategy::m_maskStrokeInfos

private

Definition at line 120 of file kis_painter_based_stroke_strategy.h.

◆ m_resources

KisResourcesSnapshotSP KisPainterBasedStrokeStrategy::m_resources

private

Definition at line 118 of file kis_painter_based_stroke_strategy.h.

◆ m_strokeInfos

QVector<KisFreehandStrokeInfo*> KisPainterBasedStrokeStrategy::m_strokeInfos

private

Definition at line 119 of file kis_painter_based_stroke_strategy.h.

◆ m_supportsContinuedInterstrokeData

bool KisPainterBasedStrokeStrategy::m_supportsContinuedInterstrokeData {false}

private

Definition at line 136 of file kis_painter_based_stroke_strategy.h.

136{false};

◆ m_supportsIndirectPainting

bool KisPainterBasedStrokeStrategy::m_supportsIndirectPainting {false}

private

Definition at line 135 of file kis_painter_based_stroke_strategy.h.

135{false};

◆ m_supportsMaskingBrush

bool KisPainterBasedStrokeStrategy::m_supportsMaskingBrush {false}

private

Definition at line 134 of file kis_painter_based_stroke_strategy.h.

134{false};

◆ m_targetDevice

KisPaintDeviceSP KisPainterBasedStrokeStrategy::m_targetDevice

private

Definition at line 127 of file kis_painter_based_stroke_strategy.h.

◆ m_transaction

QScopedPointer<KisTransaction> KisPainterBasedStrokeStrategy::m_transaction

private

Definition at line 123 of file kis_painter_based_stroke_strategy.h.

◆ m_useMergeID

bool KisPainterBasedStrokeStrategy::m_useMergeID {false}

private

Definition at line 132 of file kis_painter_based_stroke_strategy.h.

132{false};

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

libs/ui/tool/strokes/kis_painter_based_stroke_strategy.h
libs/ui/tool/strokes/kis_painter_based_stroke_strategy.cpp

Classes

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisPainterBasedStrokeStrategy() [1/3]

◆ KisPainterBasedStrokeStrategy() [2/3]

◆ ~KisPainterBasedStrokeStrategy()

◆ KisPainterBasedStrokeStrategy() [3/3]

Member Function Documentation

◆ activeSelection()

◆ cancelStrokeCallback()

◆ deletePainters()

◆ doMaskingBrushUpdates()

◆ finishStrokeCallback()

◆ init()

◆ initPainters()

◆ initStrokeCallback()

◆ maskedPainter()

◆ needsMaskingUpdates()

◆ numMaskedPainters()

◆ resumeStrokeCallback()

◆ setSupportsContinuedInterstrokeData()

◆ setSupportsIndirectPainting()

◆ setSupportsMaskingBrush()

◆ setSupportsTimedMergeId()

◆ setUndoEnabled()

◆ supportsContinuedInterstrokeData()

◆ supportsIndirectPainting()

◆ supportsMaskingBrush()

◆ supportsTimedMergeId()

◆ suspendStrokeCallback()

◆ targetDevice()

◆ targetNode()

◆ timedID()

Member Data Documentation

◆ m_activeSelection

◆ m_autokeyCommand

◆ m_fakeUndoData

◆ m_finalMergeSuspender

◆ m_maskedPainters

◆ m_maskingBrushRenderer

◆ m_maskStrokeInfos

◆ m_resources

◆ m_strokeInfos

◆ m_supportsContinuedInterstrokeData

◆ m_supportsIndirectPainting

◆ m_supportsMaskingBrush

◆ m_targetDevice

◆ m_transaction

◆ m_useMergeID