#include <kis_painting_assistant.h>

Inheritance diagram for KisPaintingAssistant:

Classes
struct	Private

Public Member Functions
void	addHandle (KisPaintingAssistantHandleSP handle, HandleType type)

virtual void	adjustLine (QPointF &point, QPointF &strokeBegin)=0

virtual QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, bool snapToAny, qreal moveThresholdPt)=0

bool	areTwoPointsClose (const QPointF &pointOne, const QPointF &pointTwo)

QColor	assistantCustomColor ()

KisPaintingAssistantHandleSP	bottomLeft ()

const KisPaintingAssistantHandleSP	bottomLeft () const

KisPaintingAssistantHandleSP	bottomMiddle ()

const KisPaintingAssistantHandleSP	bottomMiddle () const

KisPaintingAssistantHandleSP	bottomRight ()

const KisPaintingAssistantHandleSP	bottomRight () const

virtual bool	canBeLocal () const
	canBeLocal

virtual KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const =0

KisPaintingAssistantHandleSP	closestCornerHandleFromPoint (QPointF point)

void	copySharedData (KisPaintingAssistantSP assistant)

virtual void	drawAssistant (QPainter &gc, const QRectF &updateRect, const KisCoordinatesConverter converter, const KoColorDisplayRendererInterface displayRenderInterface, bool cached, KisCanvas2 *canvas=0, bool assistantVisible=true, bool previewVisible=true)

void	drawError (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface)

void	drawPath (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface, bool drawActive=true)

void	drawPreview (QPainter &painter, const QPainterPath &path, const KoColorDisplayRendererInterface *displayRenderInterface)

void	drawX (QPainter &painter, const QPointF &pt, const KoColorDisplayRendererInterface *displayRenderInterface)

QPointF	editorWidgetOffset ()

QColor	effectiveAssistantColor () const

virtual void	endStroke ()

void	findPerspectiveAssistantHandleLocation ()

virtual QPointF	getDefaultEditorPosition () const =0

virtual QPointF	getEditorPosition () const

QList< KisPaintingAssistantHandleSP >	handles ()

const QList< KisPaintingAssistantHandleSP > &	handles () const

const QString &	id () const

virtual bool	isAssistantComplete () const

bool	isDuplicating ()
	isDuplicating

bool	isLocal () const
	isLocal

bool	isLocked ()
	isLocked

bool	isSnappingActive () const

	KisPaintingAssistant (const QString &id, const QString &name)

KisPaintingAssistantHandleSP	leftMiddle ()

const KisPaintingAssistantHandleSP	leftMiddle () const

virtual bool	loadCustomXml (QXmlStreamReader *xml)

void	loadXml (KoStore *store, QMap< int, KisPaintingAssistantHandleSP > &handleMap, QString path)

const QString &	name () const

virtual int	numHandles () const =0

KisPaintingAssistantHandleSP	oppHandleOne ()

void	replaceHandle (KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)

KisPaintingAssistantHandleSP	rightMiddle ()

const KisPaintingAssistantHandleSP	rightMiddle () const

virtual void	saveCustomXml (QXmlStreamWriter *xml)

QByteArray	saveXml (QMap< KisPaintingAssistantHandleSP, int > &handleMap)

void	saveXmlList (QDomDocument &doc, QDomElement &assistantsElement, int count)

virtual void	setAdjustedBrushPosition (const QPointF position)

void	setAssistantCustomColor (QColor color)

void	setAssistantGlobalColorCache (const QColor &color)

void	setDecorationThickness (int thickness)

void	setDuplicating (bool value)
	setDuplicating

void	setEditorWidgetOffset (QPointF offset)

virtual void	setFollowBrushPosition (bool follow)

void	setLocal (bool value)
	setLocal

void	setLocked (bool value)
	setLocked

void	setSnappingActive (bool set)

void	setUseCustomColor (bool useCustomColor)

QList< KisPaintingAssistantHandleSP >	sideHandles ()

const QList< KisPaintingAssistantHandleSP > &	sideHandles () const

KisPaintingAssistantHandleSP	topLeft ()

const KisPaintingAssistantHandleSP	topLeft () const

KisPaintingAssistantHandleSP	topMiddle ()

const KisPaintingAssistantHandleSP	topMiddle () const

KisPaintingAssistantHandleSP	topRight ()

const KisPaintingAssistantHandleSP	topRight () const

virtual void	transform (const QTransform &transform)

void	uncache ()

bool	useCustomColor ()

QPointF	viewportConstrainedEditorPosition (const KisCoordinatesConverter *converter, const QSize editorSize)

virtual	~KisPaintingAssistant ()

Static Public Member Functions
static QList< KisPaintingAssistantSP >	cloneAssistantList (const QList< KisPaintingAssistantSP > &list)

static double	norm2 (const QPointF &p)

Protected Member Functions
virtual QRect	boundingRect () const

virtual void	drawCache (QPainter &gc, const KisCoordinatesConverter converter, const KoColorDisplayRendererInterface displayRenderInterface, bool assistantVisible=true)=0
	performance layer where the graphics can be drawn from a cache instead of generated every render update

QPointF	effectiveBrushPosition (const KisCoordinatesConverter converter, KisCanvas2 canvas) const
	Query the effective brush position to be used for preview lines. This is intended to be used for painting the dynamic preview lines for assistants that feature them. Affected by setAdjustedBrushPosition() and setFollowBrushPosition().

virtual KisPaintingAssistantHandleSP	firstLocalHandle () const
	firstLocalHandle Note: this doesn't guarantee it will be the topleft corner! For that, use getLocalRect().topLeft() The only purpose of those functions to exist is to be able to put getLocalRect() function in the KisPaintingAssistant instead of reimplementing it in every specific assistant.

QRectF	getLocalRect () const
	getLocalRect The function deals with local handles not being topLeft and bottomRight gracefully and returns a correct rectangle. Thanks to that the user can place handles in a "wrong" order or move them around but the local rectangle will still be correct.

void	initHandles (QList< KisPaintingAssistantHandleSP > _handles)

	KisPaintingAssistant (const KisPaintingAssistant &rhs, QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap)

QPointF	pixelToView (const QPoint pixelCoords) const

virtual KisPaintingAssistantHandleSP	secondLocalHandle () const
	secondLocalHandle Note: this doesn't guarantee it will be the bottomRight corner! For that, use getLocalRect().bottomRight() (and remember that for QRect bottomRight() works differently than for QRectF, so don't convert to QRect before accessing the corner)

Protected Attributes
QList< KisPaintingAssistantHandleSP >	m_handles

bool	m_hasBeenInsideLocalRect {false}

Private Attributes
Private *const	d

Detailed Description

A KisPaintingAssistant is an object that assist the drawing on the canvas. With this class you can implement virtual equivalent to ruler or compass.

Definition at line 91 of file kis_painting_assistant.h.

Constructor & Destructor Documentation

◆ KisPaintingAssistant() [1/2]

KisPaintingAssistant::KisPaintingAssistant	(	const QString &	id,
		const QString &	name )

Definition at line 250 of file kis_painting_assistant.cc.

                                                                                 : d(new Private)
{
    d->s->id = id;
    d->s->name = name;
    d->s->isSnappingActive = true;
    d->s->outlineVisible = true;
}

References d, id(), name(), and KisPaintingAssistant::Private::s.

◆ ~KisPaintingAssistant()

