#include <kis_tool_freehand_helper.h>

Inheritance diagram for KisToolFreehandHelper:

Classes
struct	Private

Signals
void	requestExplicitUpdateOutline ()

Public Member Functions
void	cursorMoved (const QPointF &cursorPos)

void	endPaint ()

void	initPaint (KoPointerEvent event, const QPointF &pixelCoords, KisImageWSP image, KisNodeSP currentNode, KisStrokesFacade strokesFacade, KisNodeSP overrideNode=0, KisDefaultBoundsBaseSP bounds=0)

bool	isRunning () const

	KisToolFreehandHelper (KisPaintingInformationBuilder infoBuilder, KoCanvasResourceProvider resourceManager, const KUndo2MagicString &transactionText=KUndo2MagicString(), KisSmoothingOptions *smoothingOptions=0)

void	paintEvent (KoPointerEvent *event)

KisOptimizedBrushOutline	paintOpOutline (const QPointF &savedCursorPos, const KoPointerEvent *event, const KisPaintOpSettingsSP globalSettings, KisPaintOpSettings::OutlineMode mode) const

void	setSmoothness (KisSmoothingOptionsSP smoothingOptions)

KisSmoothingOptionsSP	smoothingOptions () const

	~KisToolFreehandHelper () override

Protected Member Functions
void	cancelPaint ()

virtual void	createPainters (QVector< KisFreehandStrokeInfo * > &strokeInfos, const KisDistanceInformation &startDist)

int	elapsedStrokeTime () const

void	initPaintImpl (qreal startAngle, const KisPaintInformation &pi, KoCanvasResourceProvider resourceManager, KisImageWSP image, KisNodeSP node, KisStrokesFacade strokesFacade, KisNodeSP overrideNode=0, KisDefaultBoundsBaseSP bounds=0)

virtual void	paintAt (const KisPaintInformation &pi)

void	paintAt (int strokeInfoId, const KisPaintInformation &pi)

virtual void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2)

void	paintBezierCurve (int strokeInfoId, const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2)

virtual void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2)

void	paintLine (int strokeInfoId, const KisPaintInformation &pi1, const KisPaintInformation &pi2)

KoCanvasResourceProvider *	resourceManager () const

Private Slots
void	doAirbrushing ()

void	finishStroke ()

void	slotSmoothingTypeChanged ()

void	stabilizerPollAndPaint ()

Private Member Functions
int	computeAirbrushTimerInterval () const

qreal	currentPhysicalZoom () const

qreal	currentZoom () const

KisPaintInformation	getStabilizedPaintInfo (const QQueue< KisPaintInformation > &queue, const KisPaintInformation &lastPaintInfo)

void	paint (KisPaintInformation &info)

void	paintBezierSegment (KisPaintInformation pi1, KisPaintInformation pi2, QPointF tangent1, QPointF tangent2)

void	stabilizerEnd ()

void	stabilizerStart (KisPaintInformation firstPaintInfo)

void	updateCurrentBrushPosition (const QPointF &pixelPos)

Private Attributes
Private *const	m_d

Detailed Description

Definition at line 31 of file kis_tool_freehand_helper.h.

Constructor & Destructor Documentation

◆ KisToolFreehandHelper()

KisToolFreehandHelper::KisToolFreehandHelper	(	KisPaintingInformationBuilder *	infoBuilder,
		KoCanvasResourceProvider *	resourceManager,
		const KUndo2MagicString &	transactionText = KUndo2MagicString(),
		KisSmoothingOptions *	smoothingOptions = 0 )

Definition at line 136 of file kis_tool_freehand_helper.cpp.

    : m_d(new Private())
{
    m_d->resourceManager = resourceManager;
    m_d->infoBuilder = infoBuilder;
    m_d->transactionText = transactionText;
    m_d->smoothingOptions = KisSmoothingOptionsSP(
                smoothingOptions ? smoothingOptions : new KisSmoothingOptions());
 
    m_d->fakeDabRandomSource = new KisRandomSource();
    m_d->fakeStrokeRandomSource = new KisPerStrokeRandomSource();
 
    m_d->strokeTimeoutTimer.setSingleShot(true);
    connect(&m_d->strokeTimeoutTimer, SIGNAL(timeout()), SLOT(finishStroke()));
    connect(&m_d->airbrushingTimer, SIGNAL(timeout()), SLOT(doAirbrushing()));
    connect(&m_d->stabilizerPollTimer, SIGNAL(timeout()), SLOT(stabilizerPollAndPaint()));
    connect(m_d->smoothingOptions.data(), SIGNAL(sigSmoothingTypeChanged()), SLOT(slotSmoothingTypeChanged()));
 
    m_d->stabilizerDelayedPaintHelper.setPaintLineCallback(
                [this](const KisPaintInformation &pi1, const KisPaintInformation &pi2) {
                    paintLine(pi1, pi2);
                });
    m_d->stabilizerDelayedPaintHelper.setUpdateOutlineCallback(
                [this]() {
                    Q_EMIT requestExplicitUpdateOutline();
                });
}

◆ ~KisToolFreehandHelper()

KisToolFreehandHelper::~KisToolFreehandHelper ( )

override

Definition at line 167 of file kis_tool_freehand_helper.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

◆ cancelPaint()

void KisToolFreehandHelper::cancelPaint ( )

protected

Definition at line 751 of file kis_tool_freehand_helper.cpp.

{
    if (!m_d->strokeId) return;
 
    m_d->strokeTimeoutTimer.stop();
 
    if (m_d->airbrushingTimer.isActive()) {
        m_d->airbrushingTimer.stop();
    }
 
    if (m_d->asyncUpdateHelper.isActive()) {
        m_d->asyncUpdateHelper.cancelUpdateStream();
    }
 
    if (m_d->stabilizerPollTimer.isActive()) {
        m_d->stabilizerPollTimer.stop();
    }
 
    if (m_d->stabilizerDelayedPaintHelper.running()) {
        m_d->stabilizerDelayedPaintHelper.cancel();
    }
 
    // see a comment in endPaint()
    m_d->strokeInfos.clear();
 
    m_d->strokesFacade->cancelStroke(m_d->strokeId);
    m_d->strokeId.clear();
 
}

◆ computeAirbrushTimerInterval()

int KisToolFreehandHelper::computeAirbrushTimerInterval ( ) const

private

Definition at line 1001 of file kis_tool_freehand_helper.cpp.

