KoMarker Class Reference

#include <KoMarker.h>

Inheritance diagram for KoMarker:

Public Types
enum	MarkerCoordinateSystem { StrokeWidth , UserSpaceOnUse }

Public Member Functions
void	applyShapeStroke (const KoShape *shape, KoShapeStroke *stroke, const QPointF &pos, qreal strokeWidth, qreal nodeAngle)
QRectF	boundingRect (qreal strokeWidth, qreal nodeAngle) const
bool	compareShapesTo (const QList< KoShape * > other) const
MarkerCoordinateSystem	coordinateSystem () const
void	drawPreview (QPainter *painter, const QRectF &previewRect, const QPen &pen, KoFlake::MarkerPosition position)
qreal	explicitOrientation () const
bool	hasAutoOrientation () const
	KoMarker ()
	KoMarker (const KoMarker &rhs)
QTransform	markerTransform (qreal strokeWidth, qreal nodeAngle, const QPointF &pos=QPointF())
qreal	maxInset (qreal strokeWidth) const
QString	name () const
bool	operator== (const KoMarker &other) const
bool	operator== (const KoMarker::Private &other) const
QPainterPath	outline (qreal strokeWidth, qreal nodeAngle) const
void	paintAtPosition (QPainter *painter, const QPointF &pos, qreal strokeWidth, qreal nodeAngle)
	paintAtOrigin paints the marker at the position pos. Scales and rotates the marker if needed.
	Private ()
	Private (const Private &rhs)
QPointF	referencePoint () const
QSizeF	referenceSize () const
void	setAutoOrientation (bool value)
void	setCoordinateSystem (MarkerCoordinateSystem value)
void	setExplicitOrientation (qreal value)
void	setReferencePoint (const QPointF &value)
void	setReferenceSize (const QSizeF &size)
void	setShapes (const QList< KoShape * > &shapes)
QList< KoShape * >	shapes () const
	~KoMarker ()
	~Private ()

Static Public Member Functions
static MarkerCoordinateSystem	coordinateSystemFromString (const QString &value)
static QString	coordinateSystemToString (MarkerCoordinateSystem value)

Public Attributes
MarkerCoordinateSystem	coordinateSystem
qreal	explicitOrientation
bool	hasAutoOrientation
QString	name
QPointF	referencePoint
QSizeF	referenceSize
QScopedPointer< KoShapePainter >	shapePainter
QList< KoShape * >	shapes

Private Attributes
Private *const	d
Private Attributes inherited from Private
KisCanvas2 *	canvas
int	displayedFrame
int	intendedFrame

Additional Inherited Members
Private Member Functions inherited from Private
	Private (KisCanvas2 *c)

Detailed Description

Definition at line 28 of file KoMarker.cpp.

Member Enumeration Documentation

MarkerCoordinateSystem

enum KoMarker::MarkerCoordinateSystem

Enumerator
StrokeWidth
UserSpaceOnUse

Definition at line 42 of file KoMarker.h.

                                {
        StrokeWidth,
        UserSpaceOnUse
    };

Constructor & Destructor Documentation

~Private()

KoMarker::~Private ( )

inline

Definition at line 38 of file KoMarker.cpp.

               {
        // shape manager that is stored in the painter should be destroyed
        // before the shapes themselves
        shapePainter.reset();
        qDeleteAll(shapes);
    }

KoMarker() [1/2]

KoMarker::KoMarker

(

)

Definition at line 119 of file KoMarker.cpp.

: d(new Private())
{
}

~KoMarker()

KoMarker::~KoMarker

(

)

Definition at line 124 of file KoMarker.cpp.

{
    delete d;
}

References d.

KoMarker() [2/2]

KoMarker::KoMarker

(

const KoMarker &

rhs

)

Definition at line 134 of file KoMarker.cpp.

    : QSharedData(rhs),
      d(new Private(*rhs.d))
{
}

Member Function Documentation

applyShapeStroke()

void KoMarker::applyShapeStroke	(	const KoShape *	shape,
		KoShapeStroke *	stroke,
		const QPointF &	pos,
		qreal	strokeWidth,
		qreal	nodeAngle )

Definition at line 316 of file KoMarker.cpp.

