KisWarpTransformStrategy Class Reference

#include <kis_warp_transform_strategy.h>

Inheritance diagram for KisWarpTransformStrategy:

Classes
struct	Private

Signals
void	requestCanvasUpdate ()
void	requestImageRecalculation ()

Public Member Functions
bool	acceptsClicks () const override
bool	beginPrimaryAction (const QPointF &pt) override
virtual bool	beginPrimaryAction (KoPointerEvent *event)=0
void	continuePrimaryAction (const QPointF &pt, bool shiftModifierActive, bool altModifierActive) override
virtual void	continuePrimaryAction (KoPointerEvent *event)=0
bool	endPrimaryAction () override
virtual bool	endPrimaryAction (KoPointerEvent *event)=0
void	externalConfigChanged () override
QCursor	getCurrentCursor () const override
	KisWarpTransformStrategy (const KisCoordinatesConverter *converter, KoSnapGuide *snapGuide, ToolTransformArgs &currentArgs, TransformTransactionProperties &transaction)
void	paint (QPainter &gc) override
void	setTransformFunction (const QPointF &mousePos, bool perspectiveModifierActive, bool shiftModifierActive, bool altModifierActive) override
void	setTransformType (TransformType type)
	~KisWarpTransformStrategy () override
Public Member Functions inherited from KisSimplifiedActionPolicyStrategy
void	activateAlternateAction (KisTool::AlternateAction action) override
void	activatePrimaryAction () override
bool	beginAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
void	continueAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
void	deactivateAlternateAction (KisTool::AlternateAction action) override
bool	endAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
virtual QPointF	handleSnapPoint (const QPointF &imagePos)
void	hoverActionCommon (KoPointerEvent *event) override
	KisSimplifiedActionPolicyStrategy (const KisCoordinatesConverter *_converter, KoSnapGuide *snapGuide=0)
	~KisSimplifiedActionPolicyStrategy () override
Public Member Functions inherited from KisTransformStrategyBase
virtual void	deactivatePrimaryAction ()
virtual int	decorationThickness () const
virtual QPainterPath	getCursorOutline () const
	KisTransformStrategyBase ()
QImage	originalImage () const
virtual void	setDecorationThickness (int thickness)
void	setThumbnailImage (const QImage &image, QTransform thumbToImageTransform)
QTransform	thumbToImageTransform () const
	~KisTransformStrategyBase () override

Protected Member Functions
virtual QImage	calculateTransformedImage (ToolTransformArgs &currentArgs, const QImage &srcImage, const QVector< QPointF > &origPoints, const QVector< QPointF > &transfPoints, const QPointF &srcOffset, QPointF *dstOffset)
virtual void	drawConnectionLines (QPainter &gc, const QVector< QPointF > &origPoints, const QVector< QPointF > &transfPoints, bool isEditingPoints)
void	overrideDrawingItems (bool drawConnectionLines, bool drawOrigPoints, bool drawTransfPoints)
void	setClipOriginalPointsPosition (bool value)
void	setCloseOnStartPointClick (bool value)
Protected Member Functions inherited from KisSimplifiedActionPolicyStrategy
virtual void	hoverActionCommon (const QPointF &pt)
virtual bool	shiftModifierIsUsed () const

Private Member Functions
	Q_PRIVATE_SLOT (m_d, void recalculateTransformations())

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Definition at line 29 of file kis_warp_transform_strategy.h.

Constructor & Destructor Documentation

KisWarpTransformStrategy()

KisWarpTransformStrategy::KisWarpTransformStrategy	(	const KisCoordinatesConverter *	converter,
		KoSnapGuide *	snapGuide,
		ToolTransformArgs &	currentArgs,
		TransformTransactionProperties &	transaction )

Definition at line 97 of file kis_warp_transform_strategy.cpp.

    : KisSimplifiedActionPolicyStrategy(converter, snapGuide),
      m_d(new Private(this, converter, currentArgs, transaction))
{
    connect(&m_d->recalculateSignalCompressor, SIGNAL(timeout()),
            SLOT(recalculateTransformations()));
}

References connect(), and m_d.

~KisWarpTransformStrategy()

KisWarpTransformStrategy::~KisWarpTransformStrategy ( )

override

Definition at line 108 of file kis_warp_transform_strategy.cpp.

{
}

Member Function Documentation