{
    qreal realInterval = m_d->resources->airbrushingInterval() * AIRBRUSH_INTERVAL_FACTOR;
    return qMax(1, qFloor(realInterval));
}

References AIRBRUSH_INTERVAL_FACTOR, KisResourcesSnapshot::airbrushingInterval(), m_d, and KisToolFreehandHelper::Private::resources.

◆ createPainters()

void KisToolFreehandHelper::createPainters	(	QVector< KisFreehandStrokeInfo * > &	strokeInfos,
		const KisDistanceInformation &	startDist )

protectedvirtual

Reimplemented in KisToolMultihandHelper.

Definition at line 1077 of file kis_tool_freehand_helper.cpp.

{
    strokeInfos << new KisFreehandStrokeInfo(startDist);
}

◆ currentPhysicalZoom()

qreal KisToolFreehandHelper::currentPhysicalZoom ( ) const

private

Definition at line 1012 of file kis_tool_freehand_helper.cpp.

{
    return m_d->resourceManager ? m_d->resourceManager->resource(KoCanvasResource::EffectivePhysicalZoom).toReal() : 1.0;
}

References KoCanvasResource::EffectivePhysicalZoom, m_d, KoCanvasResourceProvider::resource(), and KisToolFreehandHelper::Private::resourceManager.

◆ currentZoom()

qreal KisToolFreehandHelper::currentZoom ( ) const

private

Definition at line 1007 of file kis_tool_freehand_helper.cpp.

{
    return m_d->resourceManager ? m_d->resourceManager->resource(KoCanvasResource::EffectiveZoom).toReal() : 1.0;
}

References KoCanvasResource::EffectiveZoom, m_d, KoCanvasResourceProvider::resource(), and KisToolFreehandHelper::Private::resourceManager.

◆ cursorMoved()

void KisToolFreehandHelper::cursorMoved ( const QPointF & cursorPos )

Definition at line 253 of file kis_tool_freehand_helper.cpp.

{
    m_d->lastCursorPos.pushThroughHistory(cursorPos, currentZoom());
}

References currentZoom(), KisToolFreehandHelper::Private::lastCursorPos, m_d, and KisPaintOpUtils::PositionHistory::pushThroughHistory().

◆ doAirbrushing

void KisToolFreehandHelper::doAirbrushing ( )

privateslot

Definition at line 977 of file kis_tool_freehand_helper.cpp.

{
    // Check that the stroke hasn't ended.
    if (!m_d->strokeInfos.isEmpty()) {
 
        // Add a new painting update at a point identical to the previous one, except for the time
        // and speed information.
        const KisPaintInformation &prevPaint = m_d->previousPaintInformation;
        KisPaintInformation nextPaint(prevPaint.pos(),
                                      prevPaint.pressure(),
                                      prevPaint.xTilt(),
                                      prevPaint.yTilt(),
                                      prevPaint.rotation(),
                                      prevPaint.tangentialPressure(),
                                      prevPaint.perspective(),
                                      elapsedStrokeTime(),
                                      0.0);
        nextPaint.setCanvasRotation(prevPaint.canvasRotation());
        nextPaint.setCanvasMirroredH(prevPaint.canvasMirroredH());
        nextPaint.setCanvasMirroredV(prevPaint.canvasMirroredV());
        paint(nextPaint);
    }
}

◆ elapsedStrokeTime()

int KisToolFreehandHelper::elapsedStrokeTime ( ) const

protected

Definition at line 781 of file kis_tool_freehand_helper.cpp.

{
    return m_d->strokeTime.elapsed();
}

References m_d, and KisToolFreehandHelper::Private::strokeTime.

◆ endPaint()

void KisToolFreehandHelper::endPaint ( )

There might be some timer events still pending, so we should cancel them. Use this flag for the purpose. Please note that we are not in MT here, so no mutex is needed

Definition at line 713 of file kis_tool_freehand_helper.cpp.

{
    if (!m_d->hasPaintAtLeastOnce) {
        paintAt(m_d->previousPaintInformation);
    } else if (m_d->smoothingOptions->smoothingType() != KisSmoothingOptions::NO_SMOOTHING) {
        finishStroke();
    }
    m_d->strokeTimeoutTimer.stop();
 
    if(m_d->airbrushingTimer.isActive()) {
        m_d->airbrushingTimer.stop();
    }
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
        stabilizerEnd();
    }
 
    if (m_d->asyncUpdateHelper.isActive()) {
        m_d->asyncUpdateHelper.endUpdateStream();
    }
 
    m_d->strokeInfos.clear();
 
    // last update to complete rendering if there is still something pending
    m_d->strokesFacade->addJob(m_d->strokeId,
       new KisAsynchronousStrokeUpdateHelper::UpdateData(true));
 
    m_d->strokesFacade->endStroke(m_d->strokeId);
    m_d->strokeId.clear();
    m_d->infoBuilder->reset();
}

◆ finishStroke

void KisToolFreehandHelper::finishStroke ( )

privateslot

Definition at line 961 of file kis_tool_freehand_helper.cpp.

{
    if (m_d->haveTangent) {
        m_d->haveTangent = false;
 
        QPointF newTangent = (m_d->previousPaintInformation.pos() - m_d->olderPaintInformation.pos()) /
            qMax(qreal(1.0), m_d->previousPaintInformation.currentTime() - m_d->olderPaintInformation.currentTime());
 
        paintBezierSegment(m_d->olderPaintInformation,
                           m_d->previousPaintInformation,
                           m_d->previousTangent,
                           newTangent);
    }
    
}

References KisPaintInformation::currentTime(), KisToolFreehandHelper::Private::haveTangent, m_d, KisToolFreehandHelper::Private::olderPaintInformation, paintBezierSegment(), KisPaintInformation::pos(), KisToolFreehandHelper::Private::previousPaintInformation, and KisToolFreehandHelper::Private::previousTangent.

◆ getStabilizedPaintInfo()

KisPaintInformation KisToolFreehandHelper::getStabilizedPaintInfo	(	const QQueue< KisPaintInformation > &	queue,
		const KisPaintInformation &	lastPaintInfo )

private

The first point is going to be overridden by lastPaintInfo, skip it.

Definition at line 815 of file kis_tool_freehand_helper.cpp.

