#include <kis_brush.h>

Inheritance diagram for KisBrush:

Classes
class	ColoringInformation

class	PaintDeviceColoringInformation

class	PlainColoringInformation

struct	Private

Public Member Functions
qreal	angle () const

virtual bool	applyingGradient () const

bool	autoSpacingActive () const

qreal	autoSpacingCoeff () const

virtual enumBrushApplication	brushApplication () const

virtual quint32	brushIndex () const

virtual QImage	brushTipImage () const
	brushImage the image the brush tip can paint with. Not all brush types have a single image.

virtual enumBrushType	brushType () const

virtual bool	canPaintFor (const KisPaintInformation &)

virtual QSizeF	characteristicSize (KisDabShape const &) const

void	clearBrushPyramid ()

virtual void	coldInitBrush ()

virtual void	generateMaskAndApplyMaskOrCreateDab (KisFixedPaintDeviceSP dst, ColoringInformation *coloringInfo, KisDabShape const &, const KisPaintInformation &info, double subPixelX, double subPixelY, qreal softnessFactor, qreal lightnessStrength) const

void	generateMaskAndApplyMaskOrCreateDab (KisFixedPaintDeviceSP dst, ColoringInformation *coloringInfo, KisDabShape const &, const KisPaintInformation &info, double subPixelX=0, double subPixelY=0, qreal softnessFactor=DEFAULT_SOFTNESS_FACTOR) const

qint32	height () const

QPointF	hotSpot (KisDabShape const &, const KisPaintInformation &info) const

virtual bool	isPiercedApprox () const

	KisBrush ()

	KisBrush (const KisBrush &rhs)

	KisBrush (const QString &filename)

virtual void	lodLimitations (KisPaintopLodLimitations *l) const

void	mask (KisFixedPaintDeviceSP dst, const KisPaintDeviceSP src, KisDabShape const &shape, const KisPaintInformation &info, double subPixelX=0, double subPixelY=0, qreal softnessFactor=DEFAULT_SOFTNESS_FACTOR, qreal lightnessStrength=DEFAULT_LIGHTNESS_STRENGTH) const

void	mask (KisFixedPaintDeviceSP dst, const KoColor &color, KisDabShape const &shape, const KisPaintInformation &info, double subPixelX=0, double subPixelY=0, qreal softnessFactor=DEFAULT_SOFTNESS_FACTOR, qreal lightnessStrength=DEFAULT_LIGHTNESS_STRENGTH) const

double	maskAngle (double angle=0) const

virtual qint32	maskHeight (KisDabShape const &, qreal subPixelX, qreal subPixelY, const KisPaintInformation &info) const

virtual qint32	maskWidth (KisDabShape const &, qreal subPixelX, qreal subPixelY, const KisPaintInformation &info) const

virtual void	notifyBrushIsGoingToBeClonedForStroke ()

virtual void	notifyStrokeStarted ()

KisBrush &	operator= (const KisBrush &rhs)=delete

virtual KisOptimizedBrushOutline	outline (bool forcePreciseOutline=false) const

virtual KisFixedPaintDeviceSP	outlineSourceImage () const

virtual KisFixedPaintDeviceSP	paintDevice (const KoColorSpace *colorSpace, KisDabShape const &, const KisPaintInformation &info, double subPixelX=0, double subPixelY=0) const

virtual void	prepareForSeqNo (const KisPaintInformation &info, int seqNo)

virtual bool	preserveLightness () const

QPair< QString, QString >	resourceType () const override

qreal	scale () const

virtual void	setAngle (qreal _angle)

void	setAutoSpacing (bool active, qreal coeff)

virtual void	setBrushApplication (enumBrushApplication brushApplication)

virtual void	setBrushTipImage (const QImage &image)

virtual void	setGradient (KoAbstractGradientSP gradient)

virtual void	setScale (qreal _scale)

virtual void	setSpacing (double spacing)

virtual void	setUserEffectiveSize (qreal value)=0

double	spacing () const

virtual bool	supportsCaching () const

virtual void	toXML (QDomDocument &, QDomElement &) const

virtual qreal	userEffectiveSize () const =0

qint32	width () const

	~KisBrush () override

Public Member Functions inherited from KoResource
bool	active () const

void	addMetaData (QString key, QVariant value)
	store the given key, value pair in the resource

virtual void	clearSideLoadedResources ()

virtual KoResourceSP	clone () const =0

virtual QString	defaultFileExtension () const

virtual QList< KoResourceLoadResult >	embeddedResources (KisResourcesInterfaceSP globalResourcesInterface) const

QString	filename () const

QImage	image () const

bool	isDirty () const

virtual bool	isEphemeral () const

virtual bool	isSerializable () const

	KoResource ()

	KoResource (const KoResource &rhs)

	KoResource (const QString &filename)

virtual QList< KoResourceLoadResult >	linkedResources (KisResourcesInterfaceSP globalResourcesInterface) const

bool	load (KisResourcesInterfaceSP resourcesInterface)

virtual bool	loadFromDevice (QIODevice *dev, KisResourcesInterfaceSP resourcesInterface)=0

QString	md5Sum (bool generateIfEmpty=true) const

QMap< QString, QVariant >	metadata () const
	get a map with all the metadata

virtual QString	name () const

KoResource &	operator= (const KoResource &rhs)=delete

bool	permanent () const

virtual QList< int >	requiredCanvasResources () const

QList< KoResourceLoadResult >	requiredResources (KisResourcesInterfaceSP globalResourcesInterface) const

int	resourceId () const

bool	save ()

virtual bool	saveToDevice (QIODevice *dev) const

