KisBrushBasedPaintOp Class Reference

#include <kis_brush_based_paintop.h>

Inheritance diagram for KisBrushBasedPaintOp:

Public Member Functions
bool	canPaint () const override
	Reimplemented, false if brush is 0.
bool	checkSizeTooSmall (qreal scale)
KisSpacingInformation	effectiveSpacing (qreal scale) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisAirbrushOptionData *airbrushOption, const KisSpacingOption *spacingOption, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisPaintInformation &pi) const
KisSpacingInformation	effectiveSpacing (qreal scale, qreal rotation, const KisSpacingOption &spacingOption, const KisPaintInformation &pi) const
	KisBrushBasedPaintOp (const KisPaintOpSettingsSP settings, KisPainter *painter, KisBrushTextureFlags textureFlags=None)
	~KisBrushBasedPaintOp () override
Public Member Functions inherited from KisPaintOp
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 ()

Static Public Member Functions
static QList< KoResourceLoadResult >	prepareEmbeddedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
static QList< KoResourceLoadResult >	prepareLinkedResources (const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface)
Static Public Member Functions inherited from KisPaintOp
static void	splitCoordinate (qreal coordinate, qint32 *whole, qreal *fraction)

Protected Attributes
KisBrushSP	m_brush
KisDabCache *	m_dabCache
KisMirrorOption	m_mirrorOption
KisPrecisionOption	m_precisionOption

Private Member Functions
KisSpacingInformation	effectiveSpacing (qreal dabWidth, qreal dabHeight, qreal extraScale, bool isotropicSpacing, qreal rotation, bool axesFlipped) const

Private Attributes
KisTextureOption	m_textureOption

Additional Inherited Members
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
Protected Member Functions inherited from KisPaintOp
KisFixedPaintDeviceSP	cachedDab ()
KisFixedPaintDeviceSP	cachedDab (const KoColorSpace *cs)
virtual KisSpacingInformation	paintAt (const KisPaintInformation &info)=0
KisPainter *	painter () const
KisPaintDeviceSP	source () const
virtual KisSpacingInformation	updateSpacingImpl (const KisPaintInformation &info) const =0
virtual KisTimingInformation	updateTimingImpl (const KisPaintInformation &info) const
Protected Member Functions inherited from KisShared
	KisShared ()
	~KisShared ()

Detailed Description

This is a base class for paintops that use a KisBrush or derived brush to paint with. This is mainly important for the spacing generation.

Definition at line 48 of file kis_brush_based_paintop.h.

Constructor & Destructor Documentation

KisBrushBasedPaintOp()

KisBrushBasedPaintOp::KisBrushBasedPaintOp	(	const KisPaintOpSettingsSP	settings,
		KisPainter *	painter,
		KisBrushTextureFlags	textureFlags = None )

Definition at line 68 of file kis_brush_based_paintop.cpp.

    : KisPaintOp(painter),
      m_textureOption(settings.data(),
                      settings->resourcesInterface(),
                      settings->canvasResourcesInterface(),
                      painter->device()->defaultBounds()->currentLevelOfDetail(),
                      textureFlags),
      m_mirrorOption(settings.data()),
      m_precisionOption(settings.data())
{
    Q_ASSERT(settings);
 
#ifdef HAVE_THREADED_TEXT_RENDERING_WORKAROUND
    m_brush = TextBrushInitializationWorkaround::instance()->tryGetBrush(settings);
#endif /* HAVE_THREADED_TEXT_RENDERING_WORKAROUND */
 
    if (!m_brush) {
        const KisBrushBasedPaintOpSettings *brushBasedSettings =
            dynamic_cast<const KisBrushBasedPaintOpSettings*>(settings.data());
 
        if (brushBasedSettings) {
            // we don't use KisBrushOptionProperties manually here because
            // we want the properties to cache this brush in m_savedBrush
            m_brush = brushBasedSettings->brush();
        }
 
        if (!m_brush) {
            qWarning() << "Could not find brush tip " << settings->getString("brush_definition") << ", will use a default brush instead";
            QString brushDefinition("<Brush useAutoSpacing=\"1\" angle=\"0\" spacing=\"0.1\" density=\"1\" BrushVersion=\"2\" type=\"auto_brush\" randomness=\"0\" autoSpacingCoeff=\"0.8\"> <MaskGenerator spikes=\"2\" hfade=\"1\" ratio=\"1\" diameter=\"40\" id=\"default\" type=\"circle\" antialiasEdges=\"1\" vfade=\"1\"/> </Brush> ");
            QDomDocument d;
            d.setContent(brushDefinition, false);
            QDomElement element = d.firstChildElement("Brush");
            m_brush = KisBrushRegistry::instance()->createBrush(element, settings->resourcesInterface()).resource<KisBrush>();
            Q_ASSERT(m_brush);
        }
    }
 
    m_brush->notifyStrokeStarted();
 
    m_dabCache = new KisDabCache(m_brush);
    m_dabCache->setPrecisionOption(&m_precisionOption);
    m_dabCache->setMirrorPostprocessing(&m_mirrorOption);
    m_dabCache->setTexturePostprocessing(&m_textureOption);
 
    m_precisionOption.setHasImprecisePositionOptions(
        m_precisionOption.hasImprecisePositionOptions()
        || m_mirrorOption.isChecked() || m_textureOption.m_enabled);
}