KisPaintingAssistant::~KisPaintingAssistant ( )

virtual

Definition at line 419 of file kis_painting_assistant.cc.

{
    Q_FOREACH (KisPaintingAssistantHandleSP handle, d->handles) {
        handle->unregisterAssistant(this);
    }
    if(!d->sideHandles.isEmpty()) {
        Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
            handle->unregisterAssistant(this);
        }
    }
    delete d;
}

References d, KisPaintingAssistant::Private::handles, KisPaintingAssistant::Private::sideHandles, and KisPaintingAssistantHandle::unregisterAssistant().

◆ KisPaintingAssistant() [2/2]

KisPaintingAssistant::KisPaintingAssistant	(	const KisPaintingAssistant &	rhs,
		QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &	handleMap )

explicitprotected

Definition at line 258 of file kis_painting_assistant.cc.

    : m_hasBeenInsideLocalRect(rhs.m_hasBeenInsideLocalRect)
    , d(new Private(*(rhs.d)))
{
    dbgUI << "creating handles...";
    Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->handles) {
        d->handles << d->reuseOrCreateHandle(handleMap, origHandle, this);
    }
    Q_FOREACH (const KisPaintingAssistantHandleSP origHandle, rhs.d->sideHandles) {
        d->sideHandles << d->reuseOrCreateHandle(handleMap, origHandle, this);
    }
#define _REUSE_H(name) d->name = d->reuseOrCreateHandle(handleMap, rhs.d->name, this, /* registerAssistant = */ false)
    _REUSE_H(topLeft);
    _REUSE_H(bottomLeft);
    _REUSE_H(topRight);
    _REUSE_H(bottomRight);
    _REUSE_H(topMiddle);
    _REUSE_H(bottomMiddle);
    _REUSE_H(rightMiddle);
    _REUSE_H(leftMiddle);
#undef _REUSE_H
    dbgUI << "done";
}

References _REUSE_H, bottomLeft(), bottomMiddle(), bottomRight(), d, dbgUI, KisPaintingAssistant::Private::handles, leftMiddle(), KisPaintingAssistant::Private::reuseOrCreateHandle(), rightMiddle(), KisPaintingAssistant::Private::sideHandles, topLeft(), topMiddle(), and topRight().

Member Function Documentation

◆ addHandle()

void KisPaintingAssistant::addHandle	(	KisPaintingAssistantHandleSP	handle,
		HandleType	type )

Definition at line 451 of file kis_painting_assistant.cc.

{
    Q_ASSERT(!d->handles.contains(handle));
    if (HandleType::SIDE == type) {
        d->sideHandles.append(handle);
    } else {
        d->handles.append(handle);
    }
 
    handle->registerAssistant(this);
    handle.data()->setType(type);
}

References d, KisSharedPtr< T >::data(), KisPaintingAssistant::Private::handles, KisPaintingAssistantHandle::registerAssistant(), KisPaintingAssistantHandle::setType(), SIDE, and KisPaintingAssistant::Private::sideHandles.

◆ adjustLine()

virtual void KisPaintingAssistant::adjustLine	(	QPointF &	point,
		QPointF &	strokeBegin )

pure virtual

Implemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

◆ adjustPosition()

virtual QPointF KisPaintingAssistant::adjustPosition	(	const QPointF &	point,
		const QPointF &	strokeBegin,
		bool	snapToAny,
		qreal	moveThresholdPt )

pure virtual

Adjust the position given in parameter.

Parameters

point	the coordinates in point in the document reference
strokeBegin	the coordinates of the beginning of the stroke
snapToAny	because now assistants can be composited out of multiple inside assistants. snapToAny true means that you can use any of the inside assistant, while it being false means you should use the last used one. The logic determining when it happens (first stroke etc.) is in the decoration, so those two options are enough.
moveThresholdPt	the threshold for the "move" of the cursor measured in pt (usually equals to 2px in screen coordinates converted to pt)

Implemented in VanishingPointAssistant, ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, and TwoPointAssistant.

◆ areTwoPointsClose()

bool KisPaintingAssistant::areTwoPointsClose	(	const QPointF &	pointOne,
		const QPointF &	pointTwo )

Definition at line 1041 of file kis_painting_assistant.cc.

{
    int m_handleSize = 16;
 
    QRectF handlerect(pointTwo - QPointF(m_handleSize * 0.5, m_handleSize * 0.5), QSizeF(m_handleSize, m_handleSize));
    return handlerect.contains(pointOne);
}

◆ assistantCustomColor()

QColor KisPaintingAssistant::assistantCustomColor ( )

Definition at line 235 of file kis_painting_assistant.cc.

{
    return d->s->assistantCustomColor;
}

References d, and KisPaintingAssistant::Private::s.

◆ bottomLeft() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft ( )

Definition at line 949 of file kis_painting_assistant.cc.

{
    return d->bottomLeft;
}

References KisPaintingAssistant::Private::bottomLeft, and d.

◆ bottomLeft() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomLeft ( ) const

Definition at line 954 of file kis_painting_assistant.cc.

{
    return d->bottomLeft;
}

References KisPaintingAssistant::Private::bottomLeft, and d.

◆ bottomMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle ( )

Definition at line 989 of file kis_painting_assistant.cc.

{
    return d->bottomMiddle;
}

References KisPaintingAssistant::Private::bottomMiddle, and d.

◆ bottomMiddle() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle ( ) const

Definition at line 994 of file kis_painting_assistant.cc.

{
    return d->bottomMiddle;
}

References KisPaintingAssistant::Private::bottomMiddle, and d.

◆ bottomRight() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight ( )

Definition at line 969 of file kis_painting_assistant.cc.

{
    return d->bottomRight;
}

References KisPaintingAssistant::Private::bottomRight, and d.

◆ bottomRight() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight ( ) const

Definition at line 974 of file kis_painting_assistant.cc.

{
    return d->bottomRight;
}

References KisPaintingAssistant::Private::bottomRight, and d.

◆ boundingRect()

QRect KisPaintingAssistant::boundingRect ( ) const

protectedvirtual

Reimplemented in ConcentricEllipseAssistant, EllipseAssistant, FisheyePointAssistant, and PerspectiveEllipseAssistant.

Definition at line 545 of file kis_painting_assistant.cc.

{
    QRectF r;
    Q_FOREACH (KisPaintingAssistantHandleSP h, handles()) {
        r = r.united(QRectF(*h, QSizeF(1,1)));
    }
    return r.adjusted(-2, -2, 2, 2).toAlignedRect();
}

References handles().

◆ canBeLocal()

bool KisPaintingAssistant::canBeLocal ( ) const

virtual

canBeLocal

Returns: if the assistant can be potentially a "local assistant" (limited to rectangular area) or not

Reimplemented in ParallelRulerAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 317 of file kis_painting_assistant.cc.

{
    return false;
}

◆ clone()

virtual KisPaintingAssistantSP KisPaintingAssistant::clone ( QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > & handleMap ) const

pure virtual

Implemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

◆ cloneAssistantList()

QList< KisPaintingAssistantSP > KisPaintingAssistant::cloneAssistantList ( const QList< KisPaintingAssistantSP > & list )

static

clones the list of assistants the originally shared handles will still be shared the cloned assistants do not share any handle with the original assistants

Definition at line 1128 of file kis_painting_assistant.cc.