{
    const QGradient *originalGradient = stroke->lineBrush().gradient();
 
    if (!originalGradient) {
        QList<KoShape*> linearizedShapes = KoShape::linearizeSubtree(d->shapes);
        Q_FOREACH(KoShape *shape, linearizedShapes) {
            // update the stroke
            KoShapeStrokeSP shapeStroke = shape->stroke() ?
                        qSharedPointerDynamicCast<KoShapeStroke>(shape->stroke()) :
                        KoShapeStrokeSP();
 
            if (shapeStroke) {
                shapeStroke = toQShared(new KoShapeStroke(*shapeStroke));
 
                shapeStroke->setLineBrush(QBrush());
                shapeStroke->setColor(stroke->color());
 
                shape->setStroke(shapeStroke);
            }
 
            // update the background
            if (shape->background()) {
                QSharedPointer<KoColorBackground> bg(new KoColorBackground(stroke->color()));
                shape->setBackground(bg);
            }
        }
    } else {
        QScopedPointer<QGradient> g(KoFlake::cloneGradient(originalGradient));
        KIS_ASSERT_RECOVER_RETURN(g);
 
        const QTransform markerTransformInverted =
                d->markerTransform(strokeWidth, nodeAngle, pos).inverted();
 
        QTransform gradientToUser;
 
        // Unwrap the gradient to work in global mode
        if (g->coordinateMode() == QGradient::ObjectBoundingMode) {
            QRectF boundingRect =
                parentShape ?
                parentShape->outline().boundingRect() :
                this->boundingRect(strokeWidth, nodeAngle);
 
            boundingRect = KisAlgebra2D::ensureRectNotSmaller(boundingRect, QSizeF(1.0, 1.0));
 
            gradientToUser = QTransform(boundingRect.width(), 0, 0, boundingRect.height(),
                                        boundingRect.x(), boundingRect.y());
 
            g->setCoordinateMode(QGradient::LogicalMode);
        }
 
        QList<KoShape*> linearizedShapes = KoShape::linearizeSubtree(d->shapes);
        Q_FOREACH(KoShape *shape, linearizedShapes) {
            // shape-unwinding transform
            QTransform t = gradientToUser * markerTransformInverted * shape->absoluteTransformation().inverted();
 
            // update the stroke
            KoShapeStrokeSP shapeStroke = shape->stroke() ?
                        qSharedPointerDynamicCast<KoShapeStroke>(shape->stroke()) :
                        KoShapeStrokeSP();
 
            if (shapeStroke) {
                shapeStroke = toQShared(new KoShapeStroke(*shapeStroke));
 
                QBrush brush(*g);
                brush.setTransform(t);
                shapeStroke->setLineBrush(brush);
                shapeStroke->setColor(Qt::transparent);
                shape->setStroke(shapeStroke);
            }
 
            // update the background
            if (shape->background()) {
 
                QSharedPointer<KoGradientBackground> bg(new KoGradientBackground(KoFlake::cloneGradient(g.data()), t));
                shape->setBackground(bg);
            }
        }
    }
}

References KoShape::absoluteTransformation(), KoShape::background(), boundingRect(), KoFlake::cloneGradient(), KoShapeStroke::color, d, KisAlgebra2D::ensureRectNotSmaller(), KIS_ASSERT_RECOVER_RETURN, KoShape::linearizeSubtree(), KoShapeStroke::lineBrush(), KoShape::outline(), KoShape::setBackground(), KoShape::setStroke(), KoShape::stroke(), and toQShared().

boundingRect()

QRectF KoMarker::boundingRect	(	qreal	strokeWidth,
		qreal	nodeAngle ) const

Bounding rect of the marker in local coordinates. It is assumed that the marker is painted with the reference point placed at position (0,0)

Definition at line 256 of file KoMarker.cpp.

{
    QRectF shapesBounds = KoShape::boundingRect(d->shapes);
 
    const QTransform t = d->markerTransform(strokeWidth, nodeAngle);
 
    if (!t.isIdentity()) {
        shapesBounds = t.mapRect(shapesBounds);
    }
 
    return shapesBounds;
}

References KoShape::boundingRect(), and d.

compareShapesTo()

bool KoMarker::compareShapesTo ( const QList< KoShape * > other ) const

inline

Definition at line 83 of file KoMarker.cpp.

                                                            {
        if (shapes.size() != other.size()) return false;
 
        for (int i = 0; i < shapes.size(); i++) {
            if (shapes[i]->outline() != other[i]->outline() ||
                shapes[i]->absoluteTransformation() != other[i]->absoluteTransformation()) {
 
                return false;
            }
        }
 
        return true;
    }

coordinateSystem()

MarkerCoordinateSystem KoMarker::coordinateSystem

(

)

const

coordinateSystemFromString()

KoMarker::MarkerCoordinateSystem KoMarker::coordinateSystemFromString ( const QString & value )

static

Definition at line 155 of file KoMarker.cpp.

{
    MarkerCoordinateSystem result = StrokeWidth;
 
    if (value == "userSpaceOnUse") {
        result = UserSpaceOnUse;
    }
 
    return result;
}

References StrokeWidth, UserSpaceOnUse, and value().

coordinateSystemToString()