{
    KisPaintInformation result(lastPaintInfo.pos(),
                               lastPaintInfo.pressure(),
                               lastPaintInfo.xTilt(),
                               lastPaintInfo.yTilt(),
                               lastPaintInfo.rotation(),
                               lastPaintInfo.tangentialPressure(),
                               lastPaintInfo.perspective(),
                               elapsedStrokeTime(),
                               lastPaintInfo.drawingSpeed());
 
    result.setCanvasRotation(lastPaintInfo.canvasRotation());
    result.setCanvasMirroredH(lastPaintInfo.canvasMirroredH());
    result.setCanvasMirroredV(lastPaintInfo.canvasMirroredV());
 
    if (queue.size() > 1) {
        QQueue<KisPaintInformation>::const_iterator it = queue.constBegin();
        QQueue<KisPaintInformation>::const_iterator end = queue.constEnd();
 
        it++;
        int i = 2;
 
        if (m_d->smoothingOptions->stabilizeSensors()) {
            while (it != end) {
                qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                result.KisPaintInformation::mixOtherWithoutTime(k, *it);
                it++;
                i++;
            }
        } else{
            while (it != end) {
                qreal k = qreal(i - 1) / i; // coeff for uniform averaging
                result.KisPaintInformation::mixOtherOnlyPosition(k, *it);
                it++;
                i++;
            }
        }
    }
 
    return result;
}

◆ initPaint()

void KisToolFreehandHelper::initPaint	(	KoPointerEvent *	event,
		const QPointF &	pixelCoords,
		KisImageWSP	image,
		KisNodeSP	currentNode,
		KisStrokesFacade *	strokesFacade,
		KisNodeSP	overrideNode = 0,
		KisDefaultBoundsBaseSP	bounds = 0 )

Parameters

event	The event
pixelCoords	The position of the KoPointerEvent, in pixel coordinates.
resourceManager	The canvas resource manager
image	The image
currentNode	The current node
strokesFacade	The strokes facade
overrideNode	The override node
bounds	The bounds

Definition at line 258 of file kis_tool_freehand_helper.cpp.

{
    // When using touch drawing, we only get coordinates when the finger is
    // actually pressed down, never when the finger is in the air. That means we
    // have to clear the distance and speed information in this case, otherwise
    // strokes start in a state depending on where the last stroke left off,
    // which is useless. Resetting these at least makes it predictable. This
    // can't sensibly be done in endPaint since there can be stylus or mouse
    // events in the meantime, whose distance and speed is also unrelated.
    if (event->isTouchEvent()) {
        m_d->lastCursorPos.reset(pixelCoords);
        m_d->infoBuilder->reset();
    }
 
    QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(pixelCoords, currentZoom());
    m_d->strokeTime.start();
    KisPaintInformation pi =
        m_d->infoBuilder->startStroke(event, elapsedStrokeTime(), m_d->resourceManager);
    qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, pixelCoords, 0.0);
 
    initPaintImpl(startAngle,
                  pi,
                  m_d->resourceManager,
                  image,
                  currentNode,
                  strokesFacade,
                  overrideNode,
                  bounds);
}

References bounds, currentZoom(), KisAlgebra2D::directionBetweenPoints(), elapsedStrokeTime(), KisToolFreehandHelper::Private::infoBuilder, initPaintImpl(), KoPointerEvent::isTouchEvent(), KisToolFreehandHelper::Private::lastCursorPos, m_d, KisPaintOpUtils::PositionHistory::pushThroughHistory(), KisPaintingInformationBuilder::reset(), KisPaintOpUtils::PositionHistory::reset(), KisToolFreehandHelper::Private::resourceManager, KisPaintingInformationBuilder::startStroke(), and KisToolFreehandHelper::Private::strokeTime.

◆ initPaintImpl()

void KisToolFreehandHelper::initPaintImpl	(	qreal	startAngle,
		const KisPaintInformation &	pi,
		KoCanvasResourceProvider *	resourceManager,
		KisImageWSP	image,
		KisNodeSP	node,
		KisStrokesFacade *	strokesFacade,
		KisNodeSP	overrideNode = 0,
		KisDefaultBoundsBaseSP	bounds = 0 )

protected

Definition at line 298 of file kis_tool_freehand_helper.cpp.

{
    m_d->strokesFacade = strokesFacade;
 
    m_d->haveTangent = false;
    m_d->previousTangent = QPointF();
 
    m_d->hasPaintAtLeastOnce = false;
 
    m_d->previousPaintInformation = pi;
 
    m_d->resources = new KisResourcesSnapshot(image,
                                              currentNode,
                                              resourceManager,
                                              bounds);
    if(overrideNode) {
        m_d->resources->setCurrentNode(overrideNode);
    }
 
    const bool airbrushing = m_d->resources->needsAirbrushing();
    const bool useSpacingUpdates = m_d->resources->needsSpacingUpdates();
 
    KisDistanceInitInfo startDistInfo(m_d->previousPaintInformation.pos(),
                                      startAngle,
                                      useSpacingUpdates ? SPACING_UPDATE_INTERVAL : LONG_TIME,
                                      airbrushing ? TIMING_UPDATE_INTERVAL : LONG_TIME,
                                      0);
    KisDistanceInformation startDist = startDistInfo.makeDistInfo();
 
    createPainters(m_d->strokeInfos,
                   startDist);
 
    KisStrokeStrategy *stroke =
        new FreehandStrokeStrategy(m_d->resources,
                                   m_d->strokeInfos,
                                   m_d->transactionText,
                                   FreehandStrokeStrategy::SupportsContinuedInterstrokeData |
                                   FreehandStrokeStrategy::SupportsTimedMergeId);
 
    m_d->strokeId = m_d->strokesFacade->startStroke(stroke);
 
    m_d->history.clear();
    m_d->distanceHistory.clear();
    m_d->hasLastDrawnPixel = false;
    m_d->hasTentativePixel = false;
 
    if (airbrushing) {
        m_d->airbrushingTimer.setInterval(computeAirbrushTimerInterval());
        m_d->airbrushingTimer.start();
    } else if (m_d->resources->presetNeedsAsynchronousUpdates()) {
        m_d->asyncUpdateHelper.startUpdateStream(m_d->strokesFacade, m_d->strokeId);
    }
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
        stabilizerStart(m_d->previousPaintInformation);
    }
 
    // If airbrushing, paint an initial dab immediately. This is a workaround for an issue where
    // some paintops (Dyna, Particle, Sketch) might never initialize their spacing/timing
    // information until paintAt is called.
    if (airbrushing) {
        paintAt(pi);
    }
}

◆ isRunning()

bool KisToolFreehandHelper::isRunning ( ) const

Definition at line 293 of file kis_tool_freehand_helper.cpp.

