#include <MyPaintPaintOp.h>

Inheritance diagram for KisMyPaintPaintOp:

Public Member Functions
	KisMyPaintPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisNodeSP node, KisImageSP image)

	~KisMyPaintPaintOp () 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

KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const override

Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()

KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)

KisPainter *	painter () const

KisPaintDeviceSP	source () const

Protected Member Functions inherited from KisShared
	KisShared ()

	~KisShared ()

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

Private Attributes
KisAirbrushOptionData	m_airBrushData

QScopedPointer< KisMyPaintPaintOpPreset >	m_brush

double	m_dtime

KisImageWSP	m_image

bool	m_isStrokeStarted

double	m_previousTime = 0

double	m_radius

KisPaintOpSettingsSP	m_settings

QScopedPointer< KisMyPaintSurface >	m_surface

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 MyPaintPaintOp.h.

Constructor & Destructor Documentation

◆ KisMyPaintPaintOp()

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

Definition at line 25 of file MyPaintPaintOp.cpp.

    : KisPaintOp (painter) {
 
    m_image = image;
 
    m_brush.reset(new KisMyPaintPaintOpPreset());
    m_surface.reset(new KisMyPaintSurface(this->painter(), nullptr, m_image));
 
    m_brush->apply(settings);
 
    if (settings->getBool("EraserMode")) {
 
        painter->setCompositeOpId(COMPOSITE_ERASE);
        mypaint_brush_set_base_value(m_brush->brush(), MYPAINT_BRUSH_SETTING_ERASER, false);
    }
 
    m_brush->setColor(this->painter()->paintColor(), painter->device()->colorSpace());
 
    if (KoToolManager::instance()->activeToolId() != "KritaShape/KisToolBrush") {
        mypaint_brush_set_base_value(m_brush->brush(), MYPAINT_BRUSH_SETTING_SLOW_TRACKING, 0.0);
    }
 
    m_settings = settings;
    m_airBrushData.read(m_settings.data());
 
    m_dtime = -1;
    m_isStrokeStarted = false;
    m_radius = exp(mypaint_brush_get_base_value(m_brush->brush(), MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC));
}

References KisPaintDevice::colorSpace(), COMPOSITE_ERASE, KisSharedPtr< T >::data(), KisPainter::device, KoToolManager::instance(), m_airBrushData, m_brush, m_dtime, m_image, m_isStrokeStarted, m_radius, m_settings, m_surface, KisPaintOp::painter, KisAirbrushOptionData::read(), and KisPainter::setCompositeOpId().

◆ ~KisMyPaintPaintOp()

KisMyPaintPaintOp::~KisMyPaintPaintOp ( )

override

Definition at line 55 of file MyPaintPaintOp.cpp.

55 {

56}

Member Function Documentation

◆ computeSpacing()

KisSpacingInformation KisMyPaintPaintOp::computeSpacing	(	const KisPaintInformation &	info,
		qreal	lodScale ) const

private

Definition at line 101 of file MyPaintPaintOp.cpp.

                                                                                                             {
 
    return KisPaintOpPluginUtils::effectiveSpacing(m_radius*2, m_radius*2,
                                                   false, 0.0, false, m_radius*2,
                                                   true, 1, lodScale, &m_airBrushData, nullptr, info);
}

References KisPaintOpPluginUtils::effectiveSpacing(), m_airBrushData, and m_radius.

◆ paintAt()

KisSpacingInformation KisMyPaintPaintOp::paintAt ( const KisPaintInformation & info )

overrideprotectedvirtual

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

Implements KisPaintOp.

