#include <SvgParser.h>

Classes
struct	DeferredUseStore

Public Types
typedef std::function< QByteArray(const QString &)	FileFetcherFunc)

Public Member Functions
QString	documentDescription () const

QString	documentTitle () const

QList< QExplicitlySharedDataPointer< KoMarker > >	knownMarkers () const

void	parseDefsElement (const QDomElement &e)

QList< KoShape * >	parseSvg (const QDomElement &e, QSizeF *fragmentSize=0)
	Parses a svg fragment, returning the list of top level child shapes.

KoShape *	parseTextElement (const QDomElement &e, KoSvgTextShape *mergeIntoShape=0)

void	setDefaultKraTextVersion (int version)

void	setFileFetcher (FileFetcherFunc func)

void	setFillStrokeInheritByDefault (const bool enable)

void	setResolution (const QRectF boundsInPixels, qreal pixelsPerInch)

void	setResolveTextPropertiesForTopLevel (const bool enable)

void	setXmlBaseDir (const QString &baseDir)
	Sets the initial xml base directory (the directory form where the file is read)

QList< KoShape * >	shapes () const
	Returns the list of all shapes of the svg document.

	SvgParser (KoDocumentResourceManager *documentResourceManager)

QVector< KoSvgSymbol * >	takeSymbols ()

QStringList	warnings () const

virtual	~SvgParser ()

Static Public Member Functions
static QDomDocument	createDocumentFromSvg (const QByteArray &data, QString errorMsg=0, int errorLine=0, int *errorColumn=0)

static QDomDocument	createDocumentFromSvg (const QString &data, QString errorMsg=0, int errorLine=0, int *errorColumn=0)

static QDomDocument	createDocumentFromSvg (QIODevice device, QString errorMsg=0, int errorLine=0, int errorColumn=0)

static QDomDocument	createDocumentFromSvg (QXmlStreamReader reader, QString errorMsg=0, int errorLine=0, int *errorColumn=0)

Protected Member Functions
void	addToGroup (QList< KoShape * > shapes, KoShapeContainer *group)
	Adds list of shapes to the given group shape.

void	applyClipping (KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)
	Applies the current clip path to the object.

void	applyCurrentBasicStyle (KoShape *shape)

void	applyCurrentStyle (KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)

void	applyFillStyle (KoShape *shape)
	Applies the current fill style to the object.

void	applyFilter (KoShape *shape)
	Applies the current filter to the object.

void	applyId (const QString &id, KoShape *shape)
	Applies id to specified shape.

void	applyMarkers (KoPathShape *shape)

void	applyMaskClipping (KoShape *shape, const QPointF &shapeToOriginalUserCoordinates)

void	applyPaintOrder (KoShape *shape)

void	applyStrokeStyle (KoShape *shape)
	Applies the current stroke style to the object.

void	applyStyle (KoShape *, const QDomElement &, const QPointF &shapeToOriginalUserCoordinates)
	Applies styles to the given shape.

void	applyStyle (KoShape *, const SvgStyles &, const QPointF &shapeToOriginalUserCoordinates)
	Applies styles to the given shape.

void	applyViewBoxTransform (const QDomElement &element)

void	buildDocument (QList< KoShape * > shapes)
	Builds the document from the given shapes list.

QList< KoShape * >	createListOfShapesFromCSS (const QDomElement e, const QString value, SvgLoadingContext &context)
	Create a list of shapes from a CSS shapes definition with potentially multiple shapes.

KoShape *	createObject (const QDomElement &, const SvgStyles &style=SvgStyles())
	Creates an object from the given xml element.

KoShape *	createObjectDirect (const QDomElement &b)

KoShape *	createPath (const QDomElement &)
	Create path object from the given xml element.

KoShape *	createShape (const QString &shapeID)
	creates a shape from the given shape id

KoShape *	createShapeFromCSS (const QDomElement e, const QString value, SvgLoadingContext &context)
	Creates a shape from a CSS shapes definition.

KoShape *	createShapeFromElement (const QDomElement &element, SvgLoadingContext &context)
	Creates shape from specified svg element.

SvgClipPathHelper *	findClipPath (const QString &id)
	find clip path with given id in clip path map

SvgFilterHelper *	findFilter (const QString &id, const QString &href=QString())
	find filter with given id in filter map

SvgGradientHelper *	findGradient (const QString &id)
	find gradient with given id in gradient map

QSharedPointer< KoVectorPatternBackground >	findPattern (const QString &id, const KoShape *shape)
	find pattern with given id in pattern map

KoShape *	getTextPath (const QDomElement &e)
	Get the path for the gives textPath element.

QDomText	getTheOnlyTextChild (const QDomElement &e)

qreal	parseAngular (const QString &unit)
	parses a angular attribute values, result in radians

bool	parseClipMask (const QDomElement &e)

bool	parseClipPath (const QDomElement &)
	Parses a clip path element.

QList< KoShape * >	parseContainer (const QDomElement &)
	Parses a container element, returning a list of child shapes.

bool	parseFilter (const QDomElement &, const QDomElement &referencedBy=QDomElement())
	Parses a filter element.

SvgGradientHelper *	parseGradient (const QDomElement &)
	Parses a gradient element.

KoShape *	parseGroup (const QDomElement &e, const QDomElement &overrideChildrenFrom=QDomElement(), bool createContext=true)
	Parses a group-like element element, saving all its topmost properties.

bool	parseMarker (const QDomElement &e)

SvgGradientHelper *	parseMeshGradient (const QDomElement &)
	Parses mesh gradient element.

QList< QPair< QString, QColor > >	parseMeshPatch (const QDomNode &meshpatch)
	Parses a single meshpatch and returns the pointer.

void	parseMetadataApplyToShape (const QDomElement &e, KoShape *shape)
	This parses the SVG native title and desc elements and adds them into additional attributes.

QSharedPointer< KoVectorPatternBackground >	parsePattern (const QDomElement &e, const KoShape *__shape)
	Parses a pattern element.

QList< KoShape * >	parseSingleElement (const QDomElement &b, DeferredUseStore *deferredUseStore=0)
	XXX.

bool	parseSymbol (const QDomElement &e)

void	parseTextChildren (const QDomElement &e, KoSvgTextLoader &textLoader)
	parse children of a <text > element into the root shape.

qreal	parseUnit (const QString &, bool horiz=false, bool vert=false, const QRectF &bbox=QRectF())
	parses a length attribute

qreal	parseUnitX (const QString &unit)
	parses a length attribute in x-direction

qreal	parseUnitXY (const QString &unit)
	parses a length attribute in xy-direction

qreal	parseUnitY (const QString &unit)
	parses a length attribute in y-direction

KoShape *	parseUse (const QDomElement &, DeferredUseStore *deferredUseStore)
	Parses a use element, returning a list of child shapes.

KoShape *	resolveUse (const QDomElement &e, const QString &key)

void	uploadStyleToContext (const QDomElement &e)

Private Attributes
QMap< QString, QSharedPointer< KoClipMask > >	m_clipMasks

QMap< QString, SvgClipPathHelper >	m_clipPaths

SvgLoadingContext	m_context

QList< KoShape * >	m_defsShapes

QString	m_documentDescription

KoDocumentResourceManager *	m_documentResourceManager

QString	m_documentTitle

QMap< QString, SvgFilterHelper >	m_filters

QMap< QString, SvgGradientHelper >	m_gradients

bool	m_inheritStrokeFillByDefault = false

bool	m_isInsideTextSubtree = false

QMap< QString, QExplicitlySharedDataPointer< KoMarker > >	m_markers

bool	m_resolveTextPropertiesForTopLevel = true

QMap< KoShape *, QTransform >	m_shapeParentTransform

QList< KoShape * >	m_shapes

QMap< QString, KoSvgSymbol * >	m_symbols

QVector< KoID >	m_warnings

Detailed Description

Definition at line 39 of file SvgParser.h.

Member Typedef Documentation

◆ FileFetcherFunc

typedef std::function<QByteArray(const QString&) SvgParser::FileFetcherFunc)

Definition at line 82 of file SvgParser.h.

Constructor & Destructor Documentation

◆ SvgParser()

SvgParser::SvgParser ( KoDocumentResourceManager * documentResourceManager )

explicit

Definition at line 127 of file SvgParser.cpp.

    : m_context(documentResourceManager)
    , m_documentResourceManager(documentResourceManager)
{
}

◆ ~SvgParser()

SvgParser::~SvgParser ( )

virtual

Definition at line 133 of file SvgParser.cpp.

{
    for (auto it = m_symbols.begin(); it != m_symbols.end(); ++it) {
        delete it.value();
    }
    qDeleteAll(m_defsShapes);
}

References m_defsShapes, and m_symbols.

Member Function Documentation

◆ addToGroup()

void SvgParser::addToGroup	(	QList< KoShape * >	shapes,
		KoShapeContainer *	group )

protected

Adds list of shapes to the given group shape.

Definition at line 1563 of file SvgParser.cpp.

{
    m_shapes += shapes;
 
    if (!group || shapes.isEmpty())
        return;
 
    // not normalized
    KoShapeGroupCommand cmd(group, shapes, false);
    cmd.redo();
}

References m_shapes, KoShapeGroupCommand::redo(), and shapes().

◆ applyClipping()

void SvgParser::applyClipping	(	KoShape *	shape,
		const QPointF &	shapeToOriginalUserCoordinates )

protected

Applies the current clip path to the object.

Definition at line 1470 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (! gc)
        return;
 
    if (gc->clipPathId.isEmpty())
        return;
 
    SvgClipPathHelper *clipPath = findClipPath(gc->clipPathId);
    if (!clipPath || clipPath->isEmpty())
        return;
 
    QList<KoShape*> shapes;
 
    Q_FOREACH (KoShape *item, clipPath->shapes()) {
        KoShape *clonedShape = item->cloneShape();
        KIS_ASSERT_RECOVER(clonedShape) { continue; }
 
        shapes.append(clonedShape);
    }
 
    if (!shapeToOriginalUserCoordinates.isNull()) {
        const QTransform t =
            QTransform::fromTranslate(shapeToOriginalUserCoordinates.x(),
                                      shapeToOriginalUserCoordinates.y());
 
        Q_FOREACH(KoShape *s, shapes) {
            s->applyAbsoluteTransformation(t);
        }
    }
 
    KoClipPath *clipPathObject = new KoClipPath(shapes,
                                                clipPath->clipPathUnits() == KoFlake::ObjectBoundingBox ?
                                                KoFlake::ObjectBoundingBox : KoFlake::UserSpaceOnUse);
    shape->setClipPath(clipPathObject);
}

References KoShape::applyAbsoluteTransformation(), SvgGraphicsContext::clipPathId, SvgClipPathHelper::clipPathUnits(), KoShape::cloneShape(), SvgLoadingContext::currentGC(), findClipPath(), SvgClipPathHelper::isEmpty(), KIS_ASSERT_RECOVER, m_context, KoFlake::ObjectBoundingBox, KoShape::setClipPath(), SvgClipPathHelper::shapes(), shapes(), and KoFlake::UserSpaceOnUse.

◆ applyCurrentBasicStyle()

void SvgParser::applyCurrentBasicStyle ( KoShape * shape )

protected

WARNING: here is a small inconsistency with the standard: in the standard, 'display' is not inherited, but in flake it is!

NOTE: though the standard says: "A value of 'display:none' indicates that the given element and <em><strong>its children</strong></em> shall not be rendered directly". Therefore, using setVisible(false) is fully legitimate here (DK 29.11.16).

Definition at line 972 of file SvgParser.cpp.

{
    if (!shape) return;
 
    SvgGraphicsContext *gc = m_context.currentGC();
    KIS_ASSERT(gc);
 
    if (!dynamic_cast<KoShapeGroup*>(shape)) {
        applyFillStyle(shape);
        applyStrokeStyle(shape);
    }
 
    if (!gc->display || !gc->visible) {
        shape->setVisible(false);
    }
    shape->setTransparency(1.0 - gc->opacity);
 
    applyPaintOrder(shape);
}

References applyFillStyle(), applyPaintOrder(), applyStrokeStyle(), SvgLoadingContext::currentGC(), SvgGraphicsContext::display, KIS_ASSERT, m_context, SvgGraphicsContext::opacity, KoShape::setTransparency(), KoShape::setVisible(), and SvgGraphicsContext::visible.

◆ applyCurrentStyle()

void SvgParser::applyCurrentStyle	(	KoShape *	shape,
		const QPointF &	shapeToOriginalUserCoordinates )

protected

Definition at line 956 of file SvgParser.cpp.

{
    if (!shape) return;
 
    applyCurrentBasicStyle(shape);
 
    if (KoPathShape *pathShape = dynamic_cast<KoPathShape*>(shape)) {
        applyMarkers(pathShape);
    }
 
    applyFilter(shape);
    applyClipping(shape, shapeToOriginalUserCoordinates);
    applyMaskClipping(shape, shapeToOriginalUserCoordinates);
 
}

References applyClipping(), applyCurrentBasicStyle(), applyFilter(), applyMarkers(), and applyMaskClipping().

◆ applyFillStyle()

void SvgParser::applyFillStyle ( KoShape * shape )

protected

Applies the current fill style to the object.