{
    return bool(m_d->strokeId);
}

References m_d, and KisToolFreehandHelper::Private::strokeId.

◆ paint()

void KisToolFreehandHelper::paint ( KisPaintInformation & info )

private

Smooth the coordinates out using the history and the distance. This is a heavily modified version of an algo used in Gimp and described in https://bugs.kde.org/show_bug.cgi?id=281267 and https://w.atwiki.jp/sigetch_2007/pages/17.html. The main differences are:

1) It uses 'distance' instead of 'velocity', since time measurements are too unstable in realworld environment

2) There is no 'Quality' parameter, since the number of samples is calculated automatically

3) 'Tail Aggressiveness' is used for controlling the end of the stroke

4) The formula is a little bit different: 'Distance' parameter stands for $3 \Sigma$

Definition at line 502 of file kis_tool_freehand_helper.cpp.

{ 
    KisPaintInformation lastUsedPaintInformation;
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING
        && (m_d->smoothingOptions->smoothnessDistanceMin() > 0.0
            || m_d->smoothingOptions->smoothnessDistanceMax() > 0.0)) {
 
        { // initialize current distance
            QPointF prevPos;
 
            if (!m_d->history.isEmpty()) {
                const KisPaintInformation &prevPi = m_d->history.last();
                prevPos = prevPi.pos();
            } else {
                prevPos = m_d->previousPaintInformation.pos();
            }
 
            qreal currentDistance = QVector2D(info.pos() - prevPos).length();
            m_d->distanceHistory.append(currentDistance);
        }
 
        m_d->history.append(info);
 
        qreal x = 0.0;
        qreal y = 0.0;
 
        if (m_d->history.size() > 3) {
            const qreal sigma = m_d->effectiveSmoothnessDistance(m_d->previousPaintInformation.drawingSpeed()) / 3.0; // '3.0' for (3 * sigma) range
 
            qreal gaussianWeight = 1 / (sqrt(2 * M_PI) * sigma);
            qreal gaussianWeight2 = sigma * sigma;
            qreal distanceSum = 0.0;
            qreal scaleSum = 0.0;
            qreal pressure = 0.0;
            qreal baseRate = 0.0;
 
            Q_ASSERT(m_d->history.size() == m_d->distanceHistory.size());
 
            for (int i = m_d->history.size() - 1; i >= 0; i--) {
                qreal rate = 0.0;
 
                const KisPaintInformation nextInfo = m_d->history.at(i);
                double distance = m_d->distanceHistory.at(i);
                Q_ASSERT(distance >= 0.0);
 
                qreal pressureGrad = 0.0;
                if (i < m_d->history.size() - 1) {
                    pressureGrad = nextInfo.pressure() - m_d->history.at(i + 1).pressure();
 
                    const qreal tailAggressiveness = 40.0 * m_d->smoothingOptions->tailAggressiveness();
 
                    if (pressureGrad > 0.0 ) {
                        pressureGrad *= tailAggressiveness * (1.0 - nextInfo.pressure());
                        distance += pressureGrad * 3.0 * sigma; // (3 * sigma) --- holds > 90% of the region
                    }
                }
 
                if (gaussianWeight2 != 0.0) {
                    distanceSum += distance;
                    rate = gaussianWeight * exp(-distanceSum * distanceSum / (2 * gaussianWeight2));
                }
 
                if (m_d->history.size() - i == 1) {
                    baseRate = rate;
                } else if (baseRate / rate > 100) {
                    break;
                }
 
                scaleSum += rate;
                x += rate * nextInfo.pos().x();
                y += rate * nextInfo.pos().y();
 
                if (m_d->smoothingOptions->smoothPressure()) {
                    pressure += rate * nextInfo.pressure();
                }
            }
 
            if (scaleSum != 0.0) {
                x /= scaleSum;
                y /= scaleSum;
 
                if (m_d->smoothingOptions->smoothPressure()) {
                    pressure /= scaleSum;
                }
            }
 
            if ((x != 0.0 && y != 0.0) || (x == info.pos().x() && y == info.pos().y())) {
                info.setPos(QPointF(x, y));
                if (m_d->smoothingOptions->smoothPressure()) {
                    info.setPressure(pressure);
                }
                m_d->history.last() = info;
            }
        }
    }
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
            || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING)
        {
            // Now paint between the coordinates, using the bezier curve interpolation
            if (!m_d->haveTangent) {
                m_d->haveTangent = true;
                m_d->previousTangent =
                    (info.pos() - m_d->previousPaintInformation.pos()) /
                    qMax(qreal(1.0), info.currentTime() - m_d->previousPaintInformation.currentTime());
            } else {
                QPointF newTangent = (info.pos() - m_d->olderPaintInformation.pos()) /
                    qMax(qreal(1.0), info.currentTime() - m_d->olderPaintInformation.currentTime());
 
                if (newTangent.isNull() || m_d->previousTangent.isNull())
                {
                    paintLine(m_d->previousPaintInformation, info);
                } else {
                    paintBezierSegment(m_d->olderPaintInformation, m_d->previousPaintInformation,
                                    m_d->previousTangent, newTangent);
                }
 
                m_d->previousTangent = newTangent;
            }
            m_d->olderPaintInformation = m_d->previousPaintInformation;
 
            // Enable stroke timeout only when not airbrushing.
            if (!m_d->airbrushingTimer.isActive()) {
                m_d->strokeTimeoutTimer.start(100);
            }
        }
 
    else if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::NO_SMOOTHING){
        paintLine(m_d->previousPaintInformation, info);
    }
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::PIXEL_PERFECT) {
        QPoint currentPixelPos = Private::toPixelPos(info.pos());
 
        // First pixel is always perfect.
        if (!m_d->hasLastDrawnPixel) {
            Private::setPaintInfoPixelPos(info, currentPixelPos);
            paintLine(info, info);
            m_d->lastDrawnPixel = currentPixelPos;
            m_d->hasLastDrawnPixel = true;
            m_d->hasTentativePixel = false;
            m_d->olderPaintInformation = info;
 
        } else {
            // Check if we need to flush a currently stashed tentative pixel.
            bool lastTentative = m_d->isTentativePixel(currentPixelPos);
            if (m_d->hasTentativePixel && !lastTentative) {
                Private::setPaintInfoPixelPos(m_d->tentativePaintInformation, m_d->tentativePixel);
                paintLine(m_d->olderPaintInformation, m_d->tentativePaintInformation);
                m_d->hasTentativePixel = false;
                m_d->lastDrawnPixel = m_d->tentativePixel;
                m_d->olderPaintInformation = m_d->tentativePaintInformation;
                lastTentative = m_d->isTentativePixel(currentPixelPos);
            }
 
            // If this pixel is too close to the previously drawn one, we mark
            // it as tentative and wait for further movements to make sure we
            // don't put it down in a place that generates a jag. If there is
            // already a tentative pixel, it will be clobbered.
            if (lastTentative) {
                m_d->hasTentativePixel = true;
                m_d->tentativePixel = currentPixelPos;
                m_d->tentativePaintInformation = info;
            } else {
                Private::setPaintInfoPixelPos(info, currentPixelPos);
                paintLine(m_d->olderPaintInformation, info);
                m_d->lastDrawnPixel = currentPixelPos;
                m_d->olderPaintInformation = info;
                // Don't need to fiddle with hasLastTentativePixel here, it can
                // only ever be false here due to the previous condition.
            }
        }
    }
 
    if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER) {
        m_d->stabilizedSampler.addEvent(info);
        if (m_d->stabilizerDelayedPaintHelper.running()) {
            // Paint here so we don't have to rely on the timer
            // This is just a tricky source for a relatively stable 7ms "timer"
            m_d->stabilizerDelayedPaintHelper.paintSome();
        }
    } else {
        m_d->previousPaintInformation = info;
    }
 
    if(m_d->airbrushingTimer.isActive()) {
        m_d->airbrushingTimer.start();
    }
}