void	setActive (bool active)

void	setDirty (bool value)
	Mark the preset as modified but not saved.

void	setFilename (const QString &filename)

void	setImage (const QImage &image)

void	setMD5Sum (const QString &md5sum)
	Set the md5sum of this resource. It must be in hex-encoded string format.

void	setName (const QString &name)

void	setPermanent (bool permanent)

void	setResourceId (int id)

void	setStorageLocation (const QString &location)

void	setValid (bool valid)

void	setVersion (int version)

virtual QList< KoResourceLoadResult >	sideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface) const

KoResourceSignature	signature () const

QString	storageLocation () const

QList< KoResourceLoadResult >	takeSideLoadedResources (KisResourcesInterfaceSP globalResourcesInterface)

virtual QImage	thumbnail () const
	thumbnail the thumbnail image to use in resource selectors

virtual QString	thumbnailPath () const
	thumbnailPath returns the path to a separate thumbnail image, outside the actual resource file itself. If the path is relative, it is supposed start in the same location as the resource itself. If it's absolute, that is, it starts with "/", it is from the root of the storage.

virtual void	updateThumbnail ()
	updateThumbnail updates the thumbnail for this resource. Reimplement if your thumbnail is something else than the image set with setImage.

bool	valid () const

int	version () const
	Get the version of the resource.

virtual	~KoResource ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Static Public Member Functions
static KisBrushSP	fromXML (const QDomElement &element, KisResourcesInterfaceSP resourcesInterface)

static KoResourceLoadResult	fromXMLLoadResult (const QDomElement &element, KisResourcesInterfaceSP resourcesInterface)

Static Public Attributes
static const QString	brushTypeMetaDataKey = "image-based-brush"

Protected Member Functions
void	generateOutlineCache ()

bool	outlineCacheIsValid () const

void	predefinedBrushToXML (const QString &type, QDomElement &e) const

void	resetOutlineCache ()

virtual void	setBrushType (enumBrushType type)

void	setHeight (qint32 height)

void	setHotSpot (QPointF)

void	setWidth (qint32 width)

Private Attributes
Private *const	d

Additional Inherited Members
Public Attributes inherited from KoResource
bool	active {true}

QString	filename

QImage	image

QString	md5sum

QMap< QString, QVariant >	metadata

bool	modified {false}

QString	name

bool	permanent {false}

int	resourceId {-1}

QString	storageLocation

bool	valid {false}

int	version {-1}

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Detailed Description

KisBrush is the base class for brush resources. A brush resource defines one or more images that are used to potato-stamp along the drawn path. The brush type defines how this brush is used – the important difference is between masks (which take the current painting color) and images (which do not). It is up to the paintop to make use of this feature.

Brushes must be serializable to an xml representation and provide a factory class that can recreate or retrieve the brush based on this representation.

XXX: This api is still a big mess – it needs a good refactoring. And the whole KoResource architecture is way over-designed.

Definition at line 66 of file kis_brush.h.

Constructor & Destructor Documentation

◆ KisBrush() [1/3]

KisBrush::KisBrush ( )

Definition at line 198 of file kis_brush.cpp.

    : KoResource(QString())
    , d(new Private)
{
}

◆ KisBrush() [2/3]

KisBrush::KisBrush ( const QString & filename )

Definition at line 204 of file kis_brush.cpp.

    : KoResource(filename)
    , d(new Private)
{
}

◆ ~KisBrush()

KisBrush::~KisBrush ( )

override

Definition at line 216 of file kis_brush.cpp.

{
    delete d;
}

References d.

◆ KisBrush() [3/3]

KisBrush::KisBrush ( const KisBrush & rhs )

Definition at line 210 of file kis_brush.cpp.

    : KoResource(rhs)
    , d(new Private(*rhs.d))
{
}

Member Function Documentation

◆ angle()

qreal KisBrush::angle ( ) const

Definition at line 743 of file kis_brush.cpp.

{
    return d->angle;
}

References KisBrush::Private::angle, and d.

◆ applyingGradient()

bool KisBrush::applyingGradient ( ) const

virtual

Definition at line 308 of file kis_brush.cpp.

{
    return d->brushApplication == GRADIENTMAP;
}

References KisBrush::Private::brushApplication, d, and GRADIENTMAP.

◆ autoSpacingActive()

bool KisBrush::autoSpacingActive ( ) const

Definition at line 538 of file kis_brush.cpp.

{
    return d->autoSpacingActive;
}

References KisBrush::Private::autoSpacingActive, and d.

◆ autoSpacingCoeff()

qreal KisBrush::autoSpacingCoeff ( ) const

Definition at line 543 of file kis_brush.cpp.

{
    return d->autoSpacingCoeff;
}

References KisBrush::Private::autoSpacingCoeff, and d.

◆ brushApplication()

enumBrushApplication KisBrush::brushApplication ( ) const

virtual

Definition at line 298 of file kis_brush.cpp.

{
    return d->brushApplication;
}

References KisBrush::Private::brushApplication, and d.

◆ brushIndex()

quint32 KisBrush::brushIndex ( ) const

virtual

Returns: the currently selected index of the brush if the brush consists of multiple images

See also: prepareForSeqNo()

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 516 of file kis_brush.cpp.

{
    return 0;
}

◆ brushTipImage()

QImage KisBrush::brushTipImage ( ) const

virtual

brushImage the image the brush tip can paint with. Not all brush types have a single image.

Returns: a valid QImage.

Reimplemented in KisAbrBrush, and KisColorfulBrush.

Definition at line 221 of file kis_brush.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(!d->brushTipImage.isNull());
    return d->brushTipImage;
}

