#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, bool cached, KisCanvas2 canvas=0, bool assistantVisible=true, bool previewVisible=true)

void	drawError (QPainter &painter, const QPainterPath &path)

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

void	drawPreview (QPainter &painter, const QPainterPath &path)

void	drawX (QPainter &painter, const QPointF &pt)

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, 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 90 of file kis_painting_assistant.h.

Constructor & Destructor Documentation

◆ KisPaintingAssistant() [1/2]

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

Definition at line 249 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 417 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 257 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 449 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 1039 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 234 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 947 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 952 of file kis_painting_assistant.cc.

{
    return d->bottomLeft;
}

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

◆ bottomMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::bottomMiddle ( )

Definition at line 987 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 992 of file kis_painting_assistant.cc.

{
    return d->bottomMiddle;
}

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

◆ bottomRight() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::bottomRight ( )

Definition at line 967 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 972 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 543 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 316 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 1126 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 1047 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 188 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,
		bool	cached,
		KisCanvas2 *	canvas = 0,
		bool	assistantVisible = true,
		bool	previewVisible = true )

virtual

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

Definition at line 479 of file kis_painting_assistant.cc.

{
    Q_UNUSED(updateRect);
 
    Q_UNUSED(previewVisible);
 
    findPerspectiveAssistantHandleLocation();
 
    if (!useCache) {
        gc.save();
        drawCache(gc, converter, 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, 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,
		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 )

Definition at line 390 of file kis_painting_assistant.cc.

{
    painter.save();
    QPen pen_a(QColor(255, 0, 0, 125), d->errorLineWidth * d->decorationThickness);
    pen_a.setCosmetic(true);
    painter.setPen(pen_a);
    painter.drawPath(path);
    painter.restore();
}

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

◆ drawPath()

void KisPaintingAssistant::drawPath	(	QPainter &	painter,
		const QPainterPath &	path,
		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 362 of file kis_painting_assistant.cc.

{
 
    QColor paintingColor = effectiveAssistantColor();
 
    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 d, KisPaintingAssistant::Private::decorationThickness, effectiveAssistantColor(), and KisPaintingAssistant::Private::mainLineWidth.

◆ drawPreview()

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

Definition at line 379 of file kis_painting_assistant.cc.

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

References d, effectiveAssistantColor(), and KisPaintingAssistant::Private::previewLineWidth.

◆ drawX()

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

Definition at line 400 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);
}

References drawPath().

◆ editorWidgetOffset()

QPointF KisPaintingAssistant::editorWidgetOffset ( )

Definition at line 351 of file kis_painting_assistant.cc.

{
    return d->s->editorWidgetOffset;
}

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

◆ effectiveAssistantColor()

QColor KisPaintingAssistant::effectiveAssistantColor ( ) const

Definition at line 244 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 1073 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 293 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 797 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 1090 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 311 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 1100 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 1022 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 1017 of file kis_painting_assistant.cc.

{
    return d->handles;
}

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

◆ id()

const QString & KisPaintingAssistant::id ( ) const

Definition at line 430 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 408 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 552 of file kis_painting_assistant.cc.

{
    return true;
}

◆ isDuplicating()

bool KisPaintingAssistant::isDuplicating ( )

isDuplicating

Returns: If the duplication button is pressed

Definition at line 346 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 321 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 331 of file kis_painting_assistant.cc.

{
    return d->s->isLocked;
}

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

◆ isSnappingActive()

bool KisPaintingAssistant::isSnappingActive ( ) const

Definition at line 283 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 1007 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 1012 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 715 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 631 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 435 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 1116 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 918 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 1067 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 440 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 997 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 1002 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 626 of file kis_painting_assistant.cc.

{
    Q_UNUSED(xml);
}

◆ saveXml()

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

Definition at line 574 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 721 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 1095 of file kis_painting_assistant.cc.

{
    return 0;
}

◆ setAdjustedBrushPosition()

void KisPaintingAssistant::setAdjustedBrushPosition ( const QPointF position )

virtual

Definition at line 300 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 229 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 239 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 1121 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 341 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 356 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 306 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 326 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 336 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 288 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 224 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 1032 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 1027 of file kis_painting_assistant.cc.

{
    return d->sideHandles;
}

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

◆ topLeft() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topLeft ( )

Definition at line 937 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 942 of file kis_painting_assistant.cc.

{
    return d->topLeft;
}

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

◆ topMiddle() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topMiddle ( )

Definition at line 977 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 982 of file kis_painting_assistant.cc.

{
    return d->topMiddle;
}

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

◆ topRight() [1/2]

KisPaintingAssistantHandleSP KisPaintingAssistant::topRight ( )

Definition at line 957 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 962 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 557 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 538 of file kis_painting_assistant.cc.

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

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

◆ useCustomColor()

bool KisPaintingAssistant::useCustomColor ( )

Definition at line 219 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 462 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 311 of file kis_painting_assistant.h.

◆ m_handles

QList<KisPaintingAssistantHandleSP> KisPaintingAssistant::m_handles

protected

Definition at line 259 of file kis_painting_assistant.h.

◆ m_hasBeenInsideLocalRect

bool KisPaintingAssistant::m_hasBeenInsideLocalRect {false}

protected

Definition at line 307 of file kis_painting_assistant.h.

307{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()