#include <freehand_stroke.h>

Inheritance diagram for FreehandStrokeStrategy:

Classes
class	Data

struct	Private

Public Types
enum	Flag { None = 0x0 , SupportsContinuedInterstrokeData = 0x1 , SupportsTimedMergeId = 0x2 }

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

Public Member Functions
KisStrokeStrategy *	createLodClone (int levelOfDetail) override

void	doStrokeCallback (KisStrokeJobData *data) override

void	finishStrokeCallback () override

	FreehandStrokeStrategy (KisResourcesSnapshotSP resources, KisFreehandStrokeInfo *strokeInfo, const KUndo2MagicString &name, Flags flags=None)

	FreehandStrokeStrategy (KisResourcesSnapshotSP resources, QVector< KisFreehandStrokeInfo * > strokeInfos, const KUndo2MagicString &name, Flags flags=None)

void	initStrokeCallback () override

void	notifyUserEndedStroke () override

void	notifyUserStartedStroke () override

	~FreehandStrokeStrategy () override

Public Member Functions inherited from KisPainterBasedStrokeStrategy
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

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

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
	FreehandStrokeStrategy (const FreehandStrokeStrategy &rhs, int levelOfDetail)

Protected Member Functions inherited from KisPainterBasedStrokeStrategy
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	init (FreehandStrokeStrategy::Flags flags)

void	issueSetDirtySignals ()

void	tryDoUpdate (bool forceEnd=false)

Private Attributes
const QScopedPointer< Private >	m_d

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

Detailed Description

Definition at line 23 of file freehand_stroke.h.

Member Enumeration Documentation

◆ Flag

enum FreehandStrokeStrategy::Flag

Enumerator
None
SupportsContinuedInterstrokeData
SupportsTimedMergeId

Definition at line 26 of file freehand_stroke.h.

              {
        None = 0x0,
        SupportsContinuedInterstrokeData = 0x1,
        SupportsTimedMergeId = 0x2
    };

Constructor & Destructor Documentation

◆ FreehandStrokeStrategy() [1/3]

FreehandStrokeStrategy::FreehandStrokeStrategy	(	KisResourcesSnapshotSP	resources,
		KisFreehandStrokeInfo *	strokeInfo,
		const KUndo2MagicString &	name,
		Flags	flags = None )

Definition at line 69 of file freehand_stroke.cpp.

    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                    resources, strokeInfo),
      m_d(new Private(resources))
{
    init(flags);
}

References KisPainterBasedStrokeStrategy::init().

◆ FreehandStrokeStrategy() [2/3]

FreehandStrokeStrategy::FreehandStrokeStrategy	(	KisResourcesSnapshotSP	resources,
		QVector< KisFreehandStrokeInfo * >	strokeInfos,
		const KUndo2MagicString &	name,
		Flags	flags = None )

Definition at line 80 of file freehand_stroke.cpp.

    : KisPainterBasedStrokeStrategy(QLatin1String("FREEHAND_STROKE"), name,
                                    resources, strokeInfos),
      m_d(new Private(resources))
{
    init(flags);
}

References KisPainterBasedStrokeStrategy::init().

◆ ~FreehandStrokeStrategy()

FreehandStrokeStrategy::~FreehandStrokeStrategy ( )

override

Definition at line 98 of file freehand_stroke.cpp.

{
    KisStrokeSpeedMonitor::instance()->notifyStrokeFinished(m_d->efficiencyMeasurer.averageCursorSpeed(),
                                                            m_d->efficiencyMeasurer.averageRenderingSpeed(),
                                                            m_d->efficiencyMeasurer.averageFps(),
                                                            m_d->resources->currentPaintOpPreset());
 
    KisUpdateTimeMonitor::instance()->endStrokeMeasure();
}

References KisUpdateTimeMonitor::endStrokeMeasure(), KisUpdateTimeMonitor::instance(), KisStrokeSpeedMonitor::instance(), m_d, and KisStrokeSpeedMonitor::notifyStrokeFinished().

◆ FreehandStrokeStrategy() [3/3]

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

protected

Definition at line 91 of file freehand_stroke.cpp.

    : KisPainterBasedStrokeStrategy(rhs, levelOfDetail),
      m_d(new Private(*rhs.m_d))
{
    m_d->randomSource.setLevelOfDetail(levelOfDetail);
}

References m_d.

Member Function Documentation

◆ createLodClone()

KisStrokeStrategy * FreehandStrokeStrategy::createLodClone ( int levelOfDetail )

overridevirtual

Reimplemented from KisStrokeStrategy.

Definition at line 331 of file freehand_stroke.cpp.