References KisBrush::Private::brushTipImage, d, and KIS_SAFE_ASSERT_RECOVER_NOOP.

◆ brushType()

enumBrushType KisBrush::brushType ( ) const

virtual

The brush type defines how the brush is used.

Definition at line 430 of file kis_brush.cpp.

{
    return d->brushType;
}

References KisBrush::Private::brushType, and d.

◆ canPaintFor()

bool KisBrush::canPaintFor ( const KisPaintInformation & )

virtual

Returns true if this brush can return something useful for the info. This is used by Pipe Brushes that can't paint sometimes

Reimplemented in KisImagePipeBrush.

Definition at line 400 of file kis_brush.cpp.

{
    return true;
}

◆ characteristicSize()

QSizeF KisBrush::characteristicSize ( KisDabShape const & shape ) const

virtual

Returns: the logical size of the brush, that is the size measured in floating point value.

This value should not be used for calculating future dab sizes because it doesn't take any rounding into account. The only use of this metric is calculation of brush-size derivatives like hotspots and spacing.

Reimplemented in KisAutoBrush.

Definition at line 477 of file kis_brush.cpp.

{
    KisDabShape normalizedShape(
                shape.scale() * d->scale,
                shape.ratio(),
                normalizeAngle(shape.rotation() + d->angle));
    return KisQImagePyramid::characteristicSize(
                QSize(width(), height()), normalizedShape);
}

References KisBrush::Private::angle, KisQImagePyramid::characteristicSize(), d, height(), normalizeAngle(), KisDabShape::ratio(), KisDabShape::rotation(), KisBrush::Private::scale, KisDabShape::scale(), and width().

◆ clearBrushPyramid()

void KisBrush::clearBrushPyramid ( )

Definition at line 565 of file kis_brush.cpp.

{
    d->brushPyramid.reset();
}

References KisBrush::Private::brushPyramid, and d.

◆ coldInitBrush()

void KisBrush::coldInitBrush ( )

virtual

Reimplemented in KisAutoBrush, and KisImagePipeBrush.

Definition at line 767 of file kis_brush.cpp.

{
    d->brushPyramid.initialize(this);
    generateOutlineCache();
}

References KisBrush::Private::brushPyramid, d, and generateOutlineCache().

◆ fromXML()

KisBrushSP KisBrush::fromXML	(	const QDomElement &	element,
		KisResourcesInterfaceSP	resourcesInterface )

static

Definition at line 453 of file kis_brush.cpp.

{
    KoResourceLoadResult result = fromXMLLoadResult(element, resourcesInterface);
 
    KisBrushSP brush = result.resource<KisBrush>();
    if (!brush) {
        QDomElement el;
        brush = KisBrushRegistry::instance()->get("auto_brush")->createBrush(el, resourcesInterface).resource<KisBrush>();
    }
    return brush;
}

References KisBrushFactory::createBrush(), fromXMLLoadResult(), KoGenericRegistry< T >::get(), KisBrushRegistry::instance(), and KoResourceLoadResult::resource().

◆ fromXMLLoadResult()

KoResourceLoadResult KisBrush::fromXMLLoadResult	(	const QDomElement &	element,
		KisResourcesInterfaceSP	resourcesInterface )

static

Definition at line 465 of file kis_brush.cpp.

{
    KoResourceLoadResult result = KisBrushRegistry::instance()->createBrush(element, resourcesInterface);
 
    KisBrushSP brush = result.resource<KisBrush>();
    if (brush && element.attribute("BrushVersion", "1") == "1") {
        brush->setScale(brush->scale() * 2.0);
    }
 
    return result;
}

References KisBrushRegistry::createBrush(), KisBrushRegistry::instance(), and KoResourceLoadResult::resource().

◆ generateMaskAndApplyMaskOrCreateDab() [1/2]

void KisBrush::generateMaskAndApplyMaskOrCreateDab	(	KisFixedPaintDeviceSP	dst,
		ColoringInformation *	coloringInfo,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		double	subPixelX,
		double	subPixelY,
		qreal	softnessFactor,
		qreal	lightnessStrength ) const

virtual

Create a mask and either mask dst (that is, change all alpha values of the existing pixels to those of the mask) or, if coloringInfo is present, clear dst and fill dst with pixels according to coloringInfo, masked according to the generated mask.

Parameters

dst	the destination that will be draw on the image, and this function will edit its alpha channel
coloringInfo	coloring information that will be copied on the dab, it can be null
shape	a shape applied on the alpha mask
info	the painting information (this is only and should only be used by KisImagePipeBrush and only to be backward compatible with the Gimp, KisImagePipeBrush is ignoring scale and angle information)
subPixelX	sub position of the brush (contained between 0.0 and 1.0)
subPixelY	sub position of the brush (contained between 0.0 and 1.0)
softnessFactor	softness factor of the brush

Returns: a mask computed from the grey-level values of the pixels in the brush.

Reimplemented in KisTextBrush, KisImagePipeBrush, and KisAutoBrush.

