SvgParser.cpp File Reference

#include "SvgParser.h"
#include <cmath>
#include <FlakeDebug.h>
#include <QColor>
#include <QDir>
#include <QPainter>
#include <QPainterPath>
#include <QRandomGenerator>
#include <KoShape.h>
#include <KoShapeRegistry.h>
#include <KoShapeFactoryBase.h>
#include <KoShapeGroup.h>
#include <KoPathShape.h>
#include <KoDocumentResourceManager.h>
#include <KoPathShapeLoader.h>
#include <commands/KoShapeGroupCommand.h>
#include <commands/KoShapeUngroupCommand.h>
#include <KoColorBackground.h>
#include <KoGradientBackground.h>
#include <KoMeshGradientBackground.h>
#include <KoPatternBackground.h>
#include <KoFilterEffectRegistry.h>
#include <KoFilterEffect.h>
#include "KoFilterEffectStack.h"
#include "KoFilterEffectLoadingContext.h"
#include <KoClipPath.h>
#include <KoClipMask.h>
#include <KoXmlNS.h>
#include <QXmlSimpleReader>
#include "SvgMeshGradient.h"
#include "SvgMeshPatch.h"
#include "SvgUtil.h"
#include "SvgShape.h"
#include "SvgGraphicContext.h"
#include "SvgFilterHelper.h"
#include "SvgGradientHelper.h"
#include "SvgClipPathHelper.h"
#include "parsers/SvgTransformParser.h"
#include "kis_pointer_utils.h"
#include <KoVectorPatternBackground.h>
#include <KoMarker.h>
#include <text/KoSvgTextShape.h>
#include <text/KoSvgTextLoader.h>
#include "kis_dom_utils.h"
#include "kis_algebra_2d.h"
#include "kis_debug.h"
#include "kis_global.h"
#include <QXmlStreamReader>
#include <algorithm>

Go to the source code of this file.

Classes
struct	SvgParser::DeferredUseStore
struct	SvgParser::DeferredUseStore::El

Macros
#define	forEachElement(elem, parent)

Functions
void	applyDashes (const KoShapeStrokeSP srcStroke, KoShapeStrokeSP dstStroke)
QPointF	bakeShapeOffset (const QTransform &patternTransform, const QPointF &shapeOffset)
QPointF	extraShapeOffset (const KoShape *shape, const QTransform coordinateSystemOnLoading)
QGradient *	prepareGradientForShape (const SvgGradientHelper *gradient, const KoShape *shape, const SvgGraphicsContext *gc, QTransform *transform)
SvgMeshGradient *	prepareMeshGradientForShape (SvgGradientHelper *gradient, const KoShape *shape, const SvgGraphicsContext *gc)

Macro Definition Documentation

forEachElement

#define forEachElement	(		elem,
			parent )

Value:

    for ( QDomNode _node = parent.firstChild(); !_node.isNull(); _node = _node.nextSibling() ) \
    if ( ( elem = _node.toElement() ).isNull() ) {} else

Definition at line 537 of file SvgParser.cpp.

#define forEachElement( elem, parent ) \
    for ( QDomNode _node = parent.firstChild(); !_node.isNull(); _node = _node.nextSibling() ) \
    if ( ( elem = _node.toElement() ).isNull() ) {} else

Function Documentation

applyDashes()

void applyDashes	(	const KoShapeStrokeSP	srcStroke,
		KoShapeStrokeSP	dstStroke )

Definition at line 1222 of file SvgParser.cpp.

{
    const double lineWidth = srcStroke->lineWidth();
    QVector<qreal> dashes = srcStroke->lineDashes();
 
    // apply line width to dashes and dash offset
    if (dashes.count() && lineWidth > 0.0) {
        const double dashOffset = srcStroke->dashOffset();
        QVector<qreal> dashes = srcStroke->lineDashes();
 
        for (int i = 0; i < dashes.count(); ++i) {
            dashes[i] /= lineWidth;
        }
 
        dstStroke->setLineStyle(Qt::CustomDashLine, dashes);
        dstStroke->setDashOffset(dashOffset / lineWidth);
    } else {
        dstStroke->setLineStyle(Qt::SolidLine, QVector<qreal>());
    }
}