{
    QMap<KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP> handleMap;
    QList<KisPaintingAssistantSP> clonedList;
    for (auto i = list.begin(); i != list.end(); ++i) {
        clonedList << (*i)->clone(handleMap);
    }
    return clonedList;
}

◆ closestCornerHandleFromPoint()

KisPaintingAssistantHandleSP KisPaintingAssistant::closestCornerHandleFromPoint ( QPointF point )

Definition at line 1049 of file kis_painting_assistant.cc.

{
    if (!d->s->m_canvas) {
        return 0;
    }
 
 
    if (areTwoPointsClose(point, pixelToView(topLeft()->toPoint()))) {
        return topLeft();
    } else if (areTwoPointsClose(point, pixelToView(topRight()->toPoint()))) {
        return topRight();
    } else if (areTwoPointsClose(point, pixelToView(bottomLeft()->toPoint()))) {
        return bottomLeft();
    } else if (areTwoPointsClose(point, pixelToView(bottomRight()->toPoint()))) {
        return bottomRight();
    }
    return 0;
}

References areTwoPointsClose(), bottomLeft(), bottomRight(), d, pixelToView(), KisPaintingAssistant::Private::s, topLeft(), and topRight().

◆ copySharedData()

void KisPaintingAssistant::copySharedData ( KisPaintingAssistantSP assistant )

Definition at line 189 of file kis_painting_assistant.cc.

{
    // Clones do not get a copy of the shared data, so this function is necessary to copy
    // the SharedData struct from the old assistant to this one. The function returns a
    // reference to a new SharedData object copied from the original
    this->d->s = (QSharedPointer<KisPaintingAssistant::Private::SharedData>)new KisPaintingAssistant::Private::SharedData;
    QSharedPointer<KisPaintingAssistant::Private::SharedData> sd = assistant->d->s;
    *this->d->s = *sd;
}

References d, and KisPaintingAssistant::Private::s.

◆ drawAssistant()

void KisPaintingAssistant::drawAssistant	(	QPainter &	gc,
		const QRectF &	updateRect,
		const KisCoordinatesConverter *	converter,
		const KoColorDisplayRendererInterface *	displayRenderInterface,
		bool	cached,
		KisCanvas2 *	canvas = 0,
		bool	assistantVisible = true,
		bool	previewVisible = true )

virtual

Reimplemented in InfiniteRulerAssistant, ConcentricEllipseAssistant, EllipseAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, CurvilinearPerspectiveAssistant, FisheyePointAssistant, ParallelRulerAssistant, PerspectiveAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 481 of file kis_painting_assistant.cc.

{
    Q_UNUSED(updateRect);
 
    Q_UNUSED(previewVisible);
 
    findPerspectiveAssistantHandleLocation();
 
    if (!useCache) {
        gc.save();
        drawCache(gc, converter, displayRenderInterface, assistantVisible);
        gc.restore();
        return;
    }
 
    const QRect bound = boundingRect();
    if (bound.isEmpty()) {
        return;
    }
 
    const QTransform transform = converter->documentToWidgetTransform();
    const QRect widgetBound = transform.mapRect(bound);
 
    const QRect paintRect = transform.mapRect(bound).intersected(gc.viewport());
    if (paintRect.isEmpty()) return;
 
    QPixmap cached;
    bool found = QPixmapCache::find(d->s->cached, &cached);
 
    if (!(found &&
          d->s->cachedTransform == transform &&
          d->s->cachedRect.translated(widgetBound.topLeft()).contains(paintRect))) {
 
        const QRect cacheRect = gc.viewport().adjusted(-100, -100, 100, 100).intersected(widgetBound);
        Q_ASSERT(!cacheRect.isEmpty());
 
        if (cached.isNull() || cached.size() != cacheRect.size()) {
            cached = QPixmap(cacheRect.size());
        }
 
        cached.fill(Qt::transparent);
        QPainter painter(&cached);
        painter.setRenderHint(QPainter::Antialiasing);
        painter.setWindow(cacheRect);
        drawCache(painter, converter, displayRenderInterface, assistantVisible);
        painter.end();
        d->s->cachedTransform = transform;
        d->s->cachedRect = cacheRect.translated(-widgetBound.topLeft());
        d->s->cached = QPixmapCache::insert(cached);
    }
 
    gc.drawPixmap(paintRect, cached, paintRect.translated(-widgetBound.topLeft() - d->s->cachedRect.topLeft()));
 
 
    if (canvas) {
        d->s->m_canvas = canvas;
    }
}

References boundingRect(), d, KisCoordinatesConverter::documentToWidgetTransform(), drawCache(), findPerspectiveAssistantHandleLocation(), KisPaintingAssistant::Private::s, and transform().

◆ drawCache()

virtual void KisPaintingAssistant::drawCache	(	QPainter &	gc,
		const KisCoordinatesConverter *	converter,
		const KoColorDisplayRendererInterface *	displayRenderInterface,
		bool	assistantVisible = true )

protectedpure virtual

performance layer where the graphics can be drawn from a cache instead of generated every render update

Implemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

◆ drawError()

void KisPaintingAssistant::drawError	(	QPainter &	painter,
		const QPainterPath &	path,
		const KoColorDisplayRendererInterface *	displayRenderInterface )

Definition at line 391 of file kis_painting_assistant.cc.

{
    painter.save();
    const QColor error = displayRenderInterface->convertColorToDisplayColorSpace(KoColor(QColor(255, 0, 0, 125), KoColorSpaceRegistry::instance()->rgb8()));
    QPen pen_a(error, d->errorLineWidth * d->decorationThickness);
    pen_a.setCosmetic(true);
    painter.setPen(pen_a);
    painter.drawPath(path);
    painter.restore();
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), d, KisPaintingAssistant::Private::decorationThickness, KisPaintingAssistant::Private::errorLineWidth, and KoColorSpaceRegistry::instance().

◆ drawPath()

void KisPaintingAssistant::drawPath	(	QPainter &	painter,
		const QPainterPath &	path,
		const KoColorDisplayRendererInterface *	displayRenderInterface,
		bool	drawActive = true )

This will render the final output. The drawCache does rendering most of the time so be sure to check that

Definition at line 363 of file kis_painting_assistant.cc.

{
 
    QColor paintingColor = displayRenderInterface->convertColorToDisplayColorSpace(KoColor(effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8()));;
 
    if (!isSnappingOn) {
        paintingColor.setAlpha(0.2 * paintingColor.alpha());
    }
 
    painter.save();
    QPen pen_a(paintingColor, d->mainLineWidth * d->decorationThickness);
    pen_a.setCosmetic(true);
    painter.setPen(pen_a);
    painter.drawPath(path);
    painter.restore();
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), d, KisPaintingAssistant::Private::decorationThickness, effectiveAssistantColor(), KoColorSpaceRegistry::instance(), and KisPaintingAssistant::Private::mainLineWidth.

◆ drawPreview()

void KisPaintingAssistant::drawPreview	(	QPainter &	painter,
		const QPainterPath &	path,
		const KoColorDisplayRendererInterface *	displayRenderInterface )

Definition at line 380 of file kis_painting_assistant.cc.

{
    painter.save();
    QPen pen_a(displayRenderInterface->convertColorToDisplayColorSpace(KoColor(effectiveAssistantColor(), KoColorSpaceRegistry::instance()->rgb8())), d->previewLineWidth);
    pen_a.setStyle(Qt::SolidLine);
    pen_a.setCosmetic(true);
    painter.setPen(pen_a);
    painter.drawPath(path);
    painter.restore();
}

References KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), d, effectiveAssistantColor(), KoColorSpaceRegistry::instance(), and KisPaintingAssistant::Private::previewLineWidth.

◆ drawX()

void KisPaintingAssistant::drawX	(	QPainter &	painter,
		const QPointF &	pt,
		const KoColorDisplayRendererInterface *	displayRenderInterface )

Definition at line 402 of file kis_painting_assistant.cc.

{
    QPainterPath path;
    path.moveTo(QPointF(pt.x() - 5.0, pt.y() - 5.0)); path.lineTo(QPointF(pt.x() + 5.0, pt.y() + 5.0));
    path.moveTo(QPointF(pt.x() - 5.0, pt.y() + 5.0)); path.lineTo(QPointF(pt.x() + 5.0, pt.y() - 5.0));
    drawPath(painter, path, displayRenderInterface);
}

References drawPath().

◆ editorWidgetOffset()

QPointF KisPaintingAssistant::editorWidgetOffset ( )

Definition at line 352 of file kis_painting_assistant.cc.

{
    return d->s->editorWidgetOffset;
}

References d, and KisPaintingAssistant::Private::s.

◆ effectiveAssistantColor()

QColor KisPaintingAssistant::effectiveAssistantColor ( ) const

Definition at line 245 of file kis_painting_assistant.cc.

{
    return d->s->useCustomColor ? d->s->assistantCustomColor : d->s->assistantGlobalColorCache;
}

References d, and KisPaintingAssistant::Private::s.

◆ effectiveBrushPosition()

QPointF KisPaintingAssistant::effectiveBrushPosition	(	const KisCoordinatesConverter *	converter,
		KisCanvas2 *	canvas ) const

protected

Query the effective brush position to be used for preview lines. This is intended to be used for painting the dynamic preview lines for assistants that feature them. Affected by setAdjustedBrushPosition() and setFollowBrushPosition().

Returns: the effective brush (cursor) position in widget coordinates

Definition at line 1075 of file kis_painting_assistant.cc.

{
    QPointF mousePos;
 
    if (d->s->followBrushPosition && d->s->adjustedPositionValid) {
        mousePos = converter->documentToWidget(d->s->adjustedBrushPosition);
    } else if (canvas) {
        // FIXME: this may be simple and cheap, but it's only integer precision!
        mousePos= canvas->canvasWidget()->mapFromGlobal(QCursor::pos());
    } else {
        //...of course, you need to have access to a canvas-widget for that.//
        mousePos = QCursor::pos(); //this'll give an offset//
        dbgUI << "no canvas given for assistant, you may have passed arguments incorrectly:";
    }
    return mousePos;
}

References KisCanvas2::canvasWidget, d, dbgUI, KisCoordinatesConverter::documentToWidget(), and KisPaintingAssistant::Private::s.

◆ endStroke()

void KisPaintingAssistant::endStroke ( )

virtual

Reimplemented in PerspectiveAssistant, and TwoPointAssistant.

Definition at line 294 of file kis_painting_assistant.cc.

{
    d->s->adjustedPositionValid = false;
    d->s->followBrushPosition = false;
    m_hasBeenInsideLocalRect = false;
}

References d, m_hasBeenInsideLocalRect, and KisPaintingAssistant::Private::s.

◆ findPerspectiveAssistantHandleLocation()

void KisPaintingAssistant::findPerspectiveAssistantHandleLocation ( )

