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, const KoColorDisplayRendererInterface *displayRendererInterface) 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)

Static Private Member Functions
static void	initializeGapShapes (QRectF outlineRect, QLineF leftLine, QLineF rightLine, QPainterPath &outLeft, QPainterPath &outRight, QRectF &outGapLineRect, QPolygonF &outGapLinePolygon)
static void	initializeOutlineObjects (const QTransform &booleanWorkaroundTransform, QList< KoShape * > allShapes, QList< QPainterPath > &outSrcOutlines, QRectF &outOutlineRect)
static bool	willShapeBeCutGeneral (KoShape *referenceShape, const QPainterPath &srcOutline, bool checkGapLineRect, const QRectF &gapLineRect)
static 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

Friends
class	CutThroughShapeStrategyTest

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 31 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 41 of file CutThroughShapeStrategy.cpp.

{
 
}

Member Function Documentation

calculateLineAngle()

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

private

Definition at line 412 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 46 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 189 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;
    }
 
    initializeOutlineObjects(booleanWorkaroundTransform, m_allShapes, srcOutlines, outlineRect);
 
 
 
    if (outlineRect.isEmpty()) {
        //qCritical() << "The outline rect is empty";
        return;
    }
 
 
    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];
 
 
    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");
        return;
    }
 
    // -------------
 
    QPainterPath left, right;
 
    QRectF gapLineRect;
    QPolygonF gapLinePolygon;
    initializeGapShapes(outlineRect, leftLine, rightLine, left, right, gapLineRect, gapLinePolygon);
 
 
    bool checkGapLineRect = !gapLineRect.isEmpty();
 
    QList<KoShape*> newSelectedShapes;
    QList<KoShape*> shapesToRemove;
    int affectedShapes = 0;
    QTransform booleanWorkaroundTransformInverted = booleanWorkaroundTransform.inverted();
 
 
    std::unique_ptr<KUndo2Command> cmd = std::unique_ptr<KUndo2Command>(new KUndo2Command(kundo2_i18n("Knife tool: cut through shapes")));
    new KoKeepShapesSelectedCommand(m_selectedShapes, {}, kisCanvas->selectedShapesProxy(), false, cmd.get());
 
 
    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], 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);
            std::unique_ptr<KoPathShape> shape = std::unique_ptr<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.get();
            }
 
            tool()->canvas()->shapeController()->addShapeDirect(shape.release(), parent, cmd.get());
 
        }
 
        // 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.get());
        new KoKeepShapesSelectedCommand({}, newSelectedShapes, tool()->canvas()->selectedShapesProxy(), true, cmd.get());
        tool()->canvas()->addCommand(cmd.release());
    }
 
 
 
}