Definition at line 1170 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (! gc)
        return;
 
    if (gc->fillType == SvgGraphicsContext::None) {
        shape->setBackground(QSharedPointer<KoShapeBackground>(0));
    } else if (gc->fillType == SvgGraphicsContext::Solid) {
        shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(gc->fillColor)));
    } else if (gc->fillType == SvgGraphicsContext::Complex) {
        // try to find referenced gradient
        SvgGradientHelper *gradient = findGradient(gc->fillId);
        if (gradient) {
            QTransform transform;
 
            if (gradient->isMeshGradient()) {
                QSharedPointer<KoMeshGradientBackground> bg;
 
                QScopedPointer<SvgMeshGradient> result(prepareMeshGradientForShape(gradient, shape, gc));
 
                bg = toQShared(new KoMeshGradientBackground(result.data(), transform));
                shape->setBackground(bg);
            } else if (gradient->gradient()) {
                QGradient *result = prepareGradientForShape(gradient, shape, gc, &transform);
                if (result) {
                    QSharedPointer<KoGradientBackground> bg;
                    bg = toQShared(new KoGradientBackground(result));
                    bg->setTransform(transform);
                    shape->setBackground(bg);
                }
            }
        } else {
            QSharedPointer<KoVectorPatternBackground> pattern =
                findPattern(gc->fillId, shape);
 
            if (pattern) {
                shape->setBackground(pattern);
            } else {
                // no referenced fill found, use fallback color
                shape->setBackground(QSharedPointer<KoColorBackground>(new KoColorBackground(gc->fillColor)));
            }
        }
    } else if (gc->fillType == SvgGraphicsContext::Inherit) {
        shape->setInheritBackground(true);
    }
 
    KoPathShape *path = dynamic_cast<KoPathShape*>(shape);
    if (path)
        path->setFillRule(gc->fillRule);
}

◆ applyFilter()

void SvgParser::applyFilter ( KoShape * shape )

protected

Applies the current filter to the object.

Definition at line 1286 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (! gc)
        return;
 
    if (gc->filterId.isEmpty())
        return;
 
    SvgFilterHelper *filter = findFilter(gc->filterId);
    if (! filter)
        return;
 
    QDomElement content = filter->content();
 
    // parse filter region
    QRectF bound(shape->position(), shape->size());
    // work on bounding box without viewbox transformation applied
    // so user space coordinates of bounding box and filter region match up
    bound = gc->viewboxTransform.inverted().mapRect(bound);
 
    QRectF filterRegion(filter->position(bound), filter->size(bound));
 
    // convert filter region to boundingbox units
    QRectF objectFilterRegion;
    objectFilterRegion.setTopLeft(SvgUtil::userSpaceToObject(filterRegion.topLeft(), bound));
    objectFilterRegion.setSize(SvgUtil::userSpaceToObject(filterRegion.size(), bound));
 
    KoFilterEffectLoadingContext context(m_context.xmlBaseDir());
    context.setShapeBoundingBox(bound);
    // enable units conversion
    context.enableFilterUnitsConversion(filter->filterUnits() == KoFlake::UserSpaceOnUse);
    context.enableFilterPrimitiveUnitsConversion(filter->primitiveUnits() == KoFlake::UserSpaceOnUse);
 
    KoFilterEffectRegistry *registry = KoFilterEffectRegistry::instance();
 
    KoFilterEffectStack *filterStack = 0;
 
    QSet<QString> stdInputs;
    stdInputs << "SourceGraphic" << "SourceAlpha";
    stdInputs << "BackgroundImage" << "BackgroundAlpha";
    stdInputs << "FillPaint" << "StrokePaint";
 
    QMap<QString, KoFilterEffect*> inputs;
 
    // create the filter effects and add them to the shape
    for (QDomNode n = content.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement primitive = n.toElement();
        KoFilterEffect *filterEffect = registry->createFilterEffectFromXml(primitive, context);
        if (!filterEffect) {
            debugFlake << "filter effect" << primitive.tagName() << "is not implemented yet";
            continue;
        }
 
        const QString input = primitive.attribute("in");
        if (!input.isEmpty()) {
            filterEffect->setInput(0, input);
        }
        const QString output = primitive.attribute("result");
        if (!output.isEmpty()) {
            filterEffect->setOutput(output);
        }
 
        QRectF subRegion;
        // parse subregion
        if (filter->primitiveUnits() == KoFlake::UserSpaceOnUse) {
            const QString xa = primitive.attribute("x");
            const QString ya = primitive.attribute("y");
            const QString wa = primitive.attribute("width");
            const QString ha = primitive.attribute("height");
 
            if (xa.isEmpty() || ya.isEmpty() || wa.isEmpty() || ha.isEmpty()) {
                bool hasStdInput = false;
                bool isFirstEffect = filterStack == 0;
                // check if one of the inputs is a standard input
                Q_FOREACH (const QString &input, filterEffect->inputs()) {
                    if ((isFirstEffect && input.isEmpty()) || stdInputs.contains(input)) {
                        hasStdInput = true;
                        break;
                    }
                }
                if (hasStdInput || primitive.tagName() == "feImage") {
                    // default to 0%, 0%, 100%, 100%
                    subRegion.setTopLeft(QPointF(0, 0));
                    subRegion.setSize(QSizeF(1, 1));
                } else {
                    // defaults to bounding rect of all referenced nodes
                    Q_FOREACH (const QString &input, filterEffect->inputs()) {
                        if (!inputs.contains(input))
                            continue;
 
                        KoFilterEffect *inputFilter = inputs[input];
                        if (inputFilter)
                            subRegion |= inputFilter->filterRect();
                    }
                }
            } else {
                const qreal x = parseUnitX(xa);
                const qreal y = parseUnitY(ya);
                const qreal w = parseUnitX(wa);
                const qreal h = parseUnitY(ha);
                subRegion.setTopLeft(SvgUtil::userSpaceToObject(QPointF(x, y), bound));
                subRegion.setSize(SvgUtil::userSpaceToObject(QSizeF(w, h), bound));
            }
        } else {
            // x, y, width, height are in percentages of the object referencing the filter
            // so we just parse the percentages
            const qreal x = SvgUtil::fromPercentage(primitive.attribute("x", "0"));
            const qreal y = SvgUtil::fromPercentage(primitive.attribute("y", "0"));
            const qreal w = SvgUtil::fromPercentage(primitive.attribute("width", "1"));
            const qreal h = SvgUtil::fromPercentage(primitive.attribute("height", "1"));
            subRegion = QRectF(QPointF(x, y), QSizeF(w, h));
        }
 
        filterEffect->setFilterRect(subRegion);
 
        if (!filterStack)
            filterStack = new KoFilterEffectStack();
 
        filterStack->appendFilterEffect(filterEffect);
        inputs[filterEffect->output()] = filterEffect;
    }
    if (filterStack) {
        filterStack->setClipRect(objectFilterRegion);
        shape->setFilterEffectStack(filterStack);
    }
}

References KoFilterEffectStack::appendFilterEffect(), SvgFilterHelper::content(), KoFilterEffectRegistry::createFilterEffectFromXml(), SvgLoadingContext::currentGC(), debugFlake, KoFilterEffectLoadingContext::enableFilterPrimitiveUnitsConversion(), KoFilterEffectLoadingContext::enableFilterUnitsConversion(), SvgGraphicsContext::filterId, KoFilterEffect::filterRect, SvgFilterHelper::filterUnits(), findFilter(), SvgUtil::fromPercentage(), KoFilterEffect::inputs, KoFilterEffectRegistry::instance(), m_context, KoFilterEffect::output, parseUnitX(), parseUnitY(), KoShape::position(), SvgFilterHelper::position(), SvgFilterHelper::primitiveUnits(), KoFilterEffectStack::setClipRect(), KoShape::setFilterEffectStack(), KoFilterEffect::setFilterRect(), KoFilterEffect::setInput(), KoFilterEffect::setOutput(), KoFilterEffectLoadingContext::setShapeBoundingBox(), KoShape::size(), SvgFilterHelper::size(), KoFlake::UserSpaceOnUse, SvgUtil::userSpaceToObject(), SvgGraphicsContext::viewboxTransform, and SvgLoadingContext::xmlBaseDir().

◆ applyId()

void SvgParser::applyId	(	const QString &	id,
		KoShape *	shape )

protected

Applies id to specified shape.

Definition at line 2367 of file SvgParser.cpp.

{
    if (id.isEmpty())
        return;
 
    KoShape *existingShape = m_context.shapeById(id);
    if (existingShape) {
        debugFlake << "SVG contains nodes with duplicated id:" << id;
        // Generate a random name and just don't register the shape.
        // We don't use the name as a unique identifier so we don't need to
        // worry about the extremely rare case of name collision.
        const QString suffix = QString::number(QRandomGenerator::system()->bounded(0x10000000, 0x7FFFFFFF), 16);
        const QString newName = id + '_' + suffix;
        shape->setName(newName);
    } else {
        shape->setName(id);
        m_context.registerShape(id, shape);
    }
}

References debugFlake, m_context, SvgLoadingContext::registerShape(), KoShape::setName(), and SvgLoadingContext::shapeById().

◆ applyMarkers()

void SvgParser::applyMarkers ( KoPathShape * shape )

protected

Definition at line 1414 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc)
        return;
 
    if (!gc->markerStartId.isEmpty() && m_markers.contains(gc->markerStartId)) {
        shape->setMarker(m_markers[gc->markerStartId].data(), KoFlake::StartMarker);
    }
 
    if (!gc->markerMidId.isEmpty() && m_markers.contains(gc->markerMidId)) {
        shape->setMarker(m_markers[gc->markerMidId].data(), KoFlake::MidMarker);
    }
 
    if (!gc->markerEndId.isEmpty() && m_markers.contains(gc->markerEndId)) {
        shape->setMarker(m_markers[gc->markerEndId].data(), KoFlake::EndMarker);
    }
 
    shape->setAutoFillMarkers(gc->autoFillMarkers);
}

References SvgGraphicsContext::autoFillMarkers, SvgLoadingContext::currentGC(), KoFlake::EndMarker, m_context, m_markers, SvgGraphicsContext::markerEndId, SvgGraphicsContext::markerMidId, SvgGraphicsContext::markerStartId, KoFlake::MidMarker, KoPathShape::setAutoFillMarkers(), KoPathShape::setMarker(), and KoFlake::StartMarker.

◆ applyMaskClipping()

void SvgParser::applyMaskClipping	(	KoShape *	shape,
		const QPointF &	shapeToOriginalUserCoordinates )

protected

Definition at line 1508 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc)
        return;
 
    if (gc->clipMaskId.isEmpty())
        return;
 
 
    QSharedPointer<KoClipMask> originalClipMask = m_clipMasks.value(gc->clipMaskId);
    if (!originalClipMask || originalClipMask->isEmpty()) return;
 
    KoClipMask *clipMask = originalClipMask->clone();
 
    clipMask->setExtraShapeOffset(shapeToOriginalUserCoordinates);
 
    shape->setClipMask(clipMask);
}

References SvgGraphicsContext::clipMaskId, SvgLoadingContext::currentGC(), m_clipMasks, m_context, KoShape::setClipMask(), and KoClipMask::setExtraShapeOffset().

◆ applyPaintOrder()

void SvgParser::applyPaintOrder ( KoShape * shape )

protected

Definition at line 1435 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc)
        return;
 
    if (!gc->paintOrder.isEmpty() && gc->paintOrder != "inherit") {
        QStringList paintOrder = gc->paintOrder.split(" ");
        QVector<KoShape::PaintOrder> order;
        Q_FOREACH(const QString p, paintOrder) {
            if (p == "fill") {
                order.append(KoShape::Fill);
            } else if (p == "stroke") {
                order.append(KoShape::Stroke);
            } else if (p == "markers") {
                order.append(KoShape::Markers);
            }
        }
        if (paintOrder.size() == 1 && order.isEmpty()) { // Normal
            order = KoShape::defaultPaintOrder();
        }
        if (order.size() == 1) {
            if (order.first() == KoShape::Fill) {
                shape->setPaintOrder(KoShape::Fill, KoShape::Stroke);
            } else if (order.first() == KoShape::Stroke) {
                shape->setPaintOrder(KoShape::Stroke, KoShape::Fill);
            } else if (order.first() == KoShape::Markers) {
                shape->setPaintOrder(KoShape::Markers, KoShape::Fill);
            }
        } else if (order.size() > 1) {
            shape->setPaintOrder(order.at(0), order.at(1));
        }
    }
}

References SvgLoadingContext::currentGC(), KoShape::defaultPaintOrder(), KoShape::Fill, m_context, KoShape::Markers, p, SvgGraphicsContext::paintOrder, KoShape::setPaintOrder(), and KoShape::Stroke.

◆ applyStrokeStyle()

void SvgParser::applyStrokeStyle ( KoShape * shape )

protected

Applies the current stroke style to the object.

Definition at line 1243 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (! gc)
        return;
 
    if (gc->strokeType == SvgGraphicsContext::None) {
        KoShapeStrokeSP stroke(new KoShapeStroke());
        stroke->setLineWidth(0.0);
        const QColor color = Qt::transparent;
        stroke->setColor(color);
        shape->setStroke(stroke);
    } else if (gc->strokeType == SvgGraphicsContext::Solid) {
        KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
        applyDashes(gc->stroke, stroke);
        shape->setStroke(stroke);
    } else if (gc->strokeType == SvgGraphicsContext::Complex) {
        // try to find referenced gradient
        SvgGradientHelper *gradient = findGradient(gc->strokeId);
        if (gradient) {
            QTransform transform;
            QGradient *result = prepareGradientForShape(gradient, shape, gc, &transform);
            if (result) {
                QBrush brush = *result;
                delete result;
                brush.setTransform(transform);
 
                KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
                stroke->setLineBrush(brush);
                applyDashes(gc->stroke, stroke);
                shape->setStroke(stroke);
            }
        } else {
            // no referenced stroke found, use fallback color
            KoShapeStrokeSP stroke(new KoShapeStroke(*gc->stroke));
            applyDashes(gc->stroke, stroke);
            shape->setStroke(stroke);
        }
    } else if (gc->strokeType == SvgGraphicsContext::Inherit) {
        shape->setInheritStroke(true);
    }
}

References applyDashes(), SvgGraphicsContext::Complex, SvgLoadingContext::currentGC(), findGradient(), SvgGraphicsContext::Inherit, m_context, SvgGraphicsContext::None, prepareGradientForShape(), KoShape::setInheritStroke(), KoShape::setStroke(), SvgGraphicsContext::Solid, SvgGraphicsContext::stroke, SvgGraphicsContext::strokeId, and SvgGraphicsContext::strokeType.

