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)
bool	willShapeBeCutGeneral (KoShape *referenceShape, const QPainterPath &srcOutline, const QRectF &leftOppositeRect, const QRectF &rightOppositeRect, bool checkGapLineRect, const QRectF &gapLineRect)
bool	willShapeBeCutPrecise (const QPainterPath &srcOutline, const QLineF gapLine, const QLineF &leftLine, const QLineF &rightLine, const QPolygonF &gapLinePolygon)

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 30 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 40 of file CutThroughShapeStrategy.cpp.

{
 
}

Member Function Documentation

calculateLineAngle()

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

private

Definition at line 393 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 45 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 144 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);
 
    QScopedPointer<KUndo2Command> cmd = QScopedPointer<KUndo2Command>(new KUndo2Command(kundo2_i18n("Knife tool: cut through shapes")));
 
 
    new KoKeepShapesSelectedCommand(m_selectedShapes, {}, kisCanvas->selectedShapesProxy(), false, cmd.data());
 
 
    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.data());
        tool()->canvas()->addCommand(cmd.take());
        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); // warning! can be empty for perfectly horizontal/vertical lines
    QRectF gapLineRightRect = KisAlgebra2D::createRectFromCorners(rightLine);
    QRectF gapLineRect = gapLineLeftRect | gapLineRightRect; // will not be empty if the gutterWidth > 0
    bool checkGapLineRect = !gapLineRect.isEmpty();
    QPolygonF gapLinePolygon = QPolygonF({leftLine.p1(), leftLine.p2(), rightLine.p2(), rightLine.p1(), leftLine.p1()});
 
    int affectedShapes = 0;
 
    for (int i = 0; i < srcOutlines.size(); i++) {
 
        KoShape* referenceShape = m_allShapes[i];
        bool wasSelected = m_selectedShapes.contains(referenceShape);
 
        bool skipThisShape = !willShapeBeCutGeneral(referenceShape, srcOutlines[i], leftOpposite.boundingRect(), rightOpposite.boundingRect(), checkGapLineRect, gapLineRect);
        skipThisShape = skipThisShape || !willShapeBeCutPrecise(srcOutlines[i], gapLine, leftLine, rightLine, gapLinePolygon);
 
        if (skipThisShape) {
            if (wasSelected) {
                newSelectedShapes << referenceShape;
            }
            continue;
        }
 
        affectedShapes++;
 
 
        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);
            QScopedPointer<KoPathShape> shape = QScopedPointer<KoPathShape>(KoPathShape::createShapeFromPainterPath(path));
            shape->closeMerge();
 
            if (shape->boundingRect().isEmpty()) {
                continue;
            }
 
            shape->setBackground(referenceShape->background());
            shape->setStroke(referenceShape->stroke());
            shape->setZIndex(referenceShape->zIndex());
 
            KoShapeContainer *parent = referenceShape->parent();
 
            if (wasSelected) {
                newSelectedShapes << shape.data();
            }
 
            tool()->canvas()->shapeController()->addShapeDirect(shape.take(), parent, cmd.data());
 
        }
 
        // 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];
 
    }
 
    if (affectedShapes > 0) {
        tool()->canvas()->shapeController()->removeShapes(shapesToRemove, cmd.data());
        new KoKeepShapesSelectedCommand({}, newSelectedShapes, tool()->canvas()->selectedShapesProxy(), true, cmd.data());
        tool()->canvas()->addCommand(cmd.take());
    }
 
 
 
}

References KoShape::absoluteTransformation(), KoCanvasBase::addCommand(), KoShape::background(), calculateLineAngle(), KoToolBase::canvas(), KisAlgebra2D::createRectFromCorners(), KoPathShape::createShapeFromPainterPath(), KisAlgebra2D::cropLineToRect(), eps, 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, KoCanvasBase::shapeController, KoShape::stroke(), KoInteractionStrategy::tool(), KoCanvasBase::updateCanvas(), willShapeBeCutGeneral(), willShapeBeCutPrecise(), and KoShape::zIndex().