bakeShapeOffset()

QPointF bakeShapeOffset ( const QTransform & patternTransform, const QPointF & shapeOffset )

inline

Definition at line 565 of file SvgParser.cpp.

{
    QTransform result =
            patternTransform *
            QTransform::fromTranslate(-shapeOffset.x(), -shapeOffset.y()) *
            patternTransform.inverted();
    KIS_ASSERT_RECOVER_NOOP(result.type() <= QTransform::TxTranslate);
 
    return QPointF(result.dx(), result.dy());
}

References KIS_ASSERT_RECOVER_NOOP.

extraShapeOffset()

QPointF extraShapeOffset ( const KoShape * shape, const QTransform coordinateSystemOnLoading )

inline

Definition at line 1720 of file SvgParser.cpp.

{
    const QTransform shapeToOriginalUserCoordinates =
        shape->absoluteTransformation().inverted() *
        coordinateSystemOnLoading;
 
    KIS_SAFE_ASSERT_RECOVER_NOOP(shapeToOriginalUserCoordinates.type() <= QTransform::TxTranslate);
    return QPointF(shapeToOriginalUserCoordinates.dx(), shapeToOriginalUserCoordinates.dy());
}

References KoShape::absoluteTransformation(), and KIS_SAFE_ASSERT_RECOVER_NOOP.

prepareGradientForShape()

QGradient * prepareGradientForShape	(	const SvgGradientHelper *	gradient,
		const KoShape *	shape,
		const SvgGraphicsContext *	gc,
		QTransform *	transform )

Create a converted gradient that looks the same, but linked to the bounding rect of the shape, so it would be transformed with the shape

If shape outline rect is valid, convert the gradient into OBB mode by doing some magic conversions: we compensate non-uniform size of the shape by applying an additional pre-transform

Definition at line 1039 of file SvgParser.cpp.

{
    QGradient *resultGradient = 0;
    KIS_ASSERT(transform);
 
    if (gradient->gradientUnits() == KoFlake::ObjectBoundingBox) {
        resultGradient = KoFlake::cloneGradient(gradient->gradient());
        *transform = gradient->transform();
    } else {
        if (gradient->gradient()->type() == QGradient::LinearGradient) {
            const QRectF boundingRect = shape->outline().boundingRect();
            const QTransform relativeToShape(boundingRect.width(), 0, 0, boundingRect.height(),
                                             boundingRect.x(), boundingRect.y());
 
            const QTransform relativeToUser =
                    relativeToShape * shape->transformation() * gc->matrix.inverted();
 
            const QTransform userToRelative = relativeToUser.inverted();
 
            const QLinearGradient *o = static_cast<const QLinearGradient*>(gradient->gradient());
            QLinearGradient *g = new QLinearGradient();
            g->setStart(userToRelative.map(o->start()));
            g->setFinalStop(userToRelative.map(o->finalStop()));
            g->setCoordinateMode(QGradient::ObjectBoundingMode);
            g->setStops(o->stops());
            g->setSpread(o->spread());
 
            resultGradient = g;
            *transform = relativeToUser * gradient->transform() * userToRelative;
 
        } else if (gradient->gradient()->type() == QGradient::RadialGradient) {
            // For radial and conical gradients such conversion is not possible
 
            resultGradient = KoFlake::cloneGradient(gradient->gradient());
            *transform = gradient->transform() * gc->matrix * shape->transformation().inverted();
 
            const QRectF outlineRect = shape->outlineRect();
            if (outlineRect.isEmpty()) return resultGradient;
 
            QRadialGradient *rgradient = static_cast<QRadialGradient*>(resultGradient);
 
            const qreal maxDimension = KisAlgebra2D::maxDimension(outlineRect);
            const QRectF uniformSize(outlineRect.topLeft(), QSizeF(maxDimension, maxDimension));
 
            const QTransform uniformizeTransform =
                    QTransform::fromTranslate(-outlineRect.x(), -outlineRect.y()) *
                    QTransform::fromScale(maxDimension / shape->outlineRect().width(),
                                          maxDimension / shape->outlineRect().height()) *
                    QTransform::fromTranslate(outlineRect.x(), outlineRect.y());
 
            const QPointF centerLocal = transform->map(rgradient->center());
            const QPointF focalLocal = transform->map(rgradient->focalPoint());
 
            const QPointF centerOBB = KisAlgebra2D::absoluteToRelative(centerLocal, uniformSize);
            const QPointF focalOBB = KisAlgebra2D::absoluteToRelative(focalLocal, uniformSize);
 
            rgradient->setCenter(centerOBB);
            rgradient->setFocalPoint(focalOBB);
 
            const qreal centerRadiusOBB = KisAlgebra2D::absoluteToRelative(rgradient->centerRadius(), uniformSize);
            const qreal focalRadiusOBB = KisAlgebra2D::absoluteToRelative(rgradient->focalRadius(), uniformSize);
 
            rgradient->setCenterRadius(centerRadiusOBB);
            rgradient->setFocalRadius(focalRadiusOBB);
 
            rgradient->setCoordinateMode(QGradient::ObjectBoundingMode);
 
            // Warning: should it really be pre-multiplication?
            *transform = uniformizeTransform * gradient->transform();
        }
    }
 
    // NOTE: this is an internal API in Qt. SVG specs specify that we
    // shouldn't interpolate in pre-multiplied space.
    resultGradient->setInterpolationMode(QGradient::ComponentInterpolation);
 
    return resultGradient;
}