◆ applyStyle() [1/2]

void SvgParser::applyStyle	(	KoShape *	obj,
		const QDomElement &	e,
		const QPointF &	shapeToOriginalUserCoordinates )

protected

Applies styles to the given shape.

Definition at line 1003 of file SvgParser.cpp.

{
    applyStyle(obj, m_context.styleParser().collectStyles(e), shapeToOriginalUserCoordinates);
}

References applyStyle(), SvgStyleParser::collectStyles(), m_context, and SvgLoadingContext::styleParser.

◆ applyStyle() [2/2]

void SvgParser::applyStyle	(	KoShape *	obj,
		const SvgStyles &	styles,
		const QPointF &	shapeToOriginalUserCoordinates )

protected

Applies styles to the given shape.

Definition at line 1008 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc)
        return;
 
    m_context.styleParser().parseStyle(styles, m_inheritStrokeFillByDefault);
 
    if (!obj)
        return;
 
    if (!dynamic_cast<KoShapeGroup*>(obj)) {
        applyFillStyle(obj);
        applyStrokeStyle(obj);
    }
 
    if (KoPathShape *pathShape = dynamic_cast<KoPathShape*>(obj)) {
        applyMarkers(pathShape);
    }
 
    applyFilter(obj);
    applyClipping(obj, shapeToOriginalUserCoordinates);
    applyMaskClipping(obj, shapeToOriginalUserCoordinates);
 
    if (!gc->display || !gc->visible) {
        obj->setVisible(false);
    }
    obj->setTransparency(1.0 - gc->opacity);
    applyPaintOrder(obj);
}

References applyClipping(), applyFillStyle(), applyFilter(), applyMarkers(), applyMaskClipping(), applyPaintOrder(), applyStrokeStyle(), SvgLoadingContext::currentGC(), SvgGraphicsContext::display, m_context, m_inheritStrokeFillByDefault, SvgGraphicsContext::opacity, SvgStyleParser::parseStyle(), KoShape::setTransparency(), KoShape::setVisible(), SvgLoadingContext::styleParser, and SvgGraphicsContext::visible.

◆ applyViewBoxTransform()

void SvgParser::applyViewBoxTransform ( const QDomElement & element )

protected

Applies viewBox transformation to the current graphical context NOTE: after applying the function currentBoundingBox can become null!

Definition at line 1674 of file SvgParser.cpp.

{
    SvgGraphicsContext *gc = m_context.currentGC();
 
    QRectF viewRect = gc->currentBoundingBox;
    QTransform viewTransform;
 
    if (SvgUtil::parseViewBox(element, gc->currentBoundingBox,
                              &viewRect, &viewTransform)) {
 
        gc->matrix = viewTransform * gc->matrix;
        gc->currentBoundingBox = viewRect;
    }
}

References SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::currentGC(), m_context, SvgGraphicsContext::matrix, and SvgUtil::parseViewBox().

◆ buildDocument()

void SvgParser::buildDocument ( QList< KoShape * > shapes )

protected

Builds the document from the given shapes list.

◆ createDocumentFromSvg() [1/4]

QDomDocument SvgParser::createDocumentFromSvg	(	const QByteArray &	data,
		QString *	errorMsg = 0,
		int *	errorLine = 0,
		int *	errorColumn = 0 )

static

Definition at line 146 of file SvgParser.cpp.

{
    return createDocumentFromSvg(QXmlStreamReader(data), errorMsg, errorLine, errorColumn);
}

References createDocumentFromSvg().

◆ createDocumentFromSvg() [2/4]

QDomDocument SvgParser::createDocumentFromSvg	(	const QString &	data,
		QString *	errorMsg = 0,
		int *	errorLine = 0,
		int *	errorColumn = 0 )

static

Definition at line 151 of file SvgParser.cpp.

{
    return createDocumentFromSvg(QXmlStreamReader(data), errorMsg, errorLine, errorColumn);
}

References createDocumentFromSvg().

◆ createDocumentFromSvg() [3/4]

QDomDocument SvgParser::createDocumentFromSvg	(	QIODevice *	device,
		QString *	errorMsg = 0,
		int *	errorLine = 0,
		int *	errorColumn = 0 )

static

Definition at line 141 of file SvgParser.cpp.

{
    return createDocumentFromSvg(QXmlStreamReader(device), errorMsg, errorLine, errorColumn);
}

References createDocumentFromSvg().

◆ createDocumentFromSvg() [4/4]

QDomDocument SvgParser::createDocumentFromSvg	(	QXmlStreamReader	reader,
		QString *	errorMsg = 0,
		int *	errorLine = 0,
		int *	errorColumn = 0 )

static

Definition at line 156 of file SvgParser.cpp.

{
    QDomDocument doc;
    reader.setNamespaceProcessing(false);
    if (!doc.setContent(&reader, false, errorMsg, errorLine, errorColumn)) {
        return {};
    }
 
    return doc;
}

◆ createListOfShapesFromCSS()

QList< KoShape * > SvgParser::createListOfShapesFromCSS	(	const QDomElement	e,
		const QString	value,
		SvgLoadingContext &	context )

protected

Create a list of shapes from a CSS shapes definition with potentially multiple shapes.

Definition at line 2321 of file SvgParser.cpp.

{
    QList<KoShape*> shapeList;
    if (value == "auto" || value == "none") {
        return shapeList;
    }
    QStringList params = value.split(")");
    Q_FOREACH(const QString param, params) {
        KoShape *s = createShapeFromCSS(e, param.trimmed()+")", context);
        if (s) {
            shapeList.append(s);
        }
    }
    return shapeList;
}

References createShapeFromCSS(), and value().

◆ createObject()

KoShape * SvgParser::createObject	(	const QDomElement &	b,
		const SvgStyles &	style = SvgStyles() )

protected

Creates an object from the given xml element.

Definition at line 2176 of file SvgParser.cpp.

{
    m_context.pushGraphicsContext(b);
 
    KoShape *obj = createShapeFromElement(b, m_context);
    if (obj) {
        obj->applyAbsoluteTransformation(m_context.currentGC()->matrix);
        const QPointF extraOffset = extraShapeOffset(obj, m_context.currentGC()->matrix);
 
        SvgStyles objStyle = style.isEmpty() ? m_context.styleParser().collectStyles(b) : style;
        m_context.styleParser().parseFont(objStyle);
        applyStyle(obj, objStyle, extraOffset);
 
        // handle id
        applyId(b.attribute("id"), obj);
        obj->setZIndex(m_context.nextZIndex());
        parseMetadataApplyToShape(b, obj);
    }
 
    m_context.popGraphicsContext();
 
    if (obj) {
        m_shapeParentTransform.insert(obj, m_context.currentGC()->matrix);
    }
 
    return obj;
}

