ExtensionSnapStrategy Class Reference

snaps extension lines of path shapes More...

#include <KoSnapStrategy.h>

Inheritance diagram for ExtensionSnapStrategy:

Public Member Functions
QPainterPath	decoration (const KoViewConverter &converter) const override
	returns the current snap strategy decoration
	ExtensionSnapStrategy ()
bool	snap (const QPointF &mousePosition, KoSnapProxy *proxy, qreal maxSnapDistance) override
Public Member Functions inherited from KoSnapStrategy
	KoSnapStrategy (KoSnapGuide::Strategy type)
QPointF	snappedPosition () const
	returns the snapped position form the last call to snapToPoints
SnapType	snappedType () const
KoSnapGuide::Strategy	type () const
	returns the strategies type
virtual	~KoSnapStrategy ()

Private Member Functions
QPointF	extensionDirection (KoPathPoint *point, const QTransform &matrix)
qreal	project (const QPointF &lineStart, const QPointF &lineEnd, const QPointF &point)
bool	snapToExtension (QPointF &position, KoPathPoint *point, const QTransform &matrix)

Private Attributes
QList< QLineF >	m_lines

Friends
class	TestSnapStrategy

Additional Inherited Members
Public Types inherited from KoSnapStrategy
enum	SnapType { ToPoint = 0 , ToLine }
Static Public Member Functions inherited from KoSnapStrategy
static qreal	scalarProduct (const QPointF &p1, const QPointF &p2)
static qreal	squareDistance (const QPointF &p1, const QPointF &p2)
Protected Member Functions inherited from KoSnapStrategy
void	setSnappedPosition (const QPointF &position, SnapType snapType)
	sets the current snapped position

Detailed Description

snaps extension lines of path shapes

Definition at line 86 of file KoSnapStrategy.h.

Constructor & Destructor Documentation

ExtensionSnapStrategy()

ExtensionSnapStrategy::ExtensionSnapStrategy

(

)

Definition at line 172 of file KoSnapStrategy.cpp.

    : KoSnapStrategy(KoSnapGuide::ExtensionSnapping)
{
}

Member Function Documentation

decoration()

QPainterPath ExtensionSnapStrategy::decoration ( const KoViewConverter & converter ) const

overridevirtual

returns the current snap strategy decoration

Implements KoSnapStrategy.

Definition at line 287 of file KoSnapStrategy.cpp.

{
    QPainterPath decoration;
    foreach (const QLineF &line, m_lines) {
        decoration.moveTo(line.p1());
        decoration.lineTo(line.p2());
    }
    return decoration;
}

References decoration(), and m_lines.

extensionDirection()

QPointF ExtensionSnapStrategy::extensionDirection ( KoPathPoint * point, const QTransform & matrix )

private

Definition at line 331 of file KoSnapStrategy.cpp.

{
    Q_ASSERT(point);
 
    KoPathShape * path = point->parent();
    KoPathPointIndex index = path->pathPointIndex(point);
 
    // check if it is a start point
    if (point->properties() & KoPathPoint::StartSubpath) {
        if (point->activeControlPoint2()) {
            return matrix.map(point->point()) - matrix.map(point->controlPoint2());
        } else {
            KoPathPoint * next = path->pointByIndex(KoPathPointIndex(index.first, index.second + 1));
            if (! next){
                return QPointF();
            }
            else if (next->activeControlPoint1()) {
                return matrix.map(point->point()) - matrix.map(next->controlPoint1());
            }
            else {
                return matrix.map(point->point()) - matrix.map(next->point());
            }
        }
    }
    else {
        if (point->activeControlPoint1()) {
            return matrix.map(point->point()) - matrix.map(point->controlPoint1());
        }
        else {
            KoPathPoint * prev = path->pointByIndex(KoPathPointIndex(index.first, index.second - 1));
            if (! prev){
                return QPointF();
            }
            else if (prev->activeControlPoint2()) {
                return matrix.map(point->point()) - matrix.map(prev->controlPoint2());
            }
            else {
                return matrix.map(point->point()) - matrix.map(prev->point());
            }
        }
    }
}

References KoPathPoint::activeControlPoint1, KoPathPoint::activeControlPoint2, KoPathPoint::controlPoint1, KoPathPoint::controlPoint2, KoPathPoint::parent(), KoPathShape::pathPointIndex(), KoPathPoint::point, KoPathPoint::properties, and KoPathPoint::StartSubpath.

project()

qreal ExtensionSnapStrategy::project ( const QPointF & lineStart, const QPointF & lineEnd, const QPointF & point )

private

Definition at line 314 of file KoSnapStrategy.cpp.

{
    // This is how the returned value should be used to get the
    // projectionPoint: ProjectionPoint = lineStart(1-resultingReal) + resultingReal*lineEnd;
 
    QPointF diff = lineEnd - lineStart;
    QPointF relPoint = point - lineStart;
    qreal diffLength = sqrt(diff.x() * diff.x() + diff.y() * diff.y());
    if (diffLength == 0.0)
        return 0.0;
 
    diff /= diffLength;
    // project mouse position relative to stop position on extension line
    qreal scalar = relPoint.x() * diff.x() + relPoint.y() * diff.y();
    return scalar /= diffLength;
}

snap()

bool ExtensionSnapStrategy::snap ( const QPointF & mousePosition, KoSnapProxy * proxy, qreal maxSnapDistance )

overridevirtual

Implements KoSnapStrategy.

Definition at line 177 of file KoSnapStrategy.cpp.

