#include <PerspectiveAssistant.h>

Inheritance diagram for PerspectiveAssistant:

Public Member Functions
void	adjustLine (QPointF &point, QPointF &strokeBegin) override

QPointF	adjustPosition (const QPointF &point, const QPointF &strokeBegin, const bool snapToAny, qreal moveThresholdPt) override

KisPaintingAssistantSP	clone (QMap< KisPaintingAssistantHandleSP, KisPaintingAssistantHandleSP > &handleMap) const override

bool	contains (const QPointF &point) const override

qreal	distance (const QPointF &point) const override

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

void	endStroke () override

QPointF	getDefaultEditorPosition () const override

bool	isActive () const override

bool	isAssistantComplete () const override

bool	loadCustomXml (QXmlStreamReader *xml) override

int	numHandles () const override

	PerspectiveAssistant (QObject *parent=0)

void	saveCustomXml (QXmlStreamWriter *xml) override

void	setSubdivisions (int subdivisions)

int	subdivisions () const

Public Member Functions inherited from KisAbstractPerspectiveGrid
	KisAbstractPerspectiveGrid (QObject *parent=0)

	~KisAbstractPerspectiveGrid () override

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

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

KisPaintingAssistantHandleSP	closestCornerHandleFromPoint (QPointF point)

void	copySharedData (KisPaintingAssistantSP assistant)

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

void	findPerspectiveAssistantHandleLocation ()

virtual QPointF	getEditorPosition () const

QList< KisPaintingAssistantHandleSP >	handles ()

const QList< KisPaintingAssistantHandleSP > &	handles () const

const QString &	id () 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

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

const QString &	name () const

KisPaintingAssistantHandleSP	oppHandleOne ()

void	replaceHandle (KisPaintingAssistantHandleSP _handle, KisPaintingAssistantHandleSP _with)

KisPaintingAssistantHandleSP	rightMiddle ()

const KisPaintingAssistantHandleSP	rightMiddle () const

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

Protected Member Functions
void	drawCache (QPainter &gc, const KisCoordinatesConverter *converter, bool assistantVisible=true) override
	performance layer where the graphics can be drawn from a cache instead of generated every render update

Protected Member Functions inherited from KisPaintingAssistant
virtual QRect	boundingRect () const

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)

Private Member Functions
bool	getTransform (QPolygonF &polyOut, QTransform &transformOut) const

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

QPointF	project (const QPointF &pt, const QPointF &strokeBegin, const bool snapToAnyDirection, qreal moveThresholdPt)

Private Attributes
PerspectiveBasedAssistantHelper::CacheData	m_cache

QPointF	m_cachedPoints [4]

QPolygonF	m_cachedPolygon

QTransform	m_cachedTransform

bool	m_cacheValid {false}

QLineF	m_snapLine

int	m_subdivisions {8}

Additional Inherited Members
Static Public Member Functions inherited from KisPaintingAssistant
static QList< KisPaintingAssistantSP >	cloneAssistantList (const QList< KisPaintingAssistantSP > &list)

static double	norm2 (const QPointF &p)

Protected Attributes inherited from KisPaintingAssistant
QList< KisPaintingAssistantHandleSP >	m_handles

bool	m_hasBeenInsideLocalRect {false}

Detailed Description

Definition at line 21 of file PerspectiveAssistant.h.

Constructor & Destructor Documentation

◆ PerspectiveAssistant() [1/2]

PerspectiveAssistant::PerspectiveAssistant ( QObject * parent = 0 )

Definition at line 29 of file PerspectiveAssistant.cc.

    : KisAbstractPerspectiveGrid(parent)
    , KisPaintingAssistant("perspective", i18n("Perspective assistant"))
{
}

◆ PerspectiveAssistant() [2/2]

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

explicitprivate

Definition at line 35 of file PerspectiveAssistant.cc.

    : KisAbstractPerspectiveGrid(rhs.parent())
    , KisPaintingAssistant(rhs, handleMap)
    , m_subdivisions(rhs.m_subdivisions)
    , m_snapLine(rhs.m_snapLine)
    , m_cachedTransform(rhs.m_cachedTransform)
    , m_cachedPolygon(rhs.m_cachedPolygon)
    , m_cacheValid(rhs.m_cacheValid)
    , m_cache(rhs.m_cache)
{
    for (int i = 0; i < 4; ++i) {
        m_cachedPoints[i] = rhs.m_cachedPoints[i];
    }
}

