SvgParser Class Reference

#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	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, bool hideShapesFromDefs=true)
	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, bool hideShapesFromDefs=true)
	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
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, bool hideShapesFromDefs=true)
	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, bool hideShapesFromDefs=true)
	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)
bool	shapeInDefs (const KoShape *shape)
	Check whether the shapes are in the defs of the SVG document.
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, 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 38 of file SvgParser.h.

Member Typedef Documentation

FileFetcherFunc

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

Definition at line 81 of file SvgParser.h.

Constructor & Destructor Documentation

SvgParser()

SvgParser::SvgParser ( KoDocumentResourceManager * documentResourceManager )

explicit

Definition at line 126 of file SvgParser.cpp.

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

~SvgParser()

SvgParser::~SvgParser ( )

virtual

Definition at line 132 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 1398 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 1305 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 936 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 921 of file SvgParser.cpp.

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

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

applyFillStyle()

void SvgParser::applyFillStyle ( KoShape * shape )

protected

Applies the current fill style to the object.

Definition at line 1133 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);
}

References SvgGraphicsContext::Complex, SvgLoadingContext::currentGC(), SvgGraphicsContext::fillColor, SvgGraphicsContext::fillId, SvgGraphicsContext::fillRule, SvgGraphicsContext::fillType, findGradient(), findPattern(), SvgGradientHelper::gradient(), SvgGraphicsContext::Inherit, SvgGradientHelper::isMeshGradient(), m_context, SvgGraphicsContext::None, prepareGradientForShape(), prepareMeshGradientForShape(), KoShape::setBackground(), KoPathShape::setFillRule(), KoShape::setInheritBackground(), SvgGraphicsContext::Solid, and toQShared().

applyId()

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

protected

Applies id to specified shape.

Definition at line 2237 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 1249 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 1343 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 1270 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 1206 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 967 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 972 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);
    }
 
    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(), 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 1509 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 172 of file SvgParser.cpp.

{
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QXmlInputSource source;
    source.setData(data);
    return createDocumentFromXmlInputSource(&source, errorMsg, errorLine, errorColumn);
#else
    return createDocumentFromSvg(QXmlStreamReader(data), errorMsg, errorLine, errorColumn);
#endif
}

References createDocumentFromSvg(), and source().

createDocumentFromSvg() [2/4]

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

static

Definition at line 183 of file SvgParser.cpp.

{
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QXmlInputSource source;
    source.setData(data);
    return createDocumentFromXmlInputSource(&source, errorMsg, errorLine, errorColumn);
#else
    return createDocumentFromSvg(QXmlStreamReader(data), errorMsg, errorLine, errorColumn);
#endif
}

References createDocumentFromSvg(), and source().

createDocumentFromSvg() [3/4]

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

static

Definition at line 162 of file SvgParser.cpp.

{
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    QXmlInputSource source(device);
    return createDocumentFromXmlInputSource(&source, errorMsg, errorLine, errorColumn);
#else
    return createDocumentFromSvg(QXmlStreamReader(device), errorMsg, errorLine, errorColumn);
#endif
}

References createDocumentFromSvg(), and source().

createDocumentFromSvg() [4/4]

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

static

Definition at line 194 of file SvgParser.cpp.

{
    QDomDocument doc;
 
 
    reader.setNamespaceProcessing(false);
#if (QT_VERSION < QT_VERSION_CHECK(6, 5, 0))
    if (!doc.setContent(&reader, false, errorMsg, errorLine, errorColumn)) {
        return {};
    }
#else
    QDomDocument::ParseResult result = doc.setContent(&reader, QDomDocument::ParseOption::PreserveSpacingOnlyNodes);
    if (!result) {
        if (errorMsg && errorLine && errorColumn) {
            *errorMsg = result.errorMessage;
            *errorLine = result.errorLine;
            *errorColumn = result.errorColumn;
        }
        return {};
    }
#endif
    return doc;
}

createListOfShapesFromCSS()

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

protected

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

