Classes
struct	HandlePoints

Public Member Functions
QCursor	getScaleCursor (const QPointF &handlePt)

QCursor	getShearCursor (const QPointF &start, const QPointF &end)

	Private (KisFreeTransformStrategy _q, const KisCoordinatesConverter _converter, ToolTransformArgs &_currentArgs, TransformTransactionProperties &_transaction)

void	recalculateBounds ()

void	recalculateTransformations ()

void	recalculateTransformedHandles ()

Public Attributes
QRectF	bounds

QTransform	boundsTransform

ToolTransformArgs	clickArgs

QPointF	clickPos

QTransform	clickTransform

const KisCoordinatesConverter *	converter
	standard members ///

ToolTransformArgs &	currentArgs

StrokeFunction	function {MOVE}
	custom members ///

QTransform	handlesTransform

bool	imageTooBig {false}

bool	isTransforming {false}

QImage	originalImage

QPointF	paintingOffset

QTransform	paintingTransform

KisFreeTransformStrategy *	q

QCursor	rotateHandlesCursor

QCursor	scaleCursors [8]

QPixmap	shearCursorPixmap

QTransform	thumbToImageTransform

TransformTransactionProperties &	transaction

QTransform	transform

HandlePoints	transformedHandles

Detailed Description

Definition at line 49 of file kis_free_transform_strategy.cpp.

Constructor & Destructor Documentation

◆ Private()

KisFreeTransformStrategy::Private::Private	(	KisFreeTransformStrategy *	_q,
		const KisCoordinatesConverter *	_converter,
		ToolTransformArgs &	_currentArgs,
		TransformTransactionProperties &	_transaction )

inline

Definition at line 51 of file kis_free_transform_strategy.cpp.

        : q(_q),
          converter(_converter),
          currentArgs(_currentArgs),
          transaction(_transaction),
          imageTooBig(false),
          isTransforming(false)
    {
        scaleCursors[0] = KisCursor::sizeHorCursor();
        scaleCursors[1] = KisCursor::sizeFDiagCursor();
        scaleCursors[2] = KisCursor::sizeVerCursor();
        scaleCursors[3] = KisCursor::sizeBDiagCursor();
        scaleCursors[4] = KisCursor::sizeHorCursor();
        scaleCursors[5] = KisCursor::sizeFDiagCursor();
        scaleCursors[6] = KisCursor::sizeVerCursor();
        scaleCursors[7] = KisCursor::sizeBDiagCursor();
 
        shearCursorPixmap = QIcon(":/shear_cursor.svg").pixmap(22, 22);
        rotateHandlesCursor = QCursor(QIcon(":/rotate_cursor_handles.svg").pixmap(32, 32));
    }

References rotateHandlesCursor, scaleCursors, shearCursorPixmap, KisCursor::sizeBDiagCursor(), KisCursor::sizeFDiagCursor(), KisCursor::sizeHorCursor(), and KisCursor::sizeVerCursor().

Member Function Documentation

◆ getScaleCursor()

QCursor KisFreeTransformStrategy::Private::getScaleCursor ( const QPointF & handlePt )

Definition at line 269 of file kis_free_transform_strategy.cpp.

{
    QPointF handlePtInWidget = converter->imageToWidget(handlePt);
    QPointF centerPtInWidget = converter->imageToWidget(currentArgs.transformedCenter());
 
    QPointF direction = handlePtInWidget - centerPtInWidget;
    qreal angle = atan2(direction.y(), direction.x());
    angle = normalizeAngle(angle);
 
    int octant = qRound(angle * 4. / M_PI) % 8;
    return scaleCursors[octant];
}

References M_PI, and normalizeAngle().

◆ getShearCursor()

QCursor KisFreeTransformStrategy::Private::getShearCursor	(	const QPointF &	start,
		const QPointF &	end )

Definition at line 282 of file kis_free_transform_strategy.cpp.