Definition at line 591 of file kis_brush.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(valid());
    Q_UNUSED(info_);
    Q_UNUSED(softnessFactor);
 
    QImage outputImage = d->brushPyramid.value(this)->createImage(KisDabShape(
                                                                         shape.scale() * d->scale, shape.ratio(),
                                                                         -normalizeAngle(shape.rotation() + d->angle)),
                                                                     subPixelX, subPixelY);
 
    qint32 maskWidth = outputImage.width();
    qint32 maskHeight = outputImage.height();
 
    dst->setRect(QRect(0, 0, maskWidth, maskHeight));
    dst->lazyGrowBufferWithoutInitialization();
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(coloringInformation);
 
    quint8* color = 0;
    if (dynamic_cast<PlainColoringInformation*>(coloringInformation)) {
        color = const_cast<quint8*>(coloringInformation->color());
    }
 
    const KoColorSpace *cs = dst->colorSpace();
    const quint32 pixelSize = cs->pixelSize();
    const quint32 maskPixelSize = sizeof(QRgb);
    quint8 *rowPointer = dst->data();
 
    const bool preserveLightness = this->preserveLightness();
    bool applyGradient = this->applyingGradient();
    QScopedPointer<KoColor> fallbackColor;
 
    if (applyGradient) {
        if (d->cachedGradient) {
            KIS_SAFE_ASSERT_RECOVER_RETURN(d->cachedGradient);
            d->cachedGradient->setColorSpace(cs); //convert gradient to colorspace so we don't have to convert each pixel
        } else {
            fallbackColor.reset(new KoColor(Qt::red, cs));
            color = fallbackColor->data();
            applyGradient = false;
        }
    }
 
    KoColor gradientcolor(Qt::blue, cs);
    for (int y = 0; y < maskHeight; y++) {
        const quint8* maskPointer = outputImage.constScanLine(y);
        if (color) {
            if (preserveLightness) {
                cs->fillGrayBrushWithColorAndLightnessWithStrength(rowPointer, reinterpret_cast<const QRgb*>(maskPointer), color, lightnessStrength, maskWidth);
            }
            else if (applyGradient) {
                quint8* pixel = rowPointer;
                for (int x = 0; x < maskWidth; x++) {
                    const QRgb* maskQRgb = reinterpret_cast<const QRgb*>(maskPointer);
                    qreal maskOpacity = qreal(qAlpha(*maskQRgb)) / 255.0;
                    if (maskOpacity > 0) {
                        qreal gradientvalue = qreal(qGray(*maskQRgb)) / 255.0;
                        gradientcolor.setColor(d->cachedGradient->cachedAt(gradientvalue), cs);
                    }
                    qreal gradientOpacity = gradientcolor.opacityF();
                    qreal opacity = gradientOpacity * maskOpacity;
                    gradientcolor.setOpacity(opacity);
                    memcpy(pixel, gradientcolor.data(), pixelSize);
 
                    maskPointer += maskPixelSize; 
                    pixel += pixelSize;
                }
            }
            else {
                cs->fillGrayBrushWithColor(rowPointer, reinterpret_cast<const QRgb*>(maskPointer), color, maskWidth);
            }
        }
        else {
            {
                quint8 *dst = rowPointer;
                for (int x = 0; x < maskWidth; x++) {
                    memcpy(dst, coloringInformation->color(), pixelSize);
                    coloringInformation->nextColumn();
                    dst += pixelSize;
                }
            }
 
            QScopedArrayPointer<quint8> alphaArray(new quint8[maskWidth]);
            fetchPremultipliedRed(reinterpret_cast<const QRgb*>(maskPointer), alphaArray.data(), maskWidth);
            cs->applyAlphaU8Mask(rowPointer, alphaArray.data(), maskWidth);
        }
 
        rowPointer += maskWidth * pixelSize;
 
        if (!color) {
            coloringInformation->nextRow();
        }
    }
 
 
}

References KisBrush::Private::angle, KoColorSpace::applyAlphaU8Mask(), applyingGradient(), KisBrush::Private::brushPyramid, KisBrush::Private::cachedGradient, KisBrush::ColoringInformation::color(), KisFixedPaintDevice::colorSpace(), d, KisFixedPaintDevice::data(), KoColor::data(), KoColorSpace::fillGrayBrushWithColor(), KoColorSpace::fillGrayBrushWithColorAndLightnessWithStrength(), KIS_SAFE_ASSERT_RECOVER_RETURN, KisFixedPaintDevice::lazyGrowBufferWithoutInitialization(), maskHeight(), maskWidth(), KisBrush::ColoringInformation::nextColumn(), KisBrush::ColoringInformation::nextRow(), normalizeAngle(), KoColor::opacityF(), KoColorSpace::pixelSize(), preserveLightness(), KisDabShape::ratio(), KisDabShape::rotation(), KisBrush::Private::scale, KisDabShape::scale(), KoColor::setColor(), KoColor::setOpacity(), KisFixedPaintDevice::setRect(), and KoResource::valid.

◆ generateMaskAndApplyMaskOrCreateDab() [2/2]

void KisBrush::generateMaskAndApplyMaskOrCreateDab	(	KisFixedPaintDeviceSP	dst,
		ColoringInformation *	coloringInfo,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		double	subPixelX = 0,
		double	subPixelY = 0,
		qreal	softnessFactor = DEFAULT_SOFTNESS_FACTOR ) const

Definition at line 582 of file kis_brush.cpp.

{
    generateMaskAndApplyMaskOrCreateDab(dst, coloringInformation, shape, info_, subPixelX, subPixelY, softnessFactor, DEFAULT_LIGHTNESS_STRENGTH);
}

References DEFAULT_LIGHTNESS_STRENGTH, and generateMaskAndApplyMaskOrCreateDab().

◆ generateOutlineCache()

void KisBrush::generateOutlineCache ( )

protected

Definition at line 718 of file kis_brush.cpp.

{
    d->brushOutline.initialize(this);
}

References KisBrush::Private::brushOutline, and d.

◆ height()

qint32 KisBrush::height ( ) const

Returns: the height (for scale == 1.0)

Definition at line 237 of file kis_brush.cpp.

{
    return d->height;
}

References d, and KisBrush::Private::height.