Definition at line 799 of file kis_painting_assistant.cc.

                                                                  {
    QList<KisPaintingAssistantHandleSP> hHandlesList;
    QList<KisPaintingAssistantHandleSP> vHandlesList;
    uint vHole = 0,hHole = 0;
    KisPaintingAssistantHandleSP oppHandle;
    if (d->handles.size() == 4 && d->s->id == "perspective") {
        //get the handle opposite to the first handle
        oppHandle = oppHandleOne();
        //Sorting handles into two list, X sorted and Y sorted into hHandlesList and vHandlesList respectively.
        Q_FOREACH (const KisPaintingAssistantHandleSP handle,d->handles) {
            hHandlesList.append(handle);
            hHole = hHandlesList.size() - 1;
            vHandlesList.append(handle);
            vHole = vHandlesList.size() - 1;
            /*
             sort handles on the basis of X-coordinate
             */
            while(hHole > 0 && hHandlesList.at(hHole -1).data()->x() > handle.data()->x()) {
                hHandlesList.swapItemsAt(hHole - 1, hHole);
                hHole = hHole - 1;
            }
            /*
             sort handles on the basis of Y-coordinate
             */
            while(vHole > 0 && vHandlesList.at(vHole -1).data()->y() > handle.data()->y()) {
                vHandlesList.swapItemsAt(vHole-1, vHole);
                vHole = vHole - 1;
            }
        }
 
        /*
         give the handles their respective positions
         */
        if(vHandlesList.at(0).data()->x() > vHandlesList.at(1).data()->x()) {
            d->topLeft = vHandlesList.at(1);
            d->topRight= vHandlesList.at(0);
        }
        else {
            d->topLeft = vHandlesList.at(0);
            d->topRight = vHandlesList.at(1);
        }
        if(vHandlesList.at(2).data()->x() > vHandlesList.at(3).data()->x()) {
            d->bottomLeft = vHandlesList.at(3);
            d->bottomRight = vHandlesList.at(2);
        }
        else {
            d->bottomLeft= vHandlesList.at(2);
            d->bottomRight = vHandlesList.at(3);
        }
 
        /*
         find if the handles that should be opposite are actually oppositely positioned
         */
        if (( (d->topLeft == d->handles.at(0).data() && d->bottomRight == oppHandle) ||
              (d->topLeft == oppHandle && d->bottomRight == d->handles.at(0).data()) ||
              (d->topRight == d->handles.at(0).data() && d->bottomLeft == oppHandle) ||
              (d->topRight == oppHandle && d->bottomLeft == d->handles.at(0).data()) ) )
        {}
        else {
            if(hHandlesList.at(0).data()->y() > hHandlesList.at(1).data()->y()) {
                d->topLeft = hHandlesList.at(1);
                d->bottomLeft= hHandlesList.at(0);
            }
            else {
                d->topLeft = hHandlesList.at(0);
                d->bottomLeft = hHandlesList.at(1);
            }
            if(hHandlesList.at(2).data()->y() > hHandlesList.at(3).data()->y()) {
                d->topRight = hHandlesList.at(3);
                d->bottomRight = hHandlesList.at(2);
            }
            else {
                d->topRight= hHandlesList.at(2);
                d->bottomRight = hHandlesList.at(3);
            }
 
        }
        /*
         Setting the middle handles as needed
         */
        if(!d->bottomMiddle && !d->topMiddle && !d->leftMiddle && !d->rightMiddle) {
  
            // Before re-adding the handles, clear old ones that have been
            // potentially loaded from disk and not re-associated with the
            // xxxMiddle pointers in d; otherwise those would stay in place.
            if(!d->sideHandles.isEmpty()) {
                Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
                    handle->unregisterAssistant(this);
                }
                d->sideHandles.clear();
            }
          
            d->bottomMiddle = new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                             (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5);
            d->topMiddle = new KisPaintingAssistantHandle((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                          (d->topLeft.data()->y() + d->topRight.data()->y())*0.5);
            d->rightMiddle= new KisPaintingAssistantHandle((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                           (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5);
            d->leftMiddle= new KisPaintingAssistantHandle((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                          (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5);
            
            addHandle(d->rightMiddle, HandleType::SIDE);
            addHandle(d->leftMiddle, HandleType::SIDE);
            addHandle(d->bottomMiddle, HandleType::SIDE);
            addHandle(d->topMiddle, HandleType::SIDE);
        }
        else
        {
            d->bottomMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->bottomRight.data()->x())*0.5,
                                                       (d->bottomLeft.data()->y() + d->bottomRight.data()->y())*0.5));
            d->topMiddle.data()->operator =(QPointF((d->topLeft.data()->x() + d->topRight.data()->x())*0.5,
                                                    (d->topLeft.data()->y() + d->topRight.data()->y())*0.5));
            d->rightMiddle.data()->operator =(QPointF((d->topRight.data()->x() + d->bottomRight.data()->x())*0.5,
                                                      (d->topRight.data()->y() + d->bottomRight.data()->y())*0.5));
            d->leftMiddle.data()->operator =(QPointF((d->bottomLeft.data()->x() + d->topLeft.data()->x())*0.5,
                                                     (d->bottomLeft.data()->y() + d->topLeft.data()->y())*0.5));
        }
 
    }
}

◆ firstLocalHandle()

KisPaintingAssistantHandleSP KisPaintingAssistant::firstLocalHandle ( ) const

protectedvirtual

firstLocalHandle Note: this doesn't guarantee it will be the topleft corner! For that, use getLocalRect().topLeft() The only purpose of those functions to exist is to be able to put getLocalRect() function in the KisPaintingAssistant instead of reimplementing it in every specific assistant.

Returns: the first handle of the rectangle of the limited area

Reimplemented in ParallelRulerAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 1092 of file kis_painting_assistant.cc.

{
    return 0;
}

◆ getDefaultEditorPosition()

virtual QPointF KisPaintingAssistant::getDefaultEditorPosition ( ) const

pure virtual

Implemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

◆ getEditorPosition()

QPointF KisPaintingAssistant::getEditorPosition ( ) const

virtual

Definition at line 312 of file kis_painting_assistant.cc.

{
    return getDefaultEditorPosition() + d->s->editorWidgetOffset;
}

References d, getDefaultEditorPosition(), and KisPaintingAssistant::Private::s.

◆ getLocalRect()

QRectF KisPaintingAssistant::getLocalRect ( ) const

protected

getLocalRect The function deals with local handles not being topLeft and bottomRight gracefully and returns a correct rectangle. Thanks to that the user can place handles in a "wrong" order or move them around but the local rectangle will still be correct.

Returns: the rectangle of the area that the assistant is limited to

Definition at line 1102 of file kis_painting_assistant.cc.

{
    if (!isLocal() || !firstLocalHandle() || !secondLocalHandle()) {
        return QRectF();
    }
 
    KisPaintingAssistantHandleSP first = firstLocalHandle();
    KisPaintingAssistantHandleSP second = secondLocalHandle();
 
    QPointF topLeft = QPointF(qMin(first->x(), second->x()), qMin(first->y(), second->y()));
    QPointF bottomRight = QPointF(qMax(first->x(), second->x()), qMax(first->y(), second->y()));
 
    QRectF rect(topLeft, bottomRight);
    return rect;
}

References bottomRight(), firstLocalHandle(), isLocal(), secondLocalHandle(), and topLeft().

◆ handles() [1/2]

QList< KisPaintingAssistantHandleSP > KisPaintingAssistant::handles ( )

Definition at line 1024 of file kis_painting_assistant.cc.

{
    return d->handles;
}

References d, and KisPaintingAssistant::Private::handles.

◆ handles() [2/2]

const QList< KisPaintingAssistantHandleSP > & KisPaintingAssistant::handles ( ) const

Definition at line 1019 of file kis_painting_assistant.cc.

{
    return d->handles;
}

References d, and KisPaintingAssistant::Private::handles.

◆ id()

const QString & KisPaintingAssistant::id ( ) const

Definition at line 432 of file kis_painting_assistant.cc.

{
    return d->s->id;
}

References d, and KisPaintingAssistant::Private::s.

◆ initHandles()

void KisPaintingAssistant::initHandles ( QList< KisPaintingAssistantHandleSP > _handles )

protected

Definition at line 410 of file kis_painting_assistant.cc.

{
    Q_ASSERT(d->handles.isEmpty());
    d->handles = _handles;
    Q_FOREACH (KisPaintingAssistantHandleSP handle, _handles) {
        handle->registerAssistant(this);
    }
}

References d, KisPaintingAssistant::Private::handles, and KisPaintingAssistantHandle::registerAssistant().

◆ isAssistantComplete()

bool KisPaintingAssistant::isAssistantComplete ( ) const

virtual

determines if the assistant has enough handles to be considered created new assistants get in a "creation" phase where they are currently being made on the canvas it will return false if we are in the middle of creating the assistant.

Reimplemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 554 of file kis_painting_assistant.cc.

{
    return true;
}

◆ isDuplicating()

bool KisPaintingAssistant::isDuplicating ( )

isDuplicating

Returns: If the duplication button is pressed

Definition at line 347 of file kis_painting_assistant.cc.

{
    return d->s->isDuplicating;
}

References d, and KisPaintingAssistant::Private::s.

◆ isLocal()

bool KisPaintingAssistant::isLocal ( ) const

isLocal

Returns: if the assistant is limited to a rectangular area or not

Definition at line 322 of file kis_painting_assistant.cc.

{
    return d->s->isLocal;
}

References d, and KisPaintingAssistant::Private::s.

◆ isLocked()

bool KisPaintingAssistant::isLocked ( )

isLocked

Returns: if the assistant is locked (= cannot be moved, or edited in any way), or not

Definition at line 332 of file kis_painting_assistant.cc.

{
    return d->s->isLocked;
}

References d, and KisPaintingAssistant::Private::s.

◆ isSnappingActive()

bool KisPaintingAssistant::isSnappingActive ( ) const

Definition at line 284 of file kis_painting_assistant.cc.

{
    return d->s->isSnappingActive;
}

References d, and KisPaintingAssistant::Private::s.

◆ leftMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle ( )

Definition at line 1009 of file kis_painting_assistant.cc.

{
    return d->leftMiddle;
}

References d, and KisPaintingAssistant::Private::leftMiddle.

◆ leftMiddle() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::leftMiddle ( ) const

Definition at line 1014 of file kis_painting_assistant.cc.

{
    return d->leftMiddle;
}

References d, and KisPaintingAssistant::Private::leftMiddle.

◆ loadCustomXml()

bool KisPaintingAssistant::loadCustomXml ( QXmlStreamReader * xml )

virtual

Reimplemented in ParallelRulerAssistant, PerspectiveAssistant, RulerAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 717 of file kis_painting_assistant.cc.

{
    Q_UNUSED(xml);
    return true;
}

◆ loadXml()

void KisPaintingAssistant::loadXml	(	KoStore *	store,
		QMap< int, KisPaintingAssistantHandleSP > &	handleMap,
		QString	path )

Definition at line 633 of file kis_painting_assistant.cc.

{
    int id = 0;
    double x = 0.0, y = 0.0;
    store->open(path);
    QByteArray data = store->read(store->size());
    QXmlStreamReader xml(data);
    QMap<int, KisPaintingAssistantHandleSP> sideHandleMap;
    while (!xml.atEnd()) {
        switch (xml.readNext()) {
        case QXmlStreamReader::StartElement:
            if (xml.name() == "assistant") {
 
                auto active = xml.attributes().value("active");
                setSnappingActive( (active != "0")  );
 
                // load custom shared assistant properties
                if ( xml.attributes().hasAttribute("useCustomColor")) {
                    auto useCustomColor = xml.attributes().value("useCustomColor");
 
                    bool usingColor = false;
                    if (useCustomColor.toString() == "1") {
                        usingColor = true;
                    }
 
 
                    setUseCustomColor(usingColor);
                }
 
                if (xml.attributes().hasAttribute("editorWidgetOffset_X") && xml.attributes().hasAttribute("editorWidgetOffset_Y")) {
                    setEditorWidgetOffset(QPointF(xml.attributes().value("editorWidgetOffset_X").toDouble(), xml.attributes().value("editorWidgetOffset_Y").toDouble()));
                }
 
                if ( xml.attributes().hasAttribute("customColor")) {
                    auto customColor = xml.attributes().value("customColor");
                    setAssistantCustomColor( KisDomUtils::qStringToQColor(customColor.toString()) );
 
                }
 
                if ( xml.attributes().hasAttribute("locked")) {
                    auto locked = xml.attributes().value("locked");
                    setLocked(locked == "1");
                }
 
            }
 
            loadCustomXml(&xml);
 
            if (xml.name() == "handle") {
                QString strId = xml.attributes().value("id").toString(),
                        strX = xml.attributes().value("x").toString(),
                        strY = xml.attributes().value("y").toString();
                if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                    id = strId.toInt();
                    x = strX.toDouble();
                    y = strY.toDouble();
                    if (!handleMap.contains(id)) {
                        handleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                    }
                }
                addHandle(handleMap.value(id), HandleType::NORMAL);
            } else if (xml.name() == "sidehandle") {
                QString strId = xml.attributes().value("id").toString(),
                        strX = xml.attributes().value("x").toString(),
                        strY = xml.attributes().value("y").toString();
                if (!strId.isEmpty() && !strX.isEmpty() && !strY.isEmpty()) {
                    id = strId.toInt();
                    x = strX.toDouble();
                    y = strY.toDouble();
                    if (!sideHandleMap.contains(id)) {
                        sideHandleMap.insert(id, new KisPaintingAssistantHandle(x, y));
                    }
                }
                addHandle(sideHandleMap.value(id), HandleType::SIDE);
 
            }
            break;
        default:
            break;
        }
    }
    store->close();
}