References KoCanvasBase::addCommand(), KoShape::background(), calculateLineAngle(), KoToolBase::canvas(), KoPathShape::createShapeFromPainterPath(), eps, KisAlgebra2D::getParallelLines(), gutterWidthInDocumentCoordinates(), KisCanvas2::image(), initializeGapShapes(), initializeOutlineObjects(), KIS_SAFE_ASSERT_RECOVER_RETURN, kundo2_i18n(), m_allShapes, m_endPoint, m_previousLineDirtyRect, m_selectedShapes, m_startPoint, 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 403 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 74 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;
 
    if (tool() && tool()->canvas()) {
        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().

initializeGapShapes()

void CutThroughShapeStrategy::initializeGapShapes ( QRectF outlineRect, QLineF leftLine, QLineF rightLine, QPainterPath & outLeft, QPainterPath & outRight, QRectF & outGapLineRect, QPolygonF & outGapLinePolygon )

staticprivate

Definition at line 165 of file CutThroughShapeStrategy.cpp.

{
 
 
    QRect outlineRectBiggerInt = kisGrowRect(outlineRect, 10).toRect();
    QLineF leftLineLong = leftLine;
    QLineF rightLineLong = rightLine;
 
 
    KisAlgebra2D::cropLineToRect(leftLineLong, outlineRectBiggerInt, true, true);
    KisAlgebra2D::cropLineToRect(rightLineLong, outlineRectBiggerInt, true, true);
 
 
    QList<QPainterPath> paths = KisAlgebra2D::getPathsFromRectangleCutThrough(QRectF(outlineRectBiggerInt), leftLineLong, rightLineLong);
    outLeft = paths[0];
    outRight = paths[1];
 
    outGapLineRect = KisAlgebra2D::createRectFromCorners(leftLine) | KisAlgebra2D::createRectFromCorners(rightLine); // will not be empty if the gutterWidth > 0
 
    outGapLinePolygon = QPolygonF({leftLine.p1(), leftLine.p2(), rightLine.p2(), rightLine.p1(), leftLine.p1()});
 
}

References KisAlgebra2D::createRectFromCorners(), KisAlgebra2D::cropLineToRect(), KisAlgebra2D::getPathsFromRectangleCutThrough(), and kisGrowRect().

initializeOutlineObjects()

void CutThroughShapeStrategy::initializeOutlineObjects ( const QTransform & booleanWorkaroundTransform, QList< KoShape * > allShapes, QList< QPainterPath > & outSrcOutlines, QRectF & outOutlineRect )

staticprivate

Definition at line 151 of file CutThroughShapeStrategy.cpp.

{
    Q_FOREACH (KoShape *shape, allShapes) {
 
        QPainterPath outlineHere =
            booleanWorkaroundTransform.map(
            shape->absoluteTransformation().map(
                shape->outline()));
 
        outSrcOutlines << outlineHere;
        outOutlineRect |= outlineHere.boundingRect();
    }
}

References KoShape::absoluteTransformation(), and KoShape::outline().

paint()

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

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

{
    painter.save();
 
    KoColor c;
    c.fromQColor(Qt::darkGray);
    QColor semitransparentGray = displayRendererInterface->convertColorToDisplayColorSpace(c);
    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(), KoColorDisplayRendererInterface::convertColorToDisplayColorSpace(), KisAlgebra2D::directionBetweenPoints(), KoViewConverter::documentToView(), KoColor::fromQColor(), KisAlgebra2D::getParallelLines(), gutterWidthInDocumentCoordinates(), kisRadiansToDegrees(), m_endPoint, and m_startPoint.

willShapeBeCutGeneral()

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

staticprivate

Definition at line 92 of file CutThroughShapeStrategy.cpp.

{
    if (dynamic_cast<KoSvgTextShape*>(referenceShape)) {
        // skip all text
        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 )

staticprivate

Definition at line 108 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;
 
 
    // it doesn't contain exactly one point, therefore it contains either both or none.
    // if it contains both, it will be true.
    // if it contains none:
    //       if it crosses either gap line, it will be true
    //       if any of the shape points are inside the gap, it will be true
    //       otherwise it's false
 
    if (bothGapLinePointsInside) {
        return true;
    }
 
    if (crossesGapLine) {
        return true;
    }
 
    Q_FOREACH(QPointF p, srcOutline.toFillPolygon()) {
        if (gapLinePolygon.containsPoint(p, Qt::WindingFill)) {
            // a shape point is inside the gap shape
            return true;
        }
    }
 
    return false;
 
}

References KisAlgebra2D::getLineSegmentCrossingLineIndexes(), and p.

Friends And Related Symbol Documentation

CutThroughShapeStrategyTest

friend class CutThroughShapeStrategyTest

friend

Definition at line 51 of file CutThroughShapeStrategy.h.

Member Data Documentation

m_allShapes

QList<KoShape *> CutThroughShapeStrategy::m_allShapes

private

Definition at line 57 of file CutThroughShapeStrategy.h.

m_endPoint

QPointF CutThroughShapeStrategy::m_endPoint = QPointF()

private

Definition at line 54 of file CutThroughShapeStrategy.h.

m_previousLineDirtyRect

QRectF CutThroughShapeStrategy::m_previousLineDirtyRect = QRectF()

private

Definition at line 55 of file CutThroughShapeStrategy.h.

m_selectedShapes

QList<KoShape *> CutThroughShapeStrategy::m_selectedShapes

private

Definition at line 56 of file CutThroughShapeStrategy.h.

m_startPoint

QPointF CutThroughShapeStrategy::m_startPoint = QPointF()

private

Definition at line 53 of file CutThroughShapeStrategy.h.

m_width

GutterWidthsConfig CutThroughShapeStrategy::m_width

private

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