◆ paintAt() [1/2]

void KisToolFreehandHelper::paintAt ( const KisPaintInformation & pi )

protectedvirtual

Reimplemented in KisToolMultihandHelper, and KisToolMultihandHelper.

Definition at line 1083 of file kis_tool_freehand_helper.cpp.

{
    paintAt(0, pi);
}

References paintAt().

◆ paintAt() [2/2]

void KisToolFreehandHelper::paintAt	(	int	strokeInfoId,
		const KisPaintInformation &	pi )

protected

Definition at line 1017 of file kis_tool_freehand_helper.cpp.

{
    updateCurrentBrushPosition(pi.pos());
    m_d->hasPaintAtLeastOnce = true;
    m_d->strokesFacade->addJob(m_d->strokeId,
                               new FreehandStrokeStrategy::Data(strokeInfoId, pi));
 
}

References KisStrokesFacade::addJob(), KisToolFreehandHelper::Private::hasPaintAtLeastOnce, m_d, KisPaintInformation::pos(), KisToolFreehandHelper::Private::strokeId, KisToolFreehandHelper::Private::strokesFacade, and updateCurrentBrushPosition().

◆ paintBezierCurve() [1/2]

void KisToolFreehandHelper::paintBezierCurve	(	const KisPaintInformation &	pi1,
		const QPointF &	control1,
		const QPointF &	control2,
		const KisPaintInformation &	pi2 )

protectedvirtual

Reimplemented in KisToolMultihandHelper, and KisToolMultihandHelper.

Definition at line 1094 of file kis_tool_freehand_helper.cpp.

{
    paintBezierCurve(0, pi1, control1, control2, pi2);
}

References paintBezierCurve().

◆ paintBezierCurve() [2/2]

void KisToolFreehandHelper::paintBezierCurve	(	int	strokeInfoId,
		const KisPaintInformation &	pi1,
		const QPointF &	control1,
		const QPointF &	control2,
		const KisPaintInformation &	pi2 )

protected

Definition at line 1038 of file kis_tool_freehand_helper.cpp.

{
    updateCurrentBrushPosition(pi2.pos());
 
#ifdef DEBUG_BEZIER_CURVES
    KisPaintInformation tpi1;
    KisPaintInformation tpi2;
 
    tpi1 = pi1;
    tpi2 = pi2;
 
    tpi1.setPressure(0.3);
    tpi2.setPressure(0.3);
 
    paintLine(tpi1, tpi2);
 
    tpi1.setPressure(0.6);
    tpi2.setPressure(0.3);
 
    tpi1.setPos(pi1.pos());
    tpi2.setPos(control1);
    paintLine(tpi1, tpi2);
 
    tpi1.setPos(pi2.pos());
    tpi2.setPos(control2);
    paintLine(tpi1, tpi2);
#endif
 
    m_d->hasPaintAtLeastOnce = true;
    m_d->strokesFacade->addJob(m_d->strokeId,
                               new FreehandStrokeStrategy::Data(strokeInfoId,
                                                                pi1, control1, control2, pi2));
 
}

References KisStrokesFacade::addJob(), KisToolFreehandHelper::Private::hasPaintAtLeastOnce, m_d, paintLine(), KisPaintInformation::pos(), KisPaintInformation::setPos(), KisPaintInformation::setPressure(), KisToolFreehandHelper::Private::strokeId, KisToolFreehandHelper::Private::strokesFacade, and updateCurrentBrushPosition().

◆ paintBezierSegment()

void KisToolFreehandHelper::paintBezierSegment	(	KisPaintInformation	pi1,
		KisPaintInformation	pi2,
		QPointF	tangent1,
		QPointF	tangent2 )

private

Definition at line 385 of file kis_tool_freehand_helper.cpp.