acceptsClicks()

bool KisWarpTransformStrategy::acceptsClicks ( ) const

overridevirtual

Reimplemented from KisTransformStrategyBase.

Definition at line 557 of file kis_warp_transform_strategy.cpp.

{
    return m_d->shouldCloseTheCage() ||
        m_d->currentArgs.isEditingTransformPoints();
}

References m_d.

beginPrimaryAction() [1/2]

bool KisWarpTransformStrategy::beginPrimaryAction ( const QPointF & pt )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 373 of file kis_warp_transform_strategy.cpp.

{
    const bool isEditingPoints = m_d->currentArgs.isEditingTransformPoints();
    bool retval = false;
 
    if (m_d->mode == Private::OVER_POINT ||
        m_d->mode == Private::MULTIPLE_POINT_SELECTION ||
        m_d->mode == Private::MOVE_MODE ||
        m_d->mode == Private::ROTATE_MODE ||
        m_d->mode == Private::SCALE_MODE) {
 
        retval = true;
 
    } else if (isEditingPoints) {
        QPointF newPos = m_d->clipOriginalPointsPosition ?
            KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
            pt;
 
        m_d->currentArgs.refOriginalPoints().append(newPos);
        m_d->currentArgs.refTransformedPoints().append(newPos);
 
        m_d->mode = Private::OVER_POINT;
        m_d->pointIndexUnderCursor = m_d->currentArgs.origPoints().size() - 1;
 
        m_d->recalculateSignalCompressor.start();
 
        retval = true;
    }
 
    if (m_d->mode == Private::OVER_POINT) {
        m_d->pointPosOnClick =
            m_d->currentArgs.transfPoints()[m_d->pointIndexUnderCursor];
        m_d->pointWasDragged = false;
 
        m_d->pointsInAction.clear();
        m_d->pointsInAction << m_d->pointIndexUnderCursor;
        m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
    } else if (m_d->mode == Private::MULTIPLE_POINT_SELECTION) {
        QVector<int>::iterator it =
            std::find(m_d->pointsInAction.begin(),
                      m_d->pointsInAction.end(),
                      m_d->pointIndexUnderCursor);
 
        if (it != m_d->pointsInAction.end()) {
            m_d->pointsInAction.erase(it);
        } else {
            m_d->pointsInAction << m_d->pointIndexUnderCursor;
        }
 
        m_d->lastNumPoints = m_d->currentArgs.transfPoints().size();
    }
 
    m_d->lastMousePos = pt;
    return retval;
}

References KisTransformUtils::clipInRect(), m_d, KisWarpTransformStrategy::Private::MOVE_MODE, KisWarpTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisWarpTransformStrategy::Private::OVER_POINT, KisWarpTransformStrategy::Private::ROTATE_MODE, and KisWarpTransformStrategy::Private::SCALE_MODE.

beginPrimaryAction() [2/2]

virtual bool KisTransformStrategyBase::beginPrimaryAction ( KoPointerEvent * event )

virtual

Reimplemented from KisSimplifiedActionPolicyStrategy.

calculateTransformedImage()

QImage KisWarpTransformStrategy::calculateTransformedImage ( ToolTransformArgs & currentArgs, const QImage & srcImage, const QVector< QPointF > & origPoints, const QVector< QPointF > & transfPoints, const QPointF & srcOffset, QPointF * dstOffset )

protectedvirtual

Reimplemented in KisCageTransformStrategy.

Definition at line 625 of file kis_warp_transform_strategy.cpp.

{
    return KisWarpTransformWorker::transformQImage(
        currentArgs.warpType(),
        origPoints, transfPoints,
        currentArgs.alpha(),
        srcImage,
        srcOffset, dstOffset);
}

References ToolTransformArgs::alpha(), KisWarpTransformWorker::transformQImage(), and ToolTransformArgs::warpType().

continuePrimaryAction() [1/2]

void KisWarpTransformStrategy::continuePrimaryAction ( const QPointF & pt, bool shiftModifierActive, bool altModifierActive )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 453 of file kis_warp_transform_strategy.cpp.