References KisBrushBasedPaintOpSettings::brush(), KisBrushRegistry::createBrush(), KisPaintOp::d, KisSharedPtr< T >::data(), KisPrecisionOption::hasImprecisePositionOptions(), KisBrushRegistry::instance(), TextBrushInitializationWorkaround::instance(), KisCurveOption::isChecked(), m_brush, m_dabCache, KisTextureOption::m_enabled, m_mirrorOption, m_precisionOption, m_textureOption, KoResourceLoadResult::resource(), KisPrecisionOption::setHasImprecisePositionOptions(), KisDabCacheBase::setMirrorPostprocessing(), KisDabCacheBase::setPrecisionOption(), KisDabCache::setTexturePostprocessing(), and TextBrushInitializationWorkaround::tryGetBrush().

~KisBrushBasedPaintOp()

KisBrushBasedPaintOp::~KisBrushBasedPaintOp ( )

override

Definition at line 117 of file kis_brush_based_paintop.cpp.

{
    delete m_dabCache;
}

References m_dabCache.

Member Function Documentation

canPaint()

bool KisBrushBasedPaintOp::canPaint ( ) const

overridevirtual

Reimplemented, false if brush is 0.

Reimplemented from KisPaintOp.

Definition at line 206 of file kis_brush_based_paintop.cpp.

{
    return m_brush != 0;
}

References m_brush.

checkSizeTooSmall()

bool KisBrushBasedPaintOp::checkSizeTooSmall

(

qreal

scale

)

Definition at line 143 of file kis_brush_based_paintop.cpp.

{
    scale *= m_brush->scale();
    return KisPaintOpUtils::checkSizeTooSmall(scale, m_brush->width(), m_brush->height());
}

References KisPaintOpUtils::checkSizeTooSmall(), and m_brush.

effectiveSpacing() [1/5]

KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing ( qreal dabWidth, qreal dabHeight, qreal extraScale, bool isotropicSpacing, qreal rotation, bool axesFlipped ) const

private

Definition at line 189 of file kis_brush_based_paintop.cpp.

{
    return KisPaintOpUtils::effectiveSpacing(dabWidth, dabHeight,
                                             extraScale,
                                             true,
                                             isotropicSpacing,
                                             rotation,
                                             axesFlipped,
                                             m_brush->spacing(),
                                             m_brush->autoSpacingActive(),
                                             m_brush->autoSpacingCoeff(),
                                             KisLodTransform::lodToScale(painter()->device()));
}

References KisPaintOpUtils::effectiveSpacing(), KisLodTransformBase::lodToScale(), m_brush, and KisPaintOp::painter.

effectiveSpacing() [2/5]

KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing

(

qreal

scale

)

const

Definition at line 149 of file kis_brush_based_paintop.cpp.

{
    // we parse dab rotation separately, so don't count it
    QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
    return effectiveSpacing(metric.width(), metric.height(), 1.0, false, 0.0, false);
}

References effectiveSpacing(), and m_brush.

effectiveSpacing() [3/5]

KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing	(	qreal	scale,
		qreal	rotation,
		const KisAirbrushOptionData *	airbrushOption,
		const KisSpacingOption *	spacingOption,
		const KisPaintInformation &	pi ) const