References m_cachedPoints.

Member Function Documentation

◆ adjustLine()

void PerspectiveAssistant::adjustLine	(	QPointF &	point,
		QPointF &	strokeBegin )

overridevirtual

Implements KisPaintingAssistant.

Definition at line 113 of file PerspectiveAssistant.cc.

{
    point = project(point, strokeBegin, true, 0.0);
}

References project().

◆ adjustPosition()

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

overridevirtual

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)

Implements KisPaintingAssistant.

Definition at line 108 of file PerspectiveAssistant.cc.

{
    return project(pt, strokeBegin, snapToAny, moveThresholdPt);
}

References project().

◆ clone()

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

overridevirtual

Implements KisPaintingAssistant.

Definition at line 50 of file PerspectiveAssistant.cc.

{
    return KisPaintingAssistantSP(new PerspectiveAssistant(*this, handleMap));
}

References PerspectiveAssistant().

◆ contains()

bool PerspectiveAssistant::contains ( const QPointF & point ) const

overridevirtual

Implements KisAbstractPerspectiveGrid.

Definition at line 124 of file PerspectiveAssistant.cc.

{
    QPolygonF poly;
    if (!PerspectiveBasedAssistantHelper::getTetragon(handles(), isAssistantComplete(), poly)) return false;
    return poly.containsPoint(pt, Qt::OddEvenFill);
}

References PerspectiveBasedAssistantHelper::getTetragon(), KisPaintingAssistant::handles(), and isAssistantComplete().

◆ distance()

qreal PerspectiveAssistant::distance ( const QPointF & pt ) const

overridevirtual

Returns the reciprocal of the distance from the given point to the 'observer', in the range [0, 1] where 0 = infinite distance and 1 = closest.

Implements KisAbstractPerspectiveGrid.

Definition at line 131 of file PerspectiveAssistant.cc.

{
    KIS_SAFE_ASSERT_RECOVER_NOOP(m_cacheValid);
    return PerspectiveBasedAssistantHelper::distanceInGrid(m_cache, pt);
}