◆ hotSpot()

QPointF KisBrush::hotSpot	(	KisDabShape const &	shape,
		const KisPaintInformation &	info ) const

Definition at line 265 of file kis_brush.cpp.

{
    Q_UNUSED(info);
 
    QSizeF metric = characteristicSize(shape);
 
    qreal w = metric.width();
    qreal h = metric.height();
 
    // The smallest brush we can produce is a single pixel.
    if (w < 1) {
        w = 1;
    }
 
    if (h < 1) {
        h = 1;
    }
 
    // XXX: This should take d->hotSpot into account, though it
    // isn't specified by gimp brushes so it would default to the center
    // anyway.
    QPointF p(w / 2, h / 2);
    return p;
}

References characteristicSize(), and p.

◆ isPiercedApprox()

bool KisBrush::isPiercedApprox ( ) const

virtual

Returns true if the brush has a bunch of pixels almost fully transparent in the very center. If the brush is pierced, then dulling mode may not work correctly due to empty samples.

WARNING: this method is relatively expensive since it iterates up to 100 pixels of the brush.

Reimplemented in KisAutoBrush.

Definition at line 325 of file kis_brush.cpp.

{
    QImage image = brushTipImage();
 
    qreal w = image.width();
    qreal h = image.height();
 
    if (w < 3 && h < 3) { return false; }
 
    qreal xPortion = qMin(0.1, 5.0 / w);
    qreal yPortion = qMin(0.1, 5.0 / h);
 
    int x0 = std::floor((0.5 - xPortion) * w);
    int x1 = std::ceil((0.5 + xPortion) * w);
 
    int y0 = std::floor((0.5 - yPortion) * h);
    int y1 = std::ceil((0.5 + yPortion) * h);
 
    const int maxNumSamples = (x1 - x0 + 1) * (y1 - y0 + 1);
    const int failedPixelsThreshold = 0.1 * maxNumSamples;
    const int thresholdValue = 0.95 * 255;
    int failedPixels = 0;
 
    for (int y = y0; y <= y1; y++) {
        for (int x = x0; x <= x1; x++) {
            QRgb pixel = image.pixel(x,y);
 
            if (qRed(pixel) > thresholdValue) {
                failedPixels++;
            }
        }
    }
 
    return failedPixels > failedPixelsThreshold;
}

References brushTipImage(), and KoResource::image.

◆ lodLimitations()

void KisBrush::lodLimitations ( KisPaintopLodLimitations * l ) const

virtual

Reimplemented in KisAutoBrush.

Definition at line 755 of file kis_brush.cpp.

{
    if (spacing() > 0.5) {
        l->limitations << KoID("huge-spacing", i18nc("PaintOp instant preview limitation", "Spacing > 0.5, consider disabling Instant Preview"));
    }
}

References KisPaintopLodLimitations::limitations, and spacing().

◆ mask() [1/2]

void KisBrush::mask	(	KisFixedPaintDeviceSP	dst,
		const KisPaintDeviceSP	src,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		double	subPixelX = 0,
		double	subPixelY = 0,
		qreal	softnessFactor = DEFAULT_SOFTNESS_FACTOR,
		qreal	lightnessStrength = DEFAULT_LIGHTNESS_STRENGTH ) const

clear dst and fill it with a mask colored with the corresponding colors of src

Definition at line 576 of file kis_brush.cpp.

{
    PaintDeviceColoringInformation pdci(src, maskWidth(shape, subPixelX, subPixelY, info));
    generateMaskAndApplyMaskOrCreateDab(dst, &pdci, shape, info, subPixelX, subPixelY, softnessFactor, lightnessStrength);
}

References generateMaskAndApplyMaskOrCreateDab(), and maskWidth().

◆ mask() [2/2]

void KisBrush::mask	(	KisFixedPaintDeviceSP	dst,
		const KoColor &	color,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		double	subPixelX = 0,
		double	subPixelY = 0,
		qreal	softnessFactor = DEFAULT_SOFTNESS_FACTOR,
		qreal	lightnessStrength = DEFAULT_LIGHTNESS_STRENGTH ) const

clear dst fill it with a mask colored with KoColor

Definition at line 570 of file kis_brush.cpp.

{
    PlainColoringInformation pci(color.data());
    generateMaskAndApplyMaskOrCreateDab(dst, &pci, shape, info, subPixelX, subPixelY, softnessFactor, lightnessStrength);
}

References KoColor::data(), and generateMaskAndApplyMaskOrCreateDab().

◆ maskAngle()

double KisBrush::maskAngle ( double angle = 0 ) const

Returns: the angle of the mask adding the given angle

Definition at line 511 of file kis_brush.cpp.

{
    return normalizeAngle(angle + d->angle);
}

References KisBrush::Private::angle, angle(), d, and normalizeAngle().

◆ maskHeight()

qint32 KisBrush::maskHeight	(	KisDabShape const &	shape,
		qreal	subPixelX,
		qreal	subPixelY,
		const KisPaintInformation &	info ) const

virtual

Returns: the height of the mask for the given scale and angle

Reimplemented in KisAutoBrush.

Definition at line 499 of file kis_brush.cpp.

{
    Q_UNUSED(info);
 
    qreal angle = normalizeAngle(shape.rotation() + d->angle);
    qreal scale = shape.scale() * d->scale;
 
    return KisQImagePyramid::imageSize(QSize(width(), height()),
                                       KisDabShape(scale, shape.ratio(), angle),
                                       subPixelX, subPixelY).height();
}

