KisMeshTransformStrategy Class Reference

#include <kis_mesh_transform_strategy.h>

Inheritance diagram for KisMeshTransformStrategy:

Classes
struct	Private

Signals
void	requestCanvasUpdate ()
void	requestImageRecalculation ()

Public Member Functions
bool	acceptsClicks () const override
bool	beginPrimaryAction (const QPointF &pt) override
virtual bool	beginPrimaryAction (const QPointF &pt)=0
bool	beginPrimaryAction (KoPointerEvent *event) override
void	continuePrimaryAction (const QPointF &pt, bool shiftModifierActive, bool altModifierActive) override
virtual void	continuePrimaryAction (const QPointF &pt, bool shiftModifierActive, bool altModifierActive)=0
void	continuePrimaryAction (KoPointerEvent *event) override
bool	endPrimaryAction () override
virtual bool	endPrimaryAction ()=0
bool	endPrimaryAction (KoPointerEvent *event) override
void	externalConfigChanged () override
QCursor	getCurrentCursor () const override
QPointF	handleSnapPoint (const QPointF &imagePos) override
	KisMeshTransformStrategy (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
bool	shiftModifierIsUsed () const override
	~KisMeshTransformStrategy () override
Public Member Functions inherited from KisSimplifiedActionPolicyStrategy
void	activateAlternateAction (KisTool::AlternateAction action) override
void	activatePrimaryAction () override
bool	beginAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
bool	beginPrimaryAction (KoPointerEvent *event) override
void	continueAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
void	continuePrimaryAction (KoPointerEvent *event) override
void	deactivateAlternateAction (KisTool::AlternateAction action) override
bool	endAlternateAction (KoPointerEvent *event, KisTool::AlternateAction action) override
bool	endPrimaryAction (KoPointerEvent *event) override
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

Private Member Functions
	Q_PRIVATE_SLOT (m_d, void recalculateTransformations())
bool	shouldDeleteNode (qreal distance, qreal param)
bool	splitHoveredSegment (const QPointF &pt)
void	verifyExpectedMeshSize ()

Private Attributes
const QScopedPointer< Private >	m_d

Additional Inherited Members
Protected Member Functions inherited from KisSimplifiedActionPolicyStrategy
virtual void	hoverActionCommon (const QPointF &pt)

Detailed Description

Definition at line 23 of file kis_mesh_transform_strategy.h.

Constructor & Destructor Documentation

KisMeshTransformStrategy()

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

Definition at line 95 of file kis_mesh_transform_strategy.cpp.

    : KisSimplifiedActionPolicyStrategy(converter, snapGuide),
      m_d(new Private(this, converter, currentArgs, transaction))
{
 
    connect(&m_d->recalculateSignalCompressor, SIGNAL(timeout()),
            SLOT(recalculateTransformations()));
 
    m_d->selectedNodes << KisBezierTransformMesh::NodeIndex(1, 1);
    m_d->hoveredSegment = KisBezierTransformMesh::SegmentIndex(KisBezierTransformMesh::NodeIndex(0,0), 1);
    m_d->hoveredControl = KisBezierTransformMesh::ControlPointIndex(KisBezierTransformMesh::NodeIndex(1, 0), KisBezierTransformMesh::ControlType::Node);
}

References m_d.

~KisMeshTransformStrategy()

KisMeshTransformStrategy::~KisMeshTransformStrategy ( )

override

Definition at line 111 of file kis_mesh_transform_strategy.cpp.

{
}

Member Function Documentation

acceptsClicks()

bool KisMeshTransformStrategy::acceptsClicks ( ) const

overridevirtual

Reimplemented from KisTransformStrategyBase.

Definition at line 804 of file kis_mesh_transform_strategy.cpp.

{
    return m_d->mode == Private::SPLIT_SEGMENT;
}

References m_d, and KisMeshTransformStrategy::Private::SPLIT_SEGMENT.

beginPrimaryAction() [1/3]

bool KisMeshTransformStrategy::beginPrimaryAction ( const QPointF & pt )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 480 of file kis_mesh_transform_strategy.cpp.

{
    // retval shows if the stroke may have a continuation
    bool retval = false;
 
    m_d->mouseClickPos = pt;
 
    QRectF selectionBounds;
 
    if (m_d->selectedNodes.size() > 1) {
        for (auto it = m_d->selectedNodes.begin(); it != m_d->selectedNodes.end(); ++it) {
            KisAlgebra2D::accumulateBounds(
                m_d->currentArgs.meshTransform()->node(*it).node, &selectionBounds);
        }
    } else {
        selectionBounds = m_d->currentArgs.meshTransform()->dstBoundingRect();
    }
 
    m_d->initialRotationCenter = selectionBounds.center();
    m_d->initialSelectionMaxDimension = KisAlgebra2D::maxDimension(selectionBounds);
    m_d->initialMeshState = *m_d->currentArgs.meshTransform();
 
    m_d->pointWasDragged = false;
 
    if (m_d->mode == Private::OVER_NODE ||
        m_d->mode == Private::OVER_POINT ||
        m_d->mode == Private::OVER_POINT_SYMMETRIC) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->hoveredControl, false);
 
        if (m_d->selectedNodes.size() <= 1 ||
            !m_d->selectedNodes.contains(m_d->hoveredControl->nodeIndex)) {
 
            m_d->selectedNodes.clear();
            m_d->selectedNodes << m_d->hoveredControl->nodeIndex;
        }
 
        retval = true;
    } else if (m_d->mode == Private::OVER_NODE_WHOLE_LINE) {
        m_d->selectedNodes.clear();
        auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredControl);
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->currentArgs.meshTransform()->endControlPoints(), false);
 
        if (it.isTopBorder() || it.isBottomBorder()) {
            for (int i = 0; i < m_d->currentArgs.meshTransform()->size().height(); i++) {
                m_d->selectedNodes << KisBezierTransformMesh::NodeIndex(m_d->hoveredControl->nodeIndex.x(), i);
            }
        } else {
            for (int i = 0; i < m_d->currentArgs.meshTransform()->size().width(); i++) {
                m_d->selectedNodes << KisBezierTransformMesh::NodeIndex(i, m_d->hoveredControl->nodeIndex.y());
            }
        }
        retval = true;
    } else if (m_d->mode == Private::OVER_SEGMENT || m_d->mode == Private::OVER_SEGMENT_SYMMETRIC) {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->hoveredSegment, false);
 
        auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredSegment);
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->currentArgs.meshTransform()->endSegments(), false);
 
        retval = true;
 
    } else if (m_d->mode == Private::OVER_PATCH || m_d->mode == Private::OVER_PATCH_LOCKED) {
        retval = true;
 
    } else if (m_d->mode == Private::SPLIT_SEGMENT) {
        retval = splitHoveredSegment(pt);
 
    } else if (m_d->mode == Private::MULTIPLE_POINT_SELECTION) {
        if (m_d->hoveredControl) {
            if (!m_d->selectedNodes.contains(m_d->hoveredControl->nodeIndex)) {
                m_d->selectedNodes.insert(m_d->hoveredControl->nodeIndex);
            } else {
                m_d->selectedNodes.remove(m_d->hoveredControl->nodeIndex);
            }
        } else if (m_d->hoveredSegment) {
            auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredSegment);
            KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->currentArgs.meshTransform()->endSegments(), false);
 
            if (!m_d->selectedNodes.contains(it.firstNodeIndex()) ||
                !m_d->selectedNodes.contains(it.secondNodeIndex())) {
 
                m_d->selectedNodes.insert(it.firstNodeIndex());
                m_d->selectedNodes.insert(it.secondNodeIndex());
            } else {
                m_d->selectedNodes.remove(it.firstNodeIndex());
                m_d->selectedNodes.remove(it.secondNodeIndex());
            }
        }
        retval = false;
    } else if (m_d->mode == Private::MOVE_MODE ||
               m_d->mode == Private::SCALE_MODE ||
               m_d->mode == Private::ROTATE_MODE) {
 
        retval = true;
    }
 
    m_d->lastMousePos = pt;
    return retval;
}