gutterWidthInDocumentCoordinates()

qreal CutThroughShapeStrategy::gutterWidthInDocumentCoordinates ( qreal lineAngle )

private

Definition at line 384 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 73 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 317 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.

willShapeBeCutGeneral()

bool CutThroughShapeStrategy::willShapeBeCutGeneral ( KoShape * referenceShape, const QPainterPath & srcOutline, const QRectF & leftOppositeRect, const QRectF & rightOppositeRect, bool checkGapLineRect, const QRectF & gapLineRect )

private

Definition at line 89 of file CutThroughShapeStrategy.cpp.

{
    if (dynamic_cast<KoSvgTextShape*>(referenceShape)) {
        // skip all text
        return false;
    }
 
    if ((srcOutline.boundingRect() & leftOppositeRect).isEmpty()
            || (srcOutline.boundingRect() & rightOppositeRect).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
 
        return false;
    }
 
    if (checkGapLineRect && (srcOutline.boundingRect() & gapLineRect).isEmpty()) {
        // the gap lines can't cross the shape since their bounding rects don't cross it
        return false;
    }
 
    return true;
}

willShapeBeCutPrecise()

bool CutThroughShapeStrategy::willShapeBeCutPrecise ( const QPainterPath & srcOutline, const QLineF gapLine, const QLineF & leftLine, const QLineF & rightLine, const QPolygonF & gapLinePolygon )

private

Definition at line 113 of file CutThroughShapeStrategy.cpp.

{
    bool containsGapLinePointStart = srcOutline.contains(gapLine.p1());
    bool containsGapLinePointEnd = srcOutline.contains(gapLine.p2());
 
    // if should skip if there is exactly one gap line point inside the shape
    bool exactlyOneGapLinePointInside = (containsGapLinePointStart != containsGapLinePointEnd);
    bool bothGapLinePointsInside = containsGapLinePointStart && containsGapLinePointEnd;
 
    if (exactlyOneGapLinePointInside) {
        return false;
    }
 
    bool crossesGapLine = KisAlgebra2D::getLineSegmentCrossingLineIndexes(leftLine, srcOutline).count() > 0
            || KisAlgebra2D::getLineSegmentCrossingLineIndexes(rightLine, srcOutline).count() > 0;
 
 
    bool containsPointWithinGap = false;
    Q_FOREACH(QPointF p, srcOutline.toFillPolygon()) {
        if (gapLinePolygon.containsPoint(p, Qt::WindingFill)) {
            containsPointWithinGap = true;
            break;
        }
    }
 
    if (!bothGapLinePointsInside && !crossesGapLine && !containsPointWithinGap) {
        return false;
    }
    return true;
}

References KisAlgebra2D::getLineSegmentCrossingLineIndexes(), and p.

Member Data Documentation

m_allShapes

QList<KoShape *> CutThroughShapeStrategy::m_allShapes

private

Definition at line 52 of file CutThroughShapeStrategy.h.

m_endPoint

QPointF CutThroughShapeStrategy::m_endPoint = QPointF()

private

Definition at line 49 of file CutThroughShapeStrategy.h.

m_previousLineDirtyRect

QRectF CutThroughShapeStrategy::m_previousLineDirtyRect = QRectF()

private

Definition at line 50 of file CutThroughShapeStrategy.h.

m_selectedShapes

QList<KoShape *> CutThroughShapeStrategy::m_selectedShapes

private

Definition at line 51 of file CutThroughShapeStrategy.h.

m_startPoint

QPointF CutThroughShapeStrategy::m_startPoint = QPointF()

private

Definition at line 48 of file CutThroughShapeStrategy.h.

m_width

GutterWidthsConfig CutThroughShapeStrategy::m_width

private

Definition at line 53 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