References PerspectiveBasedAssistantHelper::distanceInGrid(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_cache, and m_cacheValid.

◆ drawAssistant()

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

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 142 of file PerspectiveAssistant.cc.

{
    gc.save();
    gc.resetTransform();
    QTransform initialTransform = converter->documentToWidgetTransform();
    //QTransform reverseTransform = converter->widgetToDocument();
    QPolygonF poly;
    QTransform transform; // unused, but computed for caching purposes
    if (getTransform(poly, transform) && assistantVisible==true) {
        // draw vanishing points
        if (m_cache.vanishingPoint1) {
            drawX(gc, initialTransform.map(m_cache.vanishingPoint1.get()));
        }
        if (m_cache.vanishingPoint2) {
            drawX(gc, initialTransform.map(m_cache.vanishingPoint2.get()));
        }
    }
 
    if (isSnappingActive() && getTransform(poly, transform) && previewVisible==true){
        //find vanishing point, find mouse, draw line between both.
        QPainterPath path2;
        QPointF intersection(0, 0);//this is the position of the vanishing point.
        QPointF mousePos = effectiveBrushPosition(converter, canvas);
        QLineF snapLine;
        QRect viewport= gc.viewport();
        QRect bounds;
 
        //figure out if point is in the perspective grid
        QPointF intersectTransformed(0, 0); // dummy for holding transformed intersection so the code is more readable.
 
        if (poly.containsPoint(initialTransform.inverted().map(mousePos), Qt::OddEvenFill)==true){
            // check if the lines aren't parallel to each other to avoid calculation errors in the intersection calculation (bug 345754)//
            if (fmod(QLineF(poly[0], poly[1]).angle(), 180.0)>=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)+2.0 || fmod(QLineF(poly[0], poly[1]).angle(), 180.0)<=fmod(QLineF(poly[2], poly[3]).angle(), 180.0)-2.0) {
                if (QLineF(poly[0], poly[1]).intersects(QLineF(poly[2], poly[3]), &intersection) != QLineF::NoIntersection) {
                    intersectTransformed = initialTransform.map(intersection);
                    snapLine = QLineF(intersectTransformed, mousePos);
                    KisAlgebra2D::intersectLineRect(snapLine, viewport, true);
                    bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
 
                    if (bounds.contains(intersectTransformed.toPoint())){
                        path2.moveTo(intersectTransformed);
                        path2.lineTo(snapLine.p2());
                    }
                    else {
                        path2.moveTo(snapLine.p1());
                        path2.lineTo(snapLine.p2());
                    }
                }
            }
            if (fmod(QLineF(poly[1], poly[2]).angle(), 180.0)>=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)+2.0 || fmod(QLineF(poly[1], poly[2]).angle(), 180.0)<=fmod(QLineF(poly[3], poly[0]).angle(), 180.0)-2.0){
                if (QLineF(poly[1], poly[2]).intersects(QLineF(poly[3], poly[0]), &intersection) != QLineF::NoIntersection) {
                    intersectTransformed = initialTransform.map(intersection);
                    snapLine = QLineF(intersectTransformed, mousePos);
                    KisAlgebra2D::intersectLineRect(snapLine, viewport, true);
                    bounds= QRect(snapLine.p1().toPoint(), snapLine.p2().toPoint());
                    QPainterPath path;
 
                    if (bounds.contains(intersectTransformed.toPoint())){
                        path2.moveTo(intersectTransformed);
                        path2.lineTo(snapLine.p2());
                    }
                    else {
                        path2.moveTo(snapLine.p1());
                        path2.lineTo(snapLine.p2());
                    }
                }
            }
            drawPreview(gc, path2);
        }
    }
 
 
 
    // draw the grid lines themselves
    gc.setTransform(converter->documentToWidgetTransform());
 
    if (assistantVisible) {
        // getTransform was checked before but what if the preview wasn't visible etc., and we need a return value here too
        if (!getTransform(poly, transform)) {
            // color red for an invalid transform, but not for an incomplete one
            if(isAssistantComplete()) {
                QPainterPath path;
                // that will create a triangle with a point inside connected to all vertices of the triangle
                path.addPolygon(PerspectiveBasedAssistantHelper::getAllConnectedTetragon(handles()));
                drawError(gc, path);
            } else {
                QPainterPath path;
                path.addPolygon(poly);
                drawPath(gc, path, isSnappingActive());
            }
        } else {
            gc.setPen(QColor(0, 0, 0, 125));
            gc.setTransform(transform, true);
            QPainterPath path;
            qreal step = 1.0 / subdivisions();
            
            for (int y = 0; y <= subdivisions(); ++y)
            {
                QLineF line = QLineF(QPointF(0.0, y * step), QPointF(1.0, y * step));
                KisAlgebra2D::cropLineToRect(line, gc.window(), false, false);
                path.moveTo(line.p1());
                path.lineTo(line.p2());
            }
            for (int x = 0; x <= subdivisions(); ++x)
            {
                QLineF line = QLineF(QPointF(x * step, 0.0), QPointF(x * step, 1.0));
                KisAlgebra2D::cropLineToRect(line, gc.window(), false, false);
                path.moveTo(line.p1());
                path.lineTo(line.p2());
            }
 
            drawPath(gc, path, isSnappingActive());
        }
    }
    //
 
 
    gc.restore();
 
    KisPaintingAssistant::drawAssistant(gc, updateRect, converter, cached,canvas, assistantVisible, previewVisible);
}

◆ drawCache()

void PerspectiveAssistant::drawCache	(	QPainter &	gc,
		const KisCoordinatesConverter *	converter,
		bool	assistantVisible = true )

overrideprotectedvirtual

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

Implements KisPaintingAssistant.

Definition at line 264 of file PerspectiveAssistant.cc.

{
    Q_UNUSED(gc);
    Q_UNUSED(converter);
    Q_UNUSED(assistantVisible);
}

◆ endStroke()

void PerspectiveAssistant::endStroke ( )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 118 of file PerspectiveAssistant.cc.

{
    m_snapLine = QLineF();
    KisPaintingAssistant::endStroke();
}

References KisPaintingAssistant::endStroke(), and m_snapLine.

◆ getDefaultEditorPosition()

QPointF PerspectiveAssistant::getDefaultEditorPosition ( ) const

overridevirtual

Implements KisPaintingAssistant.

Definition at line 271 of file PerspectiveAssistant.cc.

{
    QPointF centroid(0, 0);
    for (int i = 0; i < 4; ++i) {
        centroid += *handles()[i];
    }
 
    return centroid * 0.25;
}