References addHandle(), KoStore::close(), loadCustomXml(), NORMAL, KoStore::open(), KisDomUtils::qStringToQColor(), KoStore::read(), setAssistantCustomColor(), setEditorWidgetOffset(), setLocked(), setSnappingActive(), setUseCustomColor(), SIDE, KoStore::size(), and useCustomColor().

◆ name()

const QString & KisPaintingAssistant::name ( ) const

Definition at line 437 of file kis_painting_assistant.cc.

{
    return d->s->name;
}

References d, and KisPaintingAssistant::Private::s.

◆ norm2()

double KisPaintingAssistant::norm2 ( const QPointF & p )

static

Definition at line 1118 of file kis_painting_assistant.cc.

{
    return p.x() * p.x() + p.y() * p.y();
}

References p.

◆ numHandles()

virtual int KisPaintingAssistant::numHandles ( ) const

pure virtual

Implemented in ConcentricEllipseAssistant, CurvilinearPerspectiveAssistant, EllipseAssistant, FisheyePointAssistant, InfiniteRulerAssistant, ParallelRulerAssistant, PerspectiveAssistant, PerspectiveEllipseAssistant, RulerAssistant, SplineAssistant, TwoPointAssistant, and VanishingPointAssistant.

◆ oppHandleOne()

KisPaintingAssistantHandleSP KisPaintingAssistant::oppHandleOne ( )

Definition at line 920 of file kis_painting_assistant.cc.