{
    if (tangent1.isNull() || tangent2.isNull()) return;
 
    const qreal maxSanePoint = 1e6;
 
    QPointF controlTarget1;
    QPointF controlTarget2;
 
    // Shows the direction in which control points go
    QPointF controlDirection1 = pi1.pos() + tangent1;
    QPointF controlDirection2 = pi2.pos() - tangent2;
 
    // Lines in the direction of the control points
    QLineF line1(pi1.pos(), controlDirection1);
    QLineF line2(pi2.pos(), controlDirection2);
 
    // Lines to check whether the control points lay on the opposite
    // side of the line
    QLineF line3(controlDirection1, controlDirection2);
    QLineF line4(pi1.pos(), pi2.pos());
 
    QPointF intersection;
    if (line3.intersects(line4, &intersection) == QLineF::BoundedIntersection) {
        qreal controlLength = line4.length() / 2;
 
        line1.setLength(controlLength);
        line2.setLength(controlLength);
 
        controlTarget1 = line1.p2();
        controlTarget2 = line2.p2();
    } else {
        QLineF::IntersectType type = line1.intersects(line2, &intersection);
 
        if (type == QLineF::NoIntersection ||
            intersection.manhattanLength() > maxSanePoint) {
 
            intersection = 0.5 * (pi1.pos() + pi2.pos());
//            dbgKrita << "WARNING: there is no intersection point "
//                     << "in the basic smoothing algorithms";
        }
 
        controlTarget1 = intersection;
        controlTarget2 = intersection;
    }
 
    // shows how near to the controlTarget the value raises
    qreal coeff = 0.8;
 
    qreal velocity1 = QLineF(QPointF(), tangent1).length();
    qreal velocity2 = QLineF(QPointF(), tangent2).length();
 
    if (velocity1 == 0.0 || velocity2 == 0.0) {
        velocity1 = 1e-6;
        velocity2 = 1e-6;
        warnKrita << "WARNING: Basic Smoothing: Velocity is Zero! Please report a bug:" << ppVar(velocity1) << ppVar(velocity2);
    }
 
    qreal similarity = qMin(velocity1/velocity2, velocity2/velocity1);
 
    // the controls should not differ more than 50%
    similarity = qMax(similarity, qreal(0.5));
 
    // when the controls are symmetric, their size should be smaller
    // to avoid corner-like curves
    coeff *= 1 - qMax(qreal(0.0), similarity - qreal(0.8));
 
    Q_ASSERT(coeff > 0);
 
 
    QPointF control1;
    QPointF control2;
 
    if (velocity1 > velocity2) {
        control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
        coeff *= similarity;
        control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
    } else {
        control2 = pi2.pos() * (1.0 - coeff) + coeff * controlTarget2;
        coeff *= similarity;
        control1 = pi1.pos() * (1.0 - coeff) + coeff * controlTarget1;
    }
 
    paintBezierCurve(pi1,
                     control1,
                     control2,
                     pi2);
}

References paintBezierCurve(), KisPaintInformation::pos(), ppVar, and warnKrita.

◆ paintEvent()

void KisToolFreehandHelper::paintEvent ( KoPointerEvent * event )

Definition at line 491 of file kis_tool_freehand_helper.cpp.

{
    KisPaintInformation info =
            m_d->infoBuilder->continueStroke(event,
                                             elapsedStrokeTime());
    KisUpdateTimeMonitor::instance()->reportMouseMove(info.pos());
 
    paint(info);
}

References KisPaintingInformationBuilder::continueStroke(), elapsedStrokeTime(), KisToolFreehandHelper::Private::infoBuilder, KisUpdateTimeMonitor::instance(), m_d, paint(), KisPaintInformation::pos(), and KisUpdateTimeMonitor::reportMouseMove().

◆ paintLine() [1/2]

void KisToolFreehandHelper::paintLine	(	const KisPaintInformation &	pi1,
		const KisPaintInformation &	pi2 )

protectedvirtual

Reimplemented in KisToolMultihandHelper, and KisToolMultihandHelper.

Definition at line 1088 of file kis_tool_freehand_helper.cpp.

{
    paintLine(0, pi1, pi2);
}

References paintLine().

◆ paintLine() [2/2]

void KisToolFreehandHelper::paintLine	(	int	strokeInfoId,
		const KisPaintInformation &	pi1,
		const KisPaintInformation &	pi2 )

protected

Definition at line 1027 of file kis_tool_freehand_helper.cpp.

{
    updateCurrentBrushPosition(pi2.pos());
    m_d->hasPaintAtLeastOnce = true;
    m_d->strokesFacade->addJob(m_d->strokeId,
                               new FreehandStrokeStrategy::Data(strokeInfoId, pi1, pi2));
 
}

References KisStrokesFacade::addJob(), KisToolFreehandHelper::Private::hasPaintAtLeastOnce, m_d, KisPaintInformation::pos(), KisToolFreehandHelper::Private::strokeId, KisToolFreehandHelper::Private::strokesFacade, and updateCurrentBrushPosition().

◆ paintOpOutline()

KisOptimizedBrushOutline KisToolFreehandHelper::paintOpOutline	(	const QPointF &	savedCursorPos,
		const KoPointerEvent *	event,
		const KisPaintOpSettingsSP	globalSettings,
		KisPaintOpSettings::OutlineMode	mode ) const

When LoD mode is active it may happen that the helper has already started a stroke, but it painted noting, because all the work is being calculated by the scaled-down LodN stroke. So at first we try to fetch the data from the lodN stroke ("buddy") and then check if there is at least something has been painted with this distance information object.

Tiny hack alert: here we fetch the distance information directly from the LodN stroke. Ideally, we should upscale its data, but here we just override it with our local copy of the coordinates.

Definition at line 182 of file kis_tool_freehand_helper.cpp.

{
    KisPaintOpSettingsSP settings = globalSettings;
    QPointF prevPoint = m_d->lastCursorPos.pushThroughHistory(savedCursorPos, currentZoom());
    qreal startAngle = KisAlgebra2D::directionBetweenPoints(prevPoint, savedCursorPos, 0);
    KisDistanceInformation distanceInfo(prevPoint, startAngle);
 
    KisPaintInformation info;
 
    if (!m_d->strokeInfos.isEmpty()) {
        settings = m_d->resources->currentPaintOpPreset()->settings();
        if (m_d->stabilizerDelayedPaintHelper.running() &&
                m_d->stabilizerDelayedPaintHelper.hasLastPaintInformation()) {
            info = m_d->stabilizerDelayedPaintHelper.lastPaintInformation();
        } else {
            info = m_d->previousPaintInformation;
        }
 
        KisDistanceInformation *buddyDistance =
            m_d->strokeInfos.first()->buddyDragDistance();
 
        if (buddyDistance) {
            distanceInfo = *buddyDistance;
            distanceInfo.overrideLastValues(prevPoint, startAngle);
 
        } else if (m_d->strokeInfos.first()->dragDistance->isStarted()) {
            distanceInfo = *m_d->strokeInfos.first()->dragDistance;
        }
    } else {
        info = m_d->infoBuilder->hover(savedCursorPos, event, !m_d->strokeInfos.isEmpty());
    }
 
    KisPaintInformation::DistanceInformationRegistrar registrar =
        info.registerDistanceInformation(&distanceInfo);
 
    info.setRandomSource(m_d->fakeDabRandomSource);
    info.setPerStrokeRandomSource(m_d->fakeStrokeRandomSource);
 
    KisOptimizedBrushOutline outline = settings->brushOutline(info, mode, currentPhysicalZoom());
 
    if (m_d->resources &&
        m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::STABILIZER &&
        m_d->smoothingOptions->useDelayDistance()) {
 
        const qreal R = m_d->smoothingOptions->delayDistance() /
            m_d->resources->effectiveZoom();
 
        outline.addEllipse(info.pos(), R, R);
    }
 
    return outline;
}