References KisAlgebra2D::accumulateBounds(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisAlgebra2D::maxDimension(), KisMeshTransformStrategy::Private::MOVE_MODE, KisMeshTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisMeshTransformStrategy::Private::OVER_NODE, KisMeshTransformStrategy::Private::OVER_NODE_WHOLE_LINE, KisMeshTransformStrategy::Private::OVER_PATCH, KisMeshTransformStrategy::Private::OVER_PATCH_LOCKED, KisMeshTransformStrategy::Private::OVER_POINT, KisMeshTransformStrategy::Private::OVER_POINT_SYMMETRIC, KisMeshTransformStrategy::Private::OVER_SEGMENT, KisMeshTransformStrategy::Private::OVER_SEGMENT_SYMMETRIC, KisMeshTransformStrategy::Private::ROTATE_MODE, KisMeshTransformStrategy::Private::SCALE_MODE, KisMeshTransformStrategy::Private::SPLIT_SEGMENT, and splitHoveredSegment().

beginPrimaryAction() [2/3]

virtual bool KisSimplifiedActionPolicyStrategy::beginPrimaryAction ( const QPointF & pt )

virtual

Implements KisSimplifiedActionPolicyStrategy.

beginPrimaryAction() [3/3]

bool KisSimplifiedActionPolicyStrategy::beginPrimaryAction ( KoPointerEvent * event )

overridevirtual

Note: Snapping with Offset is not yet used in the transform strategies. When the user starts an action, we just move the handle to the mouse position, even if it was positioned with an offset. That is not what we do in Crop Tool.

Implements KisTransformStrategyBase.

Definition at line 27 of file kis_simplified_action_policy_strategy.cpp.

{
    const QPointF rawImagePoint = m_d->converter->documentToImage(event->point);
    const QPointF snappedImagePoint = handleSnapPoint(rawImagePoint);
 
    if (m_d->snapGuide && rawImagePoint != snappedImagePoint) {
        QPointF imageOffset = snappedImagePoint - rawImagePoint;
        m_d->dragOffset = m_d->converter->imageToDocument(imageOffset);
    }
 
    const QPointF pos = snapDocPoint(event->point, event->modifiers());
 
    QPointF imagePos = m_d->converter->documentToImage(pos);
    m_d->lastImagePos = imagePos;
 
    return beginPrimaryAction(imagePos);
}

continuePrimaryAction() [1/3]

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

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 579 of file kis_mesh_transform_strategy.cpp.

{
    Q_UNUSED(shiftModifierActive);
    Q_UNUSED(altModifierActive);
 
    if (m_d->mode == Private::OVER_POINT ||
        m_d->mode == Private::OVER_POINT_SYMMETRIC ||
        m_d->mode == Private::OVER_NODE) {
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->hoveredControl);
 
        KisSmartMoveMeshControlMode mode =
            m_d->mode == Private::OVER_POINT_SYMMETRIC ?
            KisSmartMoveMeshControlMode::MoveSymmetricLock :
            KisSmartMoveMeshControlMode::MoveFree;
 
        smartMoveControl(*m_d->currentArgs.meshTransform(),
                         *m_d->hoveredControl,
                         pt - m_d->lastMousePos,
                         mode,
                         m_d->currentArgs.meshScaleHandles());
 
    } else if (m_d->mode == Private::OVER_SEGMENT || m_d->mode == Private::OVER_SEGMENT_SYMMETRIC) {
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->hoveredSegment);
 
        auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredSegment);
 
        // TODO: recover special case for degree-2 curves. There is a special
        //       function for that in KisBezierUtils::interpolateQuadric(), but
        //       it seems like not working properly.
 
        const QPointF offset = pt - m_d->lastMousePos;
 
        QPointF offsetP1;
        QPointF offsetP2;
 
        std::tie(offsetP1, offsetP2) =
            KisBezierUtils::offsetSegment(m_d->localSegmentPosition, offset);
 
 
        KisSmartMoveMeshControlMode mode =
            m_d->mode == Private::OVER_SEGMENT_SYMMETRIC ?
            KisSmartMoveMeshControlMode::MoveSymmetricLock :
            KisSmartMoveMeshControlMode::MoveFree;
 
        smartMoveControl(*m_d->currentArgs.meshTransform(), it.itP1().controlIndex(), offsetP1, mode, m_d->currentArgs.meshScaleHandles());
        smartMoveControl(*m_d->currentArgs.meshTransform(), it.itP2().controlIndex(), offsetP2, mode, m_d->currentArgs.meshScaleHandles());
 
    } else if (m_d->mode == Private::OVER_PATCH || m_d->mode == Private::OVER_PATCH_LOCKED) {
        KIS_SAFE_ASSERT_RECOVER_RETURN(m_d->hoveredPatch);
 
        using KisAlgebra2D::linearReshapeFunc;
 
        KisBezierTransformMesh &mesh = *m_d->currentArgs.meshTransform();
        mesh = m_d->initialMeshState;
 
        auto patchIt = m_d->currentArgs.meshTransform()->find(*m_d->hoveredPatch);
 
        QPointF offset = pt - m_d->mouseClickPos;
 
        auto offsetSegment =
            [this] (KisBezierTransformMesh::segment_iterator it,
                    qreal t,
                    const QPointF &offset) {
 
            QPointF offsetP1;
            QPointF offsetP2;
 
            std::tie(offsetP1, offsetP2) =
                KisBezierUtils::offsetSegment(t, offset);
 
 
            smartMoveControl(*m_d->currentArgs.meshTransform(), it.itP1().controlIndex(), offsetP1, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
            smartMoveControl(*m_d->currentArgs.meshTransform(), it.itP2().controlIndex(), offsetP2, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
        };
 
 
        const QPointF center = patchIt->localToGlobal(QPointF(0.5, 0.5));
        const qreal centerDistance = kisDistance(m_d->mouseClickPos, center);
 
        KisBezierTransformMesh::segment_iterator nearestSegment = mesh.endSegments();
        qreal nearestSegmentSignificance = 0;
        qreal nearestSegmentDistance = std::numeric_limits<qreal>::max();
        qreal nearestSegmentDistanceSignificance = 0.0;
        qreal nearestSegmentParam = 0.5;
 
        auto testSegment =
                [&nearestSegment,
                 &nearestSegmentSignificance,
                 &nearestSegmentDistance,
                 &nearestSegmentDistanceSignificance,
                 &nearestSegmentParam,
                 centerDistance,
                 this] (KisBezierTransformMesh::segment_iterator it, qreal param) {
 
            const QPointF movedPoint = KisBezierUtils::bezierCurve(it.p0(), it.p1(), it.p2(), it.p3(), param);
            const qreal distance = kisDistance(m_d->mouseClickPos, movedPoint);
 
            if (distance < nearestSegmentDistance) {
                const qreal proportion = KisBezierUtils::curveProportionByParam(it.p0(), it.p1(), it.p2(), it.p3(), param, 0.1);
 
                qreal distanceSignificance =
                    centerDistance / (centerDistance + distance);
 
                if (distanceSignificance > 0.6) {
                    distanceSignificance = std::min(1.0, linearReshapeFunc(distanceSignificance, 0.6, 0.75, 0.6, 1.0));
                }
 
                const qreal directionSignificance =
                    1.0 - std::min(1.0, std::abs(proportion - 0.5) / 0.4);
 
                nearestSegmentDistance = distance;
                nearestSegment = it;
                nearestSegmentParam = param;
                nearestSegmentSignificance = m_d->mode != Private::OVER_PATCH_LOCKED ? distanceSignificance * directionSignificance : 0;
                nearestSegmentDistanceSignificance = distanceSignificance;
            }
        };
 
        testSegment(patchIt.segmentP(), m_d->localPatchPosition.x());
        testSegment(patchIt.segmentQ(), m_d->localPatchPosition.x());
        testSegment(patchIt.segmentR(), m_d->localPatchPosition.y());
        testSegment(patchIt.segmentS(), m_d->localPatchPosition.y());
 
        KIS_SAFE_ASSERT_RECOVER_RETURN(nearestSegment != mesh.endSegments());
 
        const qreal translationOffsetCoeff =
            qBound(0.0,
                   linearReshapeFunc(1.0 - nearestSegmentDistanceSignificance,
                                     0.95, 0.75, 1.0, 0.0),
                   1.0);
        const QPointF translationOffset = translationOffsetCoeff * offset;
        offset -= translationOffset;
 
        QPointF segmentOffset;
 
        if (nearestSegmentSignificance > 0) {
            segmentOffset = nearestSegmentSignificance * offset;
            offset -= segmentOffset;
        }
 
        const qreal alpha =
            1.0 - KisBezierUtils::curveProportionByParam(nearestSegment.p0(),
                                                         nearestSegment.p1(),
                                                         nearestSegment.p2(),
                                                         nearestSegment.p3(),
                                                         nearestSegmentParam, 0.1);
 
        const qreal coeffN1 =
            alpha > 0.5 ? std::max(0.0, linearReshapeFunc(alpha, 0.6, 0.75, 1.0, 0.0)) : 1.0;
        const qreal coeffN0 =
            alpha < 0.5 ? std::max(0.0, linearReshapeFunc(alpha, 0.25, 0.4, 0.0, 1.0)) : 1.0;
 
        smartMoveControl(*m_d->currentArgs.meshTransform(), nearestSegment.itP0().controlIndex(), offset * coeffN0, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
        smartMoveControl(*m_d->currentArgs.meshTransform(), nearestSegment.itP3().controlIndex(), offset * coeffN1, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
 
        smartMoveControl(*m_d->currentArgs.meshTransform(), patchIt.nodeTopLeft().controlIndex(), translationOffset, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
        smartMoveControl(*m_d->currentArgs.meshTransform(), patchIt.nodeTopRight().controlIndex(), translationOffset, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
        smartMoveControl(*m_d->currentArgs.meshTransform(), patchIt.nodeBottomLeft().controlIndex(), translationOffset, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
        smartMoveControl(*m_d->currentArgs.meshTransform(), patchIt.nodeBottomRight().controlIndex(), translationOffset, KisSmartMoveMeshControlMode::MoveSymmetricLock, m_d->currentArgs.meshScaleHandles());
 
        offsetSegment(nearestSegment, nearestSegmentParam, segmentOffset);
 
    } else if (m_d->mode == Private::SPLIT_SEGMENT) {
        *m_d->currentArgs.meshTransform() = m_d->initialMeshState;
        const bool sanitySplitResult = splitHoveredSegment(pt);
        KIS_SAFE_ASSERT_RECOVER_NOOP(sanitySplitResult);
 
    } else if (m_d->mode == Private::MOVE_MODE || m_d->mode == Private::OVER_NODE_WHOLE_LINE) {
        const QPointF offset = pt - m_d->lastMousePos;
        if (m_d->selectedNodes.size() > 1) {
            for (auto it = m_d->selectedNodes.begin(); it != m_d->selectedNodes.end(); ++it) {
                m_d->currentArgs.meshTransform()->node(*it).translate(offset);
            }
        } else {
            m_d->currentArgs.meshTransform()->translate(offset);
        }
    } else if (m_d->mode == Private::SCALE_MODE) {
        const qreal scale = 1.0 - (pt - m_d->lastMousePos).y() / m_d->initialSelectionMaxDimension;
 
 
        const QTransform t =
            QTransform::fromTranslate(-m_d->initialRotationCenter.x(), -m_d->initialRotationCenter.y()) *
            QTransform::fromScale(scale, scale) *
            QTransform::fromTranslate(m_d->initialRotationCenter.x(), m_d->initialRotationCenter.y());
 
        if (m_d->selectedNodes.size() > 1) {
            for (auto it = m_d->selectedNodes.begin(); it != m_d->selectedNodes.end(); ++it) {
                m_d->currentArgs.meshTransform()->node(*it).transform(t);
            }
        } else {
            m_d->currentArgs.meshTransform()->transform(t);
        }
 
    } else if (m_d->mode == Private::ROTATE_MODE) {
        const QPointF oldDirection = m_d->lastMousePos - m_d->initialRotationCenter;
        const QPointF newDirection = pt - m_d->initialRotationCenter;
        const qreal rotateAngle = KisAlgebra2D::angleBetweenVectors(oldDirection, newDirection);
 
        QTransform R;
        R.rotateRadians(rotateAngle);
 
        const QTransform t =
            QTransform::fromTranslate(-m_d->initialRotationCenter.x(), -m_d->initialRotationCenter.y()) *
            R *
            QTransform::fromTranslate(m_d->initialRotationCenter.x(), m_d->initialRotationCenter.y());
 
        if (m_d->selectedNodes.size() > 1) {
            for (auto it = m_d->selectedNodes.begin(); it != m_d->selectedNodes.end(); ++it) {
                m_d->currentArgs.meshTransform()->node(*it).transform(t);
            }
        } else {
            m_d->currentArgs.meshTransform()->transform(t);
        }
    }
 
    m_d->lastMousePos = pt;
    m_d->recalculateSignalCompressor.start();
}

References KisAlgebra2D::angleBetweenVectors(), KisBezierUtils::bezierCurve(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::control_point_iterator_impl< is_const >::controlIndex(), KisBezierUtils::curveProportionByParam(), distance(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::endSegments(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::find(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::itP0(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::itP1(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::itP2(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::itP3(), KIS_SAFE_ASSERT_RECOVER_NOOP, KIS_SAFE_ASSERT_RECOVER_RETURN, kisDistance(), KisAlgebra2D::linearReshapeFunc(), m_d, KisMeshTransformStrategy::Private::MOVE_MODE, KisBezierUtils::offsetSegment(), KisMeshTransformStrategy::Private::OVER_NODE, KisMeshTransformStrategy::Private::OVER_NODE_WHOLE_LINE, KisMeshTransformStrategy::Private::OVER_PATCH, KisMeshTransformStrategy::Private::OVER_PATCH_LOCKED, KisMeshTransformStrategy::Private::OVER_POINT, KisMeshTransformStrategy::Private::OVER_POINT_SYMMETRIC, KisMeshTransformStrategy::Private::OVER_SEGMENT, KisMeshTransformStrategy::Private::OVER_SEGMENT_SYMMETRIC, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p0(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p1(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p2(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p3(), R, KisMeshTransformStrategy::Private::ROTATE_MODE, KisMeshTransformStrategy::Private::SCALE_MODE, KisMeshTransformStrategy::Private::SPLIT_SEGMENT, and splitHoveredSegment().

continuePrimaryAction() [2/3]

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

virtual

Implements KisSimplifiedActionPolicyStrategy.

continuePrimaryAction() [3/3]

void KisSimplifiedActionPolicyStrategy::continuePrimaryAction ( KoPointerEvent * event )

overridevirtual

HACK ALERT!

Here we explicitly check for Shift key pressed! The choice of the stroke type is usually done before the tablet press, but for some actions like constrain proportions we should be able to activate it even after the stroke has been started. For now, KisShortcutMatcher does not support it, so just hardcode this special case.

See bug 340496

Implements KisTransformStrategyBase.

Definition at line 28 of file kis_simplified_action_policy_strategy.cpp.

{
    const bool shiftIsActive = event->modifiers() & Qt::ShiftModifier;
    const bool altIsActive = event->modifiers() & Qt::AltModifier;
 
    const QPointF pos = snapDocPoint(event->point, event->modifiers());
    QPointF imagePos = m_d->converter->documentToImage(pos);
    m_d->lastImagePos = imagePos;
 
    return continuePrimaryAction(imagePos, shiftIsActive, altIsActive);
}

endPrimaryAction() [1/3]

bool KisMeshTransformStrategy::endPrimaryAction ( )

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 799 of file kis_mesh_transform_strategy.cpp.

{
    return m_d->mode != Private::NOTHING;
}

References m_d, and KisMeshTransformStrategy::Private::NOTHING.

endPrimaryAction() [2/3]

virtual bool KisSimplifiedActionPolicyStrategy::endPrimaryAction ( )

virtual

Implements KisSimplifiedActionPolicyStrategy.

endPrimaryAction() [3/3]

bool KisSimplifiedActionPolicyStrategy::endPrimaryAction ( KoPointerEvent * event )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 29 of file kis_simplified_action_policy_strategy.cpp.

{
    const QPointF pos = snapDocPoint(event->point, event->modifiers());
    QPointF imagePos = m_d->converter->documentToImage(pos);
    m_d->lastImagePos = imagePos;
 
    return endPrimaryAction();
}

externalConfigChanged()

void KisMeshTransformStrategy::externalConfigChanged ( )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 388 of file kis_mesh_transform_strategy.cpp.

{
    verifyExpectedMeshSize();
    m_d->recalculateTransformations();
}

References m_d, and verifyExpectedMeshSize().

getCurrentCursor()

QCursor KisMeshTransformStrategy::getCurrentCursor ( ) const

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 332 of file kis_mesh_transform_strategy.cpp.

{
    QCursor cursor;
 
    switch (m_d->mode) {
    case Private::OVER_NODE:
    case Private::OVER_POINT:
    case Private::OVER_SEGMENT:
        cursor = KisCursor::meshCursorFree();
        break;
    case Private::OVER_NODE_WHOLE_LINE:
    case Private::OVER_POINT_SYMMETRIC:
    case Private::OVER_SEGMENT_SYMMETRIC:
    case Private::OVER_PATCH:
    case Private::OVER_PATCH_LOCKED:
        cursor = KisCursor::meshCursorLocked();
        break;
    case Private::SPLIT_SEGMENT: {
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->hoveredSegment || m_d->hoveredControl,
                                             KisCursor::arrowCursor());
 
        if (m_d->hoveredControl) {
            auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredControl);
            cursor = it.isTopBorder() || it.isBottomBorder() ?
                KisCursor::splitHCursor() : KisCursor::splitVCursor();
 
        } else if (m_d->hoveredSegment) {
            auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredSegment);
 
            const QRectF segmentRect(it.p0(), it.p3());
            cursor = segmentRect.width() > segmentRect.height() ?
                KisCursor::splitHCursor() : KisCursor::splitVCursor();
        }
 
        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(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisCursor::meshCursorFree(), KisCursor::meshCursorLocked(), KisMeshTransformStrategy::Private::MOVE_MODE, KisCursor::moveCursor(), KisMeshTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisMeshTransformStrategy::Private::NOTHING, KisMeshTransformStrategy::Private::OVER_NODE, KisMeshTransformStrategy::Private::OVER_NODE_WHOLE_LINE, KisMeshTransformStrategy::Private::OVER_PATCH, KisMeshTransformStrategy::Private::OVER_PATCH_LOCKED, KisMeshTransformStrategy::Private::OVER_POINT, KisMeshTransformStrategy::Private::OVER_POINT_SYMMETRIC, KisMeshTransformStrategy::Private::OVER_SEGMENT, KisMeshTransformStrategy::Private::OVER_SEGMENT_SYMMETRIC, KisMeshTransformStrategy::Private::ROTATE_MODE, KisCursor::rotateCursor(), KisMeshTransformStrategy::Private::SCALE_MODE, KisCursor::sizeVerCursor(), KisMeshTransformStrategy::Private::SPLIT_SEGMENT, KisCursor::splitHCursor(), and KisCursor::splitVCursor().

handleSnapPoint()

QPointF KisMeshTransformStrategy::handleSnapPoint ( const QPointF & imagePos )

overridevirtual

Reimplemented from KisSimplifiedActionPolicyStrategy.

Definition at line 238 of file kis_mesh_transform_strategy.cpp.

{
    return imagePos + m_d->hoveredHandleOffset;
}

References m_d.

paint()

void KisMeshTransformStrategy::paint ( QPainter & gc, const KoColorDisplayRendererInterface * displayRendererInterface )

overridevirtual

Implements KisTransformStrategyBase.

Definition at line 264 of file kis_mesh_transform_strategy.cpp.

{
    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(KisTransformUtils::imageToFlakeTransform(m_d->converter), true);
 
    KisHandlePainterHelper handlePainter(&gc, 0.5 * KisTransformUtils::handleRadius, decorationThickness());
    KisHandlePalette palette = displayRendererInterface->handlePaletteForDisplayColorSpace();
 
    for (auto it = m_d->currentArgs.meshTransform()->beginSegments();
         it != m_d->currentArgs.meshTransform()->endSegments();
         ++it) {
 
        if (m_d->hoveredSegment && it.segmentIndex() == *m_d->hoveredSegment) {
            handlePainter.setHandleStyle(KisHandleStyle::highlightedPrimaryHandlesWithSolidOutline(palette));
        } else {
            handlePainter.setHandleStyle(KisHandleStyle::primarySelection(palette));
        }
 
        QPainterPath path;
        path.moveTo(it.p0());
        path.cubicTo(it.p1(), it.p2(), it.p3());
 
        handlePainter.drawPath(path);
    }
 
    for (auto it = m_d->currentArgs.meshTransform()->beginControlPoints();
         it != m_d->currentArgs.meshTransform()->endControlPoints();
         ++it) {
 
        if (!m_d->currentArgs.meshShowHandles() && !it.isNode()) {
            KIS_SAFE_ASSERT_RECOVER_NOOP(!m_d->hoveredControl || *m_d->hoveredControl != it.controlIndex());
 
            continue;
        }
 
 
        if (m_d->hoveredControl && *m_d->hoveredControl == it.controlIndex()) {
 
            handlePainter.setHandleStyle(KisHandleStyle::highlightedPrimaryHandles(palette));
 
        } else if (it.type() == KisBezierTransformMesh::ControlType::Node &&
                   m_d->selectedNodes.contains(it.nodeIndex())) {
 
            handlePainter.setHandleStyle(KisHandleStyle::selectedPrimaryHandles(palette));
 
        } else {
            handlePainter.setHandleStyle(KisHandleStyle::primarySelection(palette));
        }
 
        if (it.type() == KisBezierTransformMesh::ControlType::Node) {
            handlePainter.drawHandleCircle(*it);
        } else {
            handlePainter.drawConnectionLine(it.node().node, *it);
            handlePainter.drawHandleSmallCircle(*it);
        }
    }
 
    gc.restore();
}

References KisTransformStrategyBase::decorationThickness(), KisHandlePainterHelper::drawConnectionLine(), KisHandlePainterHelper::drawHandleCircle(), KisHandlePainterHelper::drawHandleSmallCircle(), KisHandlePainterHelper::drawPath(), KoColorDisplayRendererInterface::handlePaletteForDisplayColorSpace(), KisTransformUtils::handleRadius, KisHandleStyle::highlightedPrimaryHandles(), KisHandleStyle::highlightedPrimaryHandlesWithSolidOutline(), KisTransformUtils::imageToFlakeTransform(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_d, palette, KisHandleStyle::primarySelection(), KisHandleStyle::selectedPrimaryHandles(), and KisHandlePainterHelper::setHandleStyle().

Q_PRIVATE_SLOT()

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

private

requestCanvasUpdate

void KisMeshTransformStrategy::requestCanvasUpdate ( )

signal

requestImageRecalculation

void KisMeshTransformStrategy::requestImageRecalculation ( )

signal

setTransformFunction()

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

overridevirtual

Implements KisSimplifiedActionPolicyStrategy.

Definition at line 115 of file kis_mesh_transform_strategy.cpp.

{
    const qreal grabRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
 
    boost::optional<KisBezierTransformMesh::SegmentIndex> hoveredSegment;
    boost::optional<KisBezierTransformMesh::ControlPointIndex> hoveredControl;
    boost::optional<KisBezierTransformMesh::PatchIndex> hoveredPatch;
    Private::Mode mode = Private::NOTHING;
    QPointF localPatchPos;
    qreal localSegmentPos = 0.0;
 
    const bool symmetricalMode = shiftModifierActive ^ m_d->currentArgs.meshSymmetricalHandles();
 
    if (m_d->currentArgs.meshShowHandles()) {
        auto index = m_d->currentArgs.meshTransform()->hitTestControlPoint(mousePos, grabRadius);
        if (m_d->currentArgs.meshTransform()->isIndexValid(index)) {
            hoveredControl = index;
            mode = symmetricalMode ? Private::OVER_POINT_SYMMETRIC : Private::OVER_POINT;
        }
    }
 
    if (mode == Private::NOTHING) {
        auto index = m_d->currentArgs.meshTransform()->hitTestNode(mousePos, grabRadius);
        auto nodeIt = m_d->currentArgs.meshTransform()->find(index);
 
        if (nodeIt != m_d->currentArgs.meshTransform()->endControlPoints()) {
            hoveredControl = index;
            mode = shiftModifierActive && nodeIt.isBorderNode() && !nodeIt.isCornerNode() ?
                Private::OVER_NODE_WHOLE_LINE :
                Private::OVER_NODE;
        }
    }
 
    if (mode == Private::NOTHING) {
        auto index = m_d->currentArgs.meshTransform()->hitTestSegment(mousePos, grabRadius, &localSegmentPos);
        if (m_d->currentArgs.meshTransform()->isIndexValid(index)) {
            hoveredSegment = index;
            mode = symmetricalMode ? Private::OVER_SEGMENT_SYMMETRIC : Private::OVER_SEGMENT;
        }
    }
 
    if (mode == Private::NOTHING) {
        auto index = m_d->currentArgs.meshTransform()->hitTestPatch(mousePos, &localPatchPos);
        if (m_d->currentArgs.meshTransform()->isIndexValid(index)) {
            hoveredPatch = index;
            mode = !shiftModifierActive ? Private::OVER_PATCH : Private::OVER_PATCH_LOCKED;
        }
    }
 
 
    // verify that we have only one active selection at a time
    KIS_SAFE_ASSERT_RECOVER_RETURN(bool(hoveredControl) +
                                   bool(hoveredSegment) +
                                   bool(hoveredPatch)<= 1);
 
 
    KisBezierTransformMesh::control_point_iterator controlIt =
        m_d->currentArgs.meshTransform()->endControlPoints();
 
    if (hoveredControl) {
        controlIt = m_d->currentArgs.meshTransform()->find(*hoveredControl);
    }
 
    if (altModifierActive &&
        ((hoveredControl &&
          hoveredControl->isNode() &&
          controlIt.isBorderNode() &&
          !controlIt.isCornerNode()) ||
         hoveredSegment)) {
 
        mode = Private::SPLIT_SEGMENT;
 
    } else {
        if (hoveredControl || hoveredSegment) {
            if (perspectiveModifierActive) {
                mode = Private::MULTIPLE_POINT_SELECTION;
            } else if (hoveredControl &&
                       hoveredControl->isNode() &&
                       m_d->selectedNodes.size() > 1 &&
                       m_d->selectedNodes.contains(hoveredControl->nodeIndex)) {
 
                mode = Private::MOVE_MODE;
            }
        } else if (!hoveredPatch) {
            if (perspectiveModifierActive) {
                mode = Private::SCALE_MODE;
            } else if (shiftModifierActive) {
                mode = Private::MOVE_MODE;
            } else {
                mode = Private::ROTATE_MODE;
            }
        }
    }
 
    if (mode != m_d->mode ||
        hoveredControl != m_d->hoveredControl ||
        hoveredSegment != m_d->hoveredSegment ||
        hoveredPatch != m_d->hoveredPatch) {
 
        m_d->hoveredControl = hoveredControl;
        m_d->hoveredSegment = hoveredSegment;
        m_d->hoveredPatch = hoveredPatch;
 
        m_d->mode = mode;
        Q_EMIT requestCanvasUpdate();
    }
 
    m_d->localPatchPosition = localPatchPos;
    m_d->localSegmentPosition = localSegmentPos;
 
    if (hoveredControl) {
        m_d->hoveredHandleOffset = *controlIt - mousePos;
    } else if (hoveredSegment) {
        KisBezierTransformMesh::segment_iterator segmentIt =
            m_d->currentArgs.meshTransform()->find(*hoveredSegment);
        m_d->hoveredHandleOffset = segmentIt.pointAtParam(m_d->localSegmentPosition) - mousePos;
    } else {
        m_d->hoveredHandleOffset = QPointF();
    }
 
    verifyExpectedMeshSize();
}

References KisTransformUtils::effectiveHandleGrabRadius(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::control_point_iterator_impl< is_const >::isBorderNode(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::control_point_iterator_impl< is_const >::isCornerNode(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, KisMeshTransformStrategy::Private::MOVE_MODE, KisMeshTransformStrategy::Private::MULTIPLE_POINT_SELECTION, KisMeshTransformStrategy::Private::NOTHING, KisMeshTransformStrategy::Private::OVER_NODE, KisMeshTransformStrategy::Private::OVER_NODE_WHOLE_LINE, KisMeshTransformStrategy::Private::OVER_PATCH, KisMeshTransformStrategy::Private::OVER_PATCH_LOCKED, KisMeshTransformStrategy::Private::OVER_POINT, KisMeshTransformStrategy::Private::OVER_POINT_SYMMETRIC, KisMeshTransformStrategy::Private::OVER_SEGMENT, KisMeshTransformStrategy::Private::OVER_SEGMENT_SYMMETRIC, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::pointAtParam(), requestCanvasUpdate(), KisMeshTransformStrategy::Private::ROTATE_MODE, KisMeshTransformStrategy::Private::SCALE_MODE, KisMeshTransformStrategy::Private::SPLIT_SEGMENT, and verifyExpectedMeshSize().

shiftModifierIsUsed()

bool KisMeshTransformStrategy::shiftModifierIsUsed ( ) const

overridevirtual

Reimplemented from KisSimplifiedActionPolicyStrategy.

Definition at line 243 of file kis_mesh_transform_strategy.cpp.

{
    return true;
}

shouldDeleteNode()

bool KisMeshTransformStrategy::shouldDeleteNode ( qreal distance, qreal param )

private

Definition at line 470 of file kis_mesh_transform_strategy.cpp.

{
    const qreal grabRadius = KisTransformUtils::effectiveHandleGrabRadius(m_d->converter);
    return
        distance > 10 * grabRadius ||
        qFuzzyCompare(param, 0.0) ||
        qFuzzyCompare(param, 1.0);
 
}

References distance(), KisTransformUtils::effectiveHandleGrabRadius(), m_d, and qFuzzyCompare().

splitHoveredSegment()

bool KisMeshTransformStrategy::splitHoveredSegment ( const QPointF & pt )

private

Definition at line 394 of file kis_mesh_transform_strategy.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_d->hoveredSegment || m_d->hoveredControl, false);
 
    if (m_d->hoveredControl) {
        auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredControl);
 
        KisBezierTransformMesh::segment_iterator resultSegment = m_d->currentArgs.meshTransform()->endSegments();
        qreal resultParam = 0;
        qreal resultDistance = std::numeric_limits<qreal>::max();
        KisBezierTransformMesh::NodeIndex resultRemovedNodeIndex;
 
        auto estimateSegment =
            [&resultParam,
             &resultSegment,
             &resultDistance,
             &resultRemovedNodeIndex] (const KisBezierTransformMesh::segment_iterator &segment,
                               const QPoint &removedNodeOffset,
                               const QPointF &pt,
                               KisBezierTransformMesh &mesh)
        {
            if (segment != mesh.endSegments()) {
 
                qreal distance = 0.0;
                qreal param = KisBezierUtils::nearestPoint({segment.p0(), segment.p1(), segment.p2(), segment.p3()}, pt, &distance);
 
                if (distance < resultDistance) {
                    resultDistance = distance;
                    resultParam = param;
                    resultSegment = segment;
                    resultRemovedNodeIndex = segment.firstNodeIndex() + removedNodeOffset;
                }
            }
        };
 
 
        if (it.isTopBorder() || it.isBottomBorder()) {
            estimateSegment(it.leftSegment(), QPoint(2, 0), pt, *m_d->currentArgs.meshTransform());
            estimateSegment(it.rightSegment(), QPoint(0, 0), pt, *m_d->currentArgs.meshTransform());
        } else {
            estimateSegment(it.topSegment(), QPoint(0, 2), pt, *m_d->currentArgs.meshTransform());
            estimateSegment(it.bottomSegment(), QPoint(0, 0), pt, *m_d->currentArgs.meshTransform());
        }
 
        if (resultSegment != m_d->currentArgs.meshTransform()->endSegments()) {
            if (!shouldDeleteNode(resultDistance, resultParam)) {
                const qreal eps = 0.01;
                const qreal proportion = KisBezierUtils::curveProportionByParam(resultSegment.p0(), resultSegment.p1(), resultSegment.p2(), resultSegment.p3(), resultParam, eps);
 
                m_d->currentArgs.meshTransform()->subdivideSegment(resultSegment.segmentIndex(), proportion);
                m_d->currentArgs.meshTransform()->removeColumnOrRow(resultRemovedNodeIndex, !resultSegment.isHorizontal());
 
            } else {
                m_d->currentArgs.meshTransform()->removeColumnOrRow(m_d->hoveredControl->nodeIndex, !resultSegment.isHorizontal());
            }
        }
 
    } else if (m_d->hoveredSegment) {
        auto it = m_d->currentArgs.meshTransform()->find(*m_d->hoveredSegment);
        KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(it != m_d->currentArgs.meshTransform()->endSegments(), false);
 
        qreal distance = 0;
        const qreal t = KisBezierUtils::nearestPoint({it.p0(), it.p1(), it.p2(), it.p3()}, pt, &distance);
 
        if (!shouldDeleteNode(distance, t)) {
            const qreal eps = 0.01;
            const qreal proportion = KisBezierUtils::curveProportionByParam(it.p0(), it.p1(), it.p2(), it.p3(), t, eps);
            m_d->currentArgs.meshTransform()->subdivideSegment(it.segmentIndex(), proportion);
        }
    }
 
    m_d->recalculateSignalCompressor.start();
 
    return true;
}

References KisBezierUtils::curveProportionByParam(), distance(), eps, KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::isHorizontal(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KisBezierUtils::nearestPoint(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p0(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p1(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p2(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::p3(), KisBezierMeshDetails::Mesh< NodeArg, PatchArg >::segment_iterator_impl< is_const >::segmentIndex(), and shouldDeleteNode().

verifyExpectedMeshSize()

void KisMeshTransformStrategy::verifyExpectedMeshSize ( )

private

Definition at line 248 of file kis_mesh_transform_strategy.cpp.

{
    bool shouldUpdate = false;
 
    const QSize currentMeshSize = m_d->currentArgs.meshTransform()->size();
    if (currentMeshSize != m_d->lastMeshSize) {
        m_d->selectedNodes.clear();
        shouldUpdate = true;
    }
    m_d->lastMeshSize = currentMeshSize;
 
    if (shouldUpdate) {
        Q_EMIT requestCanvasUpdate();
    }
}

References m_d, and requestCanvasUpdate().

Member Data Documentation

m_d

const QScopedPointer<Private> KisMeshTransformStrategy::m_d

private

Definition at line 65 of file kis_mesh_transform_strategy.h.

---

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

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