References KisBrush::Private::angle, angle(), d, height(), KisQImagePyramid::imageSize(), normalizeAngle(), KisDabShape::ratio(), KisDabShape::rotation(), KisBrush::Private::scale, scale(), KisDabShape::scale(), and width().

◆ maskWidth()

qint32 KisBrush::maskWidth	(	KisDabShape const &	shape,
		qreal	subPixelX,
		qreal	subPixelY,
		const KisPaintInformation &	info ) const

virtual

Returns: the width of the mask for the given scale and angle

Reimplemented in KisAutoBrush.

Definition at line 487 of file kis_brush.cpp.

{
    Q_UNUSED(info);
 
    qreal angle = normalizeAngle(shape.rotation() + d->angle);
    qreal scale = shape.scale() * d->scale;
 
    return KisQImagePyramid::imageSize(QSize(width(), height()),
                                       KisDabShape(scale, shape.ratio(), angle),
                                       subPixelX, subPixelY).width();
}

References KisBrush::Private::angle, angle(), d, height(), KisQImagePyramid::imageSize(), normalizeAngle(), KisDabShape::ratio(), KisDabShape::rotation(), KisBrush::Private::scale, scale(), KisDabShape::scale(), and width().

◆ notifyBrushIsGoingToBeClonedForStroke()

void KisBrush::notifyBrushIsGoingToBeClonedForStroke ( )

virtual

Is called by the paint op before it is going to clone the brush into multiple instances to pass to different threads. During this call the brush is free to prepare some structures that may be shared by all the clones without excessive recalculation.

Default implementation for all image-based brushes: just recreate the shared pyramid

Reimplemented in KisAutoBrush, and KisImagePipeBrush.

Definition at line 552 of file kis_brush.cpp.

{
    d->brushPyramid.initialize(this);
}

References KisBrush::Private::brushPyramid, and d.

◆ notifyStrokeStarted()

void KisBrush::notifyStrokeStarted ( )

virtual

Is called by the paint op when a paintop starts a stroke. The point is that we store brushes a server while the paint ops are are recreated all the time. Is means that upon a stroke start the brushes may need to clear its state.

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 548 of file kis_brush.cpp.

549{

550}

◆ operator=()

KisBrush & KisBrush::operator= ( const KisBrush & rhs )

delete

◆ outline()

KisOptimizedBrushOutline KisBrush::outline ( bool forcePreciseOutline = false ) const

virtual

Reimplemented in KisAutoBrush, and KisImagePipeBrush.

Definition at line 748 of file kis_brush.cpp.

{
    Q_UNUSED(forcePreciseOutline);
 
    return *d->brushOutline.value(this);
}

References KisBrush::Private::brushOutline, and d.

◆ outlineCacheIsValid()

bool KisBrush::outlineCacheIsValid ( ) const

protected

Definition at line 723 of file kis_brush.cpp.

{
    return !d->brushOutline.isNull();
}

References KisBrush::Private::brushOutline, and d.

◆ outlineSourceImage()

KisFixedPaintDeviceSP KisBrush::outlineSourceImage ( ) const

virtual

Is a paint device of the brush that should be used for generation of the brush outline. Usually, it is the same device returned by brushTipImage(), but might be different in some types of brushes, like in KisAutoBrush.

We need to generate the mask manually, skipping the construction of the image pyramid

Reimplemented in KisAutoBrush.

Definition at line 372 of file kis_brush.cpp.

{
    const KoColorSpace* cs = KoColorSpaceRegistry::instance()->alpha8();
    KisFixedPaintDeviceSP dev = new KisFixedPaintDevice(cs);
    const QImage image = brushTipImage().convertToFormat(QImage::Format_ARGB32);
 
    dev->setRect(image.rect());
    dev->lazyGrowBufferWithoutInitialization();
 
    const int maskWidth = image.width();
    const int maskHeight = image.height();
 
    quint8 *dstPtr = dev->data();
 
    for (int y = 0; y < maskHeight; y++) {
        const QRgb* maskPointer = reinterpret_cast<const QRgb*>(image.constScanLine(y));
        fetchPremultipliedRed(maskPointer, dstPtr, maskWidth);
        dstPtr += maskWidth;
    }
 
    return dev;
}

References KoColorSpaceRegistry::alpha8(), brushTipImage(), KisFixedPaintDevice::data(), KoResource::image, KoColorSpaceRegistry::instance(), KisFixedPaintDevice::lazyGrowBufferWithoutInitialization(), maskHeight(), maskWidth(), and KisFixedPaintDevice::setRect().

◆ paintDevice()

KisFixedPaintDeviceSP KisBrush::paintDevice	(	const KoColorSpace *	colorSpace,
		KisDabShape const &	shape,
		const KisPaintInformation &	info,
		double	subPixelX = 0,
		double	subPixelY = 0 ) const

virtual

Return a fixed paint device that contains a correctly scaled image dab.

Reimplemented in KisAutoBrush, KisTextBrush, and KisImagePipeBrush.

Definition at line 693 of file kis_brush.cpp.

{
    Q_ASSERT(valid());
    Q_UNUSED(info);
    double angle = normalizeAngle(shape.rotation() + d->angle);
    double scale = shape.scale() * d->scale;
 
    QImage outputImage = d->brushPyramid.value(this)->createImage(
                KisDabShape(scale, shape.ratio(), -angle), subPixelX, subPixelY);
 
    KisFixedPaintDeviceSP dab = new KisFixedPaintDevice(colorSpace);
    Q_CHECK_PTR(dab);
    dab->convertFromQImage(outputImage, "");
 
    return dab;
}