References KoShape::applyAbsoluteTransformation(), applyId(), applyStyle(), SvgStyleParser::collectStyles(), createShapeFromElement(), SvgLoadingContext::currentGC(), extraShapeOffset(), m_context, m_shapeParentTransform, SvgGraphicsContext::matrix, SvgLoadingContext::nextZIndex(), SvgStyleParser::parseFont(), parseMetadataApplyToShape(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoShape::setZIndex(), and SvgLoadingContext::styleParser.

◆ createObjectDirect()

KoShape * SvgParser::createObjectDirect ( const QDomElement & b )

protected

Definition at line 2150 of file SvgParser.cpp.

{
    m_context.pushGraphicsContext(b);
    uploadStyleToContext(b);
 
    KoShape *obj = createShapeFromElement(b, m_context);
    if (obj) {
        obj->applyAbsoluteTransformation(m_context.currentGC()->matrix);
        const QPointF extraOffset = extraShapeOffset(obj, m_context.currentGC()->matrix);
 
        applyCurrentStyle(obj, extraOffset);
 
        // handle id
        applyId(b.attribute("id"), obj);
        obj->setZIndex(m_context.nextZIndex());
        parseMetadataApplyToShape(b, obj);
    }
 
    m_context.popGraphicsContext();
 
    if (obj) {
        m_shapeParentTransform.insert(obj, m_context.currentGC()->matrix);
    }
    return obj;
}

References KoShape::applyAbsoluteTransformation(), applyCurrentStyle(), applyId(), createShapeFromElement(), SvgLoadingContext::currentGC(), extraShapeOffset(), m_context, m_shapeParentTransform, SvgGraphicsContext::matrix, SvgLoadingContext::nextZIndex(), parseMetadataApplyToShape(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoShape::setZIndex(), and uploadStyleToContext().

◆ createPath()

KoShape * SvgParser::createPath ( const QDomElement & element )

protected

Create path object from the given xml element.

Definition at line 2080 of file SvgParser.cpp.

{
    KoShape *obj = 0;
    if (element.tagName() == "line") {
        KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
        if (path) {
            double x1 = element.attribute("x1").isEmpty() ? 0.0 : parseUnitX(element.attribute("x1"));
            double y1 = element.attribute("y1").isEmpty() ? 0.0 : parseUnitY(element.attribute("y1"));
            double x2 = element.attribute("x2").isEmpty() ? 0.0 : parseUnitX(element.attribute("x2"));
            double y2 = element.attribute("y2").isEmpty() ? 0.0 : parseUnitY(element.attribute("y2"));
            path->clear();
            path->moveTo(QPointF(x1, y1));
            path->lineTo(QPointF(x2, y2));
            path->normalize();
            obj = path;
        }
    } else if (element.tagName() == "polyline" || element.tagName() == "polygon") {
        KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
        if (path) {
            path->clear();
 
            bool bFirst = true;
            QStringList pointList = SvgUtil::simplifyList(element.attribute("points"));
            for (QStringList::Iterator it = pointList.begin(); it != pointList.end(); ++it) {
                QPointF point;
                point.setX(SvgUtil::fromUserSpace(KisDomUtils::toDouble(*it)));
                ++it;
                if (it == pointList.end())
                    break;
                point.setY(SvgUtil::fromUserSpace(KisDomUtils::toDouble(*it)));
                if (bFirst) {
                    path->moveTo(point);
                    bFirst = false;
                } else
                    path->lineTo(point);
            }
            if (element.tagName() == "polygon")
                path->close();
 
            path->setPosition(path->normalize());
 
            obj = path;
        }
    } else if (element.tagName() == "path") {
        KoPathShape *path = static_cast<KoPathShape*>(createShape(KoPathShapeId));
        if (path) {
            path->clear();
 
            KoPathShapeLoader loader(path);
            loader.parseSvg(element.attribute("d"), true);
            path->setPosition(path->normalize());
 
            QPointF newPosition = QPointF(SvgUtil::fromUserSpace(path->position().x()),
                                          SvgUtil::fromUserSpace(path->position().y()));
            QSizeF newSize = QSizeF(SvgUtil::fromUserSpace(path->size().width()),
                                    SvgUtil::fromUserSpace(path->size().height()));
 
            path->setSize(newSize);
            path->setPosition(newPosition);
 
            if (element.hasAttribute("sodipodi:nodetypes")) {
                path->loadNodeTypes(element.attribute("sodipodi:nodetypes"));
            }
            obj = path;
        }
    }
 
    return obj;
}

References KoPathShape::clear(), createShape(), SvgUtil::fromUserSpace(), KoPathShapeId, KoPathShapeLoader::parseSvg(), parseUnitX(), parseUnitY(), SvgUtil::simplifyList(), and KisDomUtils::toDouble().

◆ createShape()

KoShape * SvgParser::createShape ( const QString & shapeID )

protected

creates a shape from the given shape id

Definition at line 2337 of file SvgParser.cpp.

{
    KoShapeFactoryBase *factory = KoShapeRegistry::instance()->get(shapeID);
    if (!factory) {
        debugFlake << "Could not find factory for shape id" << shapeID;
        return 0;
    }
 
    KoShape *shape = factory->createDefaultShape(m_documentResourceManager);
    if (!shape) {
        debugFlake << "Could not create Default shape for shape id" << shapeID;
        return 0;
    }
    if (shape->shapeId().isEmpty()) {
        shape->setShapeId(factory->id());
    }
 
    // reset transformation that might come from the default shape
    shape->setTransformation(QTransform());
 
    // reset border
    // ??? KoShapeStrokeModelSP oldStroke = shape->stroke();
    shape->setStroke(KoShapeStrokeModelSP());
 
    // reset fill
    shape->setBackground(QSharedPointer<KoShapeBackground>(0));
 
    return shape;
}

References KoShapeFactoryBase::createDefaultShape(), debugFlake, KoGenericRegistry< T >::get(), KoShapeFactoryBase::id, KoShapeRegistry::instance(), m_documentResourceManager, KoShape::setBackground(), KoShape::setShapeId(), KoShape::setStroke(), KoShape::setTransformation(), and KoShape::shapeId().

◆ createShapeFromCSS()

KoShape * SvgParser::createShapeFromCSS	(	const QDomElement	e,
		const QString	value,
		SvgLoadingContext &	context )

protected

Creates a shape from a CSS shapes definition.

Definition at line 2249 of file SvgParser.cpp.

{
    if (value.isEmpty()) {
        return 0;
    }
    unsigned int start = value.indexOf('(') + 1;
    unsigned int end = value.indexOf(')', start);
 
    QString val = value.mid(start, end - start);
    QString fillRule;
    if (val.startsWith("evenodd,")) {
        start += QString("evenodd,").size();
        fillRule = "evenodd";
    } else if (val.startsWith("nonzero,")) {
        start += QString("nonzero,").size();
        fillRule = "nonzero";
    }
    val = value.mid(start, end - start);
 
    QDomElement el;
    if (value.startsWith("url(")) {
        start = value.indexOf('#') + 1;
        KoShape *s = m_context.shapeById(value.mid(start, end - start));
        if (s) {
            const QTransform absTf = s->absoluteTransformation();
            KoShape *cloned = s->cloneShape();
            cloned->setTransformation(absTf * m_shapeParentTransform.value(s).inverted());
            return cloned;
        }
    } else if (value.startsWith("circle(")) {
        el = e.ownerDocument().createElement("circle");
        QStringList params = val.split(" ");
        el.setAttribute("r", SvgUtil::parseUnitXY(context.currentGC(), context.resolvedProperties(), params.first()));
        if (params.contains("at")) {
            // 1 == "at"
            el.setAttribute("cx", SvgUtil::parseUnitX(context.currentGC(), context.resolvedProperties(), params.at(2)));
            el.setAttribute("cy", SvgUtil::parseUnitY(context.currentGC(), context.resolvedProperties(), params.at(3)));
        }
    } else if (value.startsWith("ellipse(")) {
        el = e.ownerDocument().createElement("ellipse");
        QStringList params = val.split(" ");
        el.setAttribute("rx", SvgUtil::parseUnitX(context.currentGC(), context.resolvedProperties(), params.at(0)));
        el.setAttribute("ry", SvgUtil::parseUnitY(context.currentGC(), context.resolvedProperties(), params.at(1)));
        if (params.contains("at")) {
            // 2 == "at"
            el.setAttribute("cx", SvgUtil::parseUnitX(context.currentGC(), context.resolvedProperties(), params.at(3)));
            el.setAttribute("cy", SvgUtil::parseUnitY(context.currentGC(), context.resolvedProperties(), params.at(4)));
        }
    } else if (value.startsWith("polygon(")) {
        el = e.ownerDocument().createElement("polygon");
        QStringList points;
        Q_FOREACH(QString point,  SvgUtil::simplifyList(val)) {
            bool xVal = points.size() % 2;
            if (xVal) {
                points.append(QString::number(SvgUtil::parseUnitX(context.currentGC(), context.resolvedProperties(), point)));
            } else {
                points.append(QString::number(SvgUtil::parseUnitY(context.currentGC(), context.resolvedProperties(), point)));
            }
        }
        el.setAttribute("points", points.join(" "));
    } else if (value.startsWith("path(")) {
        el = e.ownerDocument().createElement("path");
        // SVG path data is inside a string.
        start += 1;
        end -= 1;
        el.setAttribute("d", value.mid(start, end - start));
    }
 
    el.setAttribute("fill-rule", fillRule);
    return createShapeFromElement(el, context);
}

References KoShape::absoluteTransformation(), KoShape::cloneShape(), createShapeFromElement(), SvgLoadingContext::currentGC(), m_context, m_shapeParentTransform, SvgUtil::parseUnitX(), SvgUtil::parseUnitXY(), SvgUtil::parseUnitY(), SvgLoadingContext::resolvedProperties(), KoShape::setTransformation(), SvgLoadingContext::shapeById(), SvgUtil::simplifyList(), KoShape::size(), and value().

◆ createShapeFromElement()

KoShape * SvgParser::createShapeFromElement	(	const QDomElement &	element,
		SvgLoadingContext &	context )

protected

Creates shape from specified svg element.

Definition at line 2204 of file SvgParser.cpp.

{
    KoShape *object = 0;
 
 
    const QString tagName = SvgUtil::mapExtendedShapeTag(element.tagName(), element);
    QList<KoShapeFactoryBase*> factories = KoShapeRegistry::instance()->factoriesForElement(KoXmlNS::svg, tagName);
 
    foreach (KoShapeFactoryBase *f, factories) {
        KoShape *shape = f->createDefaultShape(m_documentResourceManager);
        if (!shape)
            continue;
 
        SvgShape *svgShape = dynamic_cast<SvgShape*>(shape);
        if (!svgShape) {
            delete shape;
            continue;
        }
 
        // reset transformation that might come from the default shape
        shape->setTransformation(QTransform());
 
        // reset border
        KoShapeStrokeModelSP oldStroke = shape->stroke();
        shape->setStroke(KoShapeStrokeModelSP());
 
        // reset fill
        shape->setBackground(QSharedPointer<KoShapeBackground>(0));
 
        if (!svgShape->loadSvg(element, context)) {
            delete shape;
            continue;
        }
 
        object = shape;
        break;
    }
 
    if (!object) {
        object = createPath(element);
    }
 
    return object;
}

References createPath(), KoShapeRegistry::factoriesForElement(), KoShapeRegistry::instance(), SvgShape::loadSvg(), m_documentResourceManager, SvgUtil::mapExtendedShapeTag(), KoShape::setBackground(), KoShape::setStroke(), KoShape::setTransformation(), KoShape::stroke(), and KoXmlNS::svg.

◆ documentDescription()

QString SvgParser::documentDescription ( ) const

Definition at line 1710 of file SvgParser.cpp.

{
    return m_documentDescription;
}

References m_documentDescription.

◆ documentTitle()

QString SvgParser::documentTitle ( ) const

Definition at line 1705 of file SvgParser.cpp.

{
    return m_documentTitle;
}

References m_documentTitle.

◆ findClipPath()

SvgClipPathHelper * SvgParser::findClipPath ( const QString & id )

protected

find clip path with given id in clip path map

Definition at line 305 of file SvgParser.cpp.

{
    return m_clipPaths.contains(id) ? &m_clipPaths[id] : 0;
}

References m_clipPaths.

◆ findFilter()

SvgFilterHelper * SvgParser::findFilter	(	const QString &	id,
		const QString &	href = QString() )

protected

find filter with given id in filter map

Definition at line 268 of file SvgParser.cpp.

{
    // check if filter was already parsed, and return it
    if (m_filters.contains(id))
        return &m_filters[ id ];
 
    // check if filter was stored for later parsing
    if (!m_context.hasDefinition(id))
        return 0;
 
    const QDomElement &e = m_context.definition(id);
    if (e.childNodes().count() == 0) {
        QString mhref = e.attribute("xlink:href").mid(1);
 
        if (m_context.hasDefinition(mhref))
            return findFilter(mhref, id);
        else
            return 0;
    } else {
        // ok parse filter now
        if (! parseFilter(m_context.definition(id), m_context.definition(href)))
            return 0;
    }
 
    // return successfully parsed filter or 0
    QString n;
    if (href.isEmpty())
        n = id;
    else
        n = href;
 
    if (m_filters.contains(n))
        return &m_filters[ n ];
    else
        return 0;
}

References SvgLoadingContext::definition(), findFilter(), SvgLoadingContext::hasDefinition(), m_context, m_filters, and parseFilter().

◆ findGradient()

SvgGradientHelper * SvgParser::findGradient ( const QString & id )

protected

find gradient with given id in gradient map

Definition at line 231 of file SvgParser.cpp.

{
    SvgGradientHelper *result = 0;
 
    // check if gradient was already parsed, and return it
    if (m_gradients.contains(id)) {
        result = &m_gradients[ id ];
    }
 
    // check if gradient was stored for later parsing
    if (!result && m_context.hasDefinition(id)) {
        const QDomElement &e = m_context.definition(id);
        if (e.tagName().contains("Gradient")) {
            result = parseGradient(m_context.definition(id));
        } else if (e.tagName() == "meshgradient") {
            result = parseMeshGradient(m_context.definition(id));
        }
    }
 
    return result;
}

References SvgLoadingContext::definition(), SvgLoadingContext::hasDefinition(), m_context, m_gradients, parseGradient(), and parseMeshGradient().

◆ findPattern()

QSharedPointer< KoVectorPatternBackground > SvgParser::findPattern	(	const QString &	id,
		const KoShape *	shape )

protected

find pattern with given id in pattern map

Definition at line 253 of file SvgParser.cpp.

{
    QSharedPointer<KoVectorPatternBackground> result;
 
    // check if gradient was stored for later parsing
    if (m_context.hasDefinition(id)) {
        const QDomElement &e = m_context.definition(id);
        if (e.tagName() == "pattern") {
            result = parsePattern(m_context.definition(id), shape);
        }
    }
 
    return result;
}

References SvgLoadingContext::definition(), SvgLoadingContext::hasDefinition(), m_context, and parsePattern().

◆ getTextPath()

KoShape * SvgParser::getTextPath ( const QDomElement & e )

protected

Get the path for the gives textPath element.

Definition at line 1782 of file SvgParser.cpp.

                                                    {
    if (e.hasAttribute("path")) {
        QDomElement p = e.ownerDocument().createElement("path");
        p.setAttribute("d", e.attribute("path"));
        KoShape *s = createPath(p);
        return s;
    } else {
        QString pathId;
        if (e.hasAttribute("href")) {
            pathId = e.attribute("href").remove(0, 1);
        } else if (e.hasAttribute("xlink:href")) {
            pathId = e.attribute("xlink:href").remove(0, 1);
        }
        if (!pathId.isNull()) {
            KoShape *s = m_context.shapeById(pathId);
            if (s) {
                const QTransform absTf = s->absoluteTransformation();
                KoShape *cloned = s->cloneShape();
                cloned->setTransformation(absTf * m_shapeParentTransform.value(s).inverted());
                return cloned;
            }
        }
    }
    return nullptr;
}

References KoShape::absoluteTransformation(), KoShape::cloneShape(), createPath(), m_context, m_shapeParentTransform, p, KoShape::setTransformation(), and SvgLoadingContext::shapeById().

◆ getTheOnlyTextChild()

QDomText SvgParser::getTheOnlyTextChild ( const QDomElement & e )

protected

Definition at line 1775 of file SvgParser.cpp.

{
    QDomNode firstChild = e.firstChild();
    return !firstChild.isNull() && firstChild == e.lastChild() && firstChild.isText() ?
                firstChild.toText() : QDomText();
}

◆ knownMarkers()

QList< QExplicitlySharedDataPointer< KoMarker > > SvgParser::knownMarkers ( ) const

Definition at line 1700 of file SvgParser.cpp.

{
    return m_markers.values();
}

References m_markers.

◆ parseAngular()

qreal SvgParser::parseAngular ( const QString & unit )

protected

parses a angular attribute values, result in radians

Definition at line 333 of file SvgParser.cpp.

{
    return SvgUtil::parseUnitAngular(m_context.currentGC(), unit);
}

References SvgLoadingContext::currentGC(), m_context, and SvgUtil::parseUnitAngular().

◆ parseClipMask()

bool SvgParser::parseClipMask ( const QDomElement & e )

protected

Definition at line 904 of file SvgParser.cpp.

{
    QSharedPointer<KoClipMask> clipMask(new KoClipMask);
 
    const QString id = e.attribute("id");
    if (id.isEmpty()) return false;
 
    clipMask->setCoordinates(KoFlake::coordinatesFromString(e.attribute("maskUnits"), KoFlake::ObjectBoundingBox));
    clipMask->setContentCoordinates(KoFlake::coordinatesFromString(e.attribute("maskContentUnits"), KoFlake::UserSpaceOnUse));
 
    QRectF maskRect;
 
    if (clipMask->coordinates() == KoFlake::ObjectBoundingBox) {
        maskRect.setRect(
            SvgUtil::fromPercentage(e.attribute("x", "-10%")),
            SvgUtil::fromPercentage(e.attribute("y", "-10%")),
            SvgUtil::fromPercentage(e.attribute("width", "120%")),
            SvgUtil::fromPercentage(e.attribute("height", "120%")));
    } else {
        maskRect.setRect(
            parseUnitX(e.attribute("x", "-10%")), // yes, percents are insane in this case,
            parseUnitY(e.attribute("y", "-10%")), // but this is what SVG 1.1 tells us...
            parseUnitX(e.attribute("width", "120%")),
            parseUnitY(e.attribute("height", "120%")));
    }
 
    clipMask->setMaskRect(maskRect);
 
 
    // ensure that the clip mask is loaded in local coordinates system
    m_context.pushGraphicsContext(e);
    m_context.currentGC()->matrix = QTransform();
    m_context.currentGC()->workaroundClearInheritedFillProperties(); // HACK!
 
    KoShape *clipShape = parseGroup(e);
 
    m_context.popGraphicsContext();
 
    if (!clipShape) return false;
    clipMask->setShapes({clipShape});
 
    m_clipMasks.insert(id, clipMask);
    return true;
}

References KoFlake::coordinatesFromString(), SvgLoadingContext::currentGC(), SvgUtil::fromPercentage(), m_clipMasks, m_context, SvgGraphicsContext::matrix, KoFlake::ObjectBoundingBox, parseGroup(), parseUnitX(), parseUnitY(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoFlake::UserSpaceOnUse, and SvgGraphicsContext::workaroundClearInheritedFillProperties().

◆ parseClipPath()

bool SvgParser::parseClipPath ( const QDomElement & e )

protected

Parses a clip path element.

Definition at line 877 of file SvgParser.cpp.

{
    SvgClipPathHelper clipPath;
 
    const QString id = e.attribute("id");
    if (id.isEmpty()) return false;
 
    clipPath.setClipPathUnits(
                KoFlake::coordinatesFromString(e.attribute("clipPathUnits"), KoFlake::UserSpaceOnUse));
 
    // ensure that the clip path is loaded in local coordinates system
    m_context.pushGraphicsContext(e);
    m_context.currentGC()->matrix = QTransform();
    m_context.currentGC()->workaroundClearInheritedFillProperties(); // HACK!
 
    KoShape *clipShape = parseGroup(e);
 
    m_context.popGraphicsContext();
 
    if (!clipShape) return false;
 
    clipPath.setShapes({clipShape});
    m_clipPaths.insert(id, clipPath);
 
    return true;
}

References KoFlake::coordinatesFromString(), SvgLoadingContext::currentGC(), m_clipPaths, m_context, SvgGraphicsContext::matrix, parseGroup(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), SvgClipPathHelper::setClipPathUnits(), SvgClipPathHelper::setShapes(), KoFlake::UserSpaceOnUse, and SvgGraphicsContext::workaroundClearInheritedFillProperties().

◆ parseContainer()

QList< KoShape * > SvgParser::parseContainer ( const QDomElement & e )

protected

Parses a container element, returning a list of child shapes.

Definition at line 1944 of file SvgParser.cpp.

{
    QList<KoShape*> shapes;
 
    // are we parsing a switch container
    bool isSwitch = e.tagName() == "switch";
 
    DeferredUseStore deferredUseStore(this);
 
    for (QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement b = n.toElement();
        if (b.isNull()) {
            continue;
        }
 
        if (isSwitch) {
            // if we are parsing a switch check the requiredFeatures, requiredExtensions
            // and systemLanguage attributes
            // TODO: evaluate feature list
            if (b.hasAttribute("requiredFeatures")) {
                continue;
            }
            if (b.hasAttribute("requiredExtensions")) {
                // we do not support any extensions
                continue;
            }
            if (b.hasAttribute("systemLanguage")) {
                // not implemented yet
            }
        }
 
        QList<KoShape*> currentShapes = parseSingleElement(b, &deferredUseStore);
        shapes.append(currentShapes);
 
        // if we are parsing a switch, stop after the first supported element
        if (isSwitch && !currentShapes.isEmpty())
            break;
    }
    return shapes;
}

References parseSingleElement(), and shapes().

◆ parseDefsElement()

void SvgParser::parseDefsElement ( const QDomElement & e )

Definition at line 1985 of file SvgParser.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(e.tagName() == "defs");
    parseSingleElement(e);
}

References KIS_SAFE_ASSERT_RECOVER_RETURN, and parseSingleElement().

◆ parseFilter()

bool SvgParser::parseFilter	(	const QDomElement &	e,
		const QDomElement &	referencedBy = QDomElement() )

protected

Parses a filter element.

Definition at line 724 of file SvgParser.cpp.

{
    SvgFilterHelper filter;
 
    // Use the filter that is referencing, or if there isn't one, the original filter
    QDomElement b;
    if (!referencedBy.isNull())
        b = referencedBy;
    else
        b = e;
 
    // check if we are referencing another filter
    if (e.hasAttribute("xlink:href")) {
        QString href = e.attribute("xlink:href").mid(1);
        if (! href.isEmpty()) {
            // copy the referenced filter if found
            SvgFilterHelper *refFilter = findFilter(href);
            if (refFilter)
                filter = *refFilter;
        }
    } else {
        filter.setContent(b);
    }
 
    if (b.attribute("filterUnits") == "userSpaceOnUse")
        filter.setFilterUnits(KoFlake::UserSpaceOnUse);
    if (b.attribute("primitiveUnits") == "objectBoundingBox")
        filter.setPrimitiveUnits(KoFlake::ObjectBoundingBox);
 
    // parse filter region rectangle
    if (filter.filterUnits() == KoFlake::UserSpaceOnUse) {
        filter.setPosition(QPointF(parseUnitX(b.attribute("x")),
                                   parseUnitY(b.attribute("y"))));
        filter.setSize(QSizeF(parseUnitX(b.attribute("width")),
                              parseUnitY(b.attribute("height"))));
    } else {
        // x, y, width, height are in percentages of the object referencing the filter
        // so we just parse the percentages
        filter.setPosition(QPointF(SvgUtil::fromPercentage(b.attribute("x", "-0.1")),
                                   SvgUtil::fromPercentage(b.attribute("y", "-0.1"))));
        filter.setSize(QSizeF(SvgUtil::fromPercentage(b.attribute("width", "1.2")),
                              SvgUtil::fromPercentage(b.attribute("height", "1.2"))));
    }
 
    m_filters.insert(b.attribute("id"), filter);
 
    return true;
}

References SvgFilterHelper::filterUnits(), findFilter(), SvgUtil::fromPercentage(), m_filters, KoFlake::ObjectBoundingBox, parseUnitX(), parseUnitY(), SvgFilterHelper::setContent(), SvgFilterHelper::setFilterUnits(), SvgFilterHelper::setPosition(), SvgFilterHelper::setPrimitiveUnits(), SvgFilterHelper::setSize(), and KoFlake::UserSpaceOnUse.

◆ parseGradient()

SvgGradientHelper * SvgParser::parseGradient ( const QDomElement & e )

protected

Parses a gradient element.

Definition at line 339 of file SvgParser.cpp.

{
    // IMPROVEMENTS:
    // - Store the parsed colorstops in some sort of a cache so they don't need to be parsed again.
    // - A gradient inherits attributes it does not have from the referencing gradient.
    // - Gradients with no color stops have no fill or stroke.
    // - Gradients with one color stop have a solid color.
 
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc) return 0;
 
    SvgGradientHelper gradHelper;
 
    QString gradientId = e.attribute("id");
    if (gradientId.isEmpty()) return 0;
 
    // check if we have this gradient already parsed
    // copy existing gradient if it exists
    if (m_gradients.contains(gradientId)) {
        return &m_gradients[gradientId];
    }
 
    if (e.hasAttribute("xlink:href")) {
        // strip the '#' symbol
        QString href = e.attribute("xlink:href").mid(1);
 
        if (!href.isEmpty()) {
            // copy the referenced gradient if found
            SvgGradientHelper *pGrad = findGradient(href);
            if (pGrad) {
                gradHelper = *pGrad;
            }
        }
    }
 
    const QGradientStops defaultStops = gradHelper.gradient()->stops();
 
    if (e.attribute("gradientUnits") == "userSpaceOnUse") {
        gradHelper.setGradientUnits(KoFlake::UserSpaceOnUse);
    }
 
    m_context.pushGraphicsContext(e);
    uploadStyleToContext(e);
 
    if (e.tagName() == "linearGradient") {
        QLinearGradient *g = new QLinearGradient();
        if (gradHelper.gradientUnits() == KoFlake::ObjectBoundingBox) {
            g->setCoordinateMode(QGradient::ObjectBoundingMode);
            g->setStart(QPointF(SvgUtil::fromPercentage(e.attribute("x1", "0%")),
                                SvgUtil::fromPercentage(e.attribute("y1", "0%"))));
            g->setFinalStop(QPointF(SvgUtil::fromPercentage(e.attribute("x2", "100%")),
                                    SvgUtil::fromPercentage(e.attribute("y2", "0%"))));
        } else {
            g->setStart(QPointF(parseUnitX(e.attribute("x1")),
                                parseUnitY(e.attribute("y1"))));
            g->setFinalStop(QPointF(parseUnitX(e.attribute("x2")),
                                    parseUnitY(e.attribute("y2"))));
        }
        gradHelper.setGradient(g);
 
    } else if (e.tagName() == "radialGradient") {
        QRadialGradient *g = new QRadialGradient();
        if (gradHelper.gradientUnits() == KoFlake::ObjectBoundingBox) {
            g->setCoordinateMode(QGradient::ObjectBoundingMode);
            g->setCenter(QPointF(SvgUtil::fromPercentage(e.attribute("cx", "50%")),
                                 SvgUtil::fromPercentage(e.attribute("cy", "50%"))));
            g->setRadius(SvgUtil::fromPercentage(e.attribute("r", "50%")));
            g->setFocalPoint(QPointF(SvgUtil::fromPercentage(e.attribute("fx", "50%")),
                                     SvgUtil::fromPercentage(e.attribute("fy", "50%"))));
        } else {
            g->setCenter(QPointF(parseUnitX(e.attribute("cx")),
                                 parseUnitY(e.attribute("cy"))));
            g->setFocalPoint(QPointF(parseUnitX(e.attribute("fx")),
                                     parseUnitY(e.attribute("fy"))));
            g->setRadius(parseUnitXY(e.attribute("r")));
        }
        gradHelper.setGradient(g);
    } else {
        debugFlake << "WARNING: Failed to parse gradient with tag" << e.tagName();
    }
 
    // handle spread method
    QGradient::Spread spreadMethod = QGradient::PadSpread;
    QString spreadMethodStr = e.attribute("spreadMethod");
    if (!spreadMethodStr.isEmpty()) {
        if (spreadMethodStr == "reflect") {
            spreadMethod = QGradient::ReflectSpread;
        } else if (spreadMethodStr == "repeat") {
            spreadMethod = QGradient::RepeatSpread;
        }
    }
 
    gradHelper.setSpreadMode(spreadMethod);
 
    // Parse the color stops.
    m_context.styleParser().parseColorStops(gradHelper.gradient(), e, gc, defaultStops);
 
    if (e.hasAttribute("gradientTransform")) {
        SvgTransformParser p(e.attribute("gradientTransform"));
        if (p.isValid()) {
            gradHelper.setTransform(p.transform());
        }
    }
 
    m_context.popGraphicsContext();
 
    m_gradients.insert(gradientId, gradHelper);
 
    return &m_gradients[gradientId];
}

References SvgLoadingContext::currentGC(), debugFlake, findGradient(), SvgUtil::fromPercentage(), SvgGradientHelper::gradient(), SvgGradientHelper::gradientUnits(), m_context, m_gradients, KoFlake::ObjectBoundingBox, p, SvgStyleParser::parseColorStops(), parseUnitX(), parseUnitXY(), parseUnitY(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), SvgGradientHelper::setGradient(), SvgGradientHelper::setGradientUnits(), SvgGradientHelper::setSpreadMode(), SvgGradientHelper::setTransform(), SvgLoadingContext::styleParser, uploadStyleToContext(), and KoFlake::UserSpaceOnUse.

◆ parseGroup()

KoShape * SvgParser::parseGroup	(	const QDomElement &	e,
		const QDomElement &	overrideChildrenFrom = QDomElement(),
		bool	createContext = true )

protected

Parses a group-like element element, saving all its topmost properties.

Definition at line 1730 of file SvgParser.cpp.

{
    if (createContext) {
        m_context.pushGraphicsContext(b);
    }
 
    KoShapeGroup *group = new KoShapeGroup();
    group->setZIndex(m_context.nextZIndex());
 
    // groups should also have their own coordinate system!
    group->applyAbsoluteTransformation(m_context.currentGC()->matrix);
    const QPointF extraOffset = extraShapeOffset(group, m_context.currentGC()->matrix);
 
    uploadStyleToContext(b);
 
    QList<KoShape*> childShapes;
 
    if (!overrideChildrenFrom.isNull()) {
        // we upload styles from both: <use> and <defs>
        uploadStyleToContext(overrideChildrenFrom);
        if (overrideChildrenFrom.tagName() == "symbol") {
            childShapes = {parseGroup(overrideChildrenFrom)};
        } else {
            childShapes = parseSingleElement(overrideChildrenFrom, 0);
        }
    } else {
        childShapes = parseContainer(b);
    }
 
    // handle id
    applyId(b.attribute("id"), group);
 
    addToGroup(childShapes, group);
 
    applyCurrentStyle(group, extraOffset); // apply style to this group after size is set
 
    parseMetadataApplyToShape(b, group);
 
    if (createContext) {
        m_context.popGraphicsContext();
    }
 
    return group;
}

References addToGroup(), KoShape::applyAbsoluteTransformation(), applyCurrentStyle(), applyId(), SvgLoadingContext::currentGC(), extraShapeOffset(), m_context, SvgGraphicsContext::matrix, SvgLoadingContext::nextZIndex(), parseContainer(), parseGroup(), parseMetadataApplyToShape(), parseSingleElement(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoShape::setZIndex(), and uploadStyleToContext().

◆ parseMarker()

bool SvgParser::parseMarker ( const QDomElement & e )

protected

Definition at line 773 of file SvgParser.cpp.

{
    const QString id = e.attribute("id");
    if (id.isEmpty()) return false;
 
    QScopedPointer<KoMarker> marker(new KoMarker());
    marker->setCoordinateSystem(
        KoMarker::coordinateSystemFromString(e.attribute("markerUnits", "strokeWidth")));
 
    marker->setReferencePoint(QPointF(parseUnitX(e.attribute("refX")),
                                      parseUnitY(e.attribute("refY"))));
 
    marker->setReferenceSize(QSizeF(parseUnitX(e.attribute("markerWidth", "3")),
                                     parseUnitY(e.attribute("markerHeight", "3"))));
 
    const QString orientation = e.attribute("orient", "0");
 
    if (orientation == "auto") {
        marker->setAutoOrientation(true);
    } else {
        marker->setExplicitOrientation(parseAngular(orientation));
    }
 
    // ensure that the clip path is loaded in local coordinates system
    m_context.pushGraphicsContext(e, false);
    m_context.currentGC()->matrix = QTransform();
    m_context.currentGC()->currentBoundingBox = QRectF(QPointF(0, 0), marker->referenceSize());
 
    KoShape *markerShape = parseGroup(e);
 
    m_context.popGraphicsContext();
 
    if (!markerShape) return false;
 
    marker->setShapes({markerShape});
 
    m_markers.insert(id, QExplicitlySharedDataPointer<KoMarker>(marker.take()));
 
    return true;
}

References KoMarker::coordinateSystemFromString(), SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::currentGC(), m_context, m_markers, SvgGraphicsContext::matrix, parseAngular(), parseGroup(), parseUnitX(), parseUnitY(), SvgLoadingContext::popGraphicsContext(), and SvgLoadingContext::pushGraphicsContext().

◆ parseMeshGradient()

SvgGradientHelper * SvgParser::parseMeshGradient ( const QDomElement & e )

protected

Parses mesh gradient element.

Definition at line 450 of file SvgParser.cpp.

{
    SvgGradientHelper gradHelper;
    QString gradientId = e.attribute("id");
    QScopedPointer<SvgMeshGradient> g(new SvgMeshGradient);
 
    // check if we have this gradient already parsed
    // copy existing gradient if it exists
    if (m_gradients.contains(gradientId)) {
        return &m_gradients[gradientId];
    }
 
    if (e.hasAttribute("xlink:href")) {
        // strip the '#' symbol
        QString href = e.attribute("xlink:href").mid(1);
 
        if (!href.isEmpty()) {
            // copy the referenced gradient if found
            SvgGradientHelper *pGrad = findGradient(href);
            if (pGrad) {
                gradHelper = *pGrad;
            }
        }
    }
 
    if (e.attribute("gradientUnits") == "userSpaceOnUse") {
        gradHelper.setGradientUnits(KoFlake::UserSpaceOnUse);
    }
 
    if (e.hasAttribute("transform")) {
        SvgTransformParser p(e.attribute("transform"));
        if (p.isValid()) {
            gradHelper.setTransform(p.transform());
        }
    }
 
    QString type = e.attribute("type");
    g->setType(SvgMeshGradient::BILINEAR);
    if (!type.isEmpty() && type == "bicubic") {
        g->setType(SvgMeshGradient::BICUBIC);
    }
 
    int irow = 0, icols;
    for (int i = 0; i < e.childNodes().size(); ++i) {
        QDomNode node = e.childNodes().at(i);
 
        if (node.nodeName() == "meshrow") {
 
            SvgMeshStop startingNode;
            if (irow == 0) {
                startingNode.point = QPointF(
                            parseUnitX(e.attribute("x")),
                            parseUnitY(e.attribute(("y"))));
                startingNode.color = QColor();
            }
 
            icols = 0;
            g->getMeshArray()->newRow();
            for (int j = 0; j < node.childNodes().size() ; ++j) {
                QDomNode meshpatchNode = node.childNodes().at(j);
 
                if (meshpatchNode.nodeName() == "meshpatch") {
                    if (irow > 0) {
                        // Starting point for this would be the bottom (right) corner of the above patch
                        startingNode = g->getMeshArray()->getStop(SvgMeshPatch::Bottom, irow - 1, icols);
                    } else if (icols != 0) {
                        // Starting point for this would be the right (top) corner of the previous patch
                        startingNode = g->getMeshArray()->getStop(SvgMeshPatch::Right, irow, icols - 1);
                    }
 
                    QList<QPair<QString, QColor>> rawStops = parseMeshPatch(meshpatchNode);
                    // TODO handle the false result
                    if (!g->getMeshArray()->addPatch(rawStops, startingNode.point)) {
                        debugFlake << "WARNING: Failed to create meshpatch";
                    }
                    icols++;
                }
            }
            irow++;
        }
    }
    gradHelper.setMeshGradient(g.data());
    m_gradients.insert(gradientId, gradHelper);
 
    return &m_gradients[gradientId];
}

References SvgMeshGradient::BICUBIC, SvgMeshGradient::BILINEAR, SvgMeshPatch::Bottom, SvgMeshStop::color, debugFlake, findGradient(), m_gradients, p, parseMeshPatch(), parseUnitX(), parseUnitY(), SvgMeshStop::point, SvgMeshPatch::Right, SvgGradientHelper::setGradientUnits(), SvgGradientHelper::setMeshGradient(), SvgGradientHelper::setTransform(), and KoFlake::UserSpaceOnUse.

◆ parseMeshPatch()

QList< QPair< QString, QColor > > SvgParser::parseMeshPatch ( const QDomNode & meshpatch )

protected

Parses a single meshpatch and returns the pointer.

Definition at line 541 of file SvgParser.cpp.

{
    // path and its associated color
    QList<QPair<QString, QColor>> rawstops;
 
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc) return rawstops;
 
    QDomElement e = meshpatchNode.toElement();
 
    QDomElement stop;
 
    forEachElement(stop, e) {
        qreal X = 0;    // dummy value, don't care, just to ensure the function won't blow up (also to avoid a Coverity issue)
        QColor color = m_context.styleParser().parseColorStop(stop, gc, X).second;
 
        QString pathStr = stop.attribute("path");
 
        rawstops.append({pathStr, color});
    }
 
    return rawstops;
}

References SvgLoadingContext::currentGC(), forEachElement, m_context, SvgStyleParser::parseColorStop(), and SvgLoadingContext::styleParser.

◆ parseMetadataApplyToShape()

void SvgParser::parseMetadataApplyToShape	(	const QDomElement &	e,
		KoShape *	shape )

protected

This parses the SVG native title and desc elements and adds them into additional attributes.

Definition at line 857 of file SvgParser.cpp.

{
    const QString titleTag = "title";
    const QString descriptionTag = "desc";
    QDomElement title = e.firstChildElement(titleTag);
    if (!title.isNull()) {
        QDomText text = getTheOnlyTextChild(title);
        if (!text.data().isEmpty()) {
            shape->setAdditionalAttribute(titleTag, text.data());
        }
    }
    QDomElement description = e.firstChildElement(descriptionTag);
    if (!description.isNull()) {
        QDomText text = getTheOnlyTextChild(description);
        if (!text.data().isEmpty()) {
            shape->setAdditionalAttribute(descriptionTag, text.data());
        }
    }
}

References getTheOnlyTextChild(), and KoShape::setAdditionalAttribute().

◆ parsePattern()

QSharedPointer< KoVectorPatternBackground > SvgParser::parsePattern	(	const QDomElement &	e,
		const KoShape *	__shape )

protected

Parses a pattern element.

Unlike the gradient parsing function, this method is called every time we reference the pattern, not when we define it. Therefore we can already use the coordinate system of the destination.

In Krita shapes X,Y coordinates are baked into the shape global transform, but the pattern should be painted in "user" coordinates. Therefore, we should handle this offset separately.

TODO: Please also note that this offset is different from extraShapeOffset(), because A.inverted() * B != A * B.inverted(). I'm not sure which variant is correct (DK)

Definition at line 576 of file SvgParser.cpp.

{
    QSharedPointer<KoVectorPatternBackground> pattHelper;
 
    SvgGraphicsContext *gc = m_context.currentGC();
    if (!gc) return pattHelper;
 
    const QString patternId = e.attribute("id");
    if (patternId.isEmpty()) return pattHelper;
 
    pattHelper = toQShared(new KoVectorPatternBackground);
 
    if (e.hasAttribute("xlink:href")) {
        // strip the '#' symbol
        QString href = e.attribute("xlink:href").mid(1);
 
        if (!href.isEmpty() &&href != patternId) {
            // copy the referenced pattern if found
            QSharedPointer<KoVectorPatternBackground> pPatt = findPattern(href, shape);
            if (pPatt) {
                pattHelper = pPatt;
            }
        }
    }
 
    pattHelper->setReferenceCoordinates(
                KoFlake::coordinatesFromString(e.attribute("patternUnits"),
                                               pattHelper->referenceCoordinates()));
 
    pattHelper->setContentCoordinates(
                KoFlake::coordinatesFromString(e.attribute("patternContentUnits"),
                                               pattHelper->contentCoordinates()));
 
    if (e.hasAttribute("patternTransform")) {
        SvgTransformParser p(e.attribute("patternTransform"));
        if (p.isValid()) {
            pattHelper->setPatternTransform(p.transform());
        }
    }
 
    if (pattHelper->referenceCoordinates() == KoFlake::ObjectBoundingBox) {
        QRectF referenceRect(
            SvgUtil::fromPercentage(e.attribute("x", "0%")),
            SvgUtil::fromPercentage(e.attribute("y", "0%")),
            SvgUtil::fromPercentage(e.attribute("width", "0%")), // 0% is according to SVG 1.1, don't ask me why!
            SvgUtil::fromPercentage(e.attribute("height", "0%"))); // 0% is according to SVG 1.1, don't ask me why!
 
        pattHelper->setReferenceRect(referenceRect);
    } else {
        QRectF referenceRect(
            parseUnitX(e.attribute("x", "0")),
            parseUnitY(e.attribute("y", "0")),
            parseUnitX(e.attribute("width", "0")), // 0 is according to SVG 1.1, don't ask me why!
            parseUnitY(e.attribute("height", "0"))); // 0 is according to SVG 1.1, don't ask me why!
 
        pattHelper->setReferenceRect(referenceRect);
    }
 
   const QTransform dstShapeTransform = shape->absoluteTransformation();
   const QTransform shapeOffsetTransform = dstShapeTransform * gc->matrix.inverted();
   KIS_SAFE_ASSERT_RECOVER_NOOP(shapeOffsetTransform.type() <= QTransform::TxTranslate);
   const QPointF extraShapeOffset(shapeOffsetTransform.dx(), shapeOffsetTransform.dy());
 
   m_context.pushGraphicsContext(e);
   gc = m_context.currentGC();
   gc->workaroundClearInheritedFillProperties(); // HACK!
 
   // start building shape tree from scratch
   gc->matrix = QTransform();
 
   const QRectF boundingRect = shape->outline().boundingRect()/*.translated(extraShapeOffset)*/;
   const QTransform relativeToShape(boundingRect.width(), 0, 0, boundingRect.height(),
                                    boundingRect.x(), boundingRect.y());
 
 
 
   // WARNING1: OBB and ViewBox transformations are *baked* into the pattern shapes!
   //          although we expect the pattern be reusable, but it is not so!
   // WARNING2: the pattern shapes are stored in *User* coordinate system, although
   //           the "official" content system might be either OBB or User. It means that
   //           this baked transform should be stripped before writing the shapes back
   //           into SVG
   if (e.hasAttribute("viewBox")) {
        gc->currentBoundingBox =
            pattHelper->referenceCoordinates() == KoFlake::ObjectBoundingBox ?
            relativeToShape.mapRect(pattHelper->referenceRect()) :
            pattHelper->referenceRect();
 
        applyViewBoxTransform(e);
        pattHelper->setContentCoordinates(pattHelper->referenceCoordinates());
 
    } else if (pattHelper->contentCoordinates() == KoFlake::ObjectBoundingBox) {
        gc->matrix = relativeToShape * gc->matrix;
    }
 
    // We do *not* apply patternTransform here! Here we only bake the untransformed
    // version of the shape. The transformed one will be done in the very end while rendering.
 
    QList<KoShape*> patternShapes = parseContainer(e);
 
    if (pattHelper->contentCoordinates() == KoFlake::UserSpaceOnUse) {
        // In Krita we normalize the shapes, bake this transform into the pattern shapes
 
        const QPointF offset = bakeShapeOffset(pattHelper->patternTransform(), extraShapeOffset);
 
        Q_FOREACH (KoShape *shape, patternShapes) {
            shape->applyAbsoluteTransformation(QTransform::fromTranslate(offset.x(), offset.y()));
        }
    }
 
    if (pattHelper->referenceCoordinates() == KoFlake::UserSpaceOnUse) {
        // In Krita we normalize the shapes, bake this transform into reference rect
        // NOTE: this is possible *only* when pattern transform is not perspective
        //       (which is always true for SVG)
 
        const QPointF offset = bakeShapeOffset(pattHelper->patternTransform(), extraShapeOffset);
 
        QRectF ref = pattHelper->referenceRect();
        ref.translate(offset);
        pattHelper->setReferenceRect(ref);
    }
 
    m_context.popGraphicsContext();
    gc = m_context.currentGC();
 
    if (!patternShapes.isEmpty()) {
        pattHelper->setShapes(patternShapes);
    }
 
    return pattHelper;
}

References KoShape::absoluteTransformation(), KoShape::applyAbsoluteTransformation(), applyViewBoxTransform(), bakeShapeOffset(), KoFlake::coordinatesFromString(), SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::currentGC(), extraShapeOffset(), findPattern(), SvgUtil::fromPercentage(), KIS_SAFE_ASSERT_RECOVER_NOOP, m_context, SvgGraphicsContext::matrix, KoFlake::ObjectBoundingBox, KoShape::outline(), p, parseContainer(), parseUnitX(), parseUnitY(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), toQShared(), KoFlake::UserSpaceOnUse, and SvgGraphicsContext::workaroundClearInheritedFillProperties().

◆ parseSingleElement()

QList< KoShape * > SvgParser::parseSingleElement	(	const QDomElement &	b,
		DeferredUseStore *	deferredUseStore = 0 )

protected

XXX.

WARNING: 'defs' are basically 'display:none' style, therefore they should not play any role in shapes outline calculation. But setVisible(false) shapes do! Should be fixed in the future!

Definition at line 1991 of file SvgParser.cpp.

{
    QList<KoShape*> shapes;
 
    // save definition for later instantiation with 'use'
    m_context.addDefinition(b);
    if (deferredUseStore) {
        deferredUseStore->checkPendingUse(b, shapes);
    }
 
    if (b.tagName() == "svg") {
        shapes += parseSvg(b);
    } else if (b.tagName() == "g" || b.tagName() == "a") {
        // treat svg link <a> as group so we don't miss its child elements
        shapes += parseGroup(b);
    } else if (b.tagName() == "symbol") {
        parseSymbol(b);
    } else if (b.tagName() == "switch") {
        m_context.pushGraphicsContext(b);
        shapes += parseContainer(b);
        m_context.popGraphicsContext();
    } else if (b.tagName() == "defs") {
        if (b.childNodes().count() > 0) {
            KoShape *defsShape = parseGroup(b);
            defsShape->setVisible(false);
            m_defsShapes << defsShape; // TODO: where to delete the shape!?
 
        }
    } else if (b.tagName() == "linearGradient" || b.tagName() == "radialGradient") {
    } else if (b.tagName() == "pattern") {
    } else if (b.tagName() == "filter") {
        parseFilter(b);
    } else if (b.tagName() == "clipPath") {
        parseClipPath(b);
    } else if (b.tagName() == "mask") {
        parseClipMask(b);
    } else if (b.tagName() == "marker") {
        parseMarker(b);
    } else if (b.tagName() == "style") {
        m_context.addStyleSheet(b);
    } else if (b.tagName() == "text" || b.tagName() == "tspan" || b.tagName() == "textPath") {
        shapes += parseTextElement(b);
    } else if (b.tagName() == "rect" || b.tagName() == "ellipse" || b.tagName() == "circle" || b.tagName() == "line" || b.tagName() == "polyline"
               || b.tagName() == "polygon" || b.tagName() == "path" || b.tagName() == "image") {
        KoShape *shape = createObjectDirect(b);
 
        if (shape) {
            if (!shape->outlineRect().isNull() || !shape->boundingRect().isNull()) {
                shapes.append(shape);
            } else {
                debugFlake << "WARNING: shape is totally empty!" << shape->shapeId() << ppVar(shape->outlineRect());
                debugFlake << "    " << shape->shapeId() << ppVar(shape->outline());
                {
                    QString string;
                    QTextStream stream(&string);
                    KisPortingUtils::setUtf8OnStream(stream);
                    stream << b;
                    debugFlake << "    " << string;
                }
                delete shape;
            }
        }
    } else if (b.tagName() == "use") {
        KoShape* s = parseUse(b, deferredUseStore);
        if (s) {
            shapes += s;
        }
    } else if (b.tagName() == "color-profile") {
        m_context.parseProfile(b);
    } else {
        // this is an unknown element, so try to load it anyway
        // there might be a shape that handles that element
        KoShape *shape = createObject(b);
        if (shape) {
            shapes.append(shape);
        }
    }
 
    return shapes;
}

References SvgLoadingContext::addDefinition(), SvgLoadingContext::addStyleSheet(), KoShape::boundingRect(), SvgParser::DeferredUseStore::checkPendingUse(), createObject(), createObjectDirect(), debugFlake, m_context, m_defsShapes, KoShape::outline(), KoShape::outlineRect(), parseClipMask(), parseClipPath(), parseContainer(), parseFilter(), parseGroup(), parseMarker(), SvgLoadingContext::parseProfile(), parseSvg(), parseSymbol(), parseTextElement(), parseUse(), SvgLoadingContext::popGraphicsContext(), ppVar, SvgLoadingContext::pushGraphicsContext(), KisPortingUtils::setUtf8OnStream(), KoShape::setVisible(), KoShape::shapeId(), and shapes().

◆ parseSvg()

QList< KoShape * > SvgParser::parseSvg	(	const QDomElement &	e,
		QSizeF *	fragmentSize = 0 )

Parses a svg fragment, returning the list of top level child shapes.

In internal SVG coordinate systems pixels are linked to absolute values with a fixed ratio.

See CSS specification: https://www.w3.org/TR/css-values-3/#absolute-lengths

Definition at line 1575 of file SvgParser.cpp.

{
    // check if we are the root svg element
    const bool isRootSvg = m_context.isRootContext();
 
    // parse 'transform' field if preset
    SvgGraphicsContext *gc = m_context.pushGraphicsContext(e);
 
    applyStyle(0, e, QPointF());
 
    const QString w = e.attribute("width");
    const QString h = e.attribute("height");
 
    qreal width = w.isEmpty() ? 666.0 : parseUnitX(w);
    qreal height = h.isEmpty() ? 555.0 : parseUnitY(h);
 
    if (w.isEmpty() || h.isEmpty()) {
        QRectF viewRect;
        QTransform viewTransform_unused;
        QRectF fakeBoundingRect(0.0, 0.0, 1.0, 1.0);
 
        if (SvgUtil::parseViewBox(e, fakeBoundingRect,
                                  &viewRect, &viewTransform_unused)) {
 
            QSizeF estimatedSize = viewRect.size();
 
            if (estimatedSize.isValid()) {
 
                if (!w.isEmpty()) {
                    estimatedSize = QSizeF(width, width * estimatedSize.height() / estimatedSize.width());
                } else if (!h.isEmpty()) {
                    estimatedSize = QSizeF(height * estimatedSize.width() / estimatedSize.height(), height);
                }
 
                width = estimatedSize.width();
                height = estimatedSize.height();
            }
        }
    }
 
    QSizeF svgFragmentSize(QSizeF(width, height));
 
    if (fragmentSize) {
        *fragmentSize = svgFragmentSize;
    }
 
    gc->currentBoundingBox = QRectF(QPointF(0, 0), svgFragmentSize);
 
    if (!isRootSvg) {
        // x and y attribute has no meaning for outermost svg elements
        const qreal x = parseUnit(e.attribute("x", "0"));
        const qreal y = parseUnit(e.attribute("y", "0"));
 
        QTransform move = QTransform::fromTranslate(x, y);
        gc->matrix = move * gc->matrix;
    }
 
    gc->pixelsPerInch = 96.0;
 
    applyViewBoxTransform(e);
 
    QList<KoShape*> shapes;
 
    // First find the metadata
    for (QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
        QDomElement b = n.toElement();
        if (b.isNull())
            continue;
 
        if (b.tagName() == "title") {
            m_documentTitle = b.text().trimmed();
        }
        else if (b.tagName() == "desc") {
            m_documentDescription = b.text().trimmed();
        }
        else if (b.tagName() == "metadata") {
            // TODO: parse the metadata
        }
    }
 
 
    // SVG 1.1: skip the rendering of the element if it has null viewBox; however an inverted viewbox is just peachy
    // and as mother makes them -- if mother is inkscape.
    if (gc->currentBoundingBox.normalized().isValid()) {
        shapes = parseContainer(e);
    }
 
    m_context.popGraphicsContext();
 
    return shapes;
}

References applyStyle(), applyViewBoxTransform(), SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::isRootContext(), m_context, m_documentDescription, m_documentTitle, SvgGraphicsContext::matrix, parseContainer(), parseUnit(), parseUnitX(), parseUnitY(), SvgUtil::parseViewBox(), SvgGraphicsContext::pixelsPerInch, SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), and shapes().