Definition at line 2191 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, hideShapesFromDefs);
        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 2038 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 2012 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 1942 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 2207 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, bool hideShapesFromDefs = true )

protected

Creates a shape from a CSS shapes definition.

Definition at line 2111 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());
            // When we have a parent, the shape is inside the defs, but when not,
            // it's in the group we're in the currently parsing.
 
            if (cloned && shapeInDefs(s) && hideShapesFromDefs) {
                cloned->setTransparency(1.0);
            }
            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);
    KoShape *shape = createShapeFromElement(el, context);
    if (shape) shape->setTransparency(1.0);
    return shape;
}

References KoShape::absoluteTransformation(), KoShape::cloneShape(), createShapeFromElement(), SvgLoadingContext::currentGC(), m_context, m_shapeParentTransform, SvgUtil::parseUnitX(), SvgUtil::parseUnitXY(), SvgUtil::parseUnitY(), SvgLoadingContext::resolvedProperties(), KoShape::setTransformation(), KoShape::setTransparency(), SvgLoadingContext::shapeById(), shapeInDefs(), 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 2066 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 1545 of file SvgParser.cpp.

{
    return m_documentDescription;
}

References m_documentDescription.

documentTitle()

QString SvgParser::documentTitle

(

)

const

Definition at line 1540 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 319 of file SvgParser.cpp.

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

References m_clipPaths.

findGradient()

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

protected

find gradient with given id in gradient map

Definition at line 282 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 304 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, bool hideShapesFromDefs = true )

protected

Get the path for the gives textPath element.

Definition at line 1639 of file SvgParser.cpp.

                                                                             {
    if (e.hasAttribute("path")) {
        QDomElement p = e.ownerDocument().createElement("path");
        p.setAttribute("d", e.attribute("path"));
        KoShape *s = createPath(p);
        if (hideShapesFromDefs) {
            s->setTransparency(1.0);
        }
        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) {
                KoShape *cloned = s->cloneShape();
                const QTransform absTf = s->absoluteTransformation();
                cloned->setTransformation(absTf * m_shapeParentTransform.value(s).inverted());
                if(cloned && shapeInDefs(s) && hideShapesFromDefs) {
                    cloned->setTransparency(1.0);
                }
                return cloned;
            }
        }
    }
    return nullptr;
}

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

getTheOnlyTextChild()

QDomText SvgParser::getTheOnlyTextChild ( const QDomElement & e )

protected

Definition at line 1622 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 1535 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 347 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 869 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 842 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 1806 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 1847 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 & , const QDomElement & referencedBy = QDomElement() )

protected

Parses a filter element.

parseGradient()

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

protected

Parses a gradient element.

Definition at line 353 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 1565 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);
 
    if (b.hasAttribute(KoSvgTextShape_TEXTCONTOURGROUP)) {
        Q_FOREACH(KoShape *shape, childShapes) {
            if (shape->shapeId() == KoSvgTextShape_SHAPEID) {
                shape->setTransformation(group->transformation());
 
                if (createContext) {
                    m_context.popGraphicsContext();
                }
                return shape;
            }
        }
    }
    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(), KoSvgTextShape_SHAPEID, KoSvgTextShape_TEXTCONTOURGROUP, m_context, SvgGraphicsContext::matrix, SvgLoadingContext::nextZIndex(), parseContainer(), parseGroup(), parseMetadataApplyToShape(), parseSingleElement(), SvgLoadingContext::popGraphicsContext(), SvgLoadingContext::pushGraphicsContext(), KoShape::setTransformation(), KoShape::setZIndex(), KoShape::shapeId(), KoShape::transformation(), and uploadStyleToContext().

parseMarker()

bool SvgParser::parseMarker ( const QDomElement & e )

protected

Definition at line 738 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 464 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 555 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 822 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 590 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 1853 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") {
        // not supported!
    } 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(), 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 1410 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 779 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, bool hideShapesFromDefs = true )

protected

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

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