{
    Q_ASSERT(std::isfinite(maxSnapDistance));
 
    const qreal maxDistance = maxSnapDistance * maxSnapDistance;
    qreal minDistances[2] = { HUGE_VAL, HUGE_VAL };
 
    QPointF snappedPoints[2] = { mousePosition, mousePosition };
    QPointF startPoints[2];
 
    QList<KoShape*> shapes = proxy->shapes(true);
 
    Q_FOREACH (KoShape * shape, shapes) {
        KoPathShape * path = dynamic_cast<KoPathShape*>(shape);
        if (! path) {
            continue;
        }
        QTransform matrix = path->absoluteTransformation();
 
        const int subpathCount = path->subpathCount();
        for (int subpathIndex = 0; subpathIndex < subpathCount; ++subpathIndex) {
            if (path->isClosedSubpath(subpathIndex))
                continue;
 
            int pointCount = path->subpathPointCount(subpathIndex);
 
            // check the extension from the start point
            KoPathPoint * first = path->pointByIndex(KoPathPointIndex(subpathIndex, 0));
            QPointF firstSnapPosition = mousePosition;
            if (snapToExtension(firstSnapPosition, first, matrix)) {
                qreal distance = squareDistance(firstSnapPosition, mousePosition);
                if (distance < maxDistance) {
                    if (distance < minDistances[0]) {
                        minDistances[1] = minDistances[0];
                        snappedPoints[1] = snappedPoints[0];
                        startPoints[1] = startPoints[0];
 
                        minDistances[0] = distance;
                        snappedPoints[0] = firstSnapPosition;
                        startPoints[0] = matrix.map(first->point());
                    }
                    else if (distance < minDistances[1]) {
                        minDistances[1] = distance;
                        snappedPoints[1] = firstSnapPosition;
                        startPoints[1] = matrix.map(first->point());
                    }
                }
            }
 
            // now check the extension from the last point
            KoPathPoint * last = path->pointByIndex(KoPathPointIndex(subpathIndex, pointCount - 1));
            QPointF lastSnapPosition = mousePosition;
            if (snapToExtension(lastSnapPosition, last, matrix)) {
                qreal distance = squareDistance(lastSnapPosition, mousePosition);
                if (distance < maxDistance) {
                    if (distance < minDistances[0]) {
                        minDistances[1] = minDistances[0];
                        snappedPoints[1] = snappedPoints[0];
                        startPoints[1] = startPoints[0];
 
                        minDistances[0] = distance;
                        snappedPoints[0] = lastSnapPosition;
                        startPoints[0] = matrix.map(last->point());
                    }
                    else if (distance < minDistances[1]) {
                        minDistances[1] = distance;
                        snappedPoints[1] = lastSnapPosition;
                        startPoints[1] = matrix.map(last->point());
                    }
                }
            }
        }
    }
 
    m_lines.clear();
    // if we have to extension near our mouse position, they might have an intersection
    // near our mouse position which we want to use as the snapped position
    if (minDistances[0] < HUGE_VAL && minDistances[1] < HUGE_VAL) {
        // check if intersection of extension lines is near mouse position
        KoPathSegment s1(startPoints[0], snappedPoints[0] + snappedPoints[0]-startPoints[0]);
        KoPathSegment s2(startPoints[1], snappedPoints[1] + snappedPoints[1]-startPoints[1]);
        QList<QPointF> isects = s1.intersections(s2);
        if (isects.count() == 1 && squareDistance(isects[0], mousePosition) < maxDistance) {
            // add both extension lines
            m_lines.append(QLineF(startPoints[0], isects[0]));
            m_lines.append(QLineF(startPoints[1], isects[0]));
            setSnappedPosition(isects[0], ToLine);
        }
        else {
            // only add nearest extension line of both
            uint index = minDistances[0] < minDistances[1] ? 0 : 1;
            m_lines.append(QLineF(startPoints[index], snappedPoints[index]));
            setSnappedPosition(snappedPoints[index], ToLine);
        }
    }
    else  if (minDistances[0] < HUGE_VAL) {
        m_lines.append(QLineF(startPoints[0], snappedPoints[0]));
        setSnappedPosition(snappedPoints[0], ToLine);
    }
    else if (minDistances[1] < HUGE_VAL) {
        m_lines.append(QLineF(startPoints[1], snappedPoints[1]));
        setSnappedPosition(snappedPoints[1], ToLine);
    }
    else {
        // none of the extension lines is near our mouse position
        return false;
    }
    return true;
}

References KoShape::absoluteTransformation(), distance(), m_lines, KoPathPoint::point, s1, s2, KoSnapStrategy::setSnappedPosition(), KoSnapProxy::shapes(), snapToExtension(), KoSnapStrategy::squareDistance(), and KoSnapStrategy::ToLine.

snapToExtension()

bool ExtensionSnapStrategy::snapToExtension ( QPointF & position, KoPathPoint * point, const QTransform & matrix )

private

Definition at line 297 of file KoSnapStrategy.cpp.

{
    Q_ASSERT(point);
    QPointF direction = extensionDirection(point, matrix);
    if (direction.isNull())
        return false;
 
    QPointF extensionStart = matrix.map(point->point());
    QPointF extensionStop = matrix.map(point->point()) + direction;
    float posOnExtension = project(extensionStart, extensionStop, position);
    if (posOnExtension < 0.0)
        return false;
 
    position = extensionStart + posOnExtension * direction;
    return true;
}

References extensionDirection(), KoPathPoint::point, and project().

Friends And Related Symbol Documentation

TestSnapStrategy

friend class TestSnapStrategy

friend

Definition at line 88 of file KoSnapStrategy.h.

Member Data Documentation

m_lines

QList<QLineF> ExtensionSnapStrategy::m_lines

private

Definition at line 97 of file KoSnapStrategy.h.

---

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

• libs/flake/KoSnapStrategy.h
• libs/flake/KoSnapStrategy.cpp