{
    QPointF intersection(0,0);
    if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersects(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
            && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(1).data()->toPoint()).intersects(QLineF(d->handles.at(2).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
    {
        return d->handles.at(1);
    }
    else if((QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersects(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::NoIntersection)
            && (QLineF(d->handles.at(0).data()->toPoint(),d->handles.at(2).data()->toPoint()).intersects(QLineF(d->handles.at(1).data()->toPoint(),d->handles.at(3).data()->toPoint()), &intersection) != QLineF::UnboundedIntersection))
    {
        return d->handles.at(2);
    }
    else
    {
        return d->handles.at(3);
    }
}

References d, and KisPaintingAssistant::Private::handles.

◆ pixelToView()

QPointF KisPaintingAssistant::pixelToView ( const QPoint pixelCoords ) const

protected

Definition at line 1069 of file kis_painting_assistant.cc.

{
    QPointF documentCoord = d->s->m_canvas->image()->pixelToDocument(pixelCoords);
    return d->s->m_canvas->viewConverter()->documentToView(documentCoord);
}

References d, and KisPaintingAssistant::Private::s.

◆ replaceHandle()

void KisPaintingAssistant::replaceHandle	(	KisPaintingAssistantHandleSP	_handle,
		KisPaintingAssistantHandleSP	_with )

Definition at line 442 of file kis_painting_assistant.cc.

{
    Q_ASSERT(d->handles.contains(_handle));
    d->handles.replace(d->handles.indexOf(_handle), _with);
    Q_ASSERT(!d->handles.contains(_handle));
    _handle->unregisterAssistant(this);
    _with->registerAssistant(this);
}

References d, KisPaintingAssistant::Private::handles, KisPaintingAssistantHandle::registerAssistant(), and KisPaintingAssistantHandle::unregisterAssistant().

◆ rightMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle ( )

Definition at line 999 of file kis_painting_assistant.cc.

{
    return d->rightMiddle;
}

References d, and KisPaintingAssistant::Private::rightMiddle.

◆ rightMiddle() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::rightMiddle ( ) const

Definition at line 1004 of file kis_painting_assistant.cc.

{
    return d->rightMiddle;
}

References d, and KisPaintingAssistant::Private::rightMiddle.

◆ saveCustomXml()

void KisPaintingAssistant::saveCustomXml ( QXmlStreamWriter * xml )

virtual

Reimplemented in ParallelRulerAssistant, PerspectiveAssistant, RulerAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 628 of file kis_painting_assistant.cc.

{
    Q_UNUSED(xml);
}

◆ saveXml()

QByteArray KisPaintingAssistant::saveXml ( QMap< KisPaintingAssistantHandleSP, int > & handleMap )

Definition at line 576 of file kis_painting_assistant.cc.

{
    QByteArray data;
    QXmlStreamWriter xml(&data);
    xml.writeStartDocument();
    xml.writeStartElement("assistant");
    xml.writeAttribute("type",d->s->id);
    xml.writeAttribute("active", QString::number(d->s->isSnappingActive));
    xml.writeAttribute("useCustomColor", QString::number(d->s->useCustomColor));
    xml.writeAttribute("customColor",  KisDomUtils::qColorToQString(d->s->assistantCustomColor));
    xml.writeAttribute("locked", QString::number(d->s->isLocked));
    xml.writeAttribute("editorWidgetOffset_X", QString::number((double)(d->s->editorWidgetOffset.x()), 'f', 3));
    xml.writeAttribute("editorWidgetOffset_Y", QString::number((double)(d->s->editorWidgetOffset.y()), 'f', 3));
 
 
 
    saveCustomXml(&xml); // if any specific assistants have custom XML data to save to
 
    // write individual handle data
    xml.writeStartElement("handles");
    Q_FOREACH (const KisPaintingAssistantHandleSP handle, d->handles) {
        int id = handleMap.size();
        if (!handleMap.contains(handle)){
            handleMap.insert(handle, id);
        }
        id = handleMap.value(handle);
        xml.writeStartElement("handle");
        xml.writeAttribute("id", QString::number(id));
        xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
        xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
        xml.writeEndElement();
    }
    xml.writeEndElement();
    if (!d->sideHandles.isEmpty()) { // for vanishing points only
    xml.writeStartElement("sidehandles");
    QMap<KisPaintingAssistantHandleSP, int> sideHandleMap;
    Q_FOREACH (KisPaintingAssistantHandleSP handle, d->sideHandles) {
        int id = sideHandleMap.size();
        sideHandleMap.insert(handle, id);
        xml.writeStartElement("sidehandle");
        xml.writeAttribute("id", QString::number(id));
        xml.writeAttribute("x", QString::number(double(handle->x()), 'f', 3));
        xml.writeAttribute("y", QString::number(double(handle->y()), 'f', 3));
        xml.writeEndElement();
      }
    }
 
    xml.writeEndElement();
    xml.writeEndDocument();
    return data;
}

References d, KisPaintingAssistant::Private::handles, KisDomUtils::qColorToQString(), KisPaintingAssistant::Private::s, saveCustomXml(), and KisPaintingAssistant::Private::sideHandles.

◆ saveXmlList()

void KisPaintingAssistant::saveXmlList	(	QDomDocument &	doc,
		QDomElement &	assistantsElement,
		int	count )

Definition at line 723 of file kis_painting_assistant.cc.

{
    if (d->s->id == "ellipse"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "ellipse");
        assistantElement.setAttribute("filename", QString("ellipse%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "spline"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "spline");
        assistantElement.setAttribute("filename", QString("spline%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "perspective"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "perspective");
        assistantElement.setAttribute("filename", QString("perspective%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "vanishing point"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "vanishing point");
        assistantElement.setAttribute("filename", QString("vanishing point%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "infinite ruler"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "infinite ruler");
        assistantElement.setAttribute("filename", QString("infinite ruler%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "parallel ruler"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "parallel ruler");
        assistantElement.setAttribute("filename", QString("parallel ruler%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "concentric ellipse"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "concentric ellipse");
        assistantElement.setAttribute("filename", QString("concentric ellipse%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "fisheye-point"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "fisheye-point");
        assistantElement.setAttribute("filename", QString("fisheye-point%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "ruler"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "ruler");
        assistantElement.setAttribute("filename", QString("ruler%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "two point"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "two point");
        assistantElement.setAttribute("filename", QString("two point%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "perspective ellipse"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "perspective ellipse");
        assistantElement.setAttribute("filename", QString("perspective ellipse%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
    else if (d->s->id == "curvilinear-perspective"){
        QDomElement assistantElement = doc.createElement("assistant");
        assistantElement.setAttribute("type", "curvilinear-perspective");
        assistantElement.setAttribute("filename", QString("curvilinear-perspective%1.assistant").arg(count));
        assistantsElement.appendChild(assistantElement);
    }
}

References d, and KisPaintingAssistant::Private::s.

◆ secondLocalHandle()

KisPaintingAssistantHandleSP KisPaintingAssistant::secondLocalHandle ( ) const

protectedvirtual

secondLocalHandle Note: this doesn't guarantee it will be the bottomRight corner! For that, use getLocalRect().bottomRight() (and remember that for QRect bottomRight() works differently than for QRectF, so don't convert to QRect before accessing the corner)

Returns

Reimplemented in ParallelRulerAssistant, TwoPointAssistant, and VanishingPointAssistant.

Definition at line 1097 of file kis_painting_assistant.cc.

{
    return 0;
}

◆ setAdjustedBrushPosition()

void KisPaintingAssistant::setAdjustedBrushPosition ( const QPointF position )

virtual

Definition at line 301 of file kis_painting_assistant.cc.

{
    d->s->adjustedBrushPosition = position;
    d->s->adjustedPositionValid = true;
}

References d, and KisPaintingAssistant::Private::s.

◆ setAssistantCustomColor()

void KisPaintingAssistant::setAssistantCustomColor ( QColor color )

Definition at line 230 of file kis_painting_assistant.cc.

{
    d->s->assistantCustomColor = color;
}

References d, and KisPaintingAssistant::Private::s.

◆ setAssistantGlobalColorCache()

void KisPaintingAssistant::setAssistantGlobalColorCache ( const QColor & color )

Definition at line 240 of file kis_painting_assistant.cc.

{
    d->s->assistantGlobalColorCache = color;
}

References d, and KisPaintingAssistant::Private::s.

◆ setDecorationThickness()

void KisPaintingAssistant::setDecorationThickness ( int thickness )

Definition at line 1123 of file kis_painting_assistant.cc.

{
    d->decorationThickness = thickness;
}

References d, and KisPaintingAssistant::Private::decorationThickness.

◆ setDuplicating()

void KisPaintingAssistant::setDuplicating ( bool value )

setDuplicating

Parameters

value setter function sets the indication that the duplication button is pressed

Definition at line 342 of file kis_painting_assistant.cc.

{
    d->s->isDuplicating = value;
}

References d, KisPaintingAssistant::Private::s, and value().

◆ setEditorWidgetOffset()

void KisPaintingAssistant::setEditorWidgetOffset ( QPointF offset )

Definition at line 357 of file kis_painting_assistant.cc.

{
    d->s->editorWidgetOffset = offset;
}

References d, and KisPaintingAssistant::Private::s.

◆ setFollowBrushPosition()

void KisPaintingAssistant::setFollowBrushPosition ( bool follow )

virtual

Definition at line 307 of file kis_painting_assistant.cc.

{
    d->s->followBrushPosition = follow;
}

References d, and KisPaintingAssistant::Private::s.

◆ setLocal()

void KisPaintingAssistant::setLocal ( bool value )

setLocal

Parameters

value set the indication if the assistant is limited to a rectangular area or not

Definition at line 327 of file kis_painting_assistant.cc.

{
    d->s->isLocal = value;
}

References d, KisPaintingAssistant::Private::s, and value().

◆ setLocked()

void KisPaintingAssistant::setLocked ( bool value )

setLocked

Parameters

value set the indication if the assistant is locked (= cannot be moved, or edited in any way) or not

Definition at line 337 of file kis_painting_assistant.cc.

{
    d->s->isLocked = value;
}

References d, KisPaintingAssistant::Private::s, and value().

◆ setSnappingActive()

void KisPaintingAssistant::setSnappingActive ( bool set )

Definition at line 289 of file kis_painting_assistant.cc.

{
    d->s->isSnappingActive = set;
}

References d, and KisPaintingAssistant::Private::s.

◆ setUseCustomColor()

void KisPaintingAssistant::setUseCustomColor ( bool useCustomColor )

Definition at line 225 of file kis_painting_assistant.cc.

{
    d->s->useCustomColor = useCustomColor;
}

References d, KisPaintingAssistant::Private::s, and useCustomColor().

◆ sideHandles() [1/2]

QList< KisPaintingAssistantHandleSP > KisPaintingAssistant::sideHandles ( )

Definition at line 1034 of file kis_painting_assistant.cc.

{
    return d->sideHandles;
}

References d, and KisPaintingAssistant::Private::sideHandles.

◆ sideHandles() [2/2]

const QList< KisPaintingAssistantHandleSP > & KisPaintingAssistant::sideHandles ( ) const

Definition at line 1029 of file kis_painting_assistant.cc.

{
    return d->sideHandles;
}

References d, and KisPaintingAssistant::Private::sideHandles.

◆ topLeft() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft ( )

Definition at line 939 of file kis_painting_assistant.cc.

{
    return d->topLeft;
}

References d, and KisPaintingAssistant::Private::topLeft.

◆ topLeft() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft ( ) const

Get the topLeft, bottomLeft, topRight and BottomRight corners of the assistant Some assistants like the perspective grid have custom logic built around certain handles

Definition at line 944 of file kis_painting_assistant.cc.

{
    return d->topLeft;
}

References d, and KisPaintingAssistant::Private::topLeft.

◆ topMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle ( )

Definition at line 979 of file kis_painting_assistant.cc.

{
    return d->topMiddle;
}

References d, and KisPaintingAssistant::Private::topMiddle.

◆ topMiddle() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle ( ) const

Definition at line 984 of file kis_painting_assistant.cc.

{
    return d->topMiddle;
}

References d, and KisPaintingAssistant::Private::topMiddle.

◆ topRight() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topRight ( )

Definition at line 959 of file kis_painting_assistant.cc.

{
    return d->topRight;
}

References d, and KisPaintingAssistant::Private::topRight.

◆ topRight() [2/2]

const KisPaintingAssistantHandleSP KisPaintingAssistant::topRight ( ) const

Definition at line 964 of file kis_painting_assistant.cc.

{
    return d->topRight;
}

References d, and KisPaintingAssistant::Private::topRight.

◆ transform()

void KisPaintingAssistant::transform ( const QTransform & transform )

virtual

Transform the assistant using the given transform. Please note that transform should be in 'document' coordinate system. Used with image-wide transformations.

Reimplemented in ConcentricEllipseAssistant, and EllipseAssistant.

Definition at line 559 of file kis_painting_assistant.cc.

{
    Q_FOREACH(KisPaintingAssistantHandleSP handle, handles()) {
        if (handle->chiefAssistant() != this) continue;
 
        *handle = transform.map(*handle);
    }
 
    Q_FOREACH(KisPaintingAssistantHandleSP handle, sideHandles()) {
        if (handle->chiefAssistant() != this) continue;
 
        *handle = transform.map(*handle);
    }
 
    uncache();
}

References KisPaintingAssistantHandle::chiefAssistant(), handles(), sideHandles(), transform(), and uncache().

◆ uncache()

void KisPaintingAssistant::uncache ( )

Definition at line 540 of file kis_painting_assistant.cc.

{
    d->s->cached = QPixmapCache::Key();
}

References d, and KisPaintingAssistant::Private::s.

◆ useCustomColor()

bool KisPaintingAssistant::useCustomColor ( )

Definition at line 220 of file kis_painting_assistant.cc.

{
    return d->s->useCustomColor;
}

References d, and KisPaintingAssistant::Private::s.

◆ viewportConstrainedEditorPosition()

QPointF KisPaintingAssistant::viewportConstrainedEditorPosition	(	const KisCoordinatesConverter *	converter,
		const QSize	editorSize )

Definition at line 464 of file kis_painting_assistant.cc.

{
    QPointF editorDocumentPos = getEditorPosition();
    QPointF editorWidgetPos = converter->documentToWidgetTransform().map(editorDocumentPos);
    QSizeF canvasSize = converter->getCanvasWidgetSize();
    const int padding = 16;
 
    editorWidgetPos.rx() = qBound(0.0,
                                  editorWidgetPos.x(),
                                  canvasSize.width() - (editorSize.width() + padding));
    editorWidgetPos.ry() = qBound(0.0,
                                  editorWidgetPos.y(),
                                  canvasSize.height() - (editorSize.height() + padding));
 
    return converter->widgetToDocument(editorWidgetPos);
}

References KisCoordinatesConverter::documentToWidgetTransform(), KisCoordinatesConverter::getCanvasWidgetSize(), getEditorPosition(), and KisCoordinatesConverter::widgetToDocument().

Member Data Documentation

◆ d

Private* const KisPaintingAssistant::d

private

Definition at line 312 of file kis_painting_assistant.h.

◆ m_handles

QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::m_handles

protected

Definition at line 260 of file kis_painting_assistant.h.

◆ m_hasBeenInsideLocalRect

bool KisPaintingAssistant::m_hasBeenInsideLocalRect {false}

protected

Definition at line 308 of file kis_painting_assistant.h.

308{false};

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

libs/ui/kis_painting_assistant.h
libs/ui/kis_painting_assistant.cc

Classes

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ KisPaintingAssistant() [1/2]

◆ ~KisPaintingAssistant()

◆ KisPaintingAssistant() [2/2]

Member Function Documentation

◆ addHandle()

◆ adjustLine()

◆ adjustPosition()

◆ areTwoPointsClose()

◆ assistantCustomColor()

◆ bottomLeft() [1/2]

◆ bottomLeft() [2/2]

◆ bottomMiddle() [1/2]

◆ bottomMiddle() [2/2]

◆ bottomRight() [1/2]

◆ bottomRight() [2/2]

◆ boundingRect()

◆ canBeLocal()

◆ clone()

◆ cloneAssistantList()

◆ closestCornerHandleFromPoint()

◆ copySharedData()

◆ drawAssistant()

◆ drawCache()

◆ drawError()

◆ drawPath()

◆ drawPreview()

◆ drawX()

◆ editorWidgetOffset()

◆ effectiveAssistantColor()

◆ effectiveBrushPosition()

◆ endStroke()

◆ findPerspectiveAssistantHandleLocation()

◆ firstLocalHandle()

◆ getDefaultEditorPosition()

◆ getEditorPosition()

◆ getLocalRect()

◆ handles() [1/2]

◆ handles() [2/2]

◆ id()

◆ initHandles()

◆ isAssistantComplete()

◆ isDuplicating()

◆ isLocal()

◆ isLocked()

◆ isSnappingActive()

◆ leftMiddle() [1/2]

◆ leftMiddle() [2/2]

◆ loadCustomXml()

◆ loadXml()

◆ name()

◆ norm2()

◆ numHandles()

◆ oppHandleOne()

◆ pixelToView()

◆ replaceHandle()

◆ rightMiddle() [1/2]

◆ rightMiddle() [2/2]

◆ saveCustomXml()

◆ saveXml()

◆ saveXmlList()

◆ secondLocalHandle()

◆ setAdjustedBrushPosition()

◆ setAssistantCustomColor()

◆ setAssistantGlobalColorCache()

◆ setDecorationThickness()

◆ setDuplicating()

◆ setEditorWidgetOffset()

◆ setFollowBrushPosition()

◆ setLocal()

◆ setLocked()

◆ setSnappingActive()

◆ setUseCustomColor()