{
    Q_UNUSED(shiftModifierActive);
    Q_UNUSED(altModifierActive);
 
    // toplevel code switches to HOVER mode if nothing is selected
    KIS_ASSERT_RECOVER_RETURN(m_d->mode == Private::MOVE_MODE ||
                              m_d->mode == Private::ROTATE_MODE ||
                              m_d->mode == Private::SCALE_MODE ||
                              (m_d->mode == Private::OVER_POINT &&
                               m_d->pointIndexUnderCursor >= 0 &&
                               m_d->pointsInAction.size() == 1) ||
                              (m_d->mode == Private::MULTIPLE_POINT_SELECTION &&
                               m_d->pointIndexUnderCursor >= 0));
 
    if (m_d->mode == Private::OVER_POINT) {
        if (m_d->currentArgs.isEditingTransformPoints()) {
            QPointF newPos = m_d->clipOriginalPointsPosition ?
                KisTransformUtils::clipInRect(pt, m_d->transaction.originalRect()) :
                pt;
            m_d->currentArgs.origPoint(m_d->pointIndexUnderCursor) = newPos;
            m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = newPos;
        } else {
            m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor) = pt;
        }
 
 
        const qreal handleRadiusSq = pow2(KisTransformUtils::effectiveHandleGrabRadius(m_d->converter));
        qreal dist =
            kisSquareDistance(
                m_d->currentArgs.transfPoint(m_d->pointIndexUnderCursor),
                m_d->pointPosOnClick);
 
        if (dist > handleRadiusSq) {
            m_d->pointWasDragged = true;
        }
    } else if (m_d->mode == Private::MOVE_MODE) {
        QPointF center;
        QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
        QPointF diff = pt - m_d->lastMousePos;
 
        QVector<QPointF*>::iterator it = selectedPoints.begin();
        QVector<QPointF*>::iterator end = selectedPoints.end();
        for (; it != end; ++it) {
            **it += diff;
        }
    } else if (m_d->mode == Private::ROTATE_MODE) {
        QPointF center;
        QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
        QPointF oldDirection = m_d->lastMousePos - center;
        QPointF newDirection = pt - center;
 
        qreal rotateAngle = KisAlgebra2D::angleBetweenVectors(oldDirection, newDirection);
        QTransform R;
        R.rotateRadians(rotateAngle);
 
        QTransform t =
            QTransform::fromTranslate(-center.x(), -center.y()) *
            R *
            QTransform::fromTranslate(center.x(), center.y());
 
        QVector<QPointF*>::iterator it = selectedPoints.begin();
        QVector<QPointF*>::iterator end = selectedPoints.end();
        for (; it != end; ++it) {
            **it = t.map(**it);
        }
    } else if (m_d->mode == Private::SCALE_MODE) {
        QPointF center;
        QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center);
 
        QPolygonF polygon(m_d->currentArgs.origPoints());
        QSizeF maxSize = polygon.boundingRect().size();
        qreal maxDimension = qMax(maxSize.width(), maxSize.height());
 
        qreal scale = 1.0 - (pt - m_d->lastMousePos).y() / maxDimension;
 
        QTransform t =
            QTransform::fromTranslate(-center.x(), -center.y()) *
            QTransform::fromScale(scale, scale) *
            QTransform::fromTranslate(center.x(), center.y());
 
        QVector<QPointF*>::iterator it = selectedPoints.begin();
        QVector<QPointF*>::iterator end = selectedPoints.end();
        for (; it != end; ++it) {
            **it = t.map(**it);
        }
    }
 
    m_d->lastMousePos = pt;
    m_d->recalculateSignalCompressor.start();
 
}

References KisAlgebra2D::angleBetweenVectors(), KisTransformUtils::clipInRect(), KisTransformUtils::effectiveHandleGrabRadius(), KIS_ASSERT_RECOVER_RETURN, kisSquareDistance(), m_d, KisWarpTransformStrategy::Private::MOVE_MODE, KisWarpTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisWarpTransformStrategy::Private::OVER_POINT, pow2(), R, KisWarpTransformStrategy::Private::ROTATE_MODE, and KisWarpTransformStrategy::Private::SCALE_MODE.

continuePrimaryAction() [2/2]

virtual void KisTransformStrategyBase::continuePrimaryAction ( KoPointerEvent * event )

virtual

Reimplemented from KisSimplifiedActionPolicyStrategy.

drawConnectionLines()

void KisWarpTransformStrategy::drawConnectionLines ( QPainter & gc, const QVector< QPointF > & origPoints, const QVector< QPointF > & transfPoints, bool isEditingPoints )