{
    if (!m_d->resources->presetAllowsLod()) return 0;
    if (!m_d->resources->currentNode()->supportsLodPainting()) return 0;
 
    FreehandStrokeStrategy *clone = new FreehandStrokeStrategy(*this, levelOfDetail);
    return clone;
}

References FreehandStrokeStrategy(), and m_d.

◆ doStrokeCallback()

void FreehandStrokeStrategy::doStrokeCallback ( KisStrokeJobData * data )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 143 of file freehand_stroke.cpp.

{
    if (KisAsynchronousStrokeUpdateHelper::UpdateData *d =
            dynamic_cast<KisAsynchronousStrokeUpdateHelper::UpdateData*>(data)) {
 
        // this job is lod-clonable in contrast to FreehandStrokeRunnableJobDataWithUpdate!
        tryDoUpdate(d->forceUpdate);
 
    } else if (Data *d = dynamic_cast<Data*>(data)) {
        KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(d->strokeInfoId);
 
        KisUpdateTimeMonitor::instance()->reportPaintOpPreset(maskedPainter->preset());
        KisRandomSourceSP rnd = m_d->randomSource.source();
        KisPerStrokeRandomSourceSP strokeRnd = m_d->randomSource.perStrokeSource();
 
        switch(d->type) {
        case Data::POINT:
            d->pi1.setRandomSource(rnd);
            d->pi1.setPerStrokeRandomSource(strokeRnd);
            maskedPainter->paintAt(d->pi1);
            m_d->efficiencyMeasurer.addSample(d->pi1.pos());
            break;
        case Data::LINE:
            d->pi1.setRandomSource(rnd);
            d->pi2.setRandomSource(rnd);
            d->pi1.setPerStrokeRandomSource(strokeRnd);
            d->pi2.setPerStrokeRandomSource(strokeRnd);
            maskedPainter->paintLine(d->pi1, d->pi2);
            m_d->efficiencyMeasurer.addSample(d->pi2.pos());
            break;
        case Data::CURVE:
            d->pi1.setRandomSource(rnd);
            d->pi2.setRandomSource(rnd);
            d->pi1.setPerStrokeRandomSource(strokeRnd);
            d->pi2.setPerStrokeRandomSource(strokeRnd);
            maskedPainter->paintBezierCurve(d->pi1,
                                         d->control1,
                                         d->control2,
                                         d->pi2);
            m_d->efficiencyMeasurer.addSample(d->pi2.pos());
            break;
        case Data::POLYLINE:
            maskedPainter->paintPolyline(d->points, 0, d->points.size());
            m_d->efficiencyMeasurer.addSamples(d->points);
            break;
        case Data::POLYGON:
            maskedPainter->paintPolygon(d->points);
            m_d->efficiencyMeasurer.addSamples(d->points);
            break;
        case Data::RECT:
            maskedPainter->paintRect(d->rect);
            m_d->efficiencyMeasurer.addSample(d->rect.topLeft());
            m_d->efficiencyMeasurer.addSample(d->rect.topRight());
            m_d->efficiencyMeasurer.addSample(d->rect.bottomRight());
            m_d->efficiencyMeasurer.addSample(d->rect.bottomLeft());
            break;
        case Data::ELLIPSE:
            maskedPainter->paintEllipse(d->rect);
            // TODO: add speed measures
            break;
        case Data::PAINTER_PATH:
            maskedPainter->paintPainterPath(d->path);
            // TODO: add speed measures
            break;
        case Data::QPAINTER_PATH:
            maskedPainter->drawPainterPath(d->path, d->pen);
            break;
        case Data::QPAINTER_PATH_FILL:
            maskedPainter->drawAndFillPainterPath(d->path, d->pen, d->customColor);
            break;
        };
 
        tryDoUpdate();
    } else {
        KisPainterBasedStrokeStrategy::doStrokeCallback(data);
 
        FreehandStrokeRunnableJobDataWithUpdate *dataWithUpdate =
            dynamic_cast<FreehandStrokeRunnableJobDataWithUpdate*>(data);
 
        if (dataWithUpdate) {
            tryDoUpdate();
        }
    }
}

◆ finishStrokeCallback()

void FreehandStrokeStrategy::finishStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 136 of file freehand_stroke.cpp.

{
    m_d->efficiencyMeasurer.notifyRenderingFinished();
    KisPainterBasedStrokeStrategy::finishStrokeCallback();
}

References KisPainterBasedStrokeStrategy::finishStrokeCallback(), and m_d.

◆ init()

void FreehandStrokeStrategy::init ( FreehandStrokeStrategy::Flags flags )

private

In case the paintop uses asynchronous updates, we should set priority to it, because FPS is controlled separately, not by the queue's merging algorithm.

Definition at line 108 of file freehand_stroke.cpp.