Definition at line 166 of file kis_brush_based_paintop.cpp.

{
    bool isotropicSpacing = spacingOption && spacingOption->isotropicSpacing();
 
    MirrorProperties prop = m_mirrorOption.apply(pi);
    const bool implicitFlipped = prop.horizontalMirror != prop.verticalMirror;
 
    // we parse dab rotation separately, so don't count it
    QSizeF metric = m_brush->characteristicSize(KisDabShape(scale, 1.0, 0));
 
    return KisPaintOpPluginUtils::effectiveSpacing(metric.width(), metric.height(),
                                                   isotropicSpacing, rotation, implicitFlipped,
                                                   m_brush->spacing(),
                                                   m_brush->autoSpacingActive(),
                                                   m_brush->autoSpacingCoeff(),
                                                   KisLodTransform::lodToScale(painter()->device()),
                                                   airbrushOption, spacingOption,
                                                   pi);
}

References KisMirrorOption::apply(), KisPaintOpPluginUtils::effectiveSpacing(), MirrorProperties::horizontalMirror, KisSpacingOption::isotropicSpacing(), KisLodTransformBase::lodToScale(), m_brush, m_mirrorOption, KisPaintOp::painter, and MirrorProperties::verticalMirror.

effectiveSpacing() [4/5]

KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing	(	qreal	scale,
		qreal	rotation,
		const KisPaintInformation &	pi ) const

Definition at line 156 of file kis_brush_based_paintop.cpp.

{
    return effectiveSpacing(scale, rotation, static_cast<KisAirbrushOptionData*>(nullptr), nullptr, pi);
}

References effectiveSpacing().

effectiveSpacing() [5/5]

KisSpacingInformation KisBrushBasedPaintOp::effectiveSpacing	(	qreal	scale,
		qreal	rotation,
		const KisSpacingOption &	spacingOption,
		const KisPaintInformation &	pi ) const

Definition at line 161 of file kis_brush_based_paintop.cpp.

{
    return effectiveSpacing(scale, rotation, static_cast<KisAirbrushOptionData*>(nullptr), &spacingOption, pi);
}

References effectiveSpacing().

prepareEmbeddedResources()

QList< KoResourceLoadResult > KisBrushBasedPaintOp::prepareEmbeddedResources ( const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface )

static

Definition at line 134 of file kis_brush_based_paintop.cpp.

{
    QList<KoResourceLoadResult> resources;
 
    resources << KisTextureOption::prepareEmbeddedResources(settings, resourcesInterface);
 
    return resources;
}

References KisTextureOption::prepareEmbeddedResources().

prepareLinkedResources()

QList< KoResourceLoadResult > KisBrushBasedPaintOp::prepareLinkedResources ( const KisPaintOpSettingsSP settings, KisResourcesInterfaceSP resourcesInterface )

static

Definition at line 122 of file kis_brush_based_paintop.cpp.

{
    QList<KoResourceLoadResult> resources;
 
    KisBrushOptionProperties brushOption;
    resources << brushOption.prepareLinkedResources(settings, resourcesInterface);
 
    resources << KisTextureOption::prepareLinkedResources(settings, resourcesInterface);
 
    return resources;
}

References KisPaintopPropertiesCanvasResourcesBase::prepareLinkedResources(), and KisTextureOption::prepareLinkedResources().

Member Data Documentation

m_brush

KisBrushSP KisBrushBasedPaintOp::m_brush

protected

Definition at line 82 of file kis_brush_based_paintop.h.

m_dabCache

KisDabCache* KisBrushBasedPaintOp::m_dabCache

protected

Definition at line 81 of file kis_brush_based_paintop.h.

m_mirrorOption

KisMirrorOption KisBrushBasedPaintOp::m_mirrorOption

protected

Definition at line 88 of file kis_brush_based_paintop.h.

m_precisionOption

KisPrecisionOption KisBrushBasedPaintOp::m_precisionOption

protected

Definition at line 89 of file kis_brush_based_paintop.h.

m_textureOption

KisTextureOption KisBrushBasedPaintOp::m_textureOption

private

Definition at line 85 of file kis_brush_based_paintop.h.

---

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

• plugins/paintops/libpaintop/kis_brush_based_paintop.h
• plugins/paintops/libpaintop/kis_brush_based_paintop.cpp