KisRoundMarkerOp Class Reference

#include <kis_roundmarkerop.h>

Inheritance diagram for KisRoundMarkerOp:

Public Member Functions
	KisRoundMarkerOp (KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)
	~KisRoundMarkerOp () override
Public Member Functions inherited from KisPaintOp
virtual bool	canPaint () const
virtual std::pair< int, bool >	doAsynchronousUpdate (QVector< KisRunnableStrokeJobData * > &jobs)
	KisPaintOp (KisPainter *painter)
void	paintAt (const KisPaintInformation &info, KisDistanceInformation *currentDistance)
virtual void	paintBezierCurve (const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
virtual void	paintLine (const KisPaintInformation &pi1, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)
	Private (KisPaintOp *_q)
void	updateSpacing (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
void	updateTiming (const KisPaintInformation &info, KisDistanceInformation &currentDistance) const
virtual	~KisPaintOp ()
Public Member Functions inherited from Private
	Private (KisCanvas2 *c)
Public Member Functions inherited from KisShared
bool	deref ()
bool	ref ()
int	refCount ()
QAtomicInt *	sharedWeakReference ()

Protected Member Functions
KisSpacingInformation	paintAt (const KisPaintInformation &info) override
KisSpacingInformation	updateSpacingImpl (const KisPaintInformation &info) const override
Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()
KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)
KisPainter *	painter () const
KisPaintDeviceSP	source () const
virtual KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Private Member Functions
KisSpacingInformation	computeSpacing (const KisPaintInformation &info, qreal diameter) const

Private Attributes
bool	m_firstRun
QPointF	m_lastPaintPos
qreal	m_lastRadius
KisRoundMarkerOpOptionData	m_markerOption
KisSizeOption	m_sizeOption
KisSpacingOption	m_spacingOption
KisPaintDeviceSP	m_tempDev

Additional Inherited Members
Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 *whole, qreal *fraction)
Public Attributes inherited from KisPaintOp
KisFixedPaintDeviceSP	dab
bool	fanCornersEnabled {false}
qreal	fanCornersStep {1.0}
KisPainter *	painter {nullptr}
KisPaintOp *	q {nullptr}
Public Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Detailed Description

Definition at line 22 of file kis_roundmarkerop.h.

Constructor & Destructor Documentation

KisRoundMarkerOp()

KisRoundMarkerOp::KisRoundMarkerOp	(	KisPaintOpSettingsSP	settings,
		KisPainter *	painter,
		KisNodeSP	node,
		KisImageSP	image )

Definition at line 34 of file kis_roundmarkerop.cpp.

    : KisPaintOp(painter)
    , m_sizeOption(settings.data())
    , m_spacingOption(settings.data())
{
    Q_UNUSED(node);
 
    Q_ASSERT(settings);
    Q_ASSERT(painter);
 
    m_firstRun = true;
    m_lastRadius = 1.0;
 
    m_markerOption.read(settings.data());
}

References KisSharedPtr< T >::data(), m_firstRun, m_lastRadius, m_markerOption, KisPaintOp::painter, and KisRoundMarkerOpOptionData::read().

~KisRoundMarkerOp()

KisRoundMarkerOp::~KisRoundMarkerOp ( )

override

Definition at line 50 of file kis_roundmarkerop.cpp.

{
}

Member Function Documentation

computeSpacing()

KisSpacingInformation KisRoundMarkerOp::computeSpacing ( const KisPaintInformation & info, qreal diameter ) const

private

Definition at line 154 of file kis_roundmarkerop.cpp.

{
    const qreal rotation = 0; // TODO
    const bool axesFlipped = false; // TODO
 
    qreal extraSpacingScale = 1.0;
    if (m_spacingOption.isChecked()) {
        extraSpacingScale = m_spacingOption.apply(info);
    }
 
    return KisPaintOpUtils::effectiveSpacing(diameter, diameter,
                                             extraSpacingScale, true, true, rotation, axesFlipped,
                                             m_markerOption.spacing,
                                             m_markerOption.useAutoSpacing,
                                             m_markerOption.autoSpacingCoeff,
                                             KisLodTransform::lodToScale(painter()->device()));
}

References KisSpacingOption::apply(), KisRoundMarkerOpOptionData::autoSpacingCoeff, KisPaintOpUtils::effectiveSpacing(), KisCurveOption::isChecked(), KisLodTransformBase::lodToScale(), m_markerOption, m_spacingOption, KisPaintOp::painter, KisRoundMarkerOpOptionData::spacing, and KisRoundMarkerOpOptionData::useAutoSpacing.

paintAt()

KisSpacingInformation KisRoundMarkerOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

The implementation of painting of a dab and updating spacing. This does NOT need to update the timing information.

Save the center of the current dab to know where to read the data during the next pass. We do not save scatteredPos here, because it may differ slightly from the real center of the brush (due to rounding effects), which will result in a really weird quality.

Implements KisPaintOp.

Definition at line 54 of file kis_roundmarkerop.cpp.