Definition at line 1671 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, hideShapesFromDefs);
                }
                textLoader.setTextPathOnCurrentNode(getTextPath(b, hideShapesFromDefs));
                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 1704 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;
 
    bool hideShapesFromDefs = true;
    if (mergeIntoShape) {
        rootTextShape = mergeIntoShape;
        hideShapesFromDefs = false;
    } 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, hideShapesFromDefs);
            rootTextShape->setShapesInside(shapesInside);
        }
 
        if (!m_context.currentGC()->shapeSubtractValue.isEmpty()) {
            QList<KoShape*> shapesSubtract = createListOfShapesFromCSS(e, m_context.currentGC()->shapeSubtractValue, m_context, hideShapesFromDefs);
            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, hideShapesFromDefs);
    }
 
    m_context.popGraphicsContext();
 
    m_isInsideTextSubtree = false;
 
    //rootTextShape->debugParsing();
 
 
    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(), 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 327 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 332 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 342 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 337 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 1363 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 1382 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 251 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 1550 of file SvgParser.cpp.

{
    m_context.setFileFetcher(func);
}

References m_context, and SvgLoadingContext::setFileFetcher().

setFillStrokeInheritByDefault()

void SvgParser::setFillStrokeInheritByDefault

(

const bool

enable

)

Definition at line 257 of file SvgParser.cpp.

{
    m_inheritStrokeFillByDefault = enable;
}

References m_inheritStrokeFillByDefault.

setResolution()

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

Definition at line 238 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 262 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 218 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().

shapeInDefs()

bool SvgParser::shapeInDefs ( const KoShape * shape )

protected

Check whether the shapes are in the defs of the SVG document.

Definition at line 1629 of file SvgParser.cpp.

{
    for (auto defs = m_defsShapes.begin(); defs != m_defsShapes.end(); defs++) {
        KoShape *dShape = *defs;
        if (!dShape) continue;
        if (dShape->hasCommonParent(shape)) return true;
    }
    return false;
}

References KoShape::hasCommonParent(), and m_defsShapes.

shapes()

QList< KoShape * > SvgParser::shapes

(

)

const

Returns the list of all shapes of the svg document.

Definition at line 267 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 272 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 914 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 1524 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 228 of file SvgParser.h.

m_clipPaths

QMap<QString, SvgClipPathHelper> SvgParser::m_clipPaths

private

Definition at line 227 of file SvgParser.h.

m_context

SvgLoadingContext SvgParser::m_context

private

Definition at line 225 of file SvgParser.h.

m_defsShapes

QList<KoShape*> SvgParser::m_defsShapes

private

Definition at line 233 of file SvgParser.h.

m_documentDescription

QString SvgParser::m_documentDescription

private

Definition at line 236 of file SvgParser.h.

m_documentResourceManager

KoDocumentResourceManager* SvgParser::m_documentResourceManager

private

Definition at line 230 of file SvgParser.h.

m_documentTitle

QString SvgParser::m_documentTitle

private

Definition at line 235 of file SvgParser.h.

m_gradients

QMap<QString, SvgGradientHelper> SvgParser::m_gradients

private

Definition at line 226 of file SvgParser.h.

m_inheritStrokeFillByDefault

bool SvgParser::m_inheritStrokeFillByDefault = false

private

Definition at line 239 of file SvgParser.h.

m_isInsideTextSubtree

bool SvgParser::m_isInsideTextSubtree = false

private

Definition at line 234 of file SvgParser.h.

m_markers

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

private

Definition at line 229 of file SvgParser.h.

m_resolveTextPropertiesForTopLevel

bool SvgParser::m_resolveTextPropertiesForTopLevel = true

private

Definition at line 240 of file SvgParser.h.

m_shapeParentTransform

QMap<KoShape *, QTransform> SvgParser::m_shapeParentTransform

private

Definition at line 238 of file SvgParser.h.

m_shapes

QList<KoShape*> SvgParser::m_shapes

private

Definition at line 231 of file SvgParser.h.

m_symbols

QMap<QString, KoSvgSymbol*> SvgParser::m_symbols

private

Definition at line 232 of file SvgParser.h.

m_warnings

QVector<KoID> SvgParser::m_warnings

private

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