{
    setSupportsWrapAroundMode(true);
    setSupportsMaskingBrush(true);
    setSupportsIndirectPainting(true);
    setSupportsContinuedInterstrokeData(flags & SupportsContinuedInterstrokeData);
    setSupportsTimedMergeId(flags & SupportsTimedMergeId);
 
    enableJob(KisSimpleStrokeStrategy::JOB_DOSTROKE);
 
    if (m_d->needsAsynchronousUpdates) {
        setBalancingRatioOverride(0.01); // set priority to updates
    }
 
    KisUpdateTimeMonitor::instance()->startStrokeMeasure();
    m_d->efficiencyMeasurer.setEnabled(KisStrokeSpeedMonitor::instance()->haveStrokeSpeedMeasurement());
}

References KisSimpleStrokeStrategy::enableJob(), KisUpdateTimeMonitor::instance(), KisStrokeSpeedMonitor::instance(), KisSimpleStrokeStrategy::JOB_DOSTROKE, m_d, KisStrokeStrategy::setBalancingRatioOverride(), KisPainterBasedStrokeStrategy::setSupportsContinuedInterstrokeData(), KisPainterBasedStrokeStrategy::setSupportsIndirectPainting(), KisPainterBasedStrokeStrategy::setSupportsMaskingBrush(), KisPainterBasedStrokeStrategy::setSupportsTimedMergeId(), KisStrokeStrategy::setSupportsWrapAroundMode(), KisUpdateTimeMonitor::startStrokeMeasure(), SupportsContinuedInterstrokeData, and SupportsTimedMergeId.

◆ initStrokeCallback()

void FreehandStrokeStrategy::initStrokeCallback ( )

overridevirtual

Reimplemented from KisSimpleStrokeStrategy.

Definition at line 130 of file freehand_stroke.cpp.

{
    KisPainterBasedStrokeStrategy::initStrokeCallback();
    m_d->efficiencyMeasurer.notifyRenderingStarted();
}

References KisPainterBasedStrokeStrategy::initStrokeCallback(), and m_d.

◆ issueSetDirtySignals()

void FreehandStrokeStrategy::issueSetDirtySignals ( )

private

Definition at line 281 of file freehand_stroke.cpp.

{
    QVector<QRect> dirtyRects;
 
    for (int i = 0; i < numMaskedPainters(); i++) {
        KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
        dirtyRects.append(maskedPainter->takeDirtyRegion());
    }
 
    if (needsMaskingUpdates()) {
 
        // optimize the rects so that they would never intersect with each other!
        // that is a mandatory step for the multithreaded execution of merging jobs
 
        // sanity check: updates from the brush should have already been normalized
        //               to the wrapping rect
        const KisDefaultBoundsBaseSP defaultBounds = targetNode()->projection()->defaultBounds();
        if (defaultBounds->wrapAroundMode()) {
            const QRect wrapRect = defaultBounds->imageBorderRect();
            for (auto it = dirtyRects.begin(); it != dirtyRects.end(); ++it) {
                KIS_SAFE_ASSERT_RECOVER(wrapRect.contains(*it)) {
                    ENTER_FUNCTION() << ppVar(*it) << ppVar(wrapRect);
                    *it = *it & wrapRect;
                }
            }
        }
 
        const int maxPatchSizeForMaskingUpdates = 64;
        const QRect totalRect =
            std::accumulate(dirtyRects.constBegin(), dirtyRects.constEnd(), QRect(), std::bit_or<QRect>());
 
        dirtyRects = KisPaintOpUtils::splitAndFilterDabRect(totalRect, dirtyRects, maxPatchSizeForMaskingUpdates);
 
        QVector<KisRunnableStrokeJobData*> jobs = doMaskingBrushUpdates(dirtyRects);
 
        KritaUtils::addJobSequential(jobs,
            [this, dirtyRects] () {
                this->targetNode()->setDirty(dirtyRects);
            }
        );
 
        runnableJobsInterface()->addRunnableJobs(jobs);
 
    } else {
        targetNode()->setDirty(dirtyRects);
    }
 
    //KisUpdateTimeMonitor::instance()->reportJobFinished(data, dirtyRects);
}

References KritaUtils::addJobSequential(), KisRunnableStrokeJobsInterface::addRunnableJobs(), KisPaintDevice::defaultBounds(), KisPainterBasedStrokeStrategy::doMaskingBrushUpdates(), ENTER_FUNCTION, KisDefaultBoundsBase::imageBorderRect(), KIS_SAFE_ASSERT_RECOVER, KisPainterBasedStrokeStrategy::maskedPainter(), KisPainterBasedStrokeStrategy::needsMaskingUpdates(), KisPainterBasedStrokeStrategy::numMaskedPainters(), ppVar, KisBaseNode::projection(), KisRunnableBasedStrokeStrategy::runnableJobsInterface(), KisNode::setDirty(), KisPaintOpUtils::splitAndFilterDabRect(), KisMaskedFreehandStrokePainter::takeDirtyRegion(), KisPainterBasedStrokeStrategy::targetNode(), and KisDefaultBoundsBase::wrapAroundMode().