QString KoMarker::coordinateSystemToString ( KoMarker::MarkerCoordinateSystem value )

static

Definition at line 166 of file KoMarker.cpp.

{
    return
        value == StrokeWidth ?
        "strokeWidth" :
                "userSpaceOnUse";
}

References StrokeWidth, and value().

drawPreview()

void KoMarker::drawPreview	(	QPainter *	painter,
		const QRectF &	previewRect,
		const QPen &	pen,
		KoFlake::MarkerPosition	position )

Draws a preview of the marker in previewRect of painter

Definition at line 285 of file KoMarker.cpp.

{
    const QRectF outlineRect = outline(pen.widthF(), 0).boundingRect(); // normalized to 0,0
    QPointF marker;
    QPointF start;
    QPointF end;
 
    if (position == KoFlake::StartMarker) {
        marker = QPointF(-outlineRect.left() + previewRect.left(), previewRect.center().y());
        start = marker;
        end = QPointF(previewRect.right(), start.y());
    } else if (position == KoFlake::MidMarker) {
        start = QPointF(previewRect.left(), previewRect.center().y());
        marker = QPointF(-outlineRect.center().x() + previewRect.center().x(), start.y());
        end = QPointF(previewRect.right(), start.y());
    } else if (position == KoFlake::EndMarker) {
        start = QPointF(previewRect.left(), previewRect.center().y());
        marker = QPointF(-outlineRect.right() + previewRect.right(), start.y());
        end = marker;
    }
 
    painter->save();
    painter->setPen(pen);
    painter->setClipRect(previewRect);
 
    painter->drawLine(start, end);
    paintAtPosition(painter, marker, pen.widthF(), 0);
 
    painter->restore();
}

References KoFlake::EndMarker, KoFlake::MidMarker, outline(), paintAtPosition(), and KoFlake::StartMarker.

explicitOrientation()

qreal KoMarker::explicitOrientation

(

)

const

hasAutoOrientation()

bool KoMarker::hasAutoOrientation

(

)

const

markerTransform()

QTransform KoMarker::markerTransform ( qreal strokeWidth, qreal nodeAngle, const QPointF & pos = QPointF() )

inline

Definition at line 97 of file KoMarker.cpp.

                                                                                                   {
        const QTransform translate = QTransform::fromTranslate(-referencePoint.x(), -referencePoint.y());
 
        QTransform t = translate;
 
        if (coordinateSystem == StrokeWidth) {
            t *= QTransform::fromScale(strokeWidth, strokeWidth);
        }
 
        const qreal angle = hasAutoOrientation ? nodeAngle : explicitOrientation;
        if (angle != 0.0) {
            QTransform r;
            r.rotateRadians(angle);
            t *= r;
        }
 
        t *= QTransform::fromTranslate(pos.x(), pos.y());
 
        return t;
    }

maxInset()

qreal KoMarker::maxInset

(

qreal

strokeWidth

)

const

Return maximum distance that the marker can take outside the shape itself

Definition at line 243 of file KoMarker.cpp.

{
    QRectF shapesBounds = boundingRect(strokeWidth, 0.0); // normalized to 0,0
    qreal result = 0.0;
 
    result = qMax(KisAlgebra2D::norm(shapesBounds.topLeft()), result);
    result = qMax(KisAlgebra2D::norm(shapesBounds.topRight()), result);
    result = qMax(KisAlgebra2D::norm(shapesBounds.bottomLeft()), result);
    result = qMax(KisAlgebra2D::norm(shapesBounds.bottomRight()), result);
 
    return result;
}

References boundingRect(), and KisAlgebra2D::norm().

name()

QString KoMarker::name

(

)

const

Display name of the marker

Returns

Display name of the marker

operator==() [1/2]

bool KoMarker::operator==

(

const KoMarker &

other

)

const

Definition at line 140 of file KoMarker.cpp.

{
    return *d == *other.d;
}

References d.

operator==() [2/2]

bool KoMarker::operator== ( const KoMarker::Private & other ) const

inline

Definition at line 45 of file KoMarker.cpp.

    {
        // WARNING: comparison of shapes is extremely fuzzy! Don't
        //          trust it in life-critical cases!
 
        return name == other.name &&
            coordinateSystem == other.coordinateSystem &&
            referencePoint == other.referencePoint &&
            referenceSize == other.referenceSize &&
            hasAutoOrientation == other.hasAutoOrientation &&
            explicitOrientation == other.explicitOrientation &&
            compareShapesTo(other.shapes);
    }

outline()

QPainterPath KoMarker::outline	(	qreal	strokeWidth,
		qreal	nodeAngle ) const

Outline of the marker in local coordinates. It is assumed that the marker is painted with the reference point placed at position (0,0)

Definition at line 269 of file KoMarker.cpp.