◆ parseSymbol()

bool SvgParser::parseSymbol ( const QDomElement & e )

protected

Definition at line 814 of file SvgParser.cpp.

{
    const QString id = e.attribute("id");
 
    if (id.isEmpty()) return false;
 
    QScopedPointer<KoSvgSymbol> svgSymbol(new KoSvgSymbol());
 
    // ensure that the clip path is loaded in local coordinates system
    m_context.pushGraphicsContext(e, false);
    m_context.currentGC()->matrix = QTransform();
    m_context.currentGC()->currentBoundingBox = QRectF(0.0, 0.0, 1.0, 1.0);
 
    QString title = e.firstChildElement("title").toElement().text();
 
    QScopedPointer<KoShape> symbolShape(parseGroup(e));
 
    m_context.popGraphicsContext();
 
    if (!symbolShape) return false;
 
    svgSymbol->shape = symbolShape.take();
    svgSymbol->title = title;
    svgSymbol->id = id;
    if (title.isEmpty()) svgSymbol->title = id;
 
    if (svgSymbol->shape->boundingRect() == QRectF(0.0, 0.0, 0.0, 0.0)) {
        debugFlake << "Symbol" << id << "seems to be empty, discarding";
        return false;
    }
 
    // TODO: out default set of symbols had duplicated ids! We should
    //       make sure they are unique!
    if (m_symbols.contains(id)) {
        delete m_symbols[id];
        m_symbols.remove(id);
    }
 
    m_symbols.insert(id, svgSymbol.take());
 
    return true;
}

References SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::currentGC(), debugFlake, m_context, m_symbols, SvgGraphicsContext::matrix, parseGroup(), SvgLoadingContext::popGraphicsContext(), and SvgLoadingContext::pushGraphicsContext().

◆ parseTextChildren()

void SvgParser::parseTextChildren	(	const QDomElement &	e,
		KoSvgTextLoader &	textLoader )

protected

parse children of a <text > element into the root shape.

TODO: we should skip dublin core metadata too...

Definition at line 1808 of file SvgParser.cpp.

                                                                                   {
    QDomText t = getTheOnlyTextChild(e);
    if (!t.isNull()) {
        textLoader.loadSvgText(t, m_context);
    } else {
        textLoader.enterNodeSubtree();
        for (QDomNode n = e.firstChild(); !n.isNull(); n = n.nextSibling()) {
            QDomElement b = n.toElement();
            if (b.tagName() == "title" || b.tagName() == "desc") continue; 
            textLoader.nextNode();
            if (b.isNull()) {
                textLoader.loadSvgText(n.toText(), m_context);
                KoShape *styleDummy = new KoPathShape();
                applyCurrentBasicStyle(styleDummy);
                textLoader.setStyleInfo(styleDummy);
            } else {
                m_context.pushGraphicsContext(b);
                uploadStyleToContext(b);
                textLoader.loadSvg(b, m_context);
                if (b.hasChildNodes()) {
                    parseTextChildren(b, textLoader);
                }
                textLoader.setTextPathOnCurrentNode(getTextPath(b));
                m_context.popGraphicsContext();
            }
        }
        textLoader.leaveNodeSubtree();
    }
    KoShape *styleDummy = new KoPathShape();
    applyCurrentBasicStyle(styleDummy);
    textLoader.setStyleInfo(styleDummy);
}