protectedvirtual

Reimplemented in KisCageTransformStrategy.

Definition at line 202 of file kis_warp_transform_strategy.cpp.

{
    Q_UNUSED(isEditingPoints);
 
    QPen antsPen;
    QPen outlinePen;
 
    KisPaintingTweaks::initAntsPen(&antsPen, &outlinePen);
    antsPen.setWidth(decorationThickness());
    outlinePen.setWidth(decorationThickness());
 
    const int numPoints = origPoints.size();
 
    for (int i = 0; i < numPoints; ++i) {
        gc.setPen(outlinePen);
        gc.drawLine(transfPoints[i], origPoints[i]);
        gc.setPen(antsPen);
        gc.drawLine(transfPoints[i], origPoints[i]);
    }
}

References KisTransformStrategyBase::decorationThickness(), and KisPaintingTweaks::initAntsPen().

endPrimaryAction() [1/2]

bool KisWarpTransformStrategy::endPrimaryAction ( )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 563 of file kis_warp_transform_strategy.cpp.

{
    if (m_d->shouldCloseTheCage()) {
        m_d->currentArgs.setEditingTransformPoints(false);
    }
 
    return true;
}

References m_d.

endPrimaryAction() [2/2]

virtual bool KisTransformStrategyBase::endPrimaryAction ( KoPointerEvent * event )

virtual

Reimplemented from KisSimplifiedActionPolicyStrategy.

externalConfigChanged()

void KisWarpTransformStrategy::externalConfigChanged ( )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 364 of file kis_warp_transform_strategy.cpp.

{
    if (m_d->lastNumPoints != m_d->currentArgs.transfPoints().size()) {
        m_d->pointsInAction.clear();
    }
 
    m_d->recalculateTransformations();
}

References m_d.

getCurrentCursor()

QCursor KisWarpTransformStrategy::getCurrentCursor ( ) const

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 151 of file kis_warp_transform_strategy.cpp.

{
    QCursor cursor;
 
    switch (m_d->mode) {
    case Private::OVER_POINT:
        cursor = KisCursor::pointingHandCursor();
        break;
    case Private::MULTIPLE_POINT_SELECTION:
        cursor = KisCursor::crossCursor();
        break;
    case Private::MOVE_MODE:
        cursor = KisCursor::moveCursor();
        break;
    case Private::ROTATE_MODE:
        cursor = KisCursor::rotateCursor();
        break;
    case Private::SCALE_MODE:
        cursor = KisCursor::sizeVerCursor();
        break;
    case Private::NOTHING:
        cursor = KisCursor::arrowCursor();
        break;
    }
 
    return cursor;
}

References KisCursor::arrowCursor(), KisCursor::crossCursor(), m_d, KisWarpTransformStrategy::Private::MOVE_MODE, KisCursor::moveCursor(), KisWarpTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisWarpTransformStrategy::Private::NOTHING, KisWarpTransformStrategy::Private::OVER_POINT, KisCursor::pointingHandCursor(), KisWarpTransformStrategy::Private::ROTATE_MODE, KisCursor::rotateCursor(), KisWarpTransformStrategy::Private::SCALE_MODE, and KisCursor::sizeVerCursor().

overrideDrawingItems()

void KisWarpTransformStrategy::overrideDrawingItems ( bool drawConnectionLines, bool drawOrigPoints, bool drawTransfPoints )

protected

Definition at line 179 of file kis_warp_transform_strategy.cpp.

{
    m_d->drawConnectionLines = drawConnectionLines;
    m_d->drawOrigPoints = drawOrigPoints;
    m_d->drawTransfPoints = drawTransfPoints;
}

References drawConnectionLines(), and m_d.

paint()

void KisWarpTransformStrategy::paint ( QPainter & gc )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 226 of file kis_warp_transform_strategy.cpp.