References KisPaintingAssistant::handles().

◆ getTransform()

bool PerspectiveAssistant::getTransform	(	QPolygonF &	polyOut,
		QTransform &	transformOut ) const

private

Definition at line 281 of file PerspectiveAssistant.cc.

{
    if (m_cachedPolygon.size() != 0 && isAssistantComplete()) {
        for (int i = 0; i <= 4; ++i) {
            if (i == 4) {
                poly = m_cachedPolygon;
                transform = m_cachedTransform;
                return m_cacheValid;
            }
            if (m_cachedPoints[i] != *handles()[i]) break;
        }
    }
 
    m_cachedPolygon.clear();
    m_cacheValid = false;
 
    if (!PerspectiveBasedAssistantHelper::getTetragon(handles(), isAssistantComplete(), poly)) {
        m_cachedPolygon = poly;
        return false;
    }
 
    if (!QTransform::squareToQuad(poly, transform)) {
        qWarning("Failed to create perspective mapping");
        return false;
    }
 
    for (int i = 0; i < 4; ++i) {
        m_cachedPoints[i] = *handles()[i];
    }
 
    m_cachedPolygon = poly;
    m_cachedTransform = transform;
    PerspectiveBasedAssistantHelper::updateCacheData(m_cache, poly);
    m_cacheValid = true;
    return true;
}

References PerspectiveBasedAssistantHelper::getTetragon(), KisPaintingAssistant::handles(), isAssistantComplete(), m_cache, m_cachedPoints, m_cachedPolygon, m_cachedTransform, m_cacheValid, KisPaintingAssistant::transform(), and PerspectiveBasedAssistantHelper::updateCacheData().

◆ isActive()

bool PerspectiveAssistant::isActive ( ) const

overridevirtual

Implements KisAbstractPerspectiveGrid.

Definition at line 137 of file PerspectiveAssistant.cc.

{
    return isSnappingActive();
}

References KisPaintingAssistant::isSnappingActive().

◆ isAssistantComplete()

bool PerspectiveAssistant::isAssistantComplete ( ) const

overridevirtual

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 from KisPaintingAssistant.

Definition at line 318 of file PerspectiveAssistant.cc.

{
    return handles().size() >= 4; // specify 4 corners to make assistant complete
}

References KisPaintingAssistant::handles().

◆ loadCustomXml()