References applyCurrentBasicStyle(), KoSvgTextLoader::enterNodeSubtree(), getTextPath(), getTheOnlyTextChild(), KoSvgTextLoader::leaveNodeSubtree(), KoSvgTextLoader::loadSvg(), KoSvgTextLoader::loadSvgText(), m_context, KoSvgTextLoader::nextNode(), parseTextChildren(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoSvgTextLoader::setStyleInfo(), KoSvgTextLoader::setTextPathOnCurrentNode(), and uploadStyleToContext().

◆ parseTextElement()

KoShape * SvgParser::parseTextElement	(	const QDomElement &	e,
		KoSvgTextShape *	mergeIntoShape = 0 )

Definition at line 1841 of file SvgParser.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(e.tagName() == "text" || e.tagName() == "tspan" || e.tagName() == "textPath", 0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(m_isInsideTextSubtree || e.tagName() == "text", 0);
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(e.tagName() == "text" || !mergeIntoShape, 0);
 
    KoSvgTextShape *rootTextShape  = 0;
 
    if (mergeIntoShape) {
        rootTextShape = mergeIntoShape;
    } else {
        KoShapeFactoryBase *factory = KoShapeRegistry::instance()->value("KoSvgTextShapeID");
        rootTextShape = dynamic_cast<KoSvgTextShape*>(factory->createDefaultShape(m_documentResourceManager));
    }
    KoSvgTextLoader textLoader(rootTextShape);
 
    if (rootTextShape) {
        m_isInsideTextSubtree = true;
    }
 
    m_context.pushGraphicsContext(e);
    uploadStyleToContext(e);
 
    if (rootTextShape) {
        if (!m_context.currentGC()->shapeInsideValue.isEmpty()) {
            QList<KoShape*> shapesInside = createListOfShapesFromCSS(e, m_context.currentGC()->shapeInsideValue, m_context);
            rootTextShape->setShapesInside(shapesInside);
        }
 
        if (!m_context.currentGC()->shapeSubtractValue.isEmpty()) {
            QList<KoShape*> shapesSubtract = createListOfShapesFromCSS(e, m_context.currentGC()->shapeSubtractValue, m_context);
            rootTextShape->setShapesSubtract(shapesSubtract);
        }
    }
 
    if (e.hasAttribute("krita:textVersion")) {
        m_context.currentGC()->textProperties.setProperty(KoSvgTextProperties::KraTextVersionId, e.attribute("krita:textVersion", "1").toInt());
 
        if (m_isInsideTextSubtree) {
            debugFlake << "WARNING: \"krita:textVersion\" attribute appeared in non-root text shape";
        }
    }
 
    parseMetadataApplyToShape(e, rootTextShape);
 
    if (!mergeIntoShape) {
        rootTextShape->setZIndex(m_context.nextZIndex());
    }
 
 
    if (m_context.currentGC()->textProperties.hasProperty(KoSvgTextProperties::KraTextVersionId) &&
        m_context.currentGC()->textProperties.property(KoSvgTextProperties::KraTextVersionId).toInt() < 2) {
 
        static const KoID warning("warn_text_version_1",
                                  i18nc("warning while loading SVG text",
                                        "The document has vector text created "
                                        "in Krita 4.x. When you save the document, "
                                        "the text object will be converted into "
                                        "Krita 5 format that will no longer be "
                                        "compatible with Krita 4.x"));
 
        if (!m_warnings.contains(warning)) {
            m_warnings << warning;
        }
    }
 
    textLoader.loadSvg(e, m_context, m_resolveTextPropertiesForTopLevel);
 
    // 1) apply transformation only in case we are not overriding the shape!
    // 2) the transformation should be applied *before* the shape is added to the group!
    if (!mergeIntoShape) {
        // groups should also have their own coordinate system!
        rootTextShape->applyAbsoluteTransformation(m_context.currentGC()->matrix);
        const QPointF extraOffset = extraShapeOffset(rootTextShape, m_context.currentGC()->matrix);
 
        // handle id
        applyId(e.attribute("id"), rootTextShape);
        applyCurrentStyle(rootTextShape, extraOffset); // apply style to this group after size is set
    } else {
        m_context.currentGC()->matrix = mergeIntoShape->absoluteTransformation();
        applyCurrentBasicStyle(rootTextShape);
    }
 
    QDomText onlyTextChild = getTheOnlyTextChild(e);
    if (!onlyTextChild.isNull()) {
        textLoader.loadSvgText(onlyTextChild, m_context);
 
    } else {
        parseTextChildren(e, textLoader);
 
    }
 
    m_context.popGraphicsContext();
 
    m_isInsideTextSubtree = false;
 
    //rootTextShape->debugParsing();
    rootTextShape->relayout();
 
 
    return rootTextShape;
}

References KoShape::absoluteTransformation(), KoShape::applyAbsoluteTransformation(), applyCurrentBasicStyle(), applyCurrentStyle(), applyId(), KoShapeFactoryBase::createDefaultShape(), createListOfShapesFromCSS(), SvgLoadingContext::currentGC(), debugFlake, extraShapeOffset(), getTheOnlyTextChild(), KoSvgTextProperties::hasProperty(), KoShapeRegistry::instance(), KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, KoSvgTextProperties::KraTextVersionId, KoSvgTextLoader::loadSvg(), KoSvgTextLoader::loadSvgText(), m_context, m_documentResourceManager, m_isInsideTextSubtree, m_resolveTextPropertiesForTopLevel, m_warnings, SvgGraphicsContext::matrix, SvgLoadingContext::nextZIndex(), parseMetadataApplyToShape(), parseTextChildren(), SvgLoadingContext::popGraphicsContext(), KoSvgTextProperties::property(), SvgLoadingContext::pushGraphicsContext(), KoSvgTextShape::relayout(), KoSvgTextProperties::setProperty(), KoSvgTextShape::setShapesInside(), KoSvgTextShape::setShapesSubtract(), KoShape::setZIndex(), SvgGraphicsContext::shapeInsideValue, SvgGraphicsContext::shapeSubtractValue, SvgGraphicsContext::textProperties, uploadStyleToContext(), and KoGenericRegistry< T >::value().

◆ parseUnit()

qreal SvgParser::parseUnit	(	const QString &	unit,
		bool	horiz = false,
		bool	vert = false,
		const QRectF &	bbox = QRectF() )

protected

parses a length attribute

Definition at line 313 of file SvgParser.cpp.

{
    return SvgUtil::parseUnit(m_context.currentGC(), m_context.resolvedProperties(), unit, horiz, vert, bbox);
}

References SvgLoadingContext::currentGC(), m_context, SvgUtil::parseUnit(), and SvgLoadingContext::resolvedProperties().

◆ parseUnitX()

qreal SvgParser::parseUnitX ( const QString & unit )

protected

parses a length attribute in x-direction

Definition at line 318 of file SvgParser.cpp.

{
    return SvgUtil::parseUnitX(m_context.currentGC(), m_context.resolvedProperties(), unit);
}

References SvgLoadingContext::currentGC(), m_context, SvgUtil::parseUnitX(), and SvgLoadingContext::resolvedProperties().

◆ parseUnitXY()

qreal SvgParser::parseUnitXY ( const QString & unit )

protected

parses a length attribute in xy-direction

Definition at line 328 of file SvgParser.cpp.

{
    return SvgUtil::parseUnitXY(m_context.currentGC(), m_context.resolvedProperties(), unit);
}

References SvgLoadingContext::currentGC(), m_context, SvgUtil::parseUnitXY(), and SvgLoadingContext::resolvedProperties().

◆ parseUnitY()

qreal SvgParser::parseUnitY ( const QString & unit )

protected

parses a length attribute in y-direction

Definition at line 323 of file SvgParser.cpp.

{
    return SvgUtil::parseUnitY(m_context.currentGC(), m_context.resolvedProperties(), unit);
}

References SvgLoadingContext::currentGC(), m_context, SvgUtil::parseUnitY(), and SvgLoadingContext::resolvedProperties().

◆ parseUse()

KoShape * SvgParser::parseUse	(	const QDomElement &	e,
		DeferredUseStore *	deferredUseStore )

protected

Parses a use element, returning a list of child shapes.

Definition at line 1528 of file SvgParser.cpp.

{
    QString href = e.attribute("xlink:href");
    if (href.isEmpty())
        return 0;
 
    QString key = href.mid(1);
    const bool gotDef = m_context.hasDefinition(key);
    if (gotDef) {
        return resolveUse(e, key);
    } else if (deferredUseStore) {
        deferredUseStore->add(&e, key);
        return 0;
    }
    debugFlake << "WARNING: Did not find reference for svg 'use' element. Skipping. Id: "
             << key;
    return 0;
}

References SvgParser::DeferredUseStore::add(), debugFlake, SvgLoadingContext::hasDefinition(), m_context, and resolveUse().

◆ resolveUse()

KoShape * SvgParser::resolveUse	(	const QDomElement &	e,
		const QString &	key )

protected

Definition at line 1547 of file SvgParser.cpp.

{
    KoShape *result = 0;
 
    SvgGraphicsContext *gc = m_context.pushGraphicsContext(e);
 
    // TODO: parse 'width' and 'height' as well
    gc->matrix.translate(parseUnitX(e.attribute("x", "0")), parseUnitY(e.attribute("y", "0")));
 
    const QDomElement &referencedElement = m_context.definition(key);
    result = parseGroup(e, referencedElement, false);
 
    m_context.popGraphicsContext();
    return result;
}

References SvgLoadingContext::definition(), m_context, SvgGraphicsContext::matrix, parseGroup(), parseUnitX(), parseUnitY(), SvgLoadingContext::popGraphicsContext(), and SvgLoadingContext::pushGraphicsContext().

◆ setDefaultKraTextVersion()

void SvgParser::setDefaultKraTextVersion ( int version )

Definition at line 200 of file SvgParser.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(m_context.currentGC());
    m_context.currentGC()->textProperties.setProperty(KoSvgTextProperties::KraTextVersionId, version);
}