{
    QPainterPath outline;
    Q_FOREACH (KoShape *shape, d->shapes) {
        outline |= shape->absoluteTransformation().map(shape->outline());
    }
 
    const QTransform t = d->markerTransform(strokeWidth, nodeAngle);
 
    if (!t.isIdentity()) {
        outline = t.map(outline);
    }
 
    return outline;
}

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

paintAtPosition()

void KoMarker::paintAtPosition	(	QPainter *	painter,
		const QPointF &	pos,
		qreal	strokeWidth,
		qreal	nodeAngle )

paintAtOrigin paints the marker at the position pos. Scales and rotates the marker if needed.

Definition at line 228 of file KoMarker.cpp.

{
    QTransform oldTransform = painter->transform();
 
    if (!d->shapePainter) {
        d->shapePainter.reset(new KoShapePainter());
        d->shapePainter->setShapes(d->shapes);
    }
 
    painter->setTransform(d->markerTransform(strokeWidth, nodeAngle, pos), true);
    d->shapePainter->paint(*painter);
 
    painter->setTransform(oldTransform);
}

References d.

Private() [1/2]

KoMarker::Private ( )

inline

Definition at line 31 of file KoMarker.cpp.

        : coordinateSystem(StrokeWidth),
          referenceSize(3,3),
          hasAutoOrientation(false),
          explicitOrientation(0)
    {}

Private() [2/2]

KoMarker::Private ( const Private & rhs )

inline

Definition at line 59 of file KoMarker.cpp.

        : name(rhs.name),
          coordinateSystem(rhs.coordinateSystem),
          referencePoint(rhs.referencePoint),
          referenceSize(rhs.referenceSize),
          hasAutoOrientation(rhs.hasAutoOrientation),
          explicitOrientation(rhs.explicitOrientation)
    {
        Q_FOREACH (KoShape *shape, rhs.shapes) {
            shapes << shape->cloneShape();
        }
    }

References KoShape::cloneShape().

referencePoint()

QPointF KoMarker::referencePoint

(

)

const

referenceSize()

QSizeF KoMarker::referenceSize

(

)

const

setAutoOrientation()

void KoMarker::setAutoOrientation

(

bool

value

)

Definition at line 199 of file KoMarker.cpp.

{
    d->hasAutoOrientation = value;
}

References d, and value().

setCoordinateSystem()

void KoMarker::setCoordinateSystem

(

KoMarker::MarkerCoordinateSystem

value

)

Definition at line 145 of file KoMarker.cpp.

{
    d->coordinateSystem = value;
}

References d, and value().

setExplicitOrientation()

void KoMarker::setExplicitOrientation

(

qreal

value

)

Definition at line 209 of file KoMarker.cpp.

{
    d->explicitOrientation = value;
}

References d, and value().

setReferencePoint()

void KoMarker::setReferencePoint

(

const QPointF &

value

)

Definition at line 174 of file KoMarker.cpp.

{
    d->referencePoint = value;
}

References d, and value().

setReferenceSize()

void KoMarker::setReferenceSize

(

const QSizeF &

size

)

Definition at line 184 of file KoMarker.cpp.

{
    d->referenceSize = size;
}

References d.

setShapes()

void KoMarker::setShapes

(

const QList< KoShape * > &

shapes

)

Definition at line 214 of file KoMarker.cpp.

{
    d->shapes = shapes;
 
    if (d->shapePainter) {
        d->shapePainter->setShapes(shapes);
    }
}

References d, and shapes.

shapes()

QList< KoShape * > KoMarker::shapes

(

)

const

Member Data Documentation

coordinateSystem

KoMarker::MarkerCoordinateSystem KoMarker::coordinateSystem

Definition at line 73 of file KoMarker.cpp.

d

Private* const KoMarker::d

private

Definition at line 105 of file KoMarker.h.

explicitOrientation

qreal KoMarker::explicitOrientation

Definition at line 78 of file KoMarker.cpp.

hasAutoOrientation

bool KoMarker::hasAutoOrientation

Definition at line 77 of file KoMarker.cpp.

name

QString KoMarker::name

Definition at line 72 of file KoMarker.cpp.

referencePoint

QPointF KoMarker::referencePoint

Definition at line 74 of file KoMarker.cpp.

referenceSize

QSizeF KoMarker::referenceSize

Definition at line 75 of file KoMarker.cpp.

shapePainter

QScopedPointer<KoShapePainter> KoMarker::shapePainter

Definition at line 81 of file KoMarker.cpp.

shapes

QList< KoShape * > KoMarker::shapes

Definition at line 80 of file KoMarker.cpp.

---

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

• libs/flake/KoMarker.cpp
• libs/flake/KoMarker.h