{
    // Simple error catching
    if (!painter()->device()) {
        return KisSpacingInformation(1.0);
    }
 
    // get the scaling factor calculated by the size option
    const qreal lodScale = KisLodTransform::lodToScale(painter()->device());
    const qreal scale = m_sizeOption.apply(info) * lodScale;
    const qreal rotation = 0; // TODO
 
    const qreal diameter = m_markerOption.diameter * scale;
    qreal radius = 0.5 * diameter;
 
    if (KisPaintOpUtils::checkSizeTooSmall(scale, diameter, diameter)) return KisSpacingInformation();
    KisDabShape shape(scale, 1.0, rotation);
 
    // The position will need subtracting 0.5, but you cannot do this here
    // because then the mirroring tools get wrong position to mirror
    // and the mirroring doesn't work well.
    // Subtracting must happen just before the painting.
    QPointF pos = info.pos();
 
    KisMarkerPainter gc(painter()->device(), painter()->paintColor());
 
    if (m_firstRun) {
        const QVector<QPointF> points =
            painter()->calculateAllMirroredPoints(pos);
 
        Q_FOREACH(const QPointF &pt, points) {
            // Subtracting .5 from both dimensions, because the final dab tends to exaggerate towards the lower right.
            // This aligns it with the brush cursor.
            gc.fillFullCircle(pt - QPointF(0.5, 0.5), radius);
        }
    } else {
        const QVector<QPair<QPointF, QPointF>> pairs =
            painter()->calculateAllMirroredPoints(qMakePair(m_lastPaintPos, pos));
 
        Q_FOREACH(const auto &pair, pairs) {
            // Subtracting .5 from both dimensions, because the final dab tends to exaggerate towards the lower right.
            // This aligns it with the brush cursor.
            gc.fillCirclesDiff(pair.first - QPointF(0.5, 0.5), m_lastRadius,
                               pair.second - QPointF(0.5, 0.5), radius);
        }
    }
 
    m_firstRun = false;
    m_lastPaintPos = pos;
    m_lastRadius = radius;
 
    QRectF dirtyRect(pos.x() - radius, pos.y() - radius,
                     2 * radius, 2 * radius);
    dirtyRect = kisGrowRect(dirtyRect, 1);
 
    const QVector<QRect> allDirtyRects =
        painter()->calculateAllMirroredRects(dirtyRect.toAlignedRect());
 
    painter()->addDirtyRects(allDirtyRects);
 
    // QPointF scatteredPos =
    //     m_scatterOption.apply(info,
    //                           brush->maskWidth(shape, 0, 0, info),
    //                           brush->maskHeight(shape, 0, 0, info));
 
 
 
    //updateMask(info, scale, rotation, scatteredPos);
 
    //QPointF newCenterPos = QRectF(m_dstDabRect).center();
    //QRect srcDabRect = m_dstDabRect.translated((m_lastPaintPos - newCenterPos).toPoint());
 
    //m_lastPaintPos = newCenterPos;
 
    KisSpacingInformation spacingInfo = computeSpacing(info, diameter);
 
    if (m_firstRun) {
        m_firstRun = false;
        return spacingInfo;
    }
 
 
    return spacingInfo;
}

References KisPainter::addDirtyRects(), KisStandardOption< Data >::apply(), KisPainter::calculateAllMirroredPoints(), KisPainter::calculateAllMirroredRects(), KisPaintOpUtils::checkSizeTooSmall(), computeSpacing(), KisRoundMarkerOpOptionData::diameter, KisMarkerPainter::fillCirclesDiff(), KisMarkerPainter::fillFullCircle(), kisGrowRect(), KisLodTransformBase::lodToScale(), m_firstRun, m_lastPaintPos, m_lastRadius, m_markerOption, m_sizeOption, KisPaintOp::painter, and KisPaintInformation::pos().

updateSpacingImpl()

KisSpacingInformation KisRoundMarkerOp::updateSpacingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 146 of file kis_roundmarkerop.cpp.

{
    const qreal lodScale = KisLodTransform::lodToScale(painter()->device());
    const qreal diameter = m_markerOption.diameter * m_sizeOption.apply(info) * lodScale;
 
    return computeSpacing(info, diameter);
}

References KisStandardOption< Data >::apply(), computeSpacing(), KisRoundMarkerOpOptionData::diameter, KisLodTransformBase::lodToScale(), m_markerOption, m_sizeOption, and KisPaintOp::painter.

Member Data Documentation

m_firstRun

bool KisRoundMarkerOp::m_firstRun

private

Definition at line 38 of file kis_roundmarkerop.h.

m_lastPaintPos

QPointF KisRoundMarkerOp::m_lastPaintPos

private

Definition at line 42 of file kis_roundmarkerop.h.

m_lastRadius

qreal KisRoundMarkerOp::m_lastRadius

private

Definition at line 43 of file kis_roundmarkerop.h.

m_markerOption

KisRoundMarkerOpOptionData KisRoundMarkerOp::m_markerOption

private

Definition at line 44 of file kis_roundmarkerop.h.

m_sizeOption

KisSizeOption KisRoundMarkerOp::m_sizeOption

private

Definition at line 40 of file kis_roundmarkerop.h.

m_spacingOption

KisSpacingOption KisRoundMarkerOp::m_spacingOption

private

Definition at line 41 of file kis_roundmarkerop.h.

m_tempDev

KisPaintDeviceSP KisRoundMarkerOp::m_tempDev

private

Definition at line 39 of file kis_roundmarkerop.h.

---

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

• plugins/paintops/roundmarker/kis_roundmarkerop.h
• plugins/paintops/roundmarker/kis_roundmarkerop.cpp