{
    // Draw preview image
 
    gc.save();
 
    gc.setOpacity(m_d->transaction.basePreviewOpacity());
    gc.setTransform(m_d->paintingTransform, true);
    gc.drawImage(m_d->paintingOffset, m_d->transformedImage);
 
    gc.restore();
 
 
    gc.save();
    gc.setTransform(m_d->handlesTransform, true);
 
    if (m_d->drawConnectionLines) {
        gc.setOpacity(0.5);
 
        drawConnectionLines(gc,
                            m_d->currentArgs.origPoints(),
                            m_d->currentArgs.transfPoints(),
                            m_d->currentArgs.isEditingTransformPoints());
    }
 
 
    QPen mainPen(Qt::black);
    mainPen.setCosmetic(true);
    mainPen.setWidth(decorationThickness());
    QPen outlinePen(Qt::white);
    outlinePen.setCosmetic(true);
    outlinePen.setWidth(decorationThickness());
 
    // draw handles
    {
        const int numPoints = m_d->currentArgs.origPoints().size();
 
 
 
        qreal handlesExtraScale = KisTransformUtils::scaleFromAffineMatrix(m_d->handlesTransform);
 
        qreal dstIn = 8 / handlesExtraScale;
        qreal dstOut = 10 / handlesExtraScale;
        qreal srcIn = 6 / handlesExtraScale;
        qreal srcOut = 6 / handlesExtraScale;
 
        QRectF handleRect1(-0.5 * dstIn, -0.5 * dstIn, dstIn, dstIn);
        QRectF handleRect2(-0.5 * dstOut, -0.5 * dstOut, dstOut, dstOut);
 
        if (m_d->drawTransfPoints) {
            gc.setOpacity(1.0);
 
            for (int i = 0; i < numPoints; ++i) {
                gc.setPen(outlinePen);
                gc.drawEllipse(handleRect2.translated(m_d->currentArgs.transfPoints()[i]));
                gc.setPen(mainPen);
                gc.drawEllipse(handleRect1.translated(m_d->currentArgs.transfPoints()[i]));
            }
 
            QPointF center;
            QVector<QPointF*> selectedPoints = m_d->getSelectedPoints(&center, true);
 
            QBrush selectionBrush = selectedPoints.size() > 1 ? Qt::red : Qt::black;
 
            QBrush oldBrush = gc.brush();
            gc.setBrush(selectionBrush);
            Q_FOREACH (const QPointF *pt, selectedPoints) {
                gc.drawEllipse(handleRect1.translated(*pt));
            }
            gc.setBrush(oldBrush);
 
        }
 
        if (m_d->drawOrigPoints) {
            QPainterPath inLine;
            inLine.moveTo(-0.5 * srcIn,            0);
            inLine.lineTo( 0.5 * srcIn,            0);
            inLine.moveTo(           0, -0.5 * srcIn);
            inLine.lineTo(           0,  0.5 * srcIn);
 
            QPainterPath outLine;
            outLine.moveTo(-0.5 * srcOut, -0.5 * srcOut);
            outLine.lineTo( 0.5 * srcOut, -0.5 * srcOut);
            outLine.lineTo( 0.5 * srcOut,  0.5 * srcOut);
            outLine.lineTo(-0.5 * srcOut,  0.5 * srcOut);
            outLine.lineTo(-0.5 * srcOut, -0.5 * srcOut);
 
            gc.setOpacity(0.5);
 
            for (int i = 0; i < numPoints; ++i) {
                gc.setPen(outlinePen);
                gc.drawPath(outLine.translated(m_d->currentArgs.origPoints()[i]));
                gc.setPen(mainPen);
                gc.drawPath(inLine.translated(m_d->currentArgs.origPoints()[i]));
            }
        }
 
    }
 
    // draw grid lines only if we are using the GRID mode. Also only use this logic for warp, not cage transforms
    if (m_d->currentArgs.warpCalculation() == KisWarpTransformWorker::WarpCalculation::GRID &&
        m_d->transformType == TransformType::WARP_TRANSFORM ) {
 
    // see how many rows we have. we are only going to do lines up to 6 divisions/
    // it is almost impossible to use with 6 even.
    const int numPoints = m_d->currentArgs.origPoints().size();
 
    // grid is always square, so get the square root to find # of rows
    int rowsInWarp = sqrt(m_d->currentArgs.origPoints().size());
 
 
        KisHandlePainterHelper handlePainter(&gc, 0.0, decorationThickness());
        handlePainter.setHandleStyle(KisHandleStyle::primarySelection());
 
        // draw horizontal lines
        for (int i = 0; i < numPoints; i++) {
            if (i != 0 &&  i % rowsInWarp == rowsInWarp -1) {
                // skip line if it is the last in the row
            } else {
                handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+1]  );
            }
        }
 
        // draw vertical lines
        for (int i = 0; i < numPoints; i++) {
 
            if ( (numPoints - i - 1) < rowsInWarp ) {
                // last row doesn't need to draw vertical lines
            } else {
                handlePainter.drawConnectionLine(m_d->currentArgs.transfPoints()[i], m_d->currentArgs.transfPoints()[i+rowsInWarp] );
            }
        }
 
    } // end if statement
 
    gc.restore();
}