References KisBrush::Private::angle, angle(), KisBrush::Private::brushPyramid, KisFixedPaintDevice::convertFromQImage(), d, normalizeAngle(), KisDabShape::ratio(), KisDabShape::rotation(), KisBrush::Private::scale, scale(), KisDabShape::scale(), and KoResource::valid.

◆ predefinedBrushToXML()

void KisBrush::predefinedBrushToXML	(	const QString &	type,
		QDomElement &	e ) const

protected

Definition at line 435 of file kis_brush.cpp.

{
    e.setAttribute("type", type);
    e.setAttribute("filename", filename());
    e.setAttribute("md5sum", md5Sum());
    e.setAttribute("spacing", QString::number(spacing()));
    e.setAttribute("useAutoSpacing", QString::number(autoSpacingActive()));
    e.setAttribute("autoSpacingCoeff", QString::number(autoSpacingCoeff()));
    e.setAttribute("angle", QString::number(angle()));
    e.setAttribute("scale", QString::number(scale()));
    e.setAttribute("brushApplication", QString::number((int)brushApplication()));
}

References angle(), autoSpacingActive(), autoSpacingCoeff(), brushApplication(), KoResource::filename, KoResource::md5Sum(), scale(), and spacing().

◆ prepareForSeqNo()

void KisBrush::prepareForSeqNo	(	const KisPaintInformation &	info,
		int	seqNo )

virtual

Is called by the multithreaded queue to prepare a specific brush tip for the particular seqNo.

NOTE: one should use always call prepareForSeqNo() before using the brush

Currently, this is used by pipe'd brushes to implement incremental and random parasites

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 559 of file kis_brush.cpp.

{
    Q_UNUSED(info);
    Q_UNUSED(seqNo);
}

◆ preserveLightness()

bool KisBrush::preserveLightness ( ) const

virtual

Definition at line 303 of file kis_brush.cpp.

{
    return d->brushApplication == LIGHTNESSMAP;
}

References KisBrush::Private::brushApplication, d, and LIGHTNESSMAP.

◆ resetOutlineCache()

void KisBrush::resetOutlineCache ( )

protected

Definition at line 713 of file kis_brush.cpp.

{
    d->brushOutline.reset();
}

References KisBrush::Private::brushOutline, and d.

◆ resourceType()

QPair< QString, QString > KisBrush::resourceType ( ) const

inlineoverridevirtual

Returns: the resource type

Implements KoResource.

Reimplemented in KisGbrBrush, KisPngBrush, and KisSvgBrush.

Definition at line 121 of file kis_brush.h.

                                                          {
        return QPair<QString, QString>(ResourceType::Brushes, "");
    }

References ResourceType::Brushes.

◆ scale()

qreal KisBrush::scale ( ) const

Definition at line 733 of file kis_brush.cpp.

{
    return d->scale;
}

References d, and KisBrush::Private::scale.

◆ setAngle()

void KisBrush::setAngle ( qreal _angle )

virtual

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 738 of file kis_brush.cpp.

{
    d->angle = _rotation;
}

References KisBrush::Private::angle, and d.

◆ setAutoSpacing()

void KisBrush::setAutoSpacing	(	bool	active,
		qreal	coeff )

Definition at line 532 of file kis_brush.cpp.

{
    d->autoSpacingCoeff = coeff;
    d->autoSpacingActive = active;
}

References KoResource::active, KisBrush::Private::autoSpacingActive, KisBrush::Private::autoSpacingCoeff, and d.

◆ setBrushApplication()

void KisBrush::setBrushApplication ( enumBrushApplication brushApplication )

virtual

Reimplemented in KisImagePipeBrush.

Definition at line 290 of file kis_brush.cpp.

{
    if (d->brushApplication != brushApplication) {
        d->brushApplication = brushApplication;
        clearBrushPyramid();
    }
}

References KisBrush::Private::brushApplication, brushApplication(), clearBrushPyramid(), and d.

◆ setBrushTipImage()

void KisBrush::setBrushTipImage ( const QImage & image )

virtual

The image is used to represent the brush in the gui, and may also, depending on the brush type be used to define the actual brush instance.

Reimplemented in KisAbrBrush, and KisGbrBrush.

Definition at line 405 of file kis_brush.cpp.

{
    d->brushTipImage = image;
 
    if (!image.isNull()) {
        if (image.width() > 128 || image.height() > 128) {
            KoResource::setImage(image.scaled(128, 128, Qt::KeepAspectRatio, Qt::SmoothTransformation));
        }
        else {
            KoResource::setImage(image);
        }
        setWidth(image.width());
        setHeight(image.height());
    }
    clearBrushPyramid();
    resetOutlineCache();
}

References KisBrush::Private::brushTipImage, clearBrushPyramid(), d, KoResource::image, resetOutlineCache(), setHeight(), KoResource::setImage(), and setWidth().

◆ setBrushType()

void KisBrush::setBrushType ( enumBrushType type )

protectedvirtual

XXX

Definition at line 423 of file kis_brush.cpp.

{
    d->brushType = type;
    addMetaData(brushTypeMetaDataKey,
                QVariant::fromValue(type == IMAGE || type == PIPE_IMAGE));
}

References KoResource::addMetaData(), KisBrush::Private::brushType, brushTypeMetaDataKey, d, IMAGE, and PIPE_IMAGE.

◆ setGradient()

void KisBrush::setGradient ( KoAbstractGradientSP gradient )

virtual

Reimplemented in KisImagePipeBrush.

Definition at line 313 of file kis_brush.cpp.

                                                        {
    if (gradient && gradient->valid()) {
        d->gradient = gradient;
 
        if (!d->cachedGradient) {
            d->cachedGradient = toQShared(new KoCachedGradient(d->gradient, 256, d->gradient->colorSpace()));
        } else {
            d->cachedGradient->setGradient(d->gradient, 256, d->gradient->colorSpace());
        }
    }
}

