CutThroughShapeStrategy Class Reference

#include <CutThroughShapeStrategy.h>

Inheritance diagram for CutThroughShapeStrategy:

Public Member Functions
KUndo2Command *	createCommand () override
	CutThroughShapeStrategy (KoToolBase *tool, KoSelection *selection, const QList< KoShape * > &allShapes, QPointF startPoint, const GutterWidthsConfig &width)
void	finishInteraction (Qt::KeyboardModifiers modifiers) override
void	handleMouseMove (const QPointF &mouseLocation, Qt::KeyboardModifiers modifiers) override
void	paint (QPainter &painter, const KoViewConverter &converter) override
	~CutThroughShapeStrategy () override
Public Member Functions inherited from KoInteractionStrategy
virtual void	cancelInteraction ()
	KoInteractionStrategy (KoToolBase *parent)
	constructor
KoToolBase *	tool () const
virtual	~KoInteractionStrategy ()
	Destructor.

Private Member Functions
qreal	calculateLineAngle (QPointF start, QPointF end)
qreal	gutterWidthInDocumentCoordinates (qreal lineAngle)

Private Attributes
QList< KoShape * >	m_allShapes
QPointF	m_endPoint = QPointF()
QRectF	m_previousLineDirtyRect = QRectF()
QList< KoShape * >	m_selectedShapes
QPointF	m_startPoint = QPointF()
GutterWidthsConfig	m_width

Additional Inherited Members
Protected Member Functions inherited from KoInteractionStrategy
uint	decorationThickness () const
uint	grabSensitivity () const
	Convenience function to get the global grab sensitivity.
uint	handleRadius () const
	Convenience function to get the global handle radius.
	KoInteractionStrategy (KoInteractionStrategyPrivate &)
	constructor
Protected Attributes inherited from KoInteractionStrategy
KoInteractionStrategyPrivate *	d_ptr

Detailed Description

Definition at line 23 of file CutThroughShapeStrategy.h.

Constructor & Destructor Documentation

CutThroughShapeStrategy()

CutThroughShapeStrategy::CutThroughShapeStrategy	(	KoToolBase *	tool,
		KoSelection *	selection,
		const QList< KoShape * > &	allShapes,
		QPointF	startPoint,
		const GutterWidthsConfig &	width )

Definition at line 29 of file CutThroughShapeStrategy.cpp.

    : KoInteractionStrategy(tool)
    , m_startPoint(startPoint)
    , m_endPoint(startPoint)
    , m_width(width)
{
    m_selectedShapes = selection->selectedEditableShapes();
    m_allShapes = shapes;
}

References m_allShapes, m_selectedShapes, and KoSelection::selectedEditableShapes().

~CutThroughShapeStrategy()

CutThroughShapeStrategy::~CutThroughShapeStrategy ( )

override

Definition at line 39 of file CutThroughShapeStrategy.cpp.

{
 
}

Member Function Documentation

calculateLineAngle()

qreal CutThroughShapeStrategy::calculateLineAngle ( QPointF start, QPointF end )

private

Definition at line 356 of file CutThroughShapeStrategy.cpp.

{
    QPointF vec = end - start;
    qreal angleDegrees = KisAlgebra2D::wrapValue(kisRadiansToDegrees(std::atan2(vec.y(), vec.x())), 0.0, 360.0);
    return angleDegrees;
}

References kisRadiansToDegrees(), and KisAlgebra2D::wrapValue().

createCommand()

KUndo2Command * CutThroughShapeStrategy::createCommand ( )

overridevirtual

For interactions that are undo-able this method should be implemented to return such a command. Implementations should return 0 otherwise.

Returns

a command, or 0.

Implements KoInteractionStrategy.

Definition at line 44 of file CutThroughShapeStrategy.cpp.

{
    // TODO: undoing
    return 0;
}

finishInteraction()

void CutThroughShapeStrategy::finishInteraction ( Qt::KeyboardModifiers modifiers )

overridevirtual

Override to make final changes to the data on the end of an interaction.

Implements KoInteractionStrategy.

Definition at line 87 of file CutThroughShapeStrategy.cpp.