References KisOptimizedBrushOutline::addEllipse(), KisResourcesSnapshot::currentPaintOpPreset(), currentPhysicalZoom(), currentZoom(), KisAlgebra2D::directionBetweenPoints(), KisResourcesSnapshot::effectiveZoom(), KisToolFreehandHelper::Private::fakeDabRandomSource, KisToolFreehandHelper::Private::fakeStrokeRandomSource, KisStabilizerDelayedPaintHelper::hasLastPaintInformation(), KisPaintingInformationBuilder::hover(), KisToolFreehandHelper::Private::infoBuilder, KisToolFreehandHelper::Private::lastCursorPos, KisStabilizerDelayedPaintHelper::lastPaintInformation(), m_d, KisDistanceInformation::overrideLastValues(), KisPaintInformation::pos(), KisToolFreehandHelper::Private::previousPaintInformation, KisPaintOpUtils::PositionHistory::pushThroughHistory(), R, KisPaintInformation::registerDistanceInformation(), KisToolFreehandHelper::Private::resources, KisStabilizerDelayedPaintHelper::running(), KisPaintInformation::setPerStrokeRandomSource(), KisPaintInformation::setRandomSource(), KisToolFreehandHelper::Private::smoothingOptions, KisSmoothingOptions::STABILIZER, KisToolFreehandHelper::Private::stabilizerDelayedPaintHelper, and KisToolFreehandHelper::Private::strokeInfos.

◆ requestExplicitUpdateOutline

void KisToolFreehandHelper::requestExplicitUpdateOutline ( )

signal

The signal is emitted when the outline should be updated explicitly by the tool. Used by Stabilizer option, because it paints on internal timer events instead of the on every paint() event

◆ resourceManager()

KoCanvasResourceProvider * KisToolFreehandHelper::resourceManager ( ) const

protected

Definition at line 370 of file kis_tool_freehand_helper.cpp.

{
    return m_d->resourceManager;
}

References m_d, and KisToolFreehandHelper::Private::resourceManager.

◆ setSmoothness()

void KisToolFreehandHelper::setSmoothness ( KisSmoothingOptionsSP smoothingOptions )

Definition at line 172 of file kis_tool_freehand_helper.cpp.

{
    m_d->smoothingOptions = smoothingOptions;
}

References m_d, KisToolFreehandHelper::Private::smoothingOptions, and smoothingOptions().

◆ slotSmoothingTypeChanged

void KisToolFreehandHelper::slotSmoothingTypeChanged ( )

privateslot

Definition at line 945 of file kis_tool_freehand_helper.cpp.

{
    if (!isRunning()) {
        return;
    }
    KisSmoothingOptions::SmoothingType currentSmoothingType =
            m_d->smoothingOptions->smoothingType();
    if (m_d->usingStabilizer
            && (currentSmoothingType != KisSmoothingOptions::STABILIZER)) {
        stabilizerEnd();
    } else if (!m_d->usingStabilizer
            && (currentSmoothingType == KisSmoothingOptions::STABILIZER)) {
        stabilizerStart(m_d->previousPaintInformation);
    }
}

References isRunning(), m_d, KisToolFreehandHelper::Private::previousPaintInformation, KisToolFreehandHelper::Private::smoothingOptions, KisSmoothingOptions::STABILIZER, stabilizerEnd(), stabilizerStart(), and KisToolFreehandHelper::Private::usingStabilizer.

◆ smoothingOptions()

KisSmoothingOptionsSP KisToolFreehandHelper::smoothingOptions ( ) const

Definition at line 177 of file kis_tool_freehand_helper.cpp.

{
    return m_d->smoothingOptions;
}

References m_d, and KisToolFreehandHelper::Private::smoothingOptions.

◆ stabilizerEnd()

void KisToolFreehandHelper::stabilizerEnd ( )

private

Definition at line 924 of file kis_tool_freehand_helper.cpp.

{
    // Stop the timer
    m_d->stabilizerPollTimer.stop();
 
    // Finish the line
    if (m_d->smoothingOptions->finishStabilizedCurve()) {
        // Process all the existing events first
        stabilizerPollAndPaint();
 
        // Draw the finish line with pending events and a time override
        m_d->stabilizedSampler.addFinishingEvent(m_d->stabilizerDeque.size());
        stabilizerPollAndPaint();
    }
 
    if (m_d->stabilizerDelayedPaintHelper.running()) {
        m_d->stabilizerDelayedPaintHelper.end();
    }
    m_d->usingStabilizer = false;
}

References KisStabilizedEventsSampler::addFinishingEvent(), KisStabilizerDelayedPaintHelper::end(), m_d, KisStabilizerDelayedPaintHelper::running(), KisToolFreehandHelper::Private::smoothingOptions, KisToolFreehandHelper::Private::stabilizedSampler, KisToolFreehandHelper::Private::stabilizerDelayedPaintHelper, KisToolFreehandHelper::Private::stabilizerDeque, stabilizerPollAndPaint(), KisToolFreehandHelper::Private::stabilizerPollTimer, and KisToolFreehandHelper::Private::usingStabilizer.

◆ stabilizerPollAndPaint

void KisToolFreehandHelper::stabilizerPollAndPaint ( )

privateslot

Definition at line 862 of file kis_tool_freehand_helper.cpp.