bool PerspectiveAssistant::loadCustomXml ( QXmlStreamReader * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 340 of file PerspectiveAssistant.cc.

                                                              {
    if (xml && xml->name() == "subdivisions") {
        setSubdivisions(KisDomUtils::toInt(xml->attributes().value("value").toString()));
    }
    return true;
}

References setSubdivisions(), and KisDomUtils::toInt().

◆ numHandles()

int PerspectiveAssistant::numHandles ( ) const

inlineoverridevirtual

Implements KisPaintingAssistant.

Definition at line 33 of file PerspectiveAssistant.h.

33{ return 4; }

◆ project()

QPointF PerspectiveAssistant::project	(	const QPointF &	pt,
		const QPointF &	strokeBegin,
		const bool	snapToAnyDirection,
		qreal	moveThresholdPt )

private

Definition at line 55 of file PerspectiveAssistant.cc.

{
    const static QPointF nullPoint(std::numeric_limits<qreal>::quiet_NaN(), std::numeric_limits<qreal>::quiet_NaN());
 
    Q_ASSERT(isAssistantComplete());
 
    if (snapToAnyDirection || m_snapLine.isNull()) {
        QPolygonF poly;
        QTransform transform;
 
        if (!getTransform(poly, transform)) {
            return nullPoint;
        }
 
        if (!poly.containsPoint(strokeBegin, Qt::OddEvenFill)) {
            return nullPoint; // avoid problems with multiple assistants: only snap if starting in the grid
        }
 
        if (KisAlgebra2D::norm(pt - strokeBegin) < moveThresholdPt) {
            return strokeBegin; // allow some movement before snapping
        }
 
        // construct transformation
        bool invertible;
        const QTransform inverse = transform.inverted(&invertible);
        if (!invertible) {
            return nullPoint; // shouldn't happen
        }
 
 
        // figure out which direction to go
        const QPointF start = inverse.map(strokeBegin);
        const QLineF verticalLine = QLineF(strokeBegin, transform.map(start + QPointF(0, 1)));
        const QLineF horizontalLine = QLineF(strokeBegin, transform.map(start + QPointF(1, 0)));
 
        // determine whether the horizontal or vertical line is closer to the point
        m_snapLine = KisAlgebra2D::pointToLineDistSquared(pt, verticalLine) < KisAlgebra2D::pointToLineDistSquared(pt, horizontalLine) ? verticalLine : horizontalLine;
    }
 
    // snap to line
    const qreal
            dx = m_snapLine.dx(),
            dy = m_snapLine.dy(),
            dx2 = dx * dx,
            dy2 = dy * dy,
            invsqrlen = 1.0 / (dx2 + dy2);
    QPointF r(dx2 * pt.x() + dy2 * m_snapLine.x1() + dx * dy * (pt.y() - m_snapLine.y1()),
              dx2 * m_snapLine.y1() + dy2 * pt.y() + dx * dy * (pt.x() - m_snapLine.x1()));
 
    r *= invsqrlen;
    return r;
}

References getTransform(), isAssistantComplete(), m_snapLine, KisAlgebra2D::norm(), KisAlgebra2D::pointToLineDistSquared(), and KisPaintingAssistant::transform().

◆ saveCustomXml()

void PerspectiveAssistant::saveCustomXml ( QXmlStreamWriter * xml )

overridevirtual

Reimplemented from KisPaintingAssistant.

Definition at line 332 of file PerspectiveAssistant.cc.

                                                              {
    if (xml) {
        xml->writeStartElement("subdivisions");
        xml->writeAttribute("value", KisDomUtils::toString(subdivisions()));
        xml->writeEndElement();
    }
}

References subdivisions(), and KisDomUtils::toString().

◆ setSubdivisions()

void PerspectiveAssistant::setSubdivisions ( int subdivisions )

Definition at line 327 of file PerspectiveAssistant.cc.

                                                           {
    if (subdivisions < 1) m_subdivisions = 1;
    else m_subdivisions = subdivisions;
}

References m_subdivisions, and subdivisions().

◆ subdivisions()

int PerspectiveAssistant::subdivisions ( ) const

Definition at line 323 of file PerspectiveAssistant.cc.

                                             {
    return m_subdivisions;
}

References m_subdivisions.

Member Data Documentation

◆ m_cache

PerspectiveBasedAssistantHelper::CacheData PerspectiveAssistant::m_cache

mutableprivate

Definition at line 67 of file PerspectiveAssistant.h.

◆ m_cachedPoints

QPointF PerspectiveAssistant::m_cachedPoints[4]

mutableprivate

Definition at line 64 of file PerspectiveAssistant.h.

◆ m_cachedPolygon

QPolygonF PerspectiveAssistant::m_cachedPolygon

mutableprivate

Definition at line 63 of file PerspectiveAssistant.h.

◆ m_cachedTransform

QTransform PerspectiveAssistant::m_cachedTransform

mutableprivate

Definition at line 62 of file PerspectiveAssistant.h.

◆ m_cacheValid

bool PerspectiveAssistant::m_cacheValid {false}

mutableprivate

Definition at line 65 of file PerspectiveAssistant.h.

65{false};

◆ m_snapLine

QLineF PerspectiveAssistant::m_snapLine

private

Definition at line 60 of file PerspectiveAssistant.h.

◆ m_subdivisions

int PerspectiveAssistant::m_subdivisions {8}

private

Definition at line 58 of file PerspectiveAssistant.h.

58{8};

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

plugins/assistants/Assistants/PerspectiveAssistant.h
plugins/assistants/Assistants/PerspectiveAssistant.cc

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PerspectiveAssistant() [1/2]

◆ PerspectiveAssistant() [2/2]

Member Function Documentation

◆ adjustLine()

◆ adjustPosition()

◆ clone()

◆ contains()

◆ distance()

◆ drawAssistant()

◆ drawCache()

◆ endStroke()

◆ getDefaultEditorPosition()

◆ getTransform()

◆ isActive()

◆ isAssistantComplete()

◆ loadCustomXml()

◆ numHandles()

◆ project()

◆ saveCustomXml()

◆ setSubdivisions()

◆ subdivisions()

Member Data Documentation

◆ m_cache

◆ m_cachedPoints

◆ m_cachedPolygon

◆ m_cachedTransform

◆ m_cacheValid

◆ m_snapLine

◆ m_subdivisions