References KisBrush::Private::cachedGradient, d, KisBrush::Private::gradient, and toQShared().

◆ setHeight()

void KisBrush::setHeight ( qint32 height )

protected

Definition at line 242 of file kis_brush.cpp.

{
    d->height = height;
}

References d, KisBrush::Private::height, and height().

◆ setHotSpot()

void KisBrush::setHotSpot ( QPointF pt )

protected

Definition at line 247 of file kis_brush.cpp.

{
    double x = pt.x();
    double y = pt.y();
 
    if (x < 0)
        x = 0;
    else if (x >= width())
        x = width() - 1;
 
    if (y < 0)
        y = 0;
    else if (y >= height())
        y = height() - 1;
 
    d->hotSpot = QPointF(x, y);
}

References d, height(), KisBrush::Private::hotSpot, and width().

◆ setScale()

void KisBrush::setScale ( qreal _scale )

virtual

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 728 of file kis_brush.cpp.

{
    d->scale = _scale;
}

References d, and KisBrush::Private::scale.

◆ setSpacing()

void KisBrush::setSpacing ( double spacing )

virtual

Change the spacing of the brush.

Parameters

spacing a spacing of 1.0 means that strokes will be separated from one time the size of the brush.

Reimplemented in KisImagePipeBrush, and KisTextBrush.

Definition at line 521 of file kis_brush.cpp.

{
    if (s < 0.02) s = 0.02;
    d->spacing = s;
}

References d, and KisBrush::Private::spacing.

◆ setUserEffectiveSize()

virtual void KisBrush::setUserEffectiveSize ( qreal value )

pure virtual

Implemented in KisAutoBrush, and KisScalingSizeBrush.

◆ setWidth()

void KisBrush::setWidth ( qint32 width )

protected

Definition at line 232 of file kis_brush.cpp.

{
    d->width = width;
}

References d, KisBrush::Private::width, and width().

◆ spacing()

double KisBrush::spacing ( ) const

Returns: the spacing between two strokes for this brush

Definition at line 527 of file kis_brush.cpp.

{
    return d->spacing;
}

References d, and KisBrush::Private::spacing.

◆ supportsCaching()

bool KisBrush::supportsCaching ( ) const

virtual

Reimplemented in KisAutoBrush.

Definition at line 762 of file kis_brush.cpp.

{
    return true;
}

◆ toXML()

void KisBrush::toXML	(	QDomDocument &	,
		QDomElement &	element ) const

virtual

Serialize this brush to XML.

Reimplemented in KisAutoBrush, KisTextBrush, KisAbrBrush, KisGbrBrush, KisPngBrush, KisSvgBrush, and KisColorfulBrush.

Definition at line 448 of file kis_brush.cpp.

{
    element.setAttribute("BrushVersion", "2");
}

◆ userEffectiveSize()

virtual qreal KisBrush::userEffectiveSize ( ) const

pure virtual

Implemented in KisAutoBrush, and KisScalingSizeBrush.

◆ width()

qint32 KisBrush::width ( ) const

Returns: the width (for scale == 1.0)

Definition at line 227 of file kis_brush.cpp.

{
    return d->width;
}

References d, and KisBrush::Private::width.

Member Data Documentation

◆ brushTypeMetaDataKey

const QString KisBrush::brushTypeMetaDataKey = "image-based-brush"

static

Definition at line 343 of file kis_brush.h.

◆ d

Private* const KisBrush::d

private

Definition at line 387 of file kis_brush.h.

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

libs/brush/kis_brush.h
libs/brush/kis_brush.cpp

Classes

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KisBrush() [1/3]

◆ KisBrush() [2/3]

◆ ~KisBrush()

◆ KisBrush() [3/3]

Member Function Documentation

◆ angle()

◆ applyingGradient()

◆ autoSpacingActive()

◆ autoSpacingCoeff()

◆ brushApplication()

◆ brushIndex()

◆ brushTipImage()

◆ brushType()

◆ canPaintFor()

◆ characteristicSize()

◆ clearBrushPyramid()

◆ coldInitBrush()

◆ fromXML()

◆ fromXMLLoadResult()

◆ generateMaskAndApplyMaskOrCreateDab() [1/2]

◆ generateMaskAndApplyMaskOrCreateDab() [2/2]

◆ generateOutlineCache()

◆ height()

◆ hotSpot()

◆ isPiercedApprox()

◆ lodLimitations()

◆ mask() [1/2]

◆ mask() [2/2]

◆ maskAngle()

◆ maskHeight()

◆ maskWidth()

◆ notifyBrushIsGoingToBeClonedForStroke()

◆ notifyStrokeStarted()

◆ operator=()

◆ outline()

◆ outlineCacheIsValid()

◆ outlineSourceImage()

◆ paintDevice()

◆ predefinedBrushToXML()

◆ prepareForSeqNo()

◆ preserveLightness()

◆ resetOutlineCache()

◆ resourceType()

◆ scale()

◆ setAngle()

◆ setAutoSpacing()

◆ setBrushApplication()

◆ setBrushTipImage()

◆ setBrushType()

◆ setGradient()

◆ setHeight()

◆ setHotSpot()

◆ setScale()

◆ setSpacing()

◆ setUserEffectiveSize()

◆ setWidth()

◆ spacing()

◆ supportsCaching()

◆ toXML()

◆ userEffectiveSize()

◆ width()

Member Data Documentation

◆ brushTypeMetaDataKey

◆ d