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, const KoColorDisplayRendererInterface *displayRendererInterface) 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 void	decreaseBrushSize (KoCanvasBase *canvas)
virtual QPainterPath	getCursorOutline () const
virtual void	increaseBrushSize (KoCanvasBase *canvas)
	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 98 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 m_d.

~KisWarpTransformStrategy()

KisWarpTransformStrategy::~KisWarpTransformStrategy ( )

override

Definition at line 109 of file kis_warp_transform_strategy.cpp.

{
}

Member Function Documentation

acceptsClicks()

bool KisWarpTransformStrategy::acceptsClicks ( ) const

overridevirtual

Reimplemented from KisTransformStrategyBase.

Definition at line 558 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 374 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 626 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 454 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 203 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 564 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 365 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 152 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 180 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, const KoColorDisplayRendererInterface * displayRendererInterface )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 227 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());
    }
    KisHandlePalette palette = displayRendererInterface->handlePaletteForDisplayColorSpace();
 
    QPen mainPen(palette.black);
    mainPen.setCosmetic(true);
    mainPen.setWidth(decorationThickness());
    QPen outlinePen(palette.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(palette));
 
        // 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(), KoColorDisplayRendererInterface::handlePaletteForDisplayColorSpace(), m_d, palette, 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 194 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 189 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 113 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 199 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