◆ notifyUserEndedStroke()

void FreehandStrokeStrategy::notifyUserEndedStroke ( )

overridevirtual

notifyUserEndedStroke() is a callback used by the strokes system to notify when the user ends the stroke. That moment corresponds to the user calling strokesFacade->endStroke(id) and might happen much earlier when the stroke even started its execution.

NOTE: this method will be executed in the context of the GUI thread!

Reimplemented from KisStrokeStrategy.

Definition at line 345 of file freehand_stroke.cpp.

{
    m_d->efficiencyMeasurer.notifyCursorMoveFinished();
}

References m_d.

◆ notifyUserStartedStroke()

void FreehandStrokeStrategy::notifyUserStartedStroke ( )

overridevirtual

notifyUserStartedStroke() is a callback used by the strokes system to notify when the user adds the stroke to the strokes queue. That moment corresponds to the user calling strokesFacade->startStroke(strategy) and might happen much earlier than the first job being executed.

NOTE: this method will be executed in the context of the GUI thread!

Reimplemented from KisStrokeStrategy.

Definition at line 340 of file freehand_stroke.cpp.

{
    m_d->efficiencyMeasurer.notifyCursorMoveStarted();
}

References m_d.

◆ tryDoUpdate()

void FreehandStrokeStrategy::tryDoUpdate ( bool forceEnd = false )

private

Definition at line 228 of file freehand_stroke.cpp.

{
    // we should enter this function only once!
    std::unique_lock<std::mutex> entryLock(m_d->updateEntryMutex, std::try_to_lock);
    if (!entryLock.owns_lock()) return;
 
    if (m_d->needsAsynchronousUpdates) {
        if (forceEnd || m_d->timeSinceLastUpdate.elapsed() > m_d->currentUpdatePeriod) {
            m_d->timeSinceLastUpdate.restart();
 
            for (int i = 0; i < numMaskedPainters(); i++) {
                KisMaskedFreehandStrokePainter *maskedPainter = this->maskedPainter(i);
 
                // TODO: well, we should count all N simultaneous painters for FPS rate!
                QVector<KisRunnableStrokeJobData*> jobs;
 
                bool needsMoreUpdates = false;
 
                std::tie(m_d->currentUpdatePeriod, needsMoreUpdates) =
                    maskedPainter->doAsynchronousUpdate(jobs);
 
                if (!jobs.isEmpty() ||
                    maskedPainter->hasDirtyRegion() ||
                    (forceEnd && needsMoreUpdates)) {
 
                    KritaUtils::addJobSequential(jobs,
                        [this] () {
                            this->issueSetDirtySignals();
                        }
                    );
 
                    if (forceEnd && needsMoreUpdates) {
                        KritaUtils::addJobSequential(jobs,
                            [this] () {
                                this->tryDoUpdate(true);
                            }
                        );
                    }
 
 
                    runnableJobsInterface()->addRunnableJobs(jobs);
                    m_d->efficiencyMeasurer.notifyFrameRenderingStarted();
                }
 
            }
        }
    } else {
        issueSetDirtySignals();
    }
 
 
}

References KritaUtils::addJobSequential(), KisRunnableStrokeJobsInterface::addRunnableJobs(), KisMaskedFreehandStrokePainter::doAsynchronousUpdate(), KisMaskedFreehandStrokePainter::hasDirtyRegion(), issueSetDirtySignals(), m_d, KisPainterBasedStrokeStrategy::maskedPainter(), KisPainterBasedStrokeStrategy::numMaskedPainters(), KisRunnableBasedStrokeStrategy::runnableJobsInterface(), and tryDoUpdate().

Member Data Documentation

◆ m_d

const QScopedPointer<Private> FreehandStrokeStrategy::m_d

private

Definition at line 211 of file freehand_stroke.h.

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

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ Flag

Constructor & Destructor Documentation

◆ FreehandStrokeStrategy() [1/3]

◆ FreehandStrokeStrategy() [2/3]

◆ ~FreehandStrokeStrategy()

◆ FreehandStrokeStrategy() [3/3]

Member Function Documentation

◆ createLodClone()

◆ doStrokeCallback()

◆ finishStrokeCallback()

◆ init()

◆ initStrokeCallback()

◆ issueSetDirtySignals()

◆ notifyUserEndedStroke()

◆ notifyUserStartedStroke()

◆ tryDoUpdate()

Member Data Documentation

◆ m_d