{
    tool()->canvas()->updateCanvas(m_previousLineDirtyRect);
 
 
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(tool()->canvas());
    KIS_SAFE_ASSERT_RECOVER_RETURN(kisCanvas);
    const QTransform booleanWorkaroundTransform = KritaUtils::pathShapeBooleanSpaceWorkaround(kisCanvas->image());
 
    QList<QPainterPath> srcOutlines;
    QRectF outlineRect;
 
    if (m_allShapes.length() == 0) {
        qCritical() << "No shapes are available";
        return;
    }
 
    Q_FOREACH (KoShape *shape, m_allShapes) {
 
        QPainterPath outlineHere =
            booleanWorkaroundTransform.map(
            shape->absoluteTransformation().map(
                shape->outline()));
 
        srcOutlines << outlineHere;
        outlineRect |= outlineHere.boundingRect();//booleanWorkaroundTransform.map(shape->absoluteOutlineRect()).boundingRect();
    }
 
    if (outlineRect.isEmpty()) {
        //qCritical() << "The outline rect is empty";
        return;
    }
 
    QRectF outlineRectBigger = kisGrowRect(outlineRect, 10);
    QRect outlineRectBiggerInt = outlineRectBigger.toRect();
 
    QLineF gapLine = QLineF(m_startPoint, m_endPoint);
    qreal eps = 0.0000001;
    if (gapLine.length() < eps) {
        return;
    }
 
    qreal gutterWidth = gutterWidthInDocumentCoordinates(calculateLineAngle(m_startPoint, m_endPoint));
 
    QList<QLineF> gapLines = KisAlgebra2D::getParallelLines(gapLine, gutterWidth/2);
 
    gapLine = booleanWorkaroundTransform.map(gapLine);
    gapLines[0] = booleanWorkaroundTransform.map(gapLines[0]);
    gapLines[1] = booleanWorkaroundTransform.map(gapLines[1]);
 
    QLineF leftLine = gapLines[0];
    QLineF rightLine = gapLines[1];
 
    QLineF leftLineLong = leftLine;
    QLineF rightLineLong = rightLine;
 
 
 
    KisAlgebra2D::cropLineToRect(leftLineLong, outlineRectBiggerInt, true, true);
    KisAlgebra2D::cropLineToRect(rightLineLong, outlineRectBiggerInt, true, true);
 
    KUndo2Command *cmd = new KUndo2Command(kundo2_i18n("Knife tool: cut through shapes"));
 
 
    new KoKeepShapesSelectedCommand(m_selectedShapes, {}, kisCanvas->selectedShapesProxy(), false, cmd);
 
 
    if (leftLine.length() == 0 || rightLine.length() == 0) {
        KIS_SAFE_ASSERT_RECOVER_RETURN(gapLine.length() != 0 && gapLines[0].length() != 0 && gapLines[1].length() != 0 && "Original gap lines shouldn't be empty at this point");
        // looks like *all* shapes need to be cut out
 
        tool()->canvas()->shapeController()->removeShapes(m_allShapes, cmd);
        tool()->canvas()->addCommand(cmd);
        return;
    }
 
 
    QList<QPainterPath> paths = KisAlgebra2D::getPathsFromRectangleCutThrough(QRectF(outlineRectBiggerInt), leftLineLong, rightLineLong);
    QPainterPath left = paths[0];
    QPainterPath right = paths[1];
 
    QList<QPainterPath> pathsOpposite = KisAlgebra2D::getPathsFromRectangleCutThrough(QRectF(outlineRectBiggerInt), rightLineLong, leftLineLong);
    QPainterPath leftOpposite = pathsOpposite[0];
    QPainterPath rightOpposite = pathsOpposite[1];
 
    QList<KoShape*> newSelectedShapes;
 
    QList<KoShape*> shapesToRemove;
 
    QTransform booleanWorkaroundTransformInverted = booleanWorkaroundTransform.inverted();
 
    QRectF gapLineLeftRect = KisAlgebra2D::createRectFromCorners(leftLine);
    QRectF gapLineRightRect = KisAlgebra2D::createRectFromCorners(rightLine);
 
 
    for (int i = 0; i < srcOutlines.size(); i++) {
 
        KoShape* referenceShape = m_allShapes[i];
        bool wasSelected = m_selectedShapes.contains(referenceShape);
 
        if ((srcOutlines[i].boundingRect() & leftOpposite.boundingRect()).isEmpty()
                || (srcOutlines[i].boundingRect() & rightOpposite.boundingRect()).isEmpty()) {
            // there is nothing on one side
            // everything is on the other, far away from the gap line
            // it just makes it a bit faster when there is a whole lot of shapes
 
            if (wasSelected) {
                newSelectedShapes << referenceShape;
            }
            continue;
        }
 
        if ((srcOutlines[i].boundingRect() & gapLineLeftRect).isEmpty()
                || (srcOutlines[i].boundingRect() & gapLineRightRect).isEmpty()) {
            // the gap lines can't cross the shape since their bounding rects don't cross
            if (wasSelected) {
                newSelectedShapes << referenceShape;
            }
            continue;
        }
 
        // either one of the points is inside the path, or the line crosses one of the segments
        bool containsGapLinePoint = srcOutlines[i].contains(leftLine.p1()) || srcOutlines[i].contains(leftLine.p2())
                || srcOutlines[i].contains(rightLine.p1()) || srcOutlines[i].contains(rightLine.p2());
        bool crossesGapLine = KisAlgebra2D::getLineSegmentCrossingLineIndexes(leftLine, srcOutlines[i]).count() > 0
                || KisAlgebra2D::getLineSegmentCrossingLineIndexes(rightLine, srcOutlines[i]).count() > 0;
        if (!containsGapLinePoint && !crossesGapLine) {
 
            //qCritical() << "it doesn't cross the line!";
            if (wasSelected) {
                newSelectedShapes << referenceShape;
            }
            continue;
        }
 
 
 
 
        QPainterPath leftPath = srcOutlines[i] & left;
        QPainterPath rightPath = srcOutlines[i] & right;
 
        QList<QPainterPath> bothSides;
        bothSides << leftPath << rightPath;
 
 
        Q_FOREACH(QPainterPath path, bothSides) {
            if (path.isEmpty()) {
                continue;
            }
 
            // comment copied from another place:
            // there is a bug in Qt, sometimes it leaves the resulting
            // outline open, so just close it explicitly.
            path.closeSubpath();
            // this is needed because Qt linearize curves; this allows for a
            // "sane" linearization instead of a very blocky appearance
            path = booleanWorkaroundTransformInverted.map(path);
            KoPathShape* shape = KoPathShape::createShapeFromPainterPath(path);
 
            if (shape->boundingRect().isEmpty()) {
                continue;
            }
 
            shape->setBackground(referenceShape->background());
            shape->setStroke(referenceShape->stroke());
            shape->setZIndex(referenceShape->zIndex());
 
            KoShapeContainer *parent = referenceShape->parent();
            tool()->canvas()->shapeController()->addShapeDirect(shape, parent, cmd);
 
            if (wasSelected) {
                newSelectedShapes << shape;
            }
 
 
        }
 
        // that happens no matter if there was any non-empty shape
        // because if there is none, maybe they just were underneath the gap
        shapesToRemove << m_allShapes[i];
 
    }
 
    tool()->canvas()->shapeController()->removeShapes(shapesToRemove, cmd);
    new KoKeepShapesSelectedCommand({}, newSelectedShapes, tool()->canvas()->selectedShapesProxy(), true, cmd);
 
 
    tool()->canvas()->addCommand(cmd);
 
 
 
}