References SvgLoadingContext::currentGC(), KIS_SAFE_ASSERT_RECOVER_RETURN, KoSvgTextProperties::KraTextVersionId, m_context, KoSvgTextProperties::setProperty(), and SvgGraphicsContext::textProperties.

◆ setFileFetcher()

void SvgParser::setFileFetcher ( SvgParser::FileFetcherFunc func )

Definition at line 1715 of file SvgParser.cpp.

{
    m_context.setFileFetcher(func);
}

References m_context, and SvgLoadingContext::setFileFetcher().

◆ setFillStrokeInheritByDefault()

void SvgParser::setFillStrokeInheritByDefault ( const bool enable )

Definition at line 206 of file SvgParser.cpp.

{
    m_inheritStrokeFillByDefault = enable;
}

References m_inheritStrokeFillByDefault.

◆ setResolution()

void SvgParser::setResolution	(	const QRectF	boundsInPixels,
		qreal	pixelsPerInch )

Definition at line 187 of file SvgParser.cpp.

{
    KIS_ASSERT(!m_context.currentGC());
    m_context.pushGraphicsContext();
    m_context.currentGC()->isResolutionFrame = true;
    m_context.currentGC()->pixelsPerInch = pixelsPerInch;
 
    const qreal scale = 72.0 / pixelsPerInch;
    const QTransform t = QTransform::fromScale(scale, scale);
    m_context.currentGC()->currentBoundingBox = boundsInPixels;
    m_context.currentGC()->matrix = t;
}

References SvgGraphicsContext::currentBoundingBox, SvgLoadingContext::currentGC(), SvgGraphicsContext::isResolutionFrame, KIS_ASSERT, m_context, SvgGraphicsContext::matrix, SvgGraphicsContext::pixelsPerInch, and SvgLoadingContext::pushGraphicsContext().

◆ setResolveTextPropertiesForTopLevel()

void SvgParser::setResolveTextPropertiesForTopLevel ( const bool enable )

Definition at line 211 of file SvgParser.cpp.

{
    m_resolveTextPropertiesForTopLevel = enable;
}

References m_resolveTextPropertiesForTopLevel.

◆ setXmlBaseDir()

void SvgParser::setXmlBaseDir ( const QString & baseDir )

Sets the initial xml base directory (the directory form where the file is read)

Definition at line 167 of file SvgParser.cpp.

{
    m_context.setInitialXmlBaseDir(baseDir);
 
    setFileFetcher(
        [this](const QString &name) {
            QStringList possibleNames;
            possibleNames << name;
            possibleNames << QDir::cleanPath(QDir(m_context.xmlBaseDir()).absoluteFilePath(name));
            for (QString fileName : possibleNames) {
                QFile file(fileName);
                if (file.exists()) {
                    file.open(QIODevice::ReadOnly);
                    return file.readAll();
                }
            }
            return QByteArray();
        });
}

References m_context, setFileFetcher(), SvgLoadingContext::setInitialXmlBaseDir(), and SvgLoadingContext::xmlBaseDir().

◆ shapes()

QList< KoShape * > SvgParser::shapes ( ) const

Returns the list of all shapes of the svg document.

Definition at line 216 of file SvgParser.cpp.

{
    return m_shapes;
}

References m_shapes.

◆ takeSymbols()

QVector< KoSvgSymbol * > SvgParser::takeSymbols ( )

Takes the collection of symbols contained in the svg document. The parser will no longer know about the symbols.

Definition at line 221 of file SvgParser.cpp.

{
    QVector<KoSvgSymbol*> symbols = m_symbols.values().toVector();
    m_symbols.clear();
    return symbols;
}

References m_symbols.

◆ uploadStyleToContext()

void SvgParser::uploadStyleToContext ( const QDomElement & e )

protected

Definition at line 949 of file SvgParser.cpp.

{
    SvgStyles styles = m_context.styleParser().collectStyles(e);
    m_context.styleParser().parseFont(styles);
    m_context.styleParser().parseStyle(styles, m_inheritStrokeFillByDefault);
}

References SvgStyleParser::collectStyles(), m_context, m_inheritStrokeFillByDefault, SvgStyleParser::parseFont(), SvgStyleParser::parseStyle(), and SvgLoadingContext::styleParser.

◆ warnings()

QStringList SvgParser::warnings ( ) const

Definition at line 1689 of file SvgParser.cpp.

{
    QStringList warnings;
 
    Q_FOREACH (const KoID &id, m_warnings) {
        warnings << id.name();
    }
 
    return warnings;
}

References m_warnings, and warnings().

Member Data Documentation

◆ m_clipMasks

QMap<QString, QSharedPointer<KoClipMask> > SvgParser::m_clipMasks

private

Definition at line 233 of file SvgParser.h.

◆ m_clipPaths

QMap<QString, SvgClipPathHelper> SvgParser::m_clipPaths

private

Definition at line 232 of file SvgParser.h.

◆ m_context

SvgLoadingContext SvgParser::m_context

private

Definition at line 229 of file SvgParser.h.

◆ m_defsShapes

QList<KoShape*> SvgParser::m_defsShapes

private

Definition at line 238 of file SvgParser.h.

◆ m_documentDescription

QString SvgParser::m_documentDescription

private

Definition at line 241 of file SvgParser.h.

◆ m_documentResourceManager

KoDocumentResourceManager* SvgParser::m_documentResourceManager

private

Definition at line 235 of file SvgParser.h.

◆ m_documentTitle

QString SvgParser::m_documentTitle

private

Definition at line 240 of file SvgParser.h.

◆ m_filters

QMap<QString, SvgFilterHelper> SvgParser::m_filters

private

Definition at line 231 of file SvgParser.h.

◆ m_gradients

QMap<QString, SvgGradientHelper> SvgParser::m_gradients

private

Definition at line 230 of file SvgParser.h.

◆ m_inheritStrokeFillByDefault

bool SvgParser::m_inheritStrokeFillByDefault = false

private

Definition at line 244 of file SvgParser.h.

◆ m_isInsideTextSubtree

bool SvgParser::m_isInsideTextSubtree = false

private

Definition at line 239 of file SvgParser.h.

◆ m_markers

QMap<QString, QExplicitlySharedDataPointer<KoMarker> > SvgParser::m_markers

private

Definition at line 234 of file SvgParser.h.

◆ m_resolveTextPropertiesForTopLevel

bool SvgParser::m_resolveTextPropertiesForTopLevel = true

private

Definition at line 245 of file SvgParser.h.

◆ m_shapeParentTransform

QMap<KoShape *, QTransform> SvgParser::m_shapeParentTransform

private

Definition at line 243 of file SvgParser.h.

◆ m_shapes

QList<KoShape*> SvgParser::m_shapes

private

Definition at line 236 of file SvgParser.h.

◆ m_symbols

QMap<QString, KoSvgSymbol*> SvgParser::m_symbols

private

Definition at line 237 of file SvgParser.h.

◆ m_warnings

QVector<KoID> SvgParser::m_warnings

private

Definition at line 242 of file SvgParser.h.

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

libs/flake/svg/SvgParser.h
libs/flake/svg/SvgParser.cpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FileFetcherFunc

Constructor & Destructor Documentation

◆ SvgParser()

◆ ~SvgParser()

Member Function Documentation

◆ addToGroup()

◆ applyClipping()

◆ applyCurrentBasicStyle()

◆ applyCurrentStyle()

◆ applyFillStyle()

◆ applyFilter()

◆ applyId()

◆ applyMarkers()

◆ applyMaskClipping()

◆ applyPaintOrder()

◆ applyStrokeStyle()

◆ applyStyle() [1/2]

◆ applyStyle() [2/2]

◆ applyViewBoxTransform()

◆ buildDocument()

◆ createDocumentFromSvg() [1/4]

◆ createDocumentFromSvg() [2/4]

◆ createDocumentFromSvg() [3/4]

◆ createDocumentFromSvg() [4/4]

◆ createListOfShapesFromCSS()

◆ createObject()

◆ createObjectDirect()

◆ createPath()

◆ createShape()

◆ createShapeFromCSS()

◆ createShapeFromElement()

◆ documentDescription()

◆ documentTitle()

◆ findClipPath()

◆ findFilter()

◆ findGradient()

◆ findPattern()

◆ getTextPath()

◆ getTheOnlyTextChild()

◆ knownMarkers()

◆ parseAngular()

◆ parseClipMask()

◆ parseClipPath()

◆ parseContainer()

◆ parseDefsElement()

◆ parseFilter()

◆ parseGradient()

◆ parseGroup()

◆ parseMarker()

◆ parseMeshGradient()

◆ parseMeshPatch()

◆ parseMetadataApplyToShape()

◆ parsePattern()

◆ parseSingleElement()

◆ parseSvg()

◆ parseSymbol()

◆ parseTextChildren()

◆ parseTextElement()

◆ parseUnit()

◆ parseUnitX()

◆ parseUnitXY()

◆ parseUnitY()

◆ parseUse()

◆ resolveUse()

◆ setDefaultKraTextVersion()

◆ setFileFetcher()

◆ setFillStrokeInheritByDefault()

◆ setResolution()

◆ setResolveTextPropertiesForTopLevel()

◆ setXmlBaseDir()

◆ shapes()

◆ takeSymbols()