{
    QPointF startPtInWidget = converter->imageToWidget(start);
    QPointF endPtInWidget = converter->imageToWidget(end);
    QPointF direction = endPtInWidget - startPtInWidget;
 
    qreal angle = atan2(-direction.y(), direction.x());
    return QCursor(shearCursorPixmap.transformed(QTransform().rotateRadians(-angle)));
}

◆ recalculateBounds()

void KisFreeTransformStrategy::Private::recalculateBounds ( )

Definition at line 170 of file kis_free_transform_strategy.cpp.

{
    const QPolygonF &convexHull = transaction.convexHull();
    if (!convexHull.isEmpty()) {
        bounds = boundsTransform.inverted().map(convexHull).boundingRect();
    } else {
        bounds = boundsTransform.inverted().mapRect(transaction.originalRect());
    }
}

References bounds, boundsTransform, TransformTransactionProperties::convexHull(), TransformTransactionProperties::originalRect(), and transaction.

◆ recalculateTransformations()

void KisFreeTransformStrategy::Private::recalculateTransformations ( )

The center of the original image should still stay the origin of CS

Definition at line 848 of file kis_free_transform_strategy.cpp.

{
    KisTransformUtils::MatricesPack m(currentArgs);
    QTransform sanityCheckMatrix = m.TS * m.SC * m.S * m.projectedP;
 
    KIS_ASSERT_RECOVER_NOOP(sanityCheckMatrix.map(currentArgs.originalCenter()).manhattanLength() < 1e-4);
 
    transform = m.finalTransform();
    boundsTransform = m.BRI.inverted();
    recalculateBounds();
 
    QTransform viewScaleTransform = converter->imageToDocumentTransform() * converter->documentToFlakeTransform();
    handlesTransform = boundsTransform * transform * viewScaleTransform;
 
    QTransform tl = QTransform::fromTranslate(transaction.originalTopLeft().x(), transaction.originalTopLeft().y());
    paintingTransform = tl.inverted() * q->thumbToImageTransform() * tl * transform * viewScaleTransform;
    paintingOffset = transaction.originalTopLeft();
 
    // check whether image is too big to be displayed or not
    imageTooBig = KisTransformUtils::checkImageTooBig(transaction.originalRect(), m, currentArgs.cameraPos().z());
 
    // recalculate cached handles position
    recalculateTransformedHandles();
 
    Q_EMIT q->requestShowImageTooBig(imageTooBig);
    Q_EMIT q->requestImageRecalculation();
}

References KisTransformUtils::MatricesPack::BRI, KisTransformUtils::checkImageTooBig(), KisTransformUtils::MatricesPack::finalTransform(), KIS_ASSERT_RECOVER_NOOP, KisTransformUtils::MatricesPack::projectedP, KisTransformUtils::MatricesPack::S, KisTransformUtils::MatricesPack::SC, and KisTransformUtils::MatricesPack::TS.

◆ recalculateTransformedHandles()

void KisFreeTransformStrategy::Private::recalculateTransformedHandles ( )

Definition at line 181 of file kis_free_transform_strategy.cpp.

{
    QTransform boundsFullTransform = boundsTransform * transform;
    transformedHandles.topLeft = boundsFullTransform.map(bounds.topLeft());
    transformedHandles.topMiddle = boundsFullTransform.map(topMiddle(bounds));
    transformedHandles.topRight = boundsFullTransform.map(bounds.topRight());
 
    transformedHandles.middleLeft = boundsFullTransform.map(middleLeft(bounds));
    transformedHandles.middleRight = boundsFullTransform.map(middleRight(bounds));
 
    transformedHandles.bottomLeft = boundsFullTransform.map(bounds.bottomLeft());
    transformedHandles.bottomMiddle = boundsFullTransform.map(bottomMiddle(bounds));
    transformedHandles.bottomRight = boundsFullTransform.map(bounds.bottomRight());
 
    transformedHandles.rotationCenter = transform.map(currentArgs.originalCenter() + currentArgs.rotationCenterOffset());
}