References KoShape::absoluteTransformation(), KoCanvasBase::addCommand(), KoShape::background(), KoPathShape::boundingRect(), calculateLineAngle(), KoToolBase::canvas(), KisAlgebra2D::createRectFromCorners(), KoPathShape::createShapeFromPainterPath(), KisAlgebra2D::cropLineToRect(), eps, KisAlgebra2D::getLineSegmentCrossingLineIndexes(), KisAlgebra2D::getParallelLines(), KisAlgebra2D::getPathsFromRectangleCutThrough(), gutterWidthInDocumentCoordinates(), KisCanvas2::image(), KIS_SAFE_ASSERT_RECOVER_RETURN, kisGrowRect(), kundo2_i18n(), m_allShapes, m_endPoint, m_previousLineDirtyRect, m_selectedShapes, m_startPoint, KoShape::outline(), KoShape::parent(), KritaUtils::pathShapeBooleanSpaceWorkaround(), KoCanvasBase::selectedShapesProxy(), KisCanvas2::selectedShapesProxy, KoShape::setBackground(), KoShape::setStroke(), KoShape::setZIndex(), KoCanvasBase::shapeController, KoShape::stroke(), KoInteractionStrategy::tool(), KoCanvasBase::updateCanvas(), and KoShape::zIndex().