{
    KisStabilizedEventsSampler::iterator it;
    KisStabilizedEventsSampler::iterator end;
    std::tie(it, end) = m_d->stabilizedSampler.range();
    QVector<KisPaintInformation> delayedPaintTodoItems;
 
    for (; it != end; ++it) {
        KisPaintInformation sampledInfo = *it;
 
        bool canPaint = true;
 
        if (m_d->smoothingOptions->useDelayDistance()) {
            const qreal R = m_d->smoothingOptions->delayDistance() /
                    m_d->resources->effectiveZoom();
 
            QPointF diff = sampledInfo.pos() - m_d->previousPaintInformation.pos();
            qreal dx = sqrt(pow2(diff.x()) + pow2(diff.y()));
 
            if (!(dx > R)) {
                if (m_d->resources->needsAirbrushing()) {
                    sampledInfo.setPos(m_d->previousPaintInformation.pos());
                }
                else {
                    canPaint = false;
                }
            }
        }
 
        if (canPaint) {
            KisPaintInformation newInfo = getStabilizedPaintInfo(m_d->stabilizerDeque, sampledInfo);
 
            if (m_d->stabilizerDelayedPaintHelper.running()) {
                delayedPaintTodoItems.append(newInfo);
            } else {
                paintLine(m_d->previousPaintInformation, newInfo);
            }
            m_d->previousPaintInformation = newInfo;
 
            // Push the new entry through the queue
            m_d->stabilizerDeque.dequeue();
            m_d->stabilizerDeque.enqueue(sampledInfo);
        } else if (m_d->stabilizerDeque.head().pos() != m_d->previousPaintInformation.pos()) {
            QQueue<KisPaintInformation>::iterator it = m_d->stabilizerDeque.begin();
            QQueue<KisPaintInformation>::iterator end = m_d->stabilizerDeque.end();
 
            while (it != end) {
                *it = m_d->previousPaintInformation;
                ++it;
            }
        }
    }
 
    m_d->stabilizedSampler.clear();
 
    if (m_d->stabilizerDelayedPaintHelper.running()) {
        m_d->stabilizerDelayedPaintHelper.update(delayedPaintTodoItems);
    } else {
        Q_EMIT requestExplicitUpdateOutline();
    }
}

References KisStabilizedEventsSampler::clear(), KisResourcesSnapshot::effectiveZoom(), getStabilizedPaintInfo(), m_d, KisResourcesSnapshot::needsAirbrushing(), paintLine(), KisPaintInformation::pos(), pow2(), KisToolFreehandHelper::Private::previousPaintInformation, R, KisStabilizedEventsSampler::range(), requestExplicitUpdateOutline(), KisToolFreehandHelper::Private::resources, KisStabilizerDelayedPaintHelper::running(), KisPaintInformation::setPos(), KisToolFreehandHelper::Private::smoothingOptions, KisToolFreehandHelper::Private::stabilizedSampler, KisToolFreehandHelper::Private::stabilizerDelayedPaintHelper, KisToolFreehandHelper::Private::stabilizerDeque, and KisStabilizerDelayedPaintHelper::update().

◆ stabilizerStart()

void KisToolFreehandHelper::stabilizerStart ( KisPaintInformation firstPaintInfo )

private

Definition at line 786 of file kis_tool_freehand_helper.cpp.

{
    m_d->usingStabilizer = true;
    // FIXME: Ugly hack, this is no a "distance" in any way
    int sampleSize = qRound(m_d->effectiveSmoothnessDistance(firstPaintInfo.drawingSpeed()));
    sampleSize = qMax(3, sampleSize);
 
    // Fill the deque with the current value repeated until filling the sample
    m_d->stabilizerDeque.clear();
    for (int i = sampleSize; i > 0; i--) {
        m_d->stabilizerDeque.enqueue(firstPaintInfo);
    }
 
    // Poll and draw regularly
    KisConfig cfg(true);
    int stabilizerSampleSize = cfg.stabilizerSampleSize();
    m_d->stabilizerPollTimer.setInterval(stabilizerSampleSize);
    m_d->stabilizerPollTimer.start();
 
    bool delayedPaintEnabled = cfg.stabilizerDelayedPaint();
    if (delayedPaintEnabled) {
        m_d->stabilizerDelayedPaintHelper.start(firstPaintInfo);
    }
 
    m_d->stabilizedSampler.clear();
    m_d->stabilizedSampler.addEvent(firstPaintInfo);
}

References KisStabilizedEventsSampler::addEvent(), KisStabilizedEventsSampler::clear(), KisPaintInformation::drawingSpeed(), KisToolFreehandHelper::Private::effectiveSmoothnessDistance(), m_d, KisToolFreehandHelper::Private::stabilizedSampler, KisConfig::stabilizerDelayedPaint(), KisToolFreehandHelper::Private::stabilizerDelayedPaintHelper, KisToolFreehandHelper::Private::stabilizerDeque, KisToolFreehandHelper::Private::stabilizerPollTimer, KisConfig::stabilizerSampleSize(), KisStabilizerDelayedPaintHelper::start(), and KisToolFreehandHelper::Private::usingStabilizer.

◆ updateCurrentBrushPosition()

void KisToolFreehandHelper::updateCurrentBrushPosition ( const QPointF & pixelPos )

private

Publishes the current brush position (in image pixel coordinates) to the canvas resource provider, so scripts can follow where the brush actually is during a stroke (including stabilization delay).

Definition at line 375 of file kis_tool_freehand_helper.cpp.

{
    // Store on the flake-level resource provider (the only provider this
    // helper holds), keyed by a Krita-specific resource id.
    if (KoCanvasResourceProvider *manager = resourceManager()) {
        manager->setResource(KoCanvasResource::CurrentBrushPosition,
                             QVariant::fromValue(pixelPos));
    }
}

References KoCanvasResource::CurrentBrushPosition, resourceManager(), and KoCanvasResourceProvider::setResource().

Member Data Documentation

◆ m_d

Private* const KisToolFreehandHelper::m_d

private

Definition at line 160 of file kis_tool_freehand_helper.h.

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

libs/ui/tool/kis_tool_freehand_helper.h
libs/ui/tool/kis_tool_freehand_helper.cpp

Classes

Signals

Public Member Functions

Protected Member Functions

Private Slots

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisToolFreehandHelper()

◆ ~KisToolFreehandHelper()

Member Function Documentation

◆ cancelPaint()

◆ computeAirbrushTimerInterval()

◆ createPainters()

◆ currentPhysicalZoom()

◆ currentZoom()

◆ cursorMoved()

◆ doAirbrushing

◆ elapsedStrokeTime()

◆ endPaint()

◆ finishStroke

◆ getStabilizedPaintInfo()

◆ initPaint()

◆ initPaintImpl()

◆ isRunning()

◆ paint()

◆ paintAt() [1/2]

◆ paintAt() [2/2]

◆ paintBezierCurve() [1/2]

◆ paintBezierCurve() [2/2]

◆ paintBezierSegment()

◆ paintEvent()

◆ paintLine() [1/2]

◆ paintLine() [2/2]

◆ paintOpOutline()

◆ requestExplicitUpdateOutline

◆ resourceManager()

◆ setSmoothness()

◆ slotSmoothingTypeChanged

◆ smoothingOptions()

◆ stabilizerEnd()

◆ stabilizerPollAndPaint

◆ stabilizerStart()

◆ updateCurrentBrushPosition()

Member Data Documentation

◆ m_d