Definition at line 58 of file MyPaintPaintOp.cpp.

                                                                                {
 
    if (!painter()) {
        return KisSpacingInformation(1.0);
    }
 
    const qreal lodScale = KisLodTransform::lodToScale(painter()->device());
 
    qreal radius = m_radius;
    radius *= lodScale;
    mypaint_brush_set_base_value(m_brush->brush(), MYPAINT_BRUSH_SETTING_RADIUS_LOGARITHMIC, log(radius));
 
    m_isStrokeStarted = mypaint_brush_get_state(m_brush->brush(), MYPAINT_BRUSH_STATE_STROKE_STARTED);
    if (!m_isStrokeStarted) {
 
        mypaint_brush_stroke_to(m_brush->brush(), m_surface->surface(), info.pos().x(), info.pos().y(), info.pressure(),
                               info.xTilt(), info.yTilt(), 1.0f);
 
        m_dtime = 0.015;
    }
    else {
        m_dtime = abs(info.currentTime() - m_previousTime)*0.001;
    }
 
    mypaint_brush_stroke_to(m_brush->brush(), m_surface->surface(), info.pos().x(), info.pos().y(), info.pressure(),
                           info.xTilt(), info.yTilt(), m_dtime);
 
    m_previousTime = info.currentTime();
 
    return computeSpacing(info, lodScale);
}

References computeSpacing(), KisPaintInformation::currentTime(), KisLodTransformBase::lodToScale(), m_brush, m_dtime, m_isStrokeStarted, m_previousTime, m_radius, m_surface, KisPaintOp::painter, KisPaintInformation::pos(), KisPaintInformation::pressure(), KisPaintInformation::xTilt(), and KisPaintInformation::yTilt().

◆ updateSpacingImpl()

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

overrideprotectedvirtual

Implementation of a spacing update

Implements KisPaintOp.

Definition at line 90 of file MyPaintPaintOp.cpp.

{
    KisSpacingInformation spacingInfo = computeSpacing(info, KisLodTransform::lodToScale(painter()->device()));
    return spacingInfo;
}

References computeSpacing(), KisLodTransformBase::lodToScale(), and KisPaintOp::painter.

◆ updateTimingImpl()

KisTimingInformation KisMyPaintPaintOp::updateTimingImpl ( const KisPaintInformation & info ) const

overrideprotectedvirtual

Implementation of a timing update. The default implementation always disables timing. This is suitable for paintops that do not support airbrushing.

Reimplemented from KisPaintOp.

Definition at line 96 of file MyPaintPaintOp.cpp.

                                                                                              {
 
    return KisPaintOpPluginUtils::effectiveTiming(&m_airBrushData, nullptr, info);
}

References KisPaintOpPluginUtils::effectiveTiming(), and m_airBrushData.

Member Data Documentation

◆ m_airBrushData

KisAirbrushOptionData KisMyPaintPaintOp::m_airBrushData

private

Definition at line 45 of file MyPaintPaintOp.h.

◆ m_brush

QScopedPointer<KisMyPaintPaintOpPreset> KisMyPaintPaintOp::m_brush

private

Definition at line 42 of file MyPaintPaintOp.h.

◆ m_dtime

double KisMyPaintPaintOp::m_dtime

private

Definition at line 47 of file MyPaintPaintOp.h.

◆ m_image

KisImageWSP KisMyPaintPaintOp::m_image

private

Definition at line 46 of file MyPaintPaintOp.h.

◆ m_isStrokeStarted

bool KisMyPaintPaintOp::m_isStrokeStarted

private

Definition at line 48 of file MyPaintPaintOp.h.

◆ m_previousTime

double KisMyPaintPaintOp::m_previousTime = 0

private

Definition at line 47 of file MyPaintPaintOp.h.

◆ m_radius

double KisMyPaintPaintOp::m_radius

private

Definition at line 47 of file MyPaintPaintOp.h.

◆ m_settings

KisPaintOpSettingsSP KisMyPaintPaintOp::m_settings

private

Definition at line 44 of file MyPaintPaintOp.h.

◆ m_surface

QScopedPointer<KisMyPaintSurface> KisMyPaintPaintOp::m_surface

private

Definition at line 43 of file MyPaintPaintOp.h.

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

plugins/paintops/mypaint/MyPaintPaintOp.h
plugins/paintops/mypaint/MyPaintPaintOp.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisMyPaintPaintOp()

◆ ~KisMyPaintPaintOp()

Member Function Documentation

◆ computeSpacing()

◆ paintAt()

◆ updateSpacingImpl()

◆ updateTimingImpl()

Member Data Documentation

◆ m_airBrushData

◆ m_brush

◆ m_dtime

◆ m_image

◆ m_isStrokeStarted

◆ m_previousTime

◆ m_radius

◆ m_settings

◆ m_surface