gutterWidthInDocumentCoordinates()

qreal CutThroughShapeStrategy::gutterWidthInDocumentCoordinates ( qreal lineAngle )

private

Definition at line 347 of file CutThroughShapeStrategy.cpp.

{
    KisCanvas2 *kisCanvas = static_cast<KisCanvas2 *>(tool()->canvas());
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(kisCanvas, m_width.widthForAngleInPixels(lineAngle));
    QLineF helperGapWidthLine = QLineF(QPointF(0, 0), QPointF(0, m_width.widthForAngleInPixels(lineAngle)));
    QLineF helperGapWidthLineTransformed = kisCanvas->coordinatesConverter()->imageToDocument(helperGapWidthLine);
    return helperGapWidthLineTransformed.length();
}

References KoToolBase::canvas(), KisCanvas2::coordinatesConverter, KisCoordinatesConverter::imageToDocument(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_width, KoInteractionStrategy::tool(), and GutterWidthsConfig::widthForAngleInPixels().

handleMouseMove()

void CutThroughShapeStrategy::handleMouseMove ( const QPointF & mouseLocation, Qt::KeyboardModifiers modifiers )

overridevirtual

Extending classes should implement this method to update the selectedShapes based on the new mouse position.

Parameters

mouseLocation	the new location in pt
modifiers	OR-ed set of keys pressed.

Implements KoInteractionStrategy.

Definition at line 72 of file CutThroughShapeStrategy.cpp.

{
    m_endPoint = snapEndPoint(m_startPoint, mouseLocation, modifiers);
    QRectF dirtyRect;
    KisAlgebra2D::accumulateBounds(m_startPoint, &dirtyRect);
    KisAlgebra2D::accumulateBounds(m_endPoint, &dirtyRect);
    dirtyRect = kisGrowRect(dirtyRect, gutterWidthInDocumentCoordinates(calculateLineAngle(m_startPoint, m_endPoint))); // twice as much as it should need to account for lines showing the effect
 
    QRectF accumulatedWithPrevious = m_previousLineDirtyRect | dirtyRect;
 
    tool()->canvas()->updateCanvas(accumulatedWithPrevious);
    m_previousLineDirtyRect = dirtyRect;
 
}

References KisAlgebra2D::accumulateBounds(), calculateLineAngle(), KoToolBase::canvas(), gutterWidthInDocumentCoordinates(), kisGrowRect(), m_endPoint, m_previousLineDirtyRect, m_startPoint, snapEndPoint(), KoInteractionStrategy::tool(), and KoCanvasBase::updateCanvas().

paint()

void CutThroughShapeStrategy::paint ( QPainter & painter, const KoViewConverter & converter )

overridevirtual

Reimplement this if the action needs to draw a "blob" on the canvas; that is, a transient decoration like a rubber band.

Reimplemented from KoInteractionStrategy.

Definition at line 280 of file CutThroughShapeStrategy.cpp.

{
    painter.save();
 
    QColor semitransparentGray = QColor(Qt::darkGray);
    semitransparentGray.setAlphaF(0.6);
    QPen pen = QPen(QBrush(semitransparentGray), 2);
    painter.setPen(pen);
 
    painter.setRenderHint(QPainter::RenderHint::Antialiasing, true);
 
    qreal gutterWidth = gutterWidthInDocumentCoordinates(calculateLineAngle(m_startPoint, m_endPoint));
 
    QLineF gutterCenterLine = QLineF(m_startPoint, m_endPoint);
    gutterCenterLine = converter.documentToView().map(gutterCenterLine);
    QLineF gutterWidthHelperLine = QLineF(QPointF(0, 0), QPointF(gutterWidth, 0));
    gutterWidthHelperLine = converter.documentToView().map(gutterWidthHelperLine);
 
    gutterWidth = gutterWidthHelperLine.length();
 
    QList<QLineF> gutterLines = KisAlgebra2D::getParallelLines(gutterCenterLine, gutterWidth/2);
 
    QLineF gutterLine1 = gutterLines.length() > 0 ? gutterLines[0] : gutterCenterLine;
    QLineF gutterLine2 = gutterLines.length() > 1 ? gutterLines[1] : gutterCenterLine;
 
 
    painter.drawLine(gutterLine1);
    painter.drawLine(gutterLine2);
 
    QRectF arcRect1 = QRectF(gutterCenterLine.p1() - QPointF(gutterWidth/2, gutterWidth/2), gutterCenterLine.p1() + QPointF(gutterWidth/2, gutterWidth/2));
    QRectF arcRect2 = QRectF(gutterCenterLine.p2() - QPointF(gutterWidth/2, gutterWidth/2), gutterCenterLine.p2() + QPointF(gutterWidth/2, gutterWidth/2));
 
    int qtAngleFactor = 16;
    int qtHalfCircle = qtAngleFactor*180;
 
    painter.drawArc(arcRect1, -qtAngleFactor*kisRadiansToDegrees(KisAlgebra2D::directionBetweenPoints(gutterCenterLine.p1(), gutterLine1.p1(), 0)), qtHalfCircle);
    painter.drawArc(arcRect2, -qtAngleFactor*kisRadiansToDegrees(KisAlgebra2D::directionBetweenPoints(gutterCenterLine.p2(), gutterLine1.p2(), 0)), -qtHalfCircle);
 
 
    int xLength = 3;
    qreal xLengthEllipse = 2*qSqrt(2);
 
    if (false) { // drawing X
    painter.drawLine({QLineF(gutterCenterLine.p1() - QPointF(xLength, xLength), gutterCenterLine.p1() + QPointF(xLength, xLength))});
    painter.drawLine({QLineF(gutterCenterLine.p2() - QPointF(xLength, xLength), gutterCenterLine.p2() + QPointF(xLength, xLength))});
 
    painter.drawLine({QLineF(gutterCenterLine.p1() - QPointF(xLength, -xLength), gutterCenterLine.p1() + QPointF(xLength, -xLength))});
    painter.drawLine({QLineF(gutterCenterLine.p2() - QPointF(xLength, -xLength), gutterCenterLine.p2() + QPointF(xLength, -xLength))});
    }
 
    // ellipse at the both ends of the gutter center line
    painter.drawEllipse(gutterCenterLine.p1(), xLengthEllipse, xLengthEllipse);
    painter.drawEllipse(gutterCenterLine.p2(), xLengthEllipse, xLengthEllipse);
 
 
 
    pen.setWidth(1);
    semitransparentGray.setAlphaF(0.2);
    pen.setColor(semitransparentGray);
 
    painter.setPen(pen);
 
    painter.drawLine(gutterCenterLine);
 
    painter.restore();
}

References calculateLineAngle(), KisAlgebra2D::directionBetweenPoints(), KoViewConverter::documentToView(), KisAlgebra2D::getParallelLines(), gutterWidthInDocumentCoordinates(), kisRadiansToDegrees(), m_endPoint, and m_startPoint.

Member Data Documentation

m_allShapes

QList<KoShape *> CutThroughShapeStrategy::m_allShapes

private

Definition at line 49 of file CutThroughShapeStrategy.h.

m_endPoint

QPointF CutThroughShapeStrategy::m_endPoint = QPointF()

private

Definition at line 46 of file CutThroughShapeStrategy.h.

m_previousLineDirtyRect

QRectF CutThroughShapeStrategy::m_previousLineDirtyRect = QRectF()

private

Definition at line 47 of file CutThroughShapeStrategy.h.

m_selectedShapes

QList<KoShape *> CutThroughShapeStrategy::m_selectedShapes

private

Definition at line 48 of file CutThroughShapeStrategy.h.

m_startPoint

QPointF CutThroughShapeStrategy::m_startPoint = QPointF()

private

Definition at line 45 of file CutThroughShapeStrategy.h.

m_width

GutterWidthsConfig CutThroughShapeStrategy::m_width

private

Definition at line 50 of file CutThroughShapeStrategy.h.

---

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

• plugins/tools/tool_knife/CutThroughShapeStrategy.h
• plugins/tools/tool_knife/CutThroughShapeStrategy.cpp