#include <kis_tool_line_helper.h>

Inheritance diagram for KisToolLineHelper:

Classes
struct	Private

Public Member Functions
void	addPoint (KisPaintInformation pi, const QPointF &overridePos=QPointF())

void	addPoint (KoPointerEvent *event, const QPointF &overridePos=QPointF())

void	cancel ()

void	clearPaint ()

void	clearPoints ()

void	end ()

bool	isRunning () const

	KisToolLineHelper (KisPaintingInformationBuilder infoBuilder, KoCanvasResourceProvider resourceManager, const KUndo2MagicString &transactionText)

void	movePointsTo (const QPointF &startPoint, const QPointF &endPoint)

void	repaintLine (KisImageWSP image, KisNodeSP node, KisStrokesFacade *strokesFacade)

void	setEnabled (bool value)

void	setUseSensors (bool value)

void	start (KoPointerEvent event, KoCanvasResourceProvider resourceManager)

void	translatePoints (const QPointF &offset)

	~KisToolLineHelper () override

Private Member Functions
void	adjustPointsToDDA (QVector< KisPaintInformation > &points)

Private Member Functions inherited from KisToolFreehandHelper
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

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 Attributes
Private *const	m_d

Additional Inherited Members
Signals inherited from KisToolFreehandHelper
void	requestExplicitUpdateOutline ()

Detailed Description

Definition at line 13 of file kis_tool_line_helper.h.

Constructor & Destructor Documentation

◆ KisToolLineHelper()

KisToolLineHelper::KisToolLineHelper	(	KisPaintingInformationBuilder *	infoBuilder,
		KoCanvasResourceProvider *	resourceManager,
		const KUndo2MagicString &	transactionText )

Definition at line 33 of file kis_tool_line_helper.cpp.

    : KisToolFreehandHelper(infoBuilder,
                            resourceManager,
                            transactionText,
                            new KisSmoothingOptions(false)),
      m_d(new Private(infoBuilder))
{
}

◆ ~KisToolLineHelper()

KisToolLineHelper::~KisToolLineHelper ( )

override

Definition at line 44 of file kis_tool_line_helper.cpp.

{
    delete m_d;
}

References m_d.

Member Function Documentation

◆ addPoint() [1/2]

void KisToolLineHelper::addPoint	(	KisPaintInformation	pi,
		const QPointF &	overridePos = QPointF() )

Definition at line 126 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
    if (!m_d->useSensors) {
        pi = KisPaintInformation(pi.pos());
    }
 
    if (!overridePos.isNull()) {
        pi.setPos(overridePos);
    }
 
    if (m_d->linePoints.size() > 1) {
        const QPointF startPos = m_d->linePoints.first().pos();
        const QPointF endPos = pi.pos();
 
        if (!KisAlgebra2D::fuzzyPointCompare(startPos, endPos)) {
            const qreal maxDistance = kisDistance(startPos, endPos);
            const QPointF unit = (endPos - startPos) / maxDistance;
 
            QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
            ++it;
            while (it != m_d->linePoints.end()) {
                qreal dist = kisDistance(startPos, it->pos());
                if (dist < maxDistance) {
                    QPointF pos = startPos + unit * dist;
                    it->setPos(pos);
                    ++it;
                } else {
                    it = m_d->linePoints.erase(it);
                }
            }
        } else {
            m_d->linePoints.clear();
        }
    }
 
    m_d->linePoints.append(pi);
 
}

References KisToolLineHelper::Private::enabled, KisAlgebra2D::fuzzyPointCompare(), kisDistance(), KisToolLineHelper::Private::linePoints, m_d, KisPaintInformation::pos(), KisPaintInformation::setPos(), and KisToolLineHelper::Private::useSensors.

◆ addPoint() [2/2]

void KisToolLineHelper::addPoint	(	KoPointerEvent *	event,
		const QPointF &	overridePos = QPointF() )

Definition at line 114 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
 
    // Ignore the elapsed stroke time, so that the line tool will behave as if the whole stroke is
    // drawn at once. This should prevent any possible spurious dabs caused by airbrushing features.
    KisPaintInformation pi =
            m_d->infoBuilder->continueStroke(event, 0);
 
    addPoint(pi, overridePos);
}