References KisTransformStrategyBase::decorationThickness(), KisHandlePainterHelper::drawConnectionLine(), drawConnectionLines(), m_d, KisHandleStyle::primarySelection(), KisTransformUtils::scaleFromAffineMatrix(), KisHandlePainterHelper::setHandleStyle(), and WARP_TRANSFORM.

Q_PRIVATE_SLOT()

KisWarpTransformStrategy::Q_PRIVATE_SLOT ( m_d , void recalculateTransformations() )

private

requestCanvasUpdate

void KisWarpTransformStrategy::requestCanvasUpdate ( )

signal

requestImageRecalculation

void KisWarpTransformStrategy::requestImageRecalculation ( )

signal

setClipOriginalPointsPosition()

void KisWarpTransformStrategy::setClipOriginalPointsPosition ( bool value )

protected

Definition at line 193 of file kis_warp_transform_strategy.cpp.

{
    m_d->clipOriginalPointsPosition = value;
}

References m_d, and value().

setCloseOnStartPointClick()

void KisWarpTransformStrategy::setCloseOnStartPointClick ( bool value )

protected

Definition at line 188 of file kis_warp_transform_strategy.cpp.

{
    m_d->closeOnStartPointClick = value;
}

References m_d, and value().

setTransformFunction()

void KisWarpTransformStrategy::setTransformFunction ( const QPointF & mousePos, bool perspectiveModifierActive, bool shiftModifierActive, bool altModifierActive )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 112 of file kis_warp_transform_strategy.cpp.

{
    Q_UNUSED(shiftModifierActive);
    Q_UNUSED(altModifierActive);
 
    const double handleRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
    bool cursorOverPoint = false;
    m_d->pointIndexUnderCursor = -1;
 
    KisTransformUtils::HandleChooser<Private::Mode>
        handleChooser(mousePos, Private::NOTHING);
 
    const QVector<QPointF> &points = m_d->currentArgs.transfPoints();
    for (int i = 0; i < points.size(); ++i) {
        if (handleChooser.addFunction(points[i],
                                      handleRadius, Private::NOTHING)) {
 
            cursorOverPoint = true;
            m_d->pointIndexUnderCursor = i;
        }
    }
 
    if (cursorOverPoint) {
        m_d->mode = perspectiveModifierActive &&
            !m_d->currentArgs.isEditingTransformPoints() ?
            Private::MULTIPLE_POINT_SELECTION : Private::OVER_POINT;
 
    } else if (!m_d->currentArgs.isEditingTransformPoints()) {
        QPolygonF polygon(m_d->currentArgs.transfPoints());
        bool insidePolygon = polygon.boundingRect().contains(mousePos);
        m_d->mode = insidePolygon ? Private::MOVE_MODE :
            !perspectiveModifierActive ? Private::ROTATE_MODE :
            Private::SCALE_MODE;
    } else {
        m_d->mode = Private::NOTHING;
    }
}

References KisTransformUtils::HandleChooser< Function >::addFunction(), KisTransformUtils::effectiveHandleGrabRadius(), m_d, KisWarpTransformStrategy::Private::MOVE_MODE, KisWarpTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisWarpTransformStrategy::Private::NOTHING, KisWarpTransformStrategy::Private::OVER_POINT, KisWarpTransformStrategy::Private::ROTATE_MODE, and KisWarpTransformStrategy::Private::SCALE_MODE.

setTransformType()

void KisWarpTransformStrategy::setTransformType

(

TransformType

type

)

Definition at line 198 of file kis_warp_transform_strategy.cpp.

                                                                  {
    m_d->transformType = type;
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisWarpTransformStrategy::m_d

private

Definition at line 88 of file kis_warp_transform_strategy.h.

---

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

• plugins/tools/tool_transform2/kis_warp_transform_strategy.h
• plugins/tools/tool_transform2/kis_warp_transform_strategy.cpp