References KisAlgebra2D::absoluteToRelative(), KoFlake::cloneGradient(), SvgGradientHelper::gradient(), SvgGradientHelper::gradientUnits(), KIS_ASSERT, SvgGraphicsContext::matrix, KisAlgebra2D::maxDimension(), KoFlake::ObjectBoundingBox, KoShape::outline(), KoShape::outlineRect(), SvgGradientHelper::transform(), and KoShape::transformation().

prepareMeshGradientForShape()

SvgMeshGradient * prepareMeshGradientForShape	(	SvgGradientHelper *	gradient,
		const KoShape *	shape,
		const SvgGraphicsContext *	gc )

Definition at line 1132 of file SvgParser.cpp.

                                                                           {
 
    SvgMeshGradient *resultGradient = nullptr;
 
    if (gradient->gradientUnits() == KoFlake::ObjectBoundingBox) {
 
        resultGradient = new SvgMeshGradient(*gradient->meshgradient());
 
        const QRectF boundingRect = shape->outline().boundingRect();
        const QTransform relativeToShape(boundingRect.width(), 0, 0, boundingRect.height(),
                                         boundingRect.x(), boundingRect.y());
 
        // NOTE: we apply translation right away, because caching hasn't been implemented for rendering, yet.
        // So, transform is called multiple times on the mesh and that's not nice
        resultGradient->setTransform(gradient->transform() * relativeToShape);
    } else {
        // NOTE: Krita's shapes use their own coordinate system. Where origin is at the top left
        // of the SHAPE. All the mesh patches will be rendered in the global 'user' coordinate system
        // where the origin is at the top left of the LAYER/DOCUMENT.
 
        // Get the user coordinates of the shape
        const QTransform shapeglobal = shape->absoluteTransformation() * gc->matrix.inverted();
 
        // Get the translation offset to shift the origin from "Shape" to "User"
        const QTransform translationOffset = QTransform::fromTranslate(-shapeglobal.dx(), -shapeglobal.dy());
 
        resultGradient = new SvgMeshGradient(*gradient->meshgradient());
 
        // NOTE: we apply translation right away, because caching hasn't been implemented for rendering, yet.
        // So, transform is called multiple times on the mesh and that's not nice
        resultGradient->setTransform(gradient->transform() * translationOffset);
    }
 
    return resultGradient;
}

References KoShape::absoluteTransformation(), SvgGradientHelper::gradientUnits(), SvgGraphicsContext::matrix, SvgGradientHelper::meshgradient(), KoFlake::ObjectBoundingBox, KoShape::outline(), SvgMeshGradient::setTransform(), and SvgGradientHelper::transform().