References addPoint(), KisPaintingInformationBuilder::continueStroke(), KisToolLineHelper::Private::enabled, KisToolLineHelper::Private::infoBuilder, and m_d.

◆ adjustPointsToDDA()

void KisToolLineHelper::adjustPointsToDDA ( QVector< KisPaintInformation > & points )

private

Definition at line 235 of file kis_tool_line_helper.cpp.

{
    int x = qFloor(points.first().pos().x());
    int y = qFloor(points.first().pos().y());
 
    int x2 = qFloor(points.last().pos().x());
    int y2 = qFloor(points.last().pos().y());
 
    // Width and height of the line
    int xd = x2 - x;
    int yd = y2 - y;
 
    float m = 0;
    bool lockAxis = true;
 
    if (xd == 0) {
        m = 2.0;
    } else if ( yd != 0) {
        lockAxis = false;
        m = (float)yd / (float)xd;
    }
 
    float fx = x;
    float fy = y;
 
    int inc;
    int dist;
 
    if (fabs(m) > 1.0f) {
        inc = (yd > 0) ? 1 : -1;
        m = (lockAxis)? 0 : 1.0f / m;
        m *= inc;
 
        for (int i = 0; i < points.size(); i++){
            dist = abs(qFloor(points.at(i).pos().y()) - y);
            fy = y + (dist * inc);
            fx = qRound(x + (dist * m));
            points[i].setPos(QPointF(fx,fy));
        }
 
    } else {
        inc = (xd > 0) ? 1 : -1;
        m *= inc;
 
        for (int i = 0; i < points.size(); i++){
            dist = abs(qFloor(points.at(i).pos().x()) - x);
            fx = x + (dist * inc);
            fy = qRound(y + (dist * m));
            points[i].setPos(QPointF(fx,fy));
        }
    }
}

◆ cancel()

void KisToolLineHelper::cancel ( )

Definition at line 212 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
    KIS_ASSERT_RECOVER_RETURN(isRunning());
 
    cancelPaint();
    clearPoints();
}

References KisToolFreehandHelper::cancelPaint(), clearPoints(), KisToolLineHelper::Private::enabled, isRunning(), KIS_ASSERT_RECOVER_RETURN, and m_d.

◆ clearPaint()

void KisToolLineHelper::clearPaint ( )

Definition at line 228 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
 
    cancelPaint();
}

References KisToolFreehandHelper::cancelPaint(), KisToolLineHelper::Private::enabled, and m_d.

◆ clearPoints()

void KisToolLineHelper::clearPoints ( )

Definition at line 222 of file kis_tool_line_helper.cpp.

{
    m_d->linePoints.clear();
}

References KisToolLineHelper::Private::linePoints, and m_d.

◆ end()

void KisToolLineHelper::end ( )

Definition at line 202 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
    KIS_ASSERT_RECOVER_RETURN(isRunning());
 
    endPaint();
    clearPoints();
}

References clearPoints(), KisToolLineHelper::Private::enabled, KisToolFreehandHelper::endPaint(), isRunning(), KIS_ASSERT_RECOVER_RETURN, and m_d.

◆ isRunning()

bool KisToolFreehandHelper::isRunning ( ) const

Definition at line 46 of file kis_tool_freehand_helper.cpp.

{
    return bool(m_d->strokeId);
}

◆ movePointsTo()

void KisToolLineHelper::movePointsTo	(	const QPointF &	startPoint,
		const QPointF &	endPoint )

Definition at line 177 of file kis_tool_line_helper.cpp.

{
    if (m_d->linePoints.size() <= 1 ) {
        return;
    }
 
    if (KisAlgebra2D::fuzzyPointCompare(startPoint, endPoint)) {
        return;
    }
 
    if (m_d->linePoints.size() > 1) {
        const qreal maxDistance = kisDistance(startPoint, endPoint);
        const QPointF unit = (endPoint - startPoint) / maxDistance;
 
        QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
        ++it;
        while (it != m_d->linePoints.end()) {
            qreal dist = kisDistance(startPoint, it->pos());
            QPointF pos = startPoint + unit * dist;
            it->setPos(pos);
            ++it;
        }
    }
}

References KisAlgebra2D::fuzzyPointCompare(), kisDistance(), KisToolLineHelper::Private::linePoints, and m_d.

◆ repaintLine()

void KisToolLineHelper::repaintLine	(	KisImageWSP	image,
		KisNodeSP	node,
		KisStrokesFacade *	strokesFacade )

Definition at line 59 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
 
    cancelPaint();
    if (m_d->linePoints.isEmpty()) return;
 
    qreal startAngle = 0.0;
    if (m_d->linePoints.length() > 1) {
        startAngle = KisAlgebra2D::directionBetweenPoints(m_d->linePoints[0].pos(),
                                                          m_d->linePoints[1].pos(),
                                                          0.0);
    }
 
    KisPaintOpPresetSP preset = resourceManager()->resource(KoCanvasResource::CurrentPaintOpPreset)
            .value<KisPaintOpPresetSP>();
 
    if (preset->settings()->paintOpSize() <= 1) {
        KisPaintInformation begin = m_d->linePoints.first();
        KisPaintInformation end = m_d->linePoints.last();
        m_d->linePoints.clear();
        m_d->linePoints.append(begin);
        m_d->linePoints.append(end);
        adjustPointsToDDA(m_d->linePoints);
    }
 
    QVector<KisPaintInformation>::const_iterator it = m_d->linePoints.constBegin();
    QVector<KisPaintInformation>::const_iterator end = m_d->linePoints.constEnd();
 
    initPaintImpl(startAngle, *it, resourceManager(), image, node, strokesFacade);
    ++it;
 
    while (it != end) {
        paintLine(*(it - 1), *it);
        ++it;
    }
}

References adjustPointsToDDA(), KisToolFreehandHelper::cancelPaint(), KoCanvasResource::CurrentPaintOpPreset, KisAlgebra2D::directionBetweenPoints(), KisToolLineHelper::Private::enabled, KisToolFreehandHelper::initPaintImpl(), KisToolLineHelper::Private::linePoints, m_d, KisToolFreehandHelper::paintLine(), KoCanvasResourceProvider::resource(), and KisToolFreehandHelper::resourceManager().

◆ setEnabled()

void KisToolLineHelper::setEnabled ( bool value )

Definition at line 49 of file kis_tool_line_helper.cpp.

{
    m_d->enabled = value;
}

References KisToolLineHelper::Private::enabled, m_d, and value().

◆ setUseSensors()

void KisToolLineHelper::setUseSensors ( bool value )

Definition at line 54 of file kis_tool_line_helper.cpp.

{
    m_d->useSensors = value;
}

References m_d, KisToolLineHelper::Private::useSensors, and value().

◆ start()

void KisToolLineHelper::start	(	KoPointerEvent *	event,
		KoCanvasResourceProvider *	resourceManager )

Definition at line 98 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
 
    // Ignore the elapsed stroke time, so that the line tool will behave as if the whole stroke is
    // drawn at once. This should prevent any possible spurious dabs caused by airbrushing features.
    KisPaintInformation pi =
            m_d->infoBuilder->startStroke(event, 0, resourceManager);
 
    if (!m_d->useSensors) {
        pi = KisPaintInformation(pi.pos());
    }
 
    m_d->linePoints.append(pi);
}

References KisToolLineHelper::Private::enabled, KisToolLineHelper::Private::infoBuilder, KisToolLineHelper::Private::linePoints, m_d, KisPaintInformation::pos(), KisToolFreehandHelper::resourceManager(), KisPaintingInformationBuilder::startStroke(), and KisToolLineHelper::Private::useSensors.

◆ translatePoints()

void KisToolLineHelper::translatePoints ( const QPointF & offset )

Definition at line 166 of file kis_tool_line_helper.cpp.

{
    if (!m_d->enabled) return;
 
    QVector<KisPaintInformation>::iterator it = m_d->linePoints.begin();
    while (it != m_d->linePoints.end()) {
        it->setPos(it->pos() + offset);
        ++it;
    }
}

References KisToolLineHelper::Private::enabled, KisToolLineHelper::Private::linePoints, and m_d.

Member Data Documentation

◆ m_d

Private* const KisToolLineHelper::m_d