Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

42 files changed, 13695 insertions, 0 deletions

diff --git a/svgio/source/svgreader/SvgNumber.cxx b/svgio/source/svgreader/SvgNumber.cxx
new file mode 100644
index 0000000000..c1558f3e64
--- /dev/null
+++ b/svgio/source/svgreader/SvgNumber.cxx
@@ -0,0 +1,126 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <SvgNumber.hxx>
+
+#include <o3tl/unit_conversion.hxx>
+#include <sal/log.hxx>
+
+namespace svgio::svgreader
+{
+
+double SvgNumber::solveNonPercentage(const InfoProvider& rInfoProvider) const
+{
+    if (!isSet())
+    {
+        SAL_WARN("svgio", "SvgNumber not set (!)");
+        return 0.0;
+    }
+
+    switch (meUnit)
+    {
+        case SvgUnit::em:
+            return mfNumber * rInfoProvider.getCurrentFontSizeInherited();
+        case SvgUnit::ex:
+            return mfNumber * rInfoProvider.getCurrentXHeightInherited() * 0.5;
+        case SvgUnit::px:
+            return mfNumber;
+        case SvgUnit::pt:
+            return o3tl::convert(mfNumber, o3tl::Length::pt, o3tl::Length::px);
+        case SvgUnit::pc:
+            return o3tl::convert(mfNumber, o3tl::Length::pc, o3tl::Length::px);
+        case SvgUnit::cm:
+            return o3tl::convert(mfNumber, o3tl::Length::cm, o3tl::Length::px);
+        case SvgUnit::mm:
+            return o3tl::convert(mfNumber, o3tl::Length::mm, o3tl::Length::px);
+        case SvgUnit::in:
+            return o3tl::convert(mfNumber, o3tl::Length::in, o3tl::Length::px);
+        case SvgUnit::none:
+        {
+            SAL_WARN("svgio", "Design error, this case should have been handled in the caller");
+            return mfNumber;
+        }
+        case SvgUnit::percent:
+        {
+            SAL_WARN("svgio", "Do not use with percentage!");
+            break;
+        }
+    }
+
+    return 0.0;
+}
+
+double SvgNumber::solve(const InfoProvider& rInfoProvider, NumberType aNumberType) const
+{
+    if (!isSet())
+    {
+        SAL_WARN("svgio", "SvgNumber not set (!)");
+        return 0.0;
+    }
+
+    if (meUnit == SvgUnit::percent)
+    {
+        double fRetval(mfNumber * 0.01);
+        basegfx::B2DRange aViewPort = rInfoProvider.getCurrentViewPort();
+
+        if ( aViewPort.isEmpty() )
+        {
+            SAL_WARN("svgio", "Design error, this case should have been handled in the caller");
+            // no viewPort, assume a normal page size (A4)
+            aViewPort = basegfx::B2DRange(
+                0.0,
+                0.0,
+                o3tl::convert(210.0, o3tl::Length::cm, o3tl::Length::px), // should it be mm?
+                o3tl::convert(297.0, o3tl::Length::cm, o3tl::Length::px));
+
+        }
+
+        if ( !aViewPort.isEmpty() )
+        {
+            if (NumberType::xcoordinate == aNumberType)
+            {
+                // it's a x-coordinate, relative to current width (w)
+                fRetval *= aViewPort.getWidth();
+            }
+            else if (NumberType::ycoordinate == aNumberType)
+            {
+                // it's a y-coordinate, relative to current height (h)
+                fRetval *= aViewPort.getHeight();
+            }
+            else // length
+            {
+                // it's a length, relative to sqrt((w^2 + h^2)/2)
+                const double fCurrentWidth(aViewPort.getWidth());
+                const double fCurrentHeight(aViewPort.getHeight());
+                const double fCurrentLength(
+                    sqrt((fCurrentWidth * fCurrentWidth + fCurrentHeight * fCurrentHeight)/2.0));
+
+                fRetval *= fCurrentLength;
+            }
+        }
+
+        return fRetval;
+    }
+
+    return solveNonPercentage( rInfoProvider);
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svganode.cxx b/svgio/source/svgreader/svganode.cxx
new file mode 100644
index 0000000000..67b523b7ef
--- /dev/null
+++ b/svgio/source/svgreader/svganode.cxx
@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svganode.hxx>
+
+namespace svgio::svgreader
+{
+        SvgANode::SvgANode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::A, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgANode::~SvgANode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgANode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgANode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                    //TODO: add support for xlink:href
+                    break;
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgANode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            // #i125258# for SVGTokenA decompose children
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!pStyle)
+                return;
+
+            if (Display::None != getDisplay())
+            {
+                drawinglayer::primitive2d::Primitive2DContainer aContent;
+
+                // decompose children
+                SvgNode::decomposeSvgNode(aContent, bReferenced);
+
+                if(!aContent.empty())
+                {
+                    pStyle->add_postProcess(rTarget, std::move(aContent), getTransform());
+                }
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgcharacternode.cxx b/svgio/source/svgreader/svgcharacternode.cxx
new file mode 100644
index 0000000000..7d5a2fcb9f
--- /dev/null
+++ b/svgio/source/svgreader/svgcharacternode.cxx
@@ -0,0 +1,551 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgcharacternode.hxx>
+#include <svgstyleattributes.hxx>
+#include <drawinglayer/primitive2d/textprimitive2d.hxx>
+#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
+#include <drawinglayer/primitive2d/textbreakuphelper.hxx>
+#include <drawinglayer/primitive2d/textdecoratedprimitive2d.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <utility>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+
+using namespace drawinglayer::primitive2d;
+
+namespace svgio::svgreader
+{
+        namespace {
+
+        class localTextBreakupHelper : public TextBreakupHelper
+        {
+        private:
+            SvgTextPosition&                    mrSvgTextPosition;
+
+        protected:
+            /// allow user callback to allow changes to the new TextTransformation. Default
+            /// does nothing.
+            virtual bool allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength) override;
+
+        public:
+            localTextBreakupHelper(
+                const TextSimplePortionPrimitive2D& rSource,
+                SvgTextPosition& rSvgTextPosition)
+            :   TextBreakupHelper(rSource),
+                mrSvgTextPosition(rSvgTextPosition)
+            {
+            }
+        };
+
+        }
+
+        bool localTextBreakupHelper::allowChange(sal_uInt32 /*nCount*/, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 /*nIndex*/, sal_uInt32 /*nLength*/)
+        {
+            const double fRotation(mrSvgTextPosition.consumeRotation());
+
+            if(0.0 != fRotation)
+            {
+                const basegfx::B2DPoint aBasePoint(rNewTransform * basegfx::B2DPoint(0.0, 0.0));
+
+                rNewTransform.translate(-aBasePoint.getX(), -aBasePoint.getY());
+                rNewTransform.rotate(fRotation);
+                rNewTransform.translate(aBasePoint.getX(), aBasePoint.getY());
+            }
+
+            return true;
+        }
+
+        SvgCharacterNode::SvgCharacterNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent,
+            OUString aText)
+        :   SvgNode(SVGToken::Character, rDocument, pParent),
+            maText(std::move(aText)),
+            mpParentLine(nullptr)
+        {
+        }
+
+        SvgCharacterNode::~SvgCharacterNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgCharacterNode::getSvgStyleAttributes() const
+        {
+            // no own style, use parent's
+            if(getParent())
+            {
+                return getParent()->getSvgStyleAttributes();
+            }
+            else
+            {
+                return nullptr;
+            }
+        }
+
+        drawinglayer::attribute::FontAttribute SvgCharacterNode::getFontAttribute(
+            const SvgStyleAttributes& rSvgStyleAttributes)
+        {
+            const SvgStringVector& rFontFamilyVector = rSvgStyleAttributes.getFontFamily();
+            OUString aFontFamily("Times New Roman");
+            if(!rFontFamilyVector.empty())
+                aFontFamily=rFontFamilyVector[0];
+
+            // #i122324# if the FontFamily name ends on ' embedded' it is probably a re-import
+            // of a SVG export with font embedding. Remove this to make font matching work. This
+            // is pretty safe since there should be no font family names ending on ' embedded'.
+            // Remove again when FontEmbedding is implemented in SVG import
+            if(aFontFamily.endsWith(" embedded"))
+            {
+                aFontFamily = aFontFamily.copy(0, aFontFamily.getLength() - 9);
+            }
+
+            const ::FontWeight nFontWeight(getVclFontWeight(rSvgStyleAttributes.getFontWeight()));
+            bool bItalic(FontStyle::italic == rSvgStyleAttributes.getFontStyle() || FontStyle::oblique == rSvgStyleAttributes.getFontStyle());
+
+            return drawinglayer::attribute::FontAttribute(
+                aFontFamily,
+                OUString(),
+                nFontWeight,
+                false/*bSymbol*/,
+                false/*bVertical*/,
+                bItalic,
+                false/*bMonospaced*/,
+                false/*bOutline*/,
+                false/*bRTL*/,
+                false/*bBiDiStrong*/);
+        }
+
+        rtl::Reference<BasePrimitive2D> SvgCharacterNode::createSimpleTextPrimitive(
+            SvgTextPosition& rSvgTextPosition,
+            const SvgStyleAttributes& rSvgStyleAttributes) const
+        {
+            // prepare retval, index and length
+            rtl::Reference<BasePrimitive2D> pRetval;
+            sal_uInt32 nLength(getText().getLength());
+
+            if(nLength)
+            {
+                sal_uInt32 nIndex(0);
+
+                // prepare FontAttribute
+                const drawinglayer::attribute::FontAttribute aFontAttribute(getFontAttribute(rSvgStyleAttributes));
+
+                // prepare FontSizeNumber
+                double fFontWidth(rSvgStyleAttributes.getFontSizeNumber().solve(*this));
+                double fFontHeight(fFontWidth);
+
+                // prepare locale
+                css::lang::Locale aLocale;
+
+                // prepare TextLayouterDevice
+                TextLayouterDevice aTextLayouterDevice;
+                aTextLayouterDevice.setFontAttribute(aFontAttribute, fFontWidth, fFontHeight, aLocale);
+
+                // prepare TextArray
+                ::std::vector< double > aTextArray(rSvgTextPosition.getX());
+                ::std::vector< double > aDxArray(rSvgTextPosition.getDx());
+
+                // Do nothing when X and Dx arrays are empty
+                if((!aTextArray.empty() || !aDxArray.empty()) && aTextArray.size() < nLength)
+                {
+                    const sal_uInt32 nArray(aTextArray.size());
+
+                    double fStartX(0.0);
+                    if (!aTextArray.empty())
+                    {
+                        if(rSvgTextPosition.getParent() && rSvgTextPosition.getParent()->getAbsoluteX())
+                        {
+                            fStartX = rSvgTextPosition.getParent()->getPosition().getX();
+                        }
+                        else
+                        {
+                            fStartX = aTextArray[nArray - 1];
+                        }
+                    }
+
+                    ::std::vector< double > aExtendArray(aTextLayouterDevice.getTextArray(getText(), nArray, nLength - nArray));
+                    double fComulativeDx(0.0);
+
+                    aTextArray.reserve(nLength);
+                    for(size_t a = 0; a < aExtendArray.size(); ++a)
+                    {
+                        if (a < aDxArray.size())
+                        {
+                            fComulativeDx += aDxArray[a];
+                        }
+                        aTextArray.push_back(aExtendArray[a] + fStartX + fComulativeDx);
+                    }
+                }
+
+                // get current TextPosition and TextWidth in units
+                basegfx::B2DPoint aPosition(rSvgTextPosition.getPosition());
+                double fTextWidth(aTextLayouterDevice.getTextWidth(getText(), nIndex, nLength));
+
+                // check for user-given TextLength
+                if(0.0 != rSvgTextPosition.getTextLength()
+                    && !basegfx::fTools::equal(fTextWidth, rSvgTextPosition.getTextLength()))
+                {
+                    const double fFactor(rSvgTextPosition.getTextLength() / fTextWidth);
+
+                    if(rSvgTextPosition.getLengthAdjust())
+                    {
+                        // spacing, need to create and expand TextArray
+                        if(aTextArray.empty())
+                        {
+                            aTextArray = aTextLayouterDevice.getTextArray(getText(), nIndex, nLength);
+                        }
+
+                        for(auto &a : aTextArray)
+                        {
+                            a *= fFactor;
+                        }
+                    }
+                    else
+                    {
+                        // spacing and glyphs, just apply to FontWidth
+                        fFontWidth *= fFactor;
+                    }
+
+                    fTextWidth = rSvgTextPosition.getTextLength();
+                }
+
+                // get TextAlign
+                TextAlign aTextAlign(rSvgStyleAttributes.getTextAlign());
+
+                // map TextAnchor to TextAlign, there seems not to be a difference
+                if(TextAnchor::notset != rSvgStyleAttributes.getTextAnchor())
+                {
+                    switch(rSvgStyleAttributes.getTextAnchor())
+                    {
+                        case TextAnchor::start:
+                        {
+                            aTextAlign = TextAlign::left;
+                            break;
+                        }
+                        case TextAnchor::middle:
+                        {
+                            aTextAlign = TextAlign::center;
+                            break;
+                        }
+                        case TextAnchor::end:
+                        {
+                            aTextAlign = TextAlign::right;
+                            break;
+                        }
+                        default:
+                        {
+                            break;
+                        }
+                    }
+                }
+
+                // apply TextAlign
+                switch(aTextAlign)
+                {
+                    case TextAlign::right:
+                    {
+                        aPosition.setX(aPosition.getX() - mpParentLine->getTextLineWidth());
+                        break;
+                    }
+                    case TextAlign::center:
+                    {
+                        aPosition.setX(aPosition.getX() - (mpParentLine->getTextLineWidth() * 0.5));
+                        break;
+                    }
+                    case TextAlign::notset:
+                    case TextAlign::left:
+                    case TextAlign::justify:
+                    {
+                        // TextAlign::notset, TextAlign::left: nothing to do
+                        // TextAlign::justify is not clear currently; handle as TextAlign::left
+                        break;
+                    }
+                }
+
+                // get DominantBaseline
+                const DominantBaseline aDominantBaseline(rSvgStyleAttributes.getDominantBaseline());
+
+                basegfx::B2DRange aRange(aTextLayouterDevice.getTextBoundRect(getText(), nIndex, nLength));
+                // apply DominantBaseline
+                switch(aDominantBaseline)
+                {
+                    case DominantBaseline::Middle:
+                    {
+                        aPosition.setY(aPosition.getY() - aRange.getCenterY());
+                        break;
+                    }
+                    case DominantBaseline::Hanging:
+                    {
+                        aPosition.setY(aPosition.getY() - aRange.getMinY());
+                        break;
+                    }
+                    default: // DominantBaseline::Auto
+                    {
+                        // nothing to do
+                        break;
+                    }
+                }
+
+                // get BaselineShift
+                const BaselineShift aBaselineShift(rSvgStyleAttributes.getBaselineShift());
+
+                // apply BaselineShift
+                switch(aBaselineShift)
+                {
+                    case BaselineShift::Sub:
+                    {
+                        aPosition.setY(aPosition.getY() + aTextLayouterDevice.getUnderlineOffset());
+                        break;
+                    }
+                    case BaselineShift::Super:
+                    {
+                        aPosition.setY(aPosition.getY() + aTextLayouterDevice.getOverlineOffset());
+                        break;
+                    }
+                    case BaselineShift::Percentage:
+                    case BaselineShift::Length:
+                    {
+                        const SvgNumber aNumber(rSvgStyleAttributes.getBaselineShiftNumber());
+                        const double mfBaselineShift(aNumber.solve(*this));
+
+                        aPosition.setY(aPosition.getY() - mfBaselineShift);
+                        break;
+                    }
+                    default: // BaselineShift::Baseline
+                    {
+                        // nothing to do
+                        break;
+                    }
+                }
+
+                // get fill color
+                basegfx::BColor aFill(0, 0, 0);
+                if(rSvgStyleAttributes.getFill())
+                    aFill = *rSvgStyleAttributes.getFill();
+
+                // get fill opacity
+                double fFillOpacity = 1.0;
+                if (rSvgStyleAttributes.getFillOpacity().isSet())
+                {
+                    fFillOpacity = rSvgStyleAttributes.getFillOpacity().getNumber();
+                }
+
+                // prepare TextTransformation
+                basegfx::B2DHomMatrix aTextTransform;
+
+                aTextTransform.scale(fFontWidth, fFontHeight);
+                aTextTransform.translate(aPosition.getX(), aPosition.getY());
+
+                // check TextDecoration and if TextDecoratedPortionPrimitive2D is needed
+                const TextDecoration aDeco(rSvgStyleAttributes.getTextDecoration());
+
+                if(TextDecoration::underline == aDeco
+                    || TextDecoration::overline == aDeco
+                    || TextDecoration::line_through == aDeco)
+                {
+                    // get the fill for decoration as described by SVG. We cannot
+                    // have different stroke colors/definitions for those, though
+                    const SvgStyleAttributes* pDecoDef = rSvgStyleAttributes.getTextDecorationDefiningSvgStyleAttributes();
+
+                    basegfx::BColor aDecoColor(aFill);
+                    if(pDecoDef && pDecoDef->getFill())
+                        aDecoColor = *pDecoDef->getFill();
+
+                    TextLine eFontOverline = TEXT_LINE_NONE;
+                    if(TextDecoration::overline == aDeco)
+                        eFontOverline = TEXT_LINE_SINGLE;
+
+                    TextLine eFontUnderline = TEXT_LINE_NONE;
+                    if(TextDecoration::underline == aDeco)
+                        eFontUnderline = TEXT_LINE_SINGLE;
+
+                    TextStrikeout eTextStrikeout = TEXT_STRIKEOUT_NONE;
+                    if(TextDecoration::line_through == aDeco)
+                        eTextStrikeout = TEXT_STRIKEOUT_SINGLE;
+
+                    // create decorated text primitive
+                    pRetval = new TextDecoratedPortionPrimitive2D(
+                        aTextTransform,
+                        getText(),
+                        nIndex,
+                        nLength,
+                        std::move(aTextArray),
+                        {},
+                        aFontAttribute,
+                        aLocale,
+                        aFill,
+                        COL_TRANSPARENT,
+
+                        // extra props for decorated
+                        aDecoColor,
+                        aDecoColor,
+                        eFontOverline,
+                        eFontUnderline,
+                        false,
+                        eTextStrikeout,
+                        false,
+                        TEXT_FONT_EMPHASIS_MARK_NONE,
+                        true,
+                        false,
+                        TEXT_RELIEF_NONE,
+                        false);
+                }
+                else
+                {
+                    // create text primitive
+                    pRetval = new TextSimplePortionPrimitive2D(
+                        aTextTransform,
+                        getText(),
+                        nIndex,
+                        nLength,
+                        std::move(aTextArray),
+                        {},
+                        aFontAttribute,
+                        aLocale,
+                        aFill);
+                }
+
+                if (fFillOpacity != 1.0)
+                {
+                    pRetval = new UnifiedTransparencePrimitive2D(
+                        drawinglayer::primitive2d::Primitive2DContainer{ pRetval },
+                        1.0 - fFillOpacity);
+                }
+
+                // advance current TextPosition
+                rSvgTextPosition.setPosition(rSvgTextPosition.getPosition() + basegfx::B2DVector(fTextWidth, 0.0));
+            }
+
+            return pRetval;
+        }
+
+        void SvgCharacterNode::decomposeTextWithStyle(
+            Primitive2DContainer& rTarget,
+            SvgTextPosition& rSvgTextPosition,
+            const SvgStyleAttributes& rSvgStyleAttributes) const
+        {
+            const Primitive2DReference xRef(
+                createSimpleTextPrimitive(
+                    rSvgTextPosition,
+                    rSvgStyleAttributes));
+
+            if(!(xRef.is() && (Visibility::visible == rSvgStyleAttributes.getVisibility())))
+                return;
+
+            if(!rSvgTextPosition.isRotated())
+            {
+                rTarget.push_back(xRef);
+            }
+            else
+            {
+                // need to apply rotations to each character as given
+                const TextSimplePortionPrimitive2D* pCandidate =
+                    dynamic_cast< const TextSimplePortionPrimitive2D* >(xRef.get());
+
+                if(pCandidate)
+                {
+                    localTextBreakupHelper alocalTextBreakupHelper(*pCandidate, rSvgTextPosition);
+                    Primitive2DContainer aResult = alocalTextBreakupHelper.extractResult();
+
+                    if(!aResult.empty())
+                    {
+                        rTarget.append(std::move(aResult));
+                    }
+
+                    // also consume for the implied single space
+                    rSvgTextPosition.consumeRotation();
+                }
+                else
+                {
+                    OSL_ENSURE(false, "Used primitive is not a text primitive (!)");
+                }
+            }
+        }
+
+        void SvgCharacterNode::whiteSpaceHandling()
+        {
+            bool bIsDefault(XmlSpace::Default == getXmlSpace());
+            // if xml:space="default" then remove all newline characters, otherwise convert them to space
+            // convert tab to space too
+            maText = maTextBeforeSpaceHandling = maText.replaceAll(u"\n", bIsDefault ? u"" : u" ").replaceAll(u"\t", u" ");
+
+            if(bIsDefault)
+            {
+                // strip of all leading and trailing spaces
+                // and consolidate contiguous space
+                maText = consolidateContiguousSpace(maText.trim());
+            }
+        }
+
+        SvgCharacterNode* SvgCharacterNode::addGap(SvgCharacterNode* pPreviousCharacterNode)
+        {
+            // maText may have lost all text. If that's the case, ignore as invalid character node
+            // Also ignore if maTextBeforeSpaceHandling just have spaces
+            if(!maText.isEmpty() && !o3tl::trim(maTextBeforeSpaceHandling).empty())
+            {
+                if(pPreviousCharacterNode)
+                {
+                    bool bAddGap(true);
+
+                    // Do not add a gap if last node doesn't end with a space and
+                    // current note doesn't start with a space
+                    const sal_uInt32 nLastLength(pPreviousCharacterNode->maTextBeforeSpaceHandling.getLength());
+                    if(pPreviousCharacterNode->maTextBeforeSpaceHandling[nLastLength - 1] != ' ' && maTextBeforeSpaceHandling[0] != ' ')
+                        bAddGap = false;
+
+                    // Do not add a gap if this node and last node are in different lines
+                    if(pPreviousCharacterNode->mpParentLine != mpParentLine)
+                        bAddGap = false;
+
+                    // add in-between whitespace (single space) to the beginning of the current character node
+                    if(bAddGap)
+                    {
+                        maText = " " + maText;
+                    }
+                }
+
+                // this becomes the previous character node
+                return this;
+            }
+
+            return pPreviousCharacterNode;
+        }
+
+        void SvgCharacterNode::concatenate(std::u16string_view rText)
+        {
+            maText += rText;
+        }
+
+        void SvgCharacterNode::decomposeText(Primitive2DContainer& rTarget, SvgTextPosition& rSvgTextPosition) const
+        {
+            if(!getText().isEmpty())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getSvgStyleAttributes();
+
+                if(pSvgStyleAttributes)
+                {
+                    decomposeTextWithStyle(rTarget, rSvgTextPosition, *pSvgStyleAttributes);
+                }
+            }
+        }
+
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgcirclenode.cxx b/svgio/source/svgreader/svgcirclenode.cxx
new file mode 100644
index 0000000000..21dac849be
--- /dev/null
+++ b/svgio/source/svgreader/svgcirclenode.cxx
@@ -0,0 +1,143 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgcirclenode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+namespace svgio::svgreader
+{
+        SvgCircleNode::SvgCircleNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Circle, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maCx(0),
+            maCy(0),
+            maR(0)
+        {
+        }
+
+        SvgCircleNode::~SvgCircleNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgCircleNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgCircleNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Cx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCx = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Cy:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCy = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::R:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maR = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgCircleNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!(pStyle && getR().isSet()))
+                return;
+
+            const double fR(getR().solve(*this));
+
+            if(fR <= 0.0)
+                return;
+
+            const basegfx::B2DPolygon aPath(
+                basegfx::utils::createPolygonFromCircle(
+                    basegfx::B2DPoint(
+                        getCx().isSet() ? getCx().solve(*this, NumberType::xcoordinate) : 0.0,
+                        getCy().isSet() ? getCy().solve(*this, NumberType::ycoordinate) : 0.0),
+                    fR));
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            pStyle->add_path(basegfx::B2DPolyPolygon(aPath), aNewTarget, nullptr);
+
+            if(!aNewTarget.empty())
+            {
+                pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgclippathnode.cxx b/svgio/source/svgreader/svgclippathnode.cxx
new file mode 100644
index 0000000000..5941c22da7
--- /dev/null
+++ b/svgio/source/svgreader/svgclippathnode.cxx
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgclippathnode.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <drawinglayer/processor2d/contourextractor2d.hxx>
+#include <basegfx/polygon/b2dpolypolygoncutter.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        SvgClipPathNode::SvgClipPathNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::ClipPathNode, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maClipPathUnits(SvgUnits::userSpaceOnUse)
+        {
+        }
+
+        SvgClipPathNode::~SvgClipPathNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgClipPathNode::getSvgStyleAttributes() const
+        {
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgClipPathNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::ClipPathUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setClipPathUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setClipPathUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgClipPathNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            // decompose children
+            SvgNode::decomposeSvgNode(aNewTarget, bReferenced);
+
+            if(aNewTarget.empty())
+                return;
+
+            if(getTransform())
+            {
+                // create embedding group element with transformation
+                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                        *getTransform(),
+                        std::move(aNewTarget)));
+
+                rTarget.push_back(xRef);
+            }
+            else
+            {
+                // append to current target
+                rTarget.append(aNewTarget);
+            }
+        }
+
+        void SvgClipPathNode::apply(
+            drawinglayer::primitive2d::Primitive2DContainer& rContent,
+            const std::optional<basegfx::B2DHomMatrix>& pTransform) const
+        {
+            if (rContent.empty() || Display::None == getDisplay())
+                return;
+
+            const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
+            drawinglayer::primitive2d::Primitive2DContainer aClipTarget;
+            basegfx::B2DPolyPolygon aClipPolyPolygon;
+
+            // get clipPath definition as primitives
+            decomposeSvgNode(aClipTarget, true);
+
+            if(!aClipTarget.empty())
+            {
+                // extract filled polygons as base for a mask PolyPolygon
+                drawinglayer::processor2d::ContourExtractor2D aExtractor(aViewInformation2D, true);
+
+                aExtractor.process(aClipTarget);
+
+                const basegfx::B2DPolyPolygonVector& rResult(aExtractor.getExtractedContour());
+                const sal_uInt32 nSize(rResult.size());
+
+                if(nSize > 1)
+                {
+                    // merge to single clipPolyPolygon
+                    aClipPolyPolygon = basegfx::utils::mergeToSinglePolyPolygon(rResult);
+                }
+                else if (nSize != 0)
+                {
+                    aClipPolyPolygon = rResult[0];
+                }
+            }
+
+            if(aClipPolyPolygon.count())
+            {
+                if (SvgUnits::objectBoundingBox == getClipPathUnits())
+                {
+                    // clip is object-relative, transform using content transformation
+                    const basegfx::B2DRange aContentRange(rContent.getB2DRange(aViewInformation2D));
+
+                    aClipPolyPolygon.transform(
+                        basegfx::utils::createScaleTranslateB2DHomMatrix(
+                            aContentRange.getRange(),
+                            aContentRange.getMinimum()));
+                }
+                else // userSpaceOnUse
+                {
+                    // #i124852#
+                    if(pTransform)
+                    {
+                        aClipPolyPolygon.transform(*pTransform);
+                    }
+                }
+
+                // #i124313# try to avoid creating an embedding to a MaskPrimitive2D if
+                // possible; MaskPrimitive2D processing is potentially expensive
+                bool bCreateEmbedding(true);
+                bool bAddContent(true);
+
+                if(basegfx::utils::isRectangle(aClipPolyPolygon))
+                {
+                    // ClipRegion is a rectangle, thus it is not expensive to tell
+                    // if the content is completely inside or outside of it; get ranges
+                    const basegfx::B2DRange aClipRange(aClipPolyPolygon.getB2DRange());
+                    const basegfx::B2DRange aContentRange(
+                        rContent.getB2DRange(
+                            aViewInformation2D));
+
+                    if(aClipRange.isInside(aContentRange))
+                    {
+                        // completely contained, no need to clip at all, so no need for embedding
+                        bCreateEmbedding = false;
+                    }
+                    else if(aClipRange.overlaps(aContentRange))
+                    {
+                        // overlap; embedding needed. ClipRegion can be minimized by using
+                        // the intersection of the ClipRange and the ContentRange. Minimizing
+                        // the ClipRegion potentially enhances further processing since
+                        // usually clip operations are expensive.
+                        basegfx::B2DRange aCommonRange(aContentRange);
+
+                        aCommonRange.intersect(aClipRange);
+                        aClipPolyPolygon = basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aCommonRange));
+                    }
+                    else
+                    {
+                        // not inside and no overlap -> completely outside
+                        // no need for embedding, no need for content at all
+                        bCreateEmbedding = false;
+                        bAddContent = false;
+                    }
+                }
+                else
+                {
+                    // ClipRegion is not a simple rectangle, it would be possible but expensive to
+                    // tell if the content needs clipping or not. It is also dependent of
+                    // the content's decomposition. To do this, a processor would be needed that
+                    // is capable if processing the given sequence of primitives and decide
+                    // if all is inside or all is outside. Such a ClipProcessor could be written,
+                    // but for now just create the embedding
+                }
+
+                if(bCreateEmbedding)
+                {
+                    // redefine target. Use MaskPrimitive2D with created clip
+                    // geometry. Using the automatically set mbIsClipPathContent at
+                    // SvgStyleAttributes the clip definition is without fill, stroke,
+                    // and strokeWidth and forced to black
+                    drawinglayer::primitive2d::Primitive2DReference xEmbedTransparence(
+                        new drawinglayer::primitive2d::MaskPrimitive2D(
+                            std::move(aClipPolyPolygon),
+                            std::move(rContent)));
+
+                    rContent = drawinglayer::primitive2d::Primitive2DContainer { xEmbedTransparence };
+                }
+                else
+                {
+                    if(!bAddContent)
+                    {
+                        rContent.clear();
+                    }
+                }
+            }
+            else
+            {
+                // An empty clipping path will completely clip away the element that had
+                // the clip-path property applied. (Svg spec)
+                rContent.clear();
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgdocument.cxx b/svgio/source/svgreader/svgdocument.cxx
new file mode 100644
index 0000000000..69066c96f8
--- /dev/null
+++ b/svgio/source/svgreader/svgdocument.cxx
@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgdocument.hxx>
+#include <utility>
+
+namespace svgio::svgreader
+{
+        SvgDocument::SvgDocument(OUString aAbsolutePath)
+        : maAbsolutePath(std::move(aAbsolutePath))
+        {
+        }
+
+        SvgDocument::~SvgDocument()
+        {
+        }
+
+        void SvgDocument::appendNode(std::unique_ptr<SvgNode> pNode)
+        {
+            assert(pNode);
+            maNodes.push_back(std::move(pNode));
+        }
+
+        void SvgDocument::addSvgNodeToMapper(const OUString& rStr, const SvgNode& rNode)
+        {
+            if(!rStr.isEmpty())
+            {
+                maIdTokenMapperList.emplace(rStr, &rNode);
+            }
+        }
+
+        void SvgDocument::removeSvgNodeFromMapper(const OUString& rStr)
+        {
+            if(!rStr.isEmpty())
+            {
+                maIdTokenMapperList.erase(rStr);
+            }
+        }
+
+        const SvgNode* SvgDocument::findSvgNodeById(const OUString& rStr) const
+        {
+            const IdTokenMapper::const_iterator aResult(maIdTokenMapperList.find(rStr));
+
+            if(aResult == maIdTokenMapperList.end())
+            {
+                return nullptr;
+            }
+            else
+            {
+                return aResult->second;
+            }
+        }
+
+        void SvgDocument::addSvgStyleAttributesToMapper(const OUString& rStr, const SvgStyleAttributes& rSvgStyleAttributes)
+        {
+            if(!rStr.isEmpty())
+            {
+                maIdStyleTokenMapperList.emplace(rStr, &rSvgStyleAttributes);
+            }
+        }
+
+        const SvgStyleAttributes* SvgDocument::findGlobalCssStyleAttributes(const OUString& rStr) const
+        {
+            const IdStyleTokenMapper::const_iterator aResult(maIdStyleTokenMapperList.find(rStr));
+
+            if(aResult == maIdStyleTokenMapperList.end())
+            {
+                return nullptr;
+            }
+            else
+            {
+                return aResult->second;
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgdocumenthandler.cxx b/svgio/source/svgreader/svgdocumenthandler.cxx
new file mode 100644
index 0000000000..5e89edad6c
--- /dev/null
+++ b/svgio/source/svgreader/svgdocumenthandler.cxx
@@ -0,0 +1,603 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgdocumenthandler.hxx>
+#include <svgtoken.hxx>
+#include <svgsvgnode.hxx>
+#include <svggnode.hxx>
+#include <svganode.hxx>
+#include <svgnode.hxx>
+#include <svgpathnode.hxx>
+#include <svgrectnode.hxx>
+#include <svggradientnode.hxx>
+#include <svggradientstopnode.hxx>
+#include <svgsymbolnode.hxx>
+#include <svgusenode.hxx>
+#include <svgcirclenode.hxx>
+#include <svgellipsenode.hxx>
+#include <svglinenode.hxx>
+#include <svgpolynode.hxx>
+#include <svgtextnode.hxx>
+#include <svgcharacternode.hxx>
+#include <svgtspannode.hxx>
+#include <svgtrefnode.hxx>
+#include <svgtextpathnode.hxx>
+#include <svgstylenode.hxx>
+#include <svgimagenode.hxx>
+#include <svgclippathnode.hxx>
+#include <svgfecolormatrixnode.hxx>
+#include <svgfedropshadownode.hxx>
+#include <svgfefloodnode.hxx>
+#include <svgfeimagenode.hxx>
+#include <svgfegaussianblurnode.hxx>
+#include <svgfeoffsetnode.hxx>
+#include <svgfilternode.hxx>
+#include <svgmasknode.hxx>
+#include <svgmarkernode.hxx>
+#include <svgpatternnode.hxx>
+#include <svgtitledescnode.hxx>
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+
+#include <com/sun/star/lang/Locale.hpp>
+#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
+
+using namespace com::sun::star;
+
+namespace svgio::svgreader
+{
+
+namespace
+{
+    svgio::svgreader::SvgCharacterNode* whiteSpaceHandling(svgio::svgreader::SvgNode const * pNode, svgio::svgreader::SvgTspanNode* pParentLine, svgio::svgreader::SvgCharacterNode* pLast)
+    {
+        if(pNode)
+        {
+            const auto& rChilds = pNode->getChildren();
+            const sal_uInt32 nCount(rChilds.size());
+
+            for(sal_uInt32 a(0); a < nCount; a++)
+            {
+                svgio::svgreader::SvgNode* pCandidate = rChilds[a].get();
+
+                if(pCandidate)
+                {
+                    switch(pCandidate->getType())
+                    {
+                        case SVGToken::Character:
+                        {
+                            // clean whitespace in text span
+                            svgio::svgreader::SvgCharacterNode* pCharNode = static_cast< svgio::svgreader::SvgCharacterNode* >(pCandidate);
+
+                            pCharNode->setParentLine(pParentLine);
+
+                            pCharNode->whiteSpaceHandling();
+                            pLast = pCharNode->addGap(pLast);
+
+                            double fTextWidth(0.0);
+
+                            const SvgStyleAttributes* pSvgStyleAttributes = pCharNode->getSvgStyleAttributes();
+
+                            if(pSvgStyleAttributes)
+                            {
+                                const drawinglayer::attribute::FontAttribute aFontAttribute(
+                                        svgio::svgreader::SvgCharacterNode::getFontAttribute(*pSvgStyleAttributes));
+
+                                double fFontWidth(pSvgStyleAttributes->getFontSizeNumber().solve(*pCharNode));
+                                double fFontHeight(fFontWidth);
+
+                                css::lang::Locale aLocale;
+
+                                drawinglayer::primitive2d::TextLayouterDevice aTextLayouterDevice;
+                                aTextLayouterDevice.setFontAttribute(aFontAttribute, fFontWidth, fFontHeight, aLocale);
+                                fTextWidth = aTextLayouterDevice.getTextWidth(pCharNode->getText(), 0.0, pCharNode->getText().getLength());
+                            }
+
+                            pParentLine->concatenateTextLineWidth(fTextWidth);
+                            break;
+                        }
+                        case SVGToken::Tspan:
+                        {
+                            svgio::svgreader::SvgTspanNode* pTspanNode = static_cast< svgio::svgreader::SvgTspanNode* >(pCandidate);
+
+                            // If x or y exist it means it's a new line of text
+                            if(!pTspanNode->getX().empty() || !pTspanNode->getY().empty())
+                                pParentLine = pTspanNode;
+
+                            // recursively clean whitespaces in subhierarchy
+                            pLast = whiteSpaceHandling(pCandidate, pParentLine, pLast);
+                            break;
+                        }
+                        case SVGToken::TextPath:
+                        case SVGToken::Tref:
+                        {
+                            // recursively clean whitespaces in subhierarchy
+                            pLast = whiteSpaceHandling(pCandidate, pParentLine, pLast);
+                            break;
+                        }
+                        default:
+                        {
+                            OSL_ENSURE(false, "Unexpected token inside SVGTokenText (!)");
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return pLast;
+    }
+
+} // end anonymous namespace
+
+        SvgDocHdl::SvgDocHdl(const OUString& aAbsolutePath)
+        :   maDocument(aAbsolutePath),
+            mpTarget(nullptr)
+        {
+        }
+
+        SvgDocHdl::~SvgDocHdl()
+        {
+            if (mpTarget)
+            {
+                OSL_ENSURE(false, "SvgDocHdl destructed with active target (!)");
+
+                while (mpTarget->getParent())
+                    mpTarget = const_cast< SvgNode* >(mpTarget->getParent());
+
+                const SvgNodeVector& rOwnedTopLevels = maDocument.getSvgNodeVector();
+                if (std::none_of(rOwnedTopLevels.begin(), rOwnedTopLevels.end(),
+                                [&](std::unique_ptr<SvgNode> const & p) { return p.get() == mpTarget; }))
+                    delete mpTarget;
+            }
+            OSL_ENSURE(maCssContents.empty(), "SvgDocHdl destructed with active css style stack entry (!)");
+        }
+
+        void SvgDocHdl::startDocument(  )
+        {
+            OSL_ENSURE(!mpTarget, "Already a target at document start (!)");
+            OSL_ENSURE(maCssContents.empty(), "SvgDocHdl startDocument with active css style stack entry (!)");
+        }
+
+        void SvgDocHdl::endDocument(  )
+        {
+            OSL_ENSURE(!mpTarget, "Still a target at document end (!)");
+            OSL_ENSURE(maCssContents.empty(), "SvgDocHdl endDocument with active css style stack entry (!)");
+        }
+
+        void SvgDocHdl::startElement( const OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs )
+        {
+            if(aName.isEmpty())
+                return;
+
+            const SVGToken aSVGToken(StrToSVGToken(aName, false));
+
+            switch (aSVGToken)
+            {
+                /// structural elements
+                case SVGToken::Symbol:
+                {
+                    /// new basic node for Symbol. Content gets scanned, but
+                    /// will not be decomposed (see SvgNode::decomposeSvgNode and bReferenced)
+                    mpTarget = new SvgSymbolNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Switch: //TODO: Support switch element
+                case SVGToken::Defs:
+                case SVGToken::G:
+                {
+                    /// new node for Defs/G
+                    mpTarget = new SvgGNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Svg:
+                {
+                    /// new node for Svg
+                    mpTarget = new SvgSvgNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Use:
+                {
+                    /// new node for Use
+                    mpTarget = new SvgUseNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::A:
+                {
+                    /// new node for A
+                    mpTarget = new SvgANode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// shape elements
+                case SVGToken::Circle:
+                {
+                    /// new node for Circle
+                    mpTarget = new SvgCircleNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Ellipse:
+                {
+                    /// new node for Ellipse
+                    mpTarget = new SvgEllipseNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Line:
+                {
+                    /// new node for Line
+                    mpTarget = new SvgLineNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Path:
+                {
+                    /// new node for Path
+                    mpTarget = new SvgPathNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Polygon:
+                {
+                    /// new node for Polygon
+                    mpTarget = new SvgPolyNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Polyline:
+                {
+                    /// new node for Polyline
+                    mpTarget = new SvgPolyNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Rect:
+                {
+                    /// new node for Rect
+                    mpTarget = new SvgRectNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Image:
+                {
+                    /// new node for Image
+                    mpTarget = new SvgImageNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// title and description
+                case SVGToken::Title:
+                case SVGToken::Desc:
+                {
+                    /// new node for Title and/or Desc
+                    mpTarget = new SvgTitleDescNode(aSVGToken, maDocument, mpTarget);
+                    break;
+                }
+
+                /// gradients
+                case SVGToken::LinearGradient:
+                case SVGToken::RadialGradient:
+                {
+                    mpTarget = new SvgGradientNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// gradient stops
+                case SVGToken::Stop:
+                {
+                    mpTarget = new SvgGradientStopNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// text
+                case SVGToken::Text:
+                {
+                    mpTarget = new SvgTextNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Tspan:
+                {
+                    mpTarget = new SvgTspanNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Tref:
+                {
+                    mpTarget = new SvgTrefNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::TextPath:
+                {
+                    mpTarget = new SvgTextPathNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// styles (as stylesheets)
+                case SVGToken::Style:
+                {
+                    SvgStyleNode* pNew = new SvgStyleNode(maDocument, mpTarget);
+                    mpTarget = pNew;
+
+                    // #i125326# there are attributes, read them. This will set isTextCss to false if
+                    // type attribute is different to "text/css"
+                    mpTarget->parseAttributes(xAttribs);
+
+                    if(pNew->isTextCss())
+                    {
+                        // if it is a Css style, allow reading text between the start and end tag (see
+                        // SvgDocHdl::characters for details)
+                        maCssContents.emplace_back();
+                    }
+                    break;
+                }
+
+                /// structural elements clip-path and mask. Content gets scanned, but
+                /// will not be decomposed (see SvgNode::decomposeSvgNode and bReferenced)
+                case SVGToken::ClipPathNode:
+                {
+                    /// new node for ClipPath
+                    mpTarget = new SvgClipPathNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Mask:
+                {
+                    /// new node for Mask
+                    mpTarget = new SvgMaskNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeColorMatrix:
+                {
+                    /// new node for feColorMatrix
+                    mpTarget = new SvgFeColorMatrixNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeDropShadow:
+                {
+                    /// new node for feDropShadow
+                    mpTarget = new SvgFeDropShadowNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeFlood:
+                {
+                    /// new node for feFlood
+                    mpTarget = new SvgFeFloodNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeImage:
+                {
+                    /// new node for feImage
+                    mpTarget = new SvgFeImageNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeGaussianBlur:
+                {
+                    /// new node for feGaussianBlur
+                    mpTarget = new SvgFeGaussianBlurNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::FeOffset:
+                {
+                    /// new node for feOffset
+                    mpTarget = new SvgFeOffsetNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+                case SVGToken::Filter:
+                {
+                    /// new node for Filter
+                    mpTarget = new SvgFilterNode(aSVGToken, maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// structural element marker
+                case SVGToken::Marker:
+                {
+                    /// new node for marker
+                    mpTarget = new SvgMarkerNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                /// structural element pattern
+                case SVGToken::Pattern:
+                {
+                    /// new node for pattern
+                    mpTarget = new SvgPatternNode(maDocument, mpTarget);
+                    mpTarget->parseAttributes(xAttribs);
+                    break;
+                }
+
+                default:
+                {
+                    mpTarget = new SvgNode(SVGToken::Unknown, maDocument, mpTarget);
+                    break;
+                }
+            }
+        }
+
+        void SvgDocHdl::endElement( const OUString& aName )
+        {
+            if(aName.isEmpty())
+                return;
+
+            if(!mpTarget)
+                return;
+
+            const SVGToken aSVGToken(StrToSVGToken(aName, false));
+            SvgNode* pTextNode(SVGToken::Text == aSVGToken ? mpTarget : nullptr);
+            SvgStyleNode* pCssStyle(SVGToken::Style == aSVGToken ? static_cast< SvgStyleNode* >(mpTarget) : nullptr);
+            SvgTitleDescNode* pSvgTitleDescNode(SVGToken::Title == aSVGToken || SVGToken::Desc == aSVGToken ? static_cast< SvgTitleDescNode* >(mpTarget) : nullptr);
+
+            if(!mpTarget->getParent())
+            {
+                // last element closing, save this tree
+                maDocument.appendNode(std::unique_ptr<SvgNode>(mpTarget));
+            }
+
+            mpTarget = const_cast< SvgNode* >(mpTarget->getParent());
+
+            if (pSvgTitleDescNode && mpTarget)
+            {
+                const OUString& aText(pSvgTitleDescNode->getText());
+
+                if(!aText.isEmpty())
+                {
+                    mpTarget->parseAttribute(aSVGToken, aText);
+                }
+            }
+
+            if(pCssStyle && pCssStyle->isTextCss())
+            {
+                // css style parsing
+                if(!maCssContents.empty())
+                {
+                    // need to interpret css styles and remember them as StyleSheets
+                    // #125325# Caution! the Css content may contain block comments
+                    // (see http://www.w3.org/wiki/CSS_basics#CSS_comments). These need
+                    // to be removed first
+                    const OUString aCommentFreeSource(removeBlockComments(*(maCssContents.end() - 1)));
+
+                    if(aCommentFreeSource.getLength())
+                    {
+                        pCssStyle->addCssStyleSheet(aCommentFreeSource);
+                    }
+
+                    maCssContents.pop_back();
+                }
+                else
+                {
+                    OSL_ENSURE(false, "Closing CssStyle, but no collector string on stack (!)");
+                }
+            }
+
+            if(pTextNode)
+            {
+                // cleanup read strings
+                whiteSpaceHandling(pTextNode, static_cast< SvgTspanNode*>(pTextNode), nullptr);
+            }
+        }
+
+        void SvgDocHdl::characters( const OUString& aChars )
+        {
+            const sal_uInt32 nLength(aChars.getLength());
+
+            if(!(mpTarget && nLength))
+                return;
+
+            switch(mpTarget->getType())
+            {
+                case SVGToken::Text:
+                case SVGToken::Tspan:
+                case SVGToken::TextPath:
+                {
+                    const auto& rChilds = mpTarget->getChildren();
+
+                    if(!rChilds.empty())
+                    {
+                        SvgNode* pChild = rChilds[rChilds.size() - 1].get();
+                        if ( pChild->getType() == SVGToken::Character )
+                        {
+                            SvgCharacterNode& rSvgCharacterNode = static_cast< SvgCharacterNode& >(*pChild);
+
+                            // concatenate to current character span
+                            rSvgCharacterNode.concatenate(aChars);
+                            break;
+                        }
+                    }
+
+                    // add character span as simplified tspan (no arguments)
+                    // as direct child of SvgTextNode/SvgTspanNode/SvgTextPathNode
+                    new SvgCharacterNode(maDocument, mpTarget, aChars);
+                    break;
+                }
+                case SVGToken::Style:
+                {
+                    SvgStyleNode& rSvgStyleNode = static_cast< SvgStyleNode& >(*mpTarget);
+
+                    if(rSvgStyleNode.isTextCss())
+                    {
+                        // collect characters for css style
+                        if(!maCssContents.empty())
+                        {
+                            const OUString aTrimmedChars(aChars.trim());
+
+                            if(!aTrimmedChars.isEmpty())
+                            {
+                                std::vector< OUString >::iterator aString(maCssContents.end() - 1);
+                                (*aString) += aTrimmedChars;
+                            }
+                        }
+                        else
+                        {
+                            OSL_ENSURE(false, "Closing CssStyle, but no collector string on stack (!)");
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Title:
+                case SVGToken::Desc:
+                {
+                    SvgTitleDescNode& rSvgTitleDescNode = static_cast< SvgTitleDescNode& >(*mpTarget);
+
+                    // add text directly to SvgTitleDescNode
+                    rSvgTitleDescNode.concatenate(aChars);
+                    break;
+                }
+                default:
+                {
+                    // characters not used by a known node
+                    break;
+                }
+            }
+        }
+
+        void SvgDocHdl::ignorableWhitespace(const OUString& /*aWhitespaces*/)
+        {
+        }
+
+        void SvgDocHdl::processingInstruction(const OUString& /*aTarget*/, const OUString& /*aData*/)
+        {
+        }
+
+        void SvgDocHdl::setDocumentLocator(const uno::Reference< xml::sax::XLocator >& /*xLocator*/)
+        {
+        }
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgellipsenode.cxx b/svgio/source/svgreader/svgellipsenode.cxx
new file mode 100644
index 0000000000..1843a017c5
--- /dev/null
+++ b/svgio/source/svgreader/svgellipsenode.cxx
@@ -0,0 +1,158 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgellipsenode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+namespace svgio::svgreader
+{
+        SvgEllipseNode::SvgEllipseNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Ellipse, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maCx(0),
+            maCy(0),
+            maRx(0),
+            maRy(0)
+        {
+        }
+
+        SvgEllipseNode::~SvgEllipseNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgEllipseNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgEllipseNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Cx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCx = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Cy:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCy = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Rx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maRx = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Ry:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maRy = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgEllipseNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!(pStyle && getRx().isSet() && getRy().isSet()))
+                return;
+
+            const double fRx(getRx().solve(*this, NumberType::xcoordinate));
+            const double fRy(getRy().solve(*this, NumberType::ycoordinate));
+
+            if(fRx <= 0.0 || fRy <= 0.0)
+                return;
+
+            const basegfx::B2DPolygon aPath(
+                basegfx::utils::createPolygonFromEllipse(
+                    basegfx::B2DPoint(
+                        getCx().isSet() ? getCx().solve(*this, NumberType::xcoordinate) : 0.0,
+                        getCy().isSet() ? getCy().solve(*this, NumberType::ycoordinate) : 0.0),
+                    fRx, fRy));
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            pStyle->add_path(basegfx::B2DPolyPolygon(aPath), aNewTarget, nullptr);
+
+            if(!aNewTarget.empty())
+            {
+                pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfecolormatrixnode.cxx b/svgio/source/svgreader/svgfecolormatrixnode.cxx
new file mode 100644
index 0000000000..3a7943ac4e
--- /dev/null
+++ b/svgio/source/svgreader/svgfecolormatrixnode.cxx
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgfecolormatrixnode.hxx>
+#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeColorMatrixNode::SvgFeColorMatrixNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeColorMatrix, rDocument, pParent)
+    , maType(ColorType::Matrix)
+{
+}
+
+SvgFeColorMatrixNode::~SvgFeColorMatrixNode() {}
+
+void SvgFeColorMatrixNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::Type:
+        {
+            if (!aContent.isEmpty())
+            {
+                if (o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"luminanceToAlpha"))
+                {
+                    maType = ColorType::LuminanceToAlpha;
+                }
+                else if (o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"saturate"))
+                {
+                    maType = ColorType::Saturate;
+                }
+                else if (o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hueRotate"))
+                {
+                    maType = ColorType::HueRotate;
+                }
+                else if (o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"matrix"))
+                {
+                    maType = ColorType::Matrix;
+                }
+            }
+            break;
+        }
+        case SVGToken::Values:
+        {
+            maValuesContent = aContent;
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeColorMatrixNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    if (maType == ColorType::LuminanceToAlpha)
+    {
+        const drawinglayer::primitive2d::Primitive2DReference xRef(
+            new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
+                std::move(rTarget),
+                std::make_shared<basegfx::BColorModifier_luminance_to_alpha>()));
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+    else if (maType == ColorType::Saturate)
+    {
+        SvgNumber aNum(1.0);
+        (void)readSingleNumber(maValuesContent, aNum);
+
+        const drawinglayer::primitive2d::Primitive2DReference xRef(
+            new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
+                std::move(rTarget),
+                std::make_shared<basegfx::BColorModifier_saturate>(aNum.getNumber())));
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+    else if (maType == ColorType::HueRotate)
+    {
+        SvgNumber aNum(0.0);
+        (void)readSingleNumber(maValuesContent, aNum);
+        const drawinglayer::primitive2d::Primitive2DReference xRef(
+            new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
+                std::move(rTarget), std::make_shared<basegfx::BColorModifier_hueRotate>(
+                                        basegfx::deg2rad(aNum.getNumber()))));
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+    else if (maType == ColorType::Matrix)
+    {
+        std::vector<double> aVector = readFilterMatrix(maValuesContent, *this);
+
+        const drawinglayer::primitive2d::Primitive2DReference xRef(
+            new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
+                std::move(rTarget), std::make_shared<basegfx::BColorModifier_matrix>(aVector)));
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfedropshadownode.cxx b/svgio/source/svgreader/svgfedropshadownode.cxx
new file mode 100644
index 0000000000..c968f51f5c
--- /dev/null
+++ b/svgio/source/svgreader/svgfedropshadownode.cxx
@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/Primitive2DContainer.hxx>
+#include <drawinglayer/primitive2d/shadowprimitive2d.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <svgfedropshadownode.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeDropShadowNode::SvgFeDropShadowNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeDropShadow, rDocument, pParent)
+    , maDx(0.0)
+    , maDy(0.0)
+    , maStdDeviation(0.0)
+    , maFloodColor(SvgPaint())
+    , maFloodOpacity(1.0)
+{
+}
+
+SvgFeDropShadowNode::~SvgFeDropShadowNode() {}
+
+void SvgFeDropShadowNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::Style:
+        {
+            readLocalCssStyle(aContent);
+            break;
+        }
+        case SVGToken::Dx:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maDx = aNum;
+            }
+            break;
+        }
+        case SVGToken::Dy:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maDy = aNum;
+            }
+            break;
+        }
+        case SVGToken::StdDeviation:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maStdDeviation = aNum;
+            }
+            break;
+        }
+        case SVGToken::FloodColor:
+        {
+            SvgPaint aSvgPaint;
+            OUString aURL;
+            SvgNumber aOpacity;
+
+            if (readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+            {
+                maFloodColor = aSvgPaint;
+            }
+            break;
+        }
+        case SVGToken::FloodOpacity:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maFloodOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(),
+                                           aNum.isSet());
+            }
+            break;
+        }
+
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeDropShadowNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    basegfx::B2DHomMatrix aTransform;
+    if (maDx.isSet() || maDy.isSet())
+    {
+        aTransform.translate(maDx.solve(*this, NumberType::xcoordinate),
+                             maDy.solve(*this, NumberType::ycoordinate));
+    }
+
+    drawinglayer::primitive2d::Primitive2DContainer aTempTarget;
+
+    // Create the shadow
+    aTempTarget.append(drawinglayer::primitive2d::Primitive2DReference(
+        new drawinglayer::primitive2d::ShadowPrimitive2D(
+            aTransform, maFloodColor.getBColor(), maStdDeviation.getNumber(),
+            drawinglayer::primitive2d::Primitive2DContainer(rTarget))));
+
+    const double fOpacity(maFloodOpacity.solve(*this));
+    if (basegfx::fTools::less(fOpacity, 1.0))
+    {
+        // Apply transparence to the shadow
+        aTempTarget.append(drawinglayer::primitive2d::Primitive2DReference(
+            new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(std::move(aTempTarget),
+                                                                          1.0 - fOpacity)));
+    }
+
+    // Append the original target
+    aTempTarget.append(rTarget);
+
+    rTarget = aTempTarget;
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfefloodnode.cxx b/svgio/source/svgreader/svgfefloodnode.cxx
new file mode 100644
index 0000000000..89f12c4a4d
--- /dev/null
+++ b/svgio/source/svgreader/svgfefloodnode.cxx
@@ -0,0 +1,161 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <svgfefloodnode.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeFloodNode::SvgFeFloodNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeFlood, rDocument, pParent)
+    , maX(0.0)
+    , maY(0.0)
+    , maWidth(0.0)
+    , maHeight(0.0)
+    , maFloodColor(SvgPaint())
+    , maFloodOpacity(1.0)
+{
+}
+
+SvgFeFloodNode::~SvgFeFloodNode() {}
+
+void SvgFeFloodNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::Style:
+        {
+            readLocalCssStyle(aContent);
+            break;
+        }
+        case SVGToken::X:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maX = aNum;
+            }
+            break;
+        }
+        case SVGToken::Y:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maY = aNum;
+            }
+            break;
+        }
+        case SVGToken::Width:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                if (aNum.isPositive())
+                {
+                    maWidth = aNum;
+                }
+            }
+            break;
+        }
+        case SVGToken::Height:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                if (aNum.isPositive())
+                {
+                    maHeight = aNum;
+                }
+            }
+            break;
+        }
+        case SVGToken::FloodColor:
+        {
+            SvgPaint aSvgPaint;
+            OUString aURL;
+            SvgNumber aOpacity;
+
+            if (readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+            {
+                maFloodColor = aSvgPaint;
+            }
+            break;
+        }
+        case SVGToken::FloodOpacity:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                maFloodOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(),
+                                           aNum.isSet());
+            }
+            break;
+        }
+
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeFloodNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    const double fWidth(maWidth.solve(*this, NumberType::xcoordinate));
+    const double fHeight(maHeight.solve(*this, NumberType::ycoordinate));
+
+    if (fWidth <= 0.0 || fHeight <= 0.0)
+        return;
+
+    const double fX(maX.solve(*this, NumberType::xcoordinate));
+    const double fY(maY.solve(*this, NumberType::ycoordinate));
+    const basegfx::B2DRange aRange(fX, fY, fX + fWidth, fY + fHeight);
+
+    basegfx::B2DPolyPolygon aPolygon(basegfx::utils::createPolygonFromRect(aRange));
+    drawinglayer::primitive2d::Primitive2DReference xRef(
+        new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(aPolygon,
+                                                                   maFloodColor.getBColor()));
+
+    rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+
+    const double fOpacity(maFloodOpacity.solve(*this));
+
+    if (basegfx::fTools::less(fOpacity, 1.0))
+    {
+        xRef = new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(std::move(rTarget),
+                                                                             1.0 - fOpacity);
+
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfegaussianblurnode.cxx b/svgio/source/svgreader/svgfegaussianblurnode.cxx
new file mode 100644
index 0000000000..53b1513d25
--- /dev/null
+++ b/svgio/source/svgreader/svgfegaussianblurnode.cxx
@@ -0,0 +1,70 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgfegaussianblurnode.hxx>
+#include <drawinglayer/primitive2d/softedgeprimitive2d.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeGaussianBlurNode::SvgFeGaussianBlurNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeGaussianBlur, rDocument, pParent)
+    , maStdDeviation(SvgNumber(0.0))
+{
+}
+
+SvgFeGaussianBlurNode::~SvgFeGaussianBlurNode() {}
+
+void SvgFeGaussianBlurNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::StdDeviation:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                if (aNum.isPositive())
+                {
+                    maStdDeviation = aNum;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeGaussianBlurNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    const drawinglayer::primitive2d::Primitive2DReference xRef(
+        new drawinglayer::primitive2d::SoftEdgePrimitive2D(maStdDeviation.getNumber(),
+                                                           std::move(rTarget)));
+
+    rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfeimagenode.cxx b/svgio/source/svgreader/svgfeimagenode.cxx
new file mode 100644
index 0000000000..7174bcaf4a
--- /dev/null
+++ b/svgio/source/svgreader/svgfeimagenode.cxx
@@ -0,0 +1,133 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
+#include <svgfeimagenode.hxx>
+#include <o3tl/string_view.hxx>
+#include <svgdocument.hxx>
+#include <comphelper/base64.hxx>
+#include <tools/stream.hxx>
+#include <rtl/uri.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeImageNode::SvgFeImageNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeImage, rDocument, pParent)
+{
+}
+
+SvgFeImageNode::~SvgFeImageNode() {}
+
+void SvgFeImageNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::Style:
+        {
+            readLocalCssStyle(aContent);
+            break;
+        }
+        case SVGToken::Href:
+        case SVGToken::XlinkHref:
+        {
+            const sal_Int32 nLen(aContent.getLength());
+
+            if (nLen)
+            {
+                OUString aXLink;
+                readImageLink(aContent, aXLink, maUrl, maData);
+            }
+            break;
+        }
+
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeImageNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    BitmapEx aBitmapEx;
+
+    if (!maData.isEmpty())
+    {
+        // use embedded base64 encoded data
+        css::uno::Sequence<sal_Int8> aPass;
+        ::comphelper::Base64::decode(aPass, maData);
+
+        if (aPass.hasElements())
+        {
+            SvMemoryStream aStream(aPass.getArray(), aPass.getLength(), StreamMode::READ);
+            Graphic aGraphic;
+
+            if (ERRCODE_NONE
+                == GraphicFilter::GetGraphicFilter().ImportGraphic(aGraphic, u"", aStream))
+            {
+                aBitmapEx = aGraphic.GetBitmapEx();
+            }
+        }
+    }
+    else if (!maUrl.isEmpty())
+    {
+        const OUString& rPath = getDocument().getAbsolutePath();
+        OUString aAbsUrl;
+        try
+        {
+            aAbsUrl = rtl::Uri::convertRelToAbs(rPath, maUrl);
+        }
+        catch (rtl::MalformedUriException& e)
+        {
+            SAL_WARN("svg", "caught rtl::MalformedUriException \"" << e.getMessage() << "\"");
+        }
+
+        if (!aAbsUrl.isEmpty() && rPath != aAbsUrl)
+        {
+            SvFileStream aStream(aAbsUrl, StreamMode::STD_READ);
+            Graphic aGraphic;
+
+            if (ERRCODE_NONE
+                == GraphicFilter::GetGraphicFilter().ImportGraphic(aGraphic, aAbsUrl, aStream))
+            {
+                aBitmapEx = aGraphic.GetBitmapEx();
+            }
+        }
+    }
+
+    if (!aBitmapEx.IsEmpty() && 0 != aBitmapEx.GetSizePixel().Width()
+        && 0 != aBitmapEx.GetSizePixel().Height())
+    {
+        basegfx::B2DRange aViewBox
+            = rTarget.getB2DRange(drawinglayer::geometry::ViewInformation2D());
+        const drawinglayer::primitive2d::Primitive2DReference xRef(
+            new drawinglayer::primitive2d::BitmapPrimitive2D(
+                aBitmapEx, basegfx::utils::createScaleTranslateB2DHomMatrix(
+                               aViewBox.getRange(), aViewBox.getMinimum())));
+
+        rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+    }
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfeoffsetnode.cxx b/svgio/source/svgreader/svgfeoffsetnode.cxx
new file mode 100644
index 0000000000..324920cde1
--- /dev/null
+++ b/svgio/source/svgreader/svgfeoffsetnode.cxx
@@ -0,0 +1,91 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <svgfeoffsetnode.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+SvgFeOffsetNode::SvgFeOffsetNode(SvgDocument& rDocument, SvgNode* pParent)
+    : SvgFilterNode(SVGToken::FeOffset, rDocument, pParent)
+    , maDx(SvgNumber(0.0))
+    , maDy(SvgNumber(0.0))
+{
+}
+
+SvgFeOffsetNode::~SvgFeOffsetNode() {}
+
+void SvgFeOffsetNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+{
+    // parse own
+    switch (aSVGToken)
+    {
+        case SVGToken::Dx:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                if (aNum.isPositive())
+                {
+                    maDx = aNum;
+                }
+            }
+            break;
+        }
+        case SVGToken::Dy:
+        {
+            SvgNumber aNum;
+
+            if (readSingleNumber(aContent, aNum))
+            {
+                if (aNum.isPositive())
+                {
+                    maDy = aNum;
+                }
+            }
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+}
+
+void SvgFeOffsetNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    basegfx::B2DHomMatrix aTransform;
+
+    if (maDx.isSet() || maDy.isSet())
+    {
+        aTransform.translate(maDx.solve(*this, NumberType::xcoordinate),
+                             maDy.solve(*this, NumberType::ycoordinate));
+    }
+
+    const drawinglayer::primitive2d::Primitive2DReference xRef(
+        new drawinglayer::primitive2d::TransformPrimitive2D(aTransform, std::move(rTarget)));
+
+    rTarget = drawinglayer::primitive2d::Primitive2DContainer{ xRef };
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgfilternode.cxx b/svgio/source/svgreader/svgfilternode.cxx
new file mode 100644
index 0000000000..3e21e9c2ad
--- /dev/null
+++ b/svgio/source/svgreader/svgfilternode.cxx
@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgfilternode.hxx>
+#include <svgfecolormatrixnode.hxx>
+#include <svgfedropshadownode.hxx>
+#include <svgfefloodnode.hxx>
+#include <svgfeimagenode.hxx>
+#include <svgfegaussianblurnode.hxx>
+#include <svgfeoffsetnode.hxx>
+
+namespace svgio::svgreader
+{
+SvgFilterNode::SvgFilterNode(SVGToken aType, SvgDocument& rDocument, SvgNode* pParent)
+    : SvgNode(aType, rDocument, pParent)
+{
+}
+
+SvgFilterNode::~SvgFilterNode() {}
+
+void SvgFilterNode::apply(drawinglayer::primitive2d::Primitive2DContainer& rTarget) const
+{
+    if (rTarget.empty())
+        return;
+
+    const auto& rChildren = getChildren();
+    const sal_uInt32 nCount(rChildren.size());
+
+    // apply children's filters
+    for (sal_uInt32 a(0); a < nCount; a++)
+    {
+        SvgFilterNode* pFilterNode = dynamic_cast<SvgFilterNode*>(rChildren[a].get());
+        if (pFilterNode)
+            pFilterNode->apply(rTarget);
+    }
+}
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svggnode.cxx b/svgio/source/svgreader/svggnode.cxx
new file mode 100644
index 0000000000..b70e780206
--- /dev/null
+++ b/svgio/source/svgreader/svggnode.cxx
@@ -0,0 +1,107 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svggnode.hxx>
+#include <osl/diagnose.h>
+
+namespace svgio::svgreader
+{
+        SvgGNode::SvgGNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(aType, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+            OSL_ENSURE(aType == SVGToken::Defs || aType == SVGToken::G, "SvgGNode should only be used for Group and Defs (!)");
+        }
+
+        SvgGNode::~SvgGNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgGNode::getSvgStyleAttributes() const
+        {
+            // tdf#98599 attributes may be inherit by the children, therefore read them
+            // #i125258# for SVGToken::G take CssStyles into account
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgGNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgGNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            if(SVGToken::Defs == getType())
+            {
+                // #i125258# no decompose needed for defs element, call parent for SVGTokenDefs
+                SvgNode::decomposeSvgNode(rTarget, bReferenced);
+            }
+            else
+            {
+                // #i125258# for SVGTokenG decompose children
+                const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+                if(pStyle)
+                {
+                    drawinglayer::primitive2d::Primitive2DContainer aContent;
+
+                    // decompose children
+                    SvgNode::decomposeSvgNode(aContent, bReferenced);
+
+                    if(!aContent.empty())
+                    {
+                        pStyle->add_postProcess(rTarget, std::move(aContent), getTransform());
+                    }
+                }
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svggradientnode.cxx b/svgio/source/svgreader/svggradientnode.cxx
new file mode 100644
index 0000000000..723dac6d5f
--- /dev/null
+++ b/svgio/source/svgreader/svggradientnode.cxx
@@ -0,0 +1,501 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svggradientnode.hxx>
+#include <svgdocument.hxx>
+#include <svggradientstopnode.hxx>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+
+namespace svgio::svgreader
+{
+        void SvgGradientNode::tryToFindLink()
+        {
+            if(!mpXLink && !maXLink.isEmpty())
+            {
+                mpXLink = dynamic_cast< const SvgGradientNode* >(getDocument().findSvgNodeById(maXLink));
+            }
+        }
+
+        SvgGradientNode::SvgGradientNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(aType, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maGradientUnits(SvgUnits::objectBoundingBox),
+            maSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Pad),
+            mbResolvingLink(false),
+            mpXLink(nullptr)
+        {
+            OSL_ENSURE(aType == SVGToken::LinearGradient || aType == SVGToken::RadialGradient, "SvgGradientNode should only be used for Linear and Radial gradient (!)");
+        }
+
+        SvgGradientNode::~SvgGradientNode()
+        {
+            // do NOT delete mpXLink, it's only referenced, not owned
+        }
+
+        const SvgStyleAttributes* SvgGradientNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgGradientNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::X1:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX1 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y1:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY1 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::X2:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX2 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y2:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY2 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Cx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCx = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Cy:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maCy = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Fx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maFx = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Fy:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maFy = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::R:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maR = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::GradientUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setGradientUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setGradientUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::SpreadMethod:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"pad"))
+                        {
+                            setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Pad);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"reflect"))
+                        {
+                            setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Reflect);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"repeat"))
+                        {
+                            setSpreadMethod(drawinglayer::primitive2d::SpreadMethod::Repeat);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::GradientTransform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setGradientTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    readLocalLink(aContent, maXLink);
+                    tryToFindLink();
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgGradientNode::collectGradientEntries(drawinglayer::primitive2d::SvgGradientEntryVector& aVector) const
+        {
+            if(getChildren().empty())
+            {
+                const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+                if (mpXLink && !mbResolvingLink)
+                {
+                    mbResolvingLink = true;
+                    mpXLink->collectGradientEntries(aVector);
+                    mbResolvingLink = false;
+                }
+            }
+            else
+            {
+                const sal_uInt32 nCount(getChildren().size());
+
+                for(sal_uInt32 a(0); a < nCount; a++)
+                {
+                    const SvgGradientStopNode* pCandidate = dynamic_cast< const SvgGradientStopNode* >(getChildren()[a].get());
+
+                    if(pCandidate)
+                    {
+                        const SvgStyleAttributes* pStyle = pCandidate->getSvgStyleAttributes();
+
+                        if(pStyle)
+                        {
+                            const SvgNumber aOffset(pCandidate->getOffset());
+                            double fOffset(0.0);
+
+                            if(SvgUnit::percent == aOffset.getUnit())
+                            {
+                                // percent is not relative to distances in ColorStop context, solve locally
+                                fOffset = aOffset.getNumber() * 0.01;
+                            }
+                            else
+                            {
+                                fOffset = aOffset.solve(*this);
+                            }
+
+                            if(fOffset < 0.0)
+                            {
+                                OSL_ENSURE(false, "OOps, SvgGradientStopNode with offset out of range (!)");
+                                fOffset = 0.0;
+                            }
+                            else if(fOffset > 1.0)
+                            {
+                                OSL_ENSURE(false, "OOps, SvgGradientStopNode with offset out of range (!)");
+                                fOffset = 1.0;
+                            }
+
+                            aVector.emplace_back(
+                                    fOffset,
+                                    pStyle->getStopColor(),
+                                    pStyle->getStopOpacity().solve(*this));
+                        }
+                        else
+                        {
+                            OSL_ENSURE(false, "OOps, SvgGradientStopNode without Style (!)");
+                        }
+                    }
+                }
+            }
+        }
+
+        SvgNumber SvgGradientNode::getX1() const
+        {
+            if(maX1.isSet())
+            {
+                return maX1;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getX1();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 0%
+            return SvgNumber(0.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getY1() const
+        {
+            if(maY1.isSet())
+            {
+                return maY1;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getY1();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 0%
+            return SvgNumber(0.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getX2() const
+        {
+            if(maX2.isSet())
+            {
+                return maX2;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getX2();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 100%
+            return SvgNumber(100.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getY2() const
+        {
+            if(maY2.isSet())
+            {
+                return maY2;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getY2();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 0%
+            return SvgNumber(0.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getCx() const
+        {
+            if(maCx.isSet())
+            {
+                return maCx;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getCx();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 50%
+            return SvgNumber(50.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getCy() const
+        {
+            if(maCy.isSet())
+            {
+                return maCy;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getCy();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 50%
+            return SvgNumber(50.0, SvgUnit::percent);
+        }
+
+        SvgNumber SvgGradientNode::getR() const
+        {
+            if(maR.isSet())
+            {
+                return maR;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getR();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            // default is 50%
+            return SvgNumber(50.0, SvgUnit::percent);
+        }
+
+        const SvgNumber* SvgGradientNode::getFx() const
+        {
+            if(maFx.isSet())
+            {
+                return &maFx;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getFx();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return nullptr;
+        }
+
+        const SvgNumber* SvgGradientNode::getFy() const
+        {
+            if(maFy.isSet())
+            {
+                return &maFy;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getFy();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return nullptr;
+        }
+
+        std::optional<basegfx::B2DHomMatrix> SvgGradientNode::getGradientTransform() const
+        {
+            if(mpaGradientTransform)
+            {
+                return mpaGradientTransform;
+            }
+
+            const_cast< SvgGradientNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getGradientTransform();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return std::nullopt;
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svggradientstopnode.cxx b/svgio/source/svgreader/svggradientstopnode.cxx
new file mode 100644
index 0000000000..d3b3001977
--- /dev/null
+++ b/svgio/source/svgreader/svggradientstopnode.cxx
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svggradientstopnode.hxx>
+
+namespace svgio::svgreader
+{
+        SvgGradientStopNode::SvgGradientStopNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Stop, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgGradientStopNode::~SvgGradientStopNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgGradientStopNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgGradientStopNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Offset:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maOffset = aNum;
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgimagenode.cxx b/svgio/source/svgreader/svgimagenode.cxx
new file mode 100644
index 0000000000..7e06813628
--- /dev/null
+++ b/svgio/source/svgreader/svgimagenode.cxx
@@ -0,0 +1,348 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgimagenode.hxx>
+#include <svgdocument.hxx>
+#include <tools/stream.hxx>
+#include <vcl/bitmapex.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <rtl/uri.hxx>
+#include <sal/log.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <comphelper/base64.hxx>
+#include <toolkit/helper/vclunohelper.hxx>
+
+namespace svgio::svgreader
+{
+        SvgImageNode::SvgImageNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Rect, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maX(0),
+            maY(0),
+            maWidth(0),
+            maHeight(0)
+        {
+        }
+
+        SvgImageNode::~SvgImageNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgImageNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgImageNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::PreserveAspectRatio:
+                {
+                    maSvgAspectRatio = readSvgAspectRatio(aContent);
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    const sal_Int32 nLen(aContent.getLength());
+
+                    if(nLen)
+                    {
+                        readImageLink(aContent, maXLink, maUrl, maData);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        static void extractFromGraphic(
+            const Graphic& rGraphic,
+            drawinglayer::primitive2d::Primitive2DContainer& rEmbedded,
+            basegfx::B2DRange& rViewBox,
+            BitmapEx& rBitmapEx)
+        {
+            if(GraphicType::Bitmap == rGraphic.GetType())
+            {
+                if(rGraphic.getVectorGraphicData())
+                {
+                    // embedded Svg
+                    rEmbedded = rGraphic.getVectorGraphicData()->getPrimitive2DSequence();
+
+                    // fill aViewBox
+                    rViewBox = rGraphic.getVectorGraphicData()->getRange();
+                }
+                else
+                {
+                    // get bitmap
+                    rBitmapEx = rGraphic.GetBitmapEx();
+                }
+            }
+            else
+            {
+                // evtl. convert to bitmap
+                rBitmapEx = rGraphic.GetBitmapEx();
+            }
+        }
+
+        void SvgImageNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            // get size range and create path
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!(pStyle && getWidth().isSet() && getHeight().isSet()))
+                return;
+
+            const double fWidth(getWidth().solve(*this, NumberType::xcoordinate));
+            const double fHeight(getHeight().solve(*this, NumberType::ycoordinate));
+
+            if(fWidth <= 0.0 || fHeight <= 0.0)
+                return;
+
+            BitmapEx aBitmapEx;
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            // prepare Target and ViewBox for evtl. AspectRatio mappings
+            const double fX(getX().isSet() ? getX().solve(*this, NumberType::xcoordinate) : 0.0);
+            const double fY(getY().isSet() ? getY().solve(*this, NumberType::ycoordinate) : 0.0);
+            const basegfx::B2DRange aTarget(fX, fY, fX + fWidth, fY + fHeight);
+            basegfx::B2DRange aViewBox(aTarget);
+
+            if(!maData.isEmpty())
+            {
+                // use embedded base64 encoded data
+                css::uno::Sequence< sal_Int8 > aPass;
+                ::comphelper::Base64::decode(aPass, maData);
+
+                if(aPass.hasElements())
+                {
+                    SvMemoryStream aStream(aPass.getArray(), aPass.getLength(), StreamMode::READ);
+                    Graphic aGraphic;
+
+                    if(ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(
+                        aGraphic,
+                        u"",
+                        aStream))
+                    {
+                        extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
+                    }
+                }
+            }
+            else if(!maUrl.isEmpty())
+            {
+                const OUString& rPath = getDocument().getAbsolutePath();
+                OUString aAbsUrl;
+                try {
+                    aAbsUrl = rtl::Uri::convertRelToAbs(rPath, maUrl);
+                } catch (rtl::MalformedUriException & e) {
+                    SAL_WARN(
+                        "svg",
+                        "caught rtl::MalformedUriException \""
+                            << e.getMessage() << "\"");
+                }
+
+                if (!aAbsUrl.isEmpty() && rPath != aAbsUrl)
+                {
+                    SvFileStream aStream(aAbsUrl, StreamMode::STD_READ);
+                    Graphic aGraphic;
+
+                    if(ERRCODE_NONE == GraphicFilter::GetGraphicFilter().ImportGraphic(
+                           aGraphic,
+                           aAbsUrl,
+                           aStream))
+                    {
+                        extractFromGraphic(aGraphic, aNewTarget, aViewBox, aBitmapEx);
+                    }
+                }
+            }
+            else if(!maXLink.isEmpty())
+            {
+                const SvgNode* pXLink = getDocument().findSvgNodeById(maXLink);
+
+                if(pXLink && Display::None != pXLink->getDisplay())
+                {
+                    pXLink->decomposeSvgNode(aNewTarget, true);
+
+                    if(!aNewTarget.empty())
+                    {
+                        aViewBox = aNewTarget.getB2DRange(drawinglayer::geometry::ViewInformation2D());
+                    }
+                }
+            }
+
+            if(!aBitmapEx.IsEmpty() && 0 != aBitmapEx.GetSizePixel().Width()  && 0 != aBitmapEx.GetSizePixel().Height())
+            {
+                // calculate centered unit size
+                const double fAspectRatio = static_cast<double>(aBitmapEx.GetSizePixel().Width()) / static_cast<double>(aBitmapEx.GetSizePixel().Height());
+
+                if(basegfx::fTools::equal(fAspectRatio, 0.0))
+                {
+                    // use unit range
+                    aViewBox = basegfx::B2DRange(0.0, 0.0, 1.0, 1.0);
+                }
+                else if(basegfx::fTools::more(fAspectRatio, 0.0))
+                {
+                    // width bigger height
+                    const double fHalfHeight((1.0 / fAspectRatio) * 0.5);
+                    aViewBox = basegfx::B2DRange(
+                        0.0,
+                        0.5 - fHalfHeight,
+                        1.0,
+                        0.5 + fHalfHeight);
+                }
+                else
+                {
+                    // height bigger width
+                    const double fHalfWidth(fAspectRatio * 0.5);
+                    aViewBox = basegfx::B2DRange(
+                        0.5 - fHalfWidth,
+                        0.0,
+                        0.5 + fHalfWidth,
+                        1.0);
+                }
+
+                // create content from created bitmap, use calculated unit range size
+                // as transformation to map the picture data correctly
+                aNewTarget.resize(1);
+                aNewTarget[0] = new drawinglayer::primitive2d::BitmapPrimitive2D(
+                    aBitmapEx,
+                    basegfx::utils::createScaleTranslateB2DHomMatrix(
+                        aViewBox.getRange(),
+                        aViewBox.getMinimum()));
+            }
+
+            if(aNewTarget.empty())
+                return;
+
+            // create mapping
+            const SvgAspectRatio& rRatio = maSvgAspectRatio;
+
+            // even when ratio is not set, use the defaults
+            // let mapping be created from SvgAspectRatio
+            const basegfx::B2DHomMatrix aEmbeddingTransform(rRatio.createMapping(aTarget, aViewBox));
+
+            if(!aEmbeddingTransform.isIdentity())
+            {
+                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                        aEmbeddingTransform,
+                        std::move(aNewTarget)));
+
+                aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+            }
+
+            if(!rRatio.isMeetOrSlice())
+            {
+                // need to embed in MaskPrimitive2D to ensure clipping
+                const drawinglayer::primitive2d::Primitive2DReference xMask(
+                    new drawinglayer::primitive2d::MaskPrimitive2D(
+                        basegfx::B2DPolyPolygon(
+                            basegfx::utils::createPolygonFromRect(aTarget)),
+                        std::move(aNewTarget)));
+
+                aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xMask };
+            }
+
+            // embed and add to rTarget, take local extra-transform into account
+            pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svglinenode.cxx b/svgio/source/svgreader/svglinenode.cxx
new file mode 100644
index 0000000000..41090dcee8
--- /dev/null
+++ b/svgio/source/svgreader/svglinenode.cxx
@@ -0,0 +1,153 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svglinenode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+namespace svgio::svgreader
+{
+        SvgLineNode::SvgLineNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Line, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maX1(0),
+            maY1(0),
+            maX2(0),
+            maY2(0)
+        {
+        }
+
+        SvgLineNode::~SvgLineNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgLineNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgLineNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::X1:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX1 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y1:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY1 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::X2:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX2 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y2:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY2 = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgLineNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!pStyle)
+                return;
+
+            const basegfx::B2DPoint X(
+                getX1().isSet() ? getX1().solve(*this, NumberType::xcoordinate) : 0.0,
+                getY1().isSet() ? getY1().solve(*this, NumberType::ycoordinate) : 0.0);
+            const basegfx::B2DPoint Y(
+                getX2().isSet() ? getX2().solve(*this, NumberType::xcoordinate) : 0.0,
+                getY2().isSet() ? getY2().solve(*this, NumberType::ycoordinate) : 0.0);
+
+            // X and Y may be equal, do not drop them. Markers or linecaps 'round' and 'square'
+            // need to be drawn for zero-length lines too.
+
+            basegfx::B2DPolygon aPath;
+
+            aPath.append(X);
+            aPath.append(Y);
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            pStyle->add_path(basegfx::B2DPolyPolygon(aPath), aNewTarget, nullptr);
+
+            if(!aNewTarget.empty())
+            {
+                pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgmarkernode.cxx b/svgio/source/svgreader/svgmarkernode.cxx
new file mode 100644
index 0000000000..083471b49c
--- /dev/null
+++ b/svgio/source/svgreader/svgmarkernode.cxx
@@ -0,0 +1,199 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgmarkernode.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        SvgMarkerNode::SvgMarkerNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Marker, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maRefX(0),
+            maRefY(0),
+            maMarkerUnits(MarkerUnits::strokeWidth),
+            maMarkerWidth(3),
+            maMarkerHeight(3),
+            mfAngle(0.0),
+            maMarkerOrient(MarkerOrient::notset)
+        {
+        }
+
+        SvgMarkerNode::~SvgMarkerNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgMarkerNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgMarkerNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::ViewBox:
+                {
+                    const basegfx::B2DRange aRange(readViewBox(aContent, *this));
+
+                    if(!aRange.isEmpty())
+                    {
+                        setViewBox(&aRange);
+                    }
+                    break;
+                }
+                case SVGToken::PreserveAspectRatio:
+                {
+                    maSvgAspectRatio = readSvgAspectRatio(aContent);
+                    break;
+                }
+                case SVGToken::RefX:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maRefX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::RefY:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maRefY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::MarkerUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"strokeWidth"))
+                        {
+                            setMarkerUnits(MarkerUnits::strokeWidth);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setMarkerUnits(MarkerUnits::userSpaceOnUse);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::MarkerWidth:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maMarkerWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::MarkerHeight:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maMarkerHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Orient:
+                {
+                    const sal_Int32 nLen(aContent.getLength());
+
+                    if(nLen)
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"auto"))
+                        {
+                            setMarkerOrient(MarkerOrient::auto_start);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"auto-start-reverse"))
+                        {
+                            setMarkerOrient(MarkerOrient::auto_start_reverse);
+                        }
+                        else
+                        {
+                            sal_Int32 nPos(0);
+                            double fAngle(0.0);
+
+                            if(readAngle(aContent, nPos, fAngle, nLen))
+                            {
+                                setAngle(fAngle);
+                            }
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        const drawinglayer::primitive2d::Primitive2DContainer& SvgMarkerNode::getMarkerPrimitives() const
+        {
+            if(aPrimitives.empty() && Display::None != getDisplay())
+            {
+                decomposeSvgNode(const_cast< SvgMarkerNode* >(this)->aPrimitives, true);
+            }
+
+            return aPrimitives;
+        }
+
+        basegfx::B2DRange SvgMarkerNode::getCurrentViewPort() const
+        {
+            if(getViewBox())
+            {
+                return *(getViewBox());
+            }
+            else
+            {
+                return SvgNode::getCurrentViewPort();
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgmasknode.cxx b/svgio/source/svgreader/svgmasknode.cxx
new file mode 100644
index 0000000000..57c95ee01a
--- /dev/null
+++ b/svgio/source/svgreader/svgmasknode.cxx
@@ -0,0 +1,317 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgmasknode.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/transparenceprimitive2d.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        SvgMaskNode::SvgMaskNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Mask, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maX(SvgNumber(-10.0, SvgUnit::percent, true)),
+            maY(SvgNumber(-10.0, SvgUnit::percent, true)),
+            maWidth(SvgNumber(120.0, SvgUnit::percent, true)),
+            maHeight(SvgNumber(120.0, SvgUnit::percent, true)),
+            maMaskUnits(SvgUnits::objectBoundingBox),
+            maMaskContentUnits(SvgUnits::userSpaceOnUse)
+        {
+        }
+
+        SvgMaskNode::~SvgMaskNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgMaskNode::getSvgStyleAttributes() const
+        {
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgMaskNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::MaskUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setMaskUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setMaskUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::MaskContentUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setMaskContentUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setMaskContentUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgMaskNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            // decompose children
+            SvgNode::decomposeSvgNode(aNewTarget, bReferenced);
+
+            if(aNewTarget.empty())
+                return;
+
+            if(getTransform())
+            {
+                // create embedding group element with transformation
+                drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                        *getTransform(),
+                        std::move(aNewTarget)));
+
+                aNewTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+            }
+
+            // append to current target
+            rTarget.append(aNewTarget);
+        }
+
+        void SvgMaskNode::apply(
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const std::optional<basegfx::B2DHomMatrix>& pTransform) const
+        {
+            if(rTarget.empty() || Display::None == getDisplay())
+                return;
+
+            drawinglayer::primitive2d::Primitive2DContainer aMaskTarget;
+
+            // get mask definition as primitives
+            decomposeSvgNode(aMaskTarget, true);
+
+            if(!aMaskTarget.empty())
+            {
+                // get range of content to be masked
+                const basegfx::B2DRange aContentRange(
+                        rTarget.getB2DRange(
+                            drawinglayer::geometry::ViewInformation2D()));
+                const double fContentWidth(aContentRange.getWidth());
+                const double fContentHeight(aContentRange.getHeight());
+
+                if(fContentWidth > 0.0 && fContentHeight > 0.0)
+                {
+                    // create OffscreenBufferRange
+                    basegfx::B2DRange aOffscreenBufferRange;
+
+                    if (SvgUnits::objectBoundingBox == maMaskUnits)
+                    {
+                        // fractions or percentages of the bounding box of the element to which the mask is applied
+                        const double fX(SvgUnit::percent == getX().getUnit() ? getX().getNumber() * 0.01 : getX().getNumber());
+                        const double fY(SvgUnit::percent == getY().getUnit() ? getY().getNumber() * 0.01 : getY().getNumber());
+                        const double fW(SvgUnit::percent == getWidth().getUnit() ? getWidth().getNumber() * 0.01 : getWidth().getNumber());
+                        const double fH(SvgUnit::percent == getHeight().getUnit() ? getHeight().getNumber() * 0.01 : getHeight().getNumber());
+
+                        aOffscreenBufferRange = basegfx::B2DRange(
+                            aContentRange.getMinX() + (fX * fContentWidth),
+                            aContentRange.getMinY() + (fY * fContentHeight),
+                            aContentRange.getMinX() + ((fX + fW) * fContentWidth),
+                            aContentRange.getMinY() + ((fY + fH) * fContentHeight));
+                    }
+                    else
+                    {
+                        const double fX(getX().isSet() ? getX().solve(*this, NumberType::xcoordinate) : 0.0);
+                        const double fY(getY().isSet() ? getY().solve(*this, NumberType::ycoordinate) : 0.0);
+
+                        aOffscreenBufferRange = basegfx::B2DRange(
+                            fX,
+                            fY,
+                            fX + (getWidth().isSet() ? getWidth().solve(*this, NumberType::xcoordinate) : 0.0),
+                            fY + (getHeight().isSet() ? getHeight().solve(*this, NumberType::ycoordinate) : 0.0));
+                    }
+
+                    if (SvgUnits::objectBoundingBox == maMaskContentUnits)
+                    {
+                        // mask is object-relative, embed in content transformation
+                        drawinglayer::primitive2d::Primitive2DReference xTransform(
+                            new drawinglayer::primitive2d::TransformPrimitive2D(
+                                basegfx::utils::createScaleTranslateB2DHomMatrix(
+                                    aContentRange.getRange(),
+                                    aContentRange.getMinimum()),
+                                std::move(aMaskTarget)));
+
+                        aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
+                    }
+                    else // userSpaceOnUse
+                    {
+                        // #i124852#
+                        if(pTransform)
+                        {
+                            drawinglayer::primitive2d::Primitive2DReference xTransform(
+                                new drawinglayer::primitive2d::TransformPrimitive2D(
+                                    *pTransform,
+                                    std::move(aMaskTarget)));
+
+                            aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
+                        }
+                    }
+
+                    // embed content to a ModifiedColorPrimitive2D since the definitions
+                    // how content is used as alpha is special for Svg
+                    {
+                        drawinglayer::primitive2d::Primitive2DReference xInverseMask(
+                            new drawinglayer::primitive2d::ModifiedColorPrimitive2D(
+                                std::move(aMaskTarget),
+                                std::make_shared<basegfx::BColorModifier_luminance_to_alpha>()));
+
+                        aMaskTarget = drawinglayer::primitive2d::Primitive2DContainer { xInverseMask };
+                    }
+
+                    // prepare new content
+                    drawinglayer::primitive2d::Primitive2DReference xNewContent(
+                        new drawinglayer::primitive2d::TransparencePrimitive2D(
+                            std::move(rTarget),
+                            std::move(aMaskTarget)));
+
+                    // output up to now is defined by aContentRange and mask is oriented
+                    // relative to it. It is possible that aOffscreenBufferRange defines
+                    // a smaller area. In that case, embed to a mask primitive
+                    if(!aOffscreenBufferRange.isInside(aContentRange))
+                    {
+                        xNewContent = new drawinglayer::primitive2d::MaskPrimitive2D(
+                            basegfx::B2DPolyPolygon(
+                                basegfx::utils::createPolygonFromRect(
+                                    aOffscreenBufferRange)),
+                            drawinglayer::primitive2d::Primitive2DContainer { xNewContent });
+                    }
+
+                    // redefine target. Use TransparencePrimitive2D with created mask
+                    // geometry
+                    rTarget = drawinglayer::primitive2d::Primitive2DContainer { xNewContent };
+                }
+                else
+                {
+                    // content is geometrically empty
+                    rTarget.clear();
+                }
+            }
+            else
+            {
+                // An empty clipping path will completely clip away the element that had
+                // the clip-path property applied. (Svg spec)
+                rTarget.clear();
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgnode.cxx b/svgio/source/svgreader/svgnode.cxx
new file mode 100644
index 0000000000..0ae4e80363
--- /dev/null
+++ b/svgio/source/svgreader/svgnode.cxx
@@ -0,0 +1,778 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgdocument.hxx>
+#include <svgnode.hxx>
+#include <svgstyleattributes.hxx>
+#include <drawinglayer/primitive2d/objectinfoprimitive2d.hxx>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+#include <tools/urlobj.hxx>
+
+
+namespace svgio::svgreader
+{
+        /// #i125258#
+        bool SvgNode::supportsParentStyle() const
+        {
+            return true;
+        }
+
+        const SvgStyleAttributes* SvgNode::getSvgStyleAttributes() const
+        {
+            return nullptr;
+        }
+
+        void SvgNode::addCssStyle(const SvgDocument& rDocument, const OUString& aConcatenated)
+        {
+            const SvgStyleAttributes* pNew = rDocument.findGlobalCssStyleAttributes(aConcatenated);
+
+            if(pNew)
+            {
+                // add CssStyle if found
+                maCssStyleVector.push_back(pNew);
+            }
+        }
+
+namespace {
+        std::vector< OUString > parseClass(const SvgNode& rNode)
+        {
+            std::vector< OUString > aParts;
+
+            // check for 'class' references (a list of entries is allowed)
+            if(rNode.getClass())
+            {
+                const OUString& rClassList = *rNode.getClass();
+                const sal_Int32 nLen(rClassList.getLength());
+
+                if(nLen)
+                {
+                    sal_Int32 nPos(0);
+                    OUStringBuffer aToken;
+
+                    while(nPos < nLen)
+                    {
+                        const sal_Int32 nInitPos(nPos);
+                        copyToLimiter(rClassList, u' ', nPos, aToken, nLen);
+                        skip_char(rClassList, u' ', nPos, nLen);
+                        const OUString aPart(o3tl::trim(aToken));
+                        aToken.setLength(0);
+
+                        if(aPart.getLength())
+                        {
+                            aParts.push_back(aPart);
+                        }
+
+                        if(nInitPos == nPos)
+                        {
+                            OSL_ENSURE(false, "Could not interpret on current position (!)");
+                            nPos++;
+                        }
+                    }
+                }
+            }
+
+            return aParts;
+        }
+} //namespace
+
+        void SvgNode::fillCssStyleVectorUsingHierarchyAndSelectors(
+            const SvgNode& rCurrent,
+            std::u16string_view aConcatenated)
+        {
+            const SvgDocument& rDocument = getDocument();
+
+            if(!rDocument.hasGlobalCssStyleAttributes())
+                return;
+
+            const SvgNode* pParent = rCurrent.getParent();
+            OUString sCurrentType(SVGTokenToStr(rCurrent.getType()));
+
+            // check for ID (highest priority)
+            if(rCurrent.getId())
+            {
+                const OUString& rId = *rCurrent.getId();
+
+                if(rId.getLength())
+                {
+                    const OUString aNewConcatenated("#" + rId + aConcatenated);
+                    addCssStyle(rDocument, aNewConcatenated);
+
+                    if(!sCurrentType.isEmpty())
+                        addCssStyle(rDocument, sCurrentType + aNewConcatenated);
+
+                    if(pParent)
+                    {
+                        // check for combined selectors at parent first so that higher specificity will be in front
+                        fillCssStyleVectorUsingHierarchyAndSelectors(*pParent, aNewConcatenated);
+                    }
+                }
+            }
+
+            std::vector <OUString> aClasses = parseClass(rCurrent);
+            for(const auto &aClass : aClasses)
+            {
+                const OUString aNewConcatenated("." + aClass + aConcatenated);
+                addCssStyle(rDocument, aNewConcatenated);
+
+                if(!sCurrentType.isEmpty())
+                    addCssStyle(rDocument, sCurrentType + aNewConcatenated);
+
+                if(pParent)
+                {
+                    // check for combined selectors at parent first so that higher specificity will be in front
+                    fillCssStyleVectorUsingHierarchyAndSelectors(*pParent, aNewConcatenated);
+                }
+            }
+
+            if(!sCurrentType.isEmpty())
+            {
+                const OUString aNewConcatenated(sCurrentType + aConcatenated);
+                addCssStyle(rDocument, aNewConcatenated);
+            }
+
+            OUString sType(SVGTokenToStr(getType()));
+
+            // check for class-dependent references to CssStyles
+            if(sType.isEmpty())
+                return;
+
+            if(pParent)
+            {
+                // check for combined selectors at parent first so that higher specificity will be in front
+                fillCssStyleVectorUsingHierarchyAndSelectors(*pParent, sType);
+            }
+        }
+
+        void SvgNode::fillCssStyleVectorUsingParent(const SvgNode& rCurrent)
+        {
+            const SvgDocument& rDocument = getDocument();
+
+            if(!rDocument.hasGlobalCssStyleAttributes())
+                return;
+
+            const SvgNode* pParent = rCurrent.getParent();
+
+            if (!pParent)
+                return;
+
+            OUString sParentId;
+            if (pParent->getId().has_value())
+            {
+                sParentId = pParent->getId().value();
+            }
+            std::vector <OUString> aParentClasses = parseClass(*pParent);
+            OUString sParentType(SVGTokenToStr(pParent->getType()));
+
+            if(rCurrent.getId())
+            {
+                const OUString& rId = *rCurrent.getId();
+
+                if(!rId.isEmpty())
+                {
+                    if (!sParentId.isEmpty())
+                    {
+                        const OUString aConcatenated("#" + sParentId + ">#" + rId);
+                        addCssStyle(rDocument, aConcatenated);
+                    }
+
+                    for(const auto &aParentClass : aParentClasses)
+                    {
+                        const OUString aConcatenated("." + aParentClass + ">#" + rId);
+                        addCssStyle(rDocument, aConcatenated);
+                    }
+
+                    if (!sParentType.isEmpty())
+                    {
+                        const OUString aConcatenated(sParentType + ">#" + rId);
+                        addCssStyle(rDocument, aConcatenated);
+                    }
+                }
+
+            }
+
+            std::vector <OUString> aClasses = parseClass(rCurrent);
+            for(const auto &aClass : aClasses)
+            {
+
+                if (!sParentId.isEmpty())
+                {
+                    const OUString aConcatenated("#" + sParentId + ">." + aClass);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+
+                for(const auto &aParentClass : aParentClasses)
+                {
+                    const OUString aConcatenated("." + aParentClass + ">." + aClass);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+
+                if (!sParentType.isEmpty())
+                {
+                    const OUString aConcatenated(sParentType + ">." + aClass);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+            }
+
+            OUString sCurrentType(SVGTokenToStr(getType()));
+
+            if(!sCurrentType.isEmpty())
+            {
+                if (!sParentId.isEmpty())
+                {
+                    const OUString aConcatenated("#" + sParentId + ">" + sCurrentType);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+
+                for(const auto &aParentClass : aParentClasses)
+                {
+                    const OUString aConcatenated("." + aParentClass + ">" + sCurrentType);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+
+                if (!sParentType.isEmpty())
+                {
+                    const OUString aConcatenated(sParentType + ">" + sCurrentType);
+                    addCssStyle(rDocument, aConcatenated);
+                }
+            }
+        }
+
+        void SvgNode::fillCssStyleVector(const SvgStyleAttributes& rOriginal)
+        {
+            OSL_ENSURE(!mbCssStyleVectorBuilt, "OOps, fillCssStyleVector called double ?!?");
+            mbCssStyleVectorBuilt = true;
+
+            // #i125293# If we have CssStyles we need to build a linked list of SvgStyleAttributes
+            // which represent this for the current object. There are various methods to
+            // specify CssStyles which need to be taken into account in a given order:
+            // - local CssStyle (independent from global CssStyles at SvgDocument)
+            // - 'id' CssStyle
+            // - 'class' CssStyle(s)
+            // - type-dependent elements (e..g. 'rect' for all rect elements)
+            // - Css selector '*'
+            // - local attributes (rOriginal)
+            // - inherited attributes (up the hierarchy)
+            // The first four will be collected in maCssStyleVector for the current element
+            // (once, this will not change) and be linked in the needed order using the
+            // get/setCssStyleParent at the SvgStyleAttributes which will be used preferred in
+            // member evaluation over the existing parent hierarchy
+
+            // check for local CssStyle with highest priority
+            if(mpLocalCssStyle)
+            {
+                // if we have one, use as first entry
+                maCssStyleVector.push_back(mpLocalCssStyle.get());
+            }
+
+            // tdf#156038 check for child combinator
+            fillCssStyleVectorUsingParent(*this);
+
+            // check the hierarchy for concatenated patterns of Selectors
+            fillCssStyleVectorUsingHierarchyAndSelectors(*this, std::u16string_view());
+
+
+            // tdf#99115, Add css selector '*' style only if the element is on top of the hierarchy
+            // meaning its parent is <svg>
+            const SvgNode* pParent = this->getParent();
+
+            if(pParent && pParent->getType() == SVGToken::Svg)
+            {
+                // #i125329# find Css selector '*', add as last element if found
+                const SvgStyleAttributes* pNew = getDocument().findGlobalCssStyleAttributes("*");
+
+                if(pNew)
+                {
+                    // add CssStyle for selector '*' if found
+                    maCssStyleVector.push_back(pNew);
+                }
+            }
+
+            //local attributes
+            maCssStyleVector.push_back(&rOriginal);
+        }
+
+        const SvgStyleAttributes* SvgNode::checkForCssStyle(const SvgStyleAttributes& rOriginal) const
+        {
+            if(!mbCssStyleVectorBuilt)
+            {
+                // build needed CssStyleVector for local node
+                const_cast< SvgNode* >(this)->fillCssStyleVector(rOriginal);
+            }
+
+            if(maCssStyleVector.empty())
+            {
+                // return given original if no CssStyles found
+                return &rOriginal;
+            }
+            else
+            {
+                // #i125293# rOriginal will be the last element in the linked list; use no CssStyleParent
+                // there (reset it) to ensure that the parent hierarchy will be used when it's base
+                // is referenced. This new chaining inserts the CssStyles before the original style,
+                // this makes the whole process much safer since the original style when used will
+                // be not different to the situation without CssStyles; thus loops which may be caused
+                // by trying to use the parent hierarchy of the owner of the style will be avoided
+                // already in this mechanism. It's still good to keep the supportsParentStyle
+                // from #i125258# in place, though.
+                // This chain building using pointers will be done every time when checkForCssStyle
+                // is used (not the search, only the chaining). This is needed since the CssStyles
+                // themselves will be potentially used multiple times. It is not expensive since it's
+                // only changing some pointers.
+                // The alternative would be to create the style hierarchy for every element (or even
+                // for the element containing the hierarchy) in a vector of pointers and to use that.
+                // Resetting the CssStyleParent on rOriginal is probably not needed
+                // but simply safer to do.
+
+                // loop over the existing CssStyles and link them. There is a first one, take
+                // as current
+                SvgStyleAttributes* pCurrent = const_cast< SvgStyleAttributes* >(maCssStyleVector[0]);
+
+                for(size_t a(1); a < maCssStyleVector.size(); a++)
+                {
+                    SvgStyleAttributes* pNext = const_cast< SvgStyleAttributes* >(maCssStyleVector[a]);
+
+                    pCurrent->setCssStyleParent(pNext);
+                    pCurrent = pNext;
+                }
+
+                // return 1st CssStyle as style chain start element (only for the
+                // local element, still no hierarchy used here)
+                return maCssStyleVector[0];
+            }
+        }
+
+        SvgNode::SvgNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   maType(aType),
+            mrDocument(rDocument),
+            mpParent(pParent),
+            mpAlternativeParent(nullptr),
+            maXmlSpace(XmlSpace::NotSet),
+            maDisplay(Display::Inline),
+            mbDecomposing(false),
+            mbCssStyleVectorBuilt(false)
+        {
+            if (pParent)
+            {
+                // tdf#150124 ignore when parent is unknown
+                if (pParent->getType() != SVGToken::Unknown)
+                    pParent->maChildren.emplace_back(this);
+                else
+                    mrDocument.addOrphanNode(this);
+            }
+        }
+
+        SvgNode::~SvgNode()
+        {
+        }
+
+        void SvgNode::readLocalCssStyle(std::u16string_view aContent)
+        {
+            if(!mpLocalCssStyle)
+            {
+                // create LocalCssStyle if needed but not yet added
+                mpLocalCssStyle.reset(new SvgStyleAttributes(*this));
+            }
+            else
+            {
+                // 2nd fill would be an error
+                OSL_ENSURE(false, "Svg node has two local CssStyles, this may lead to problems (!)");
+            }
+
+            if(mpLocalCssStyle)
+            {
+                // parse and set values to it
+                mpLocalCssStyle->readCssStyle(aContent);
+            }
+            else
+            {
+                OSL_ENSURE(false, "Could not get/create a local CssStyle for a node (!)");
+            }
+        }
+
+        void SvgNode::parseAttributes(const css::uno::Reference< css::xml::sax::XAttributeList >& xAttribs)
+        {
+            // no longer need to pre-sort moving 'style' entries to the back so that
+            // values get overwritten - that was the previous, not complete solution for
+            // handling the priorities between svg and Css properties
+            const sal_uInt32 nAttributes(xAttribs->getLength());
+
+            for(sal_uInt32 a(0); a < nAttributes; a++)
+            {
+                const OUString aTokenName(xAttribs->getNameByIndex(a));
+                const SVGToken aSVGToken(StrToSVGToken(aTokenName, false));
+
+                parseAttribute(aSVGToken, xAttribs->getValueByIndex(a));
+            }
+        }
+
+        Display getDisplayFromContent(std::u16string_view aContent)
+        {
+            if(!aContent.empty())
+            {
+                if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inline"))
+                {
+                    return Display::Inline;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
+                {
+                    return Display::None;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inherit"))
+                {
+                    return Display::Inherit;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"block"))
+                {
+                    return Display::Block;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"list-item"))
+                {
+                    return Display::ListItem;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"run-in"))
+                {
+                    return Display::RunIn;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"compact"))
+                {
+                    return Display::Compact;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"marker"))
+                {
+                    return Display::Marker;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table"))
+                {
+                    return Display::Table;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inline-table"))
+                {
+                    return Display::InlineTable;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-row-group"))
+                {
+                    return Display::TableRowGroup;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-header-group"))
+                {
+                    return Display::TableHeaderGroup;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-footer-group"))
+                {
+                    return Display::TableFooterGroup;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-row"))
+                {
+                    return Display::TableRow;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-column-group"))
+                {
+                    return Display::TableColumnGroup;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-column"))
+                {
+                    return Display::TableColumn;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-cell"))
+                {
+                    return Display::TableCell;
+                }
+                else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"table-caption"))
+                {
+                    return Display::TableCaption;
+                }
+            }
+
+            // return the default
+            return Display::Inline;
+        }
+
+        void SvgNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            switch(aSVGToken)
+            {
+                case SVGToken::Id:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        setId(aContent);
+                    }
+                    break;
+                }
+                case SVGToken::Class:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        setClass(aContent);
+                    }
+                    break;
+                }
+                case SVGToken::XmlSpace:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"default"))
+                        {
+                            setXmlSpace(XmlSpace::Default);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"preserve"))
+                        {
+                            setXmlSpace(XmlSpace::Preserve);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Display:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        setDisplay(getDisplayFromContent(aContent));
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            if (mbDecomposing) //guard against infinite recurse
+                return;
+
+            if(Display::None == getDisplay())
+            {
+                return;
+            }
+
+            if(!bReferenced)
+            {
+                if(SVGToken::Defs == getType() ||
+                    SVGToken::Symbol == getType() ||
+                    SVGToken::ClipPathNode == getType() ||
+                    SVGToken::Mask == getType() ||
+                    SVGToken::Marker == getType() ||
+                    SVGToken::Pattern == getType())
+                {
+                    // do not decompose defs or symbol nodes (these hold only style-like
+                    // objects which may be used by referencing them) except when doing
+                    // so controlled referenced
+
+                    // also do not decompose ClipPaths and Masks. These should be embedded
+                    // in a defs node (which gets not decomposed by itself), but you never
+                    // know
+
+                    // also not directly used are Markers and Patterns, only indirectly used
+                    // by reference
+
+                    // #i121656# also do not decompose nodes which have display="none" set
+                    // as property
+                    return;
+                }
+            }
+
+            const auto& rChildren = getChildren();
+
+            if(rChildren.empty())
+                return;
+
+            mbDecomposing = true;
+
+            const sal_uInt32 nCount(rChildren.size());
+
+            for(sal_uInt32 a(0); a < nCount; a++)
+            {
+                SvgNode* pCandidate = rChildren[a].get();
+
+                if(pCandidate && Display::None != pCandidate->getDisplay())
+                {
+                    const auto& rGrandChildren = pCandidate->getChildren();
+                    const SvgStyleAttributes* pChildStyles = pCandidate->getSvgStyleAttributes();
+                    // decompose:
+                    // - visible terminal nodes
+                    // - all non-terminal nodes (might contain visible nodes down the hierarchy)
+                    if( !rGrandChildren.empty() || ( pChildStyles && (Visibility::visible == pChildStyles->getVisibility())) )
+                    {
+                        drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+                        pCandidate->decomposeSvgNode(aNewTarget, bReferenced);
+
+                        if(!aNewTarget.empty())
+                        {
+                            rTarget.append(aNewTarget);
+                        }
+                    }
+                }
+                else if(!pCandidate)
+                {
+                    OSL_ENSURE(false, "Null-Pointer in child node list (!)");
+                }
+            }
+
+            if(!rTarget.empty())
+            {
+                const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
+                if(pStyles)
+                {
+                    // check if we have Title or Desc
+                    const OUString& rTitle = pStyles->getTitle();
+                    const OUString& rDesc = pStyles->getDesc();
+
+                    if(!rTitle.isEmpty() || !rDesc.isEmpty())
+                    {
+                        // default object name is empty
+                        OUString aObjectName;
+
+                        // use path as object name when outmost element
+                        if (SVGToken::Svg == getType())
+                        {
+                            aObjectName = getDocument().getAbsolutePath();
+
+                            if(!aObjectName.isEmpty())
+                            {
+                                INetURLObject aURL(aObjectName);
+
+                                aObjectName = aURL.getName(
+                                    INetURLObject::LAST_SEGMENT,
+                                    true,
+                                    INetURLObject::DecodeMechanism::WithCharset);
+                            }
+                        }
+
+                        // pack in ObjectInfoPrimitive2D group
+                        drawinglayer::primitive2d::Primitive2DReference xRef(
+                            new drawinglayer::primitive2d::ObjectInfoPrimitive2D(
+                                std::move(rTarget),
+                                aObjectName,
+                                rTitle,
+                                rDesc));
+
+                        rTarget = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+                    }
+                }
+            }
+            mbDecomposing = false;
+        }
+
+        basegfx::B2DRange SvgNode::getCurrentViewPort() const
+        {
+            if(getParent())
+            {
+                return getParent()->getCurrentViewPort();
+            }
+            else
+            {
+                return basegfx::B2DRange(); // return empty B2DRange
+            }
+        }
+
+        double SvgNode::getCurrentFontSizeInherited() const
+        {
+            if(getParent())
+            {
+                return getParent()->getCurrentFontSize();
+            }
+            else
+            {
+                return 0.0;
+            }
+        }
+
+        double SvgNode::getCurrentFontSize() const
+        {
+            if(getSvgStyleAttributes())
+                return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::xcoordinate);
+
+            return getCurrentFontSizeInherited();
+        }
+
+        double SvgNode::getCurrentXHeightInherited() const
+        {
+            if(getParent())
+            {
+                return getParent()->getCurrentXHeight();
+            }
+            else
+            {
+                return 0.0;
+            }
+        }
+
+        double SvgNode::getCurrentXHeight() const
+        {
+            if(getSvgStyleAttributes())
+                // for XHeight, use FontSize currently
+                return getSvgStyleAttributes()->getFontSizeNumber().solve(*this, NumberType::ycoordinate);
+
+            return getCurrentXHeightInherited();
+        }
+
+        void SvgNode::setId(OUString const & rId)
+        {
+            if(mpId)
+            {
+                mrDocument.removeSvgNodeFromMapper(*mpId);
+                mpId.reset();
+            }
+
+            mpId = rId;
+            mrDocument.addSvgNodeToMapper(*mpId, *this);
+        }
+
+        void SvgNode::setClass(OUString const & rClass)
+        {
+            if(mpClass)
+            {
+                mrDocument.removeSvgNodeFromMapper(*mpClass);
+                mpClass.reset();
+            }
+
+            mpClass = rClass;
+            mrDocument.addSvgNodeToMapper(*mpClass, *this);
+        }
+
+        XmlSpace SvgNode::getXmlSpace() const
+        {
+            if(maXmlSpace != XmlSpace::NotSet)
+            {
+                return maXmlSpace;
+            }
+
+            if(getParent())
+            {
+                return getParent()->getXmlSpace();
+            }
+
+            // default is XmlSpace::Default
+            return XmlSpace::Default;
+        }
+
+        void SvgNode::accept(Visitor & rVisitor)
+        {
+            rVisitor.visit(*this);
+        }
+} // end of namespace svgio
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgpaint.cxx b/svgio/source/svgreader/svgpaint.cxx
new file mode 100644
index 0000000000..725dd9174a
--- /dev/null
+++ b/svgio/source/svgreader/svgpaint.cxx
@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgpaint.hxx>
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgpathnode.cxx b/svgio/source/svgreader/svgpathnode.cxx
new file mode 100644
index 0000000000..307d5c9f03
--- /dev/null
+++ b/svgio/source/svgreader/svgpathnode.cxx
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgpathnode.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+
+namespace svgio::svgreader
+{
+        SvgPathNode::SvgPathNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Path, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgPathNode::~SvgPathNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgPathNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgPathNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::D:
+                {
+                    basegfx::B2DPolyPolygon aPath;
+
+                    if(basegfx::utils::importFromSvgD(aPath, aContent, false, &maHelpPointIndices))
+                    {
+                        if(aPath.count())
+                        {
+                            setPath(aPath);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::PathLength:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maPathLength = aNum;
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgPathNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            // fill and/or stroke needed, also a path
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(pStyle && getPath())
+            {
+                drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                pStyle->add_path(*getPath(), aNewTarget, &maHelpPointIndices);
+
+                if(!aNewTarget.empty())
+                {
+                    pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+                }
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgpatternnode.cxx b/svgio/source/svgreader/svgpatternnode.cxx
new file mode 100644
index 0000000000..4c180558d5
--- /dev/null
+++ b/svgio/source/svgreader/svgpatternnode.cxx
@@ -0,0 +1,465 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgpatternnode.hxx>
+#include <svgdocument.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        void SvgPatternNode::tryToFindLink()
+        {
+            if(!mpXLink && !maXLink.isEmpty())
+            {
+                mpXLink = dynamic_cast< const SvgPatternNode* >(getDocument().findSvgNodeById(maXLink));
+            }
+        }
+
+        SvgPatternNode::SvgPatternNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Pattern, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            mbResolvingLink(false),
+            mpXLink(nullptr)
+        {
+        }
+
+        SvgPatternNode::~SvgPatternNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgPatternNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgPatternNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::ViewBox:
+                {
+                    const basegfx::B2DRange aRange(readViewBox(aContent, *this));
+
+                    if(!aRange.isEmpty())
+                    {
+                        setViewBox(&aRange);
+                    }
+                    break;
+                }
+                case SVGToken::PreserveAspectRatio:
+                {
+                    maSvgAspectRatio = readSvgAspectRatio(aContent);
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::PatternUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setPatternUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setPatternUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::PatternContentUnits:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrUserSpaceOnUse))
+                        {
+                            setPatternContentUnits(SvgUnits::userSpaceOnUse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrObjectBoundingBox))
+                        {
+                            setPatternContentUnits(SvgUnits::objectBoundingBox);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::PatternTransform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setPatternTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    readLocalLink(aContent, maXLink);
+                    tryToFindLink();
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgPatternNode::getValuesRelative(double& rfX, double& rfY, double& rfW, double& rfH, const basegfx::B2DRange& rGeoRange, SvgNode const & rUser) const
+        {
+            double fTargetWidth(rGeoRange.getWidth());
+            double fTargetHeight(rGeoRange.getHeight());
+
+            if(fTargetWidth <= 0.0 || fTargetHeight <= 0.0)
+                return;
+
+            const SvgUnits aPatternUnits(getPatternUnits() ? *getPatternUnits() : SvgUnits::objectBoundingBox);
+
+            if (SvgUnits::objectBoundingBox == aPatternUnits)
+            {
+                rfW = (getWidth().isSet()) ? getWidth().getNumber() : 0.0;
+                rfH = (getHeight().isSet()) ? getHeight().getNumber() : 0.0;
+
+                if(SvgUnit::percent == getWidth().getUnit())
+                {
+                    rfW *= 0.01;
+                }
+
+                if(SvgUnit::percent == getHeight().getUnit())
+                {
+                    rfH *= 0.01;
+                }
+            }
+            else
+            {
+                rfW = (getWidth().isSet()) ? getWidth().solve(rUser, NumberType::xcoordinate) : 0.0;
+                rfH = (getHeight().isSet()) ? getHeight().solve(rUser, NumberType::ycoordinate) : 0.0;
+
+                // make relative to rGeoRange
+                rfW /= fTargetWidth;
+                rfH /= fTargetHeight;
+            }
+
+            if(rfW <= 0.0 || rfH <= 0.0)
+                return;
+
+            if (SvgUnits::objectBoundingBox == aPatternUnits)
+            {
+                rfX = (getX().isSet()) ? getX().getNumber() : 0.0;
+                rfY = (getY().isSet()) ? getY().getNumber() : 0.0;
+
+                if(SvgUnit::percent == getX().getUnit())
+                {
+                    rfX *= 0.01;
+                }
+
+                if(SvgUnit::percent == getY().getUnit())
+                {
+                    rfY *= 0.01;
+                }
+            }
+            else
+            {
+                rfX = (getX().isSet()) ? getX().solve(rUser, NumberType::xcoordinate) : 0.0;
+                rfY = (getY().isSet()) ? getY().solve(rUser, NumberType::ycoordinate) : 0.0;
+
+                // make relative to rGeoRange
+                rfX = (rfX - rGeoRange.getMinX()) / fTargetWidth;
+                rfY = (rfY - rGeoRange.getMinY()) / fTargetHeight;
+            }
+        }
+
+        const drawinglayer::primitive2d::Primitive2DContainer& SvgPatternNode::getPatternPrimitives() const
+        {
+            if(aPrimitives.empty() && Display::None != getDisplay())
+            {
+                decomposeSvgNode(const_cast< SvgPatternNode* >(this)->aPrimitives, true);
+            }
+
+            if(aPrimitives.empty() && !maXLink.isEmpty())
+            {
+                const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+                if (mpXLink && !mbResolvingLink)
+                {
+                    mbResolvingLink = true;
+                    const drawinglayer::primitive2d::Primitive2DContainer& ret = mpXLink->getPatternPrimitives();
+                    mbResolvingLink = false;
+                    return ret;
+                }
+            }
+
+            return aPrimitives;
+        }
+
+        basegfx::B2DRange SvgPatternNode::getCurrentViewPort() const
+        {
+            if(getViewBox())
+            {
+                return *(getViewBox());
+            }
+            else
+            {
+                return SvgNode::getCurrentViewPort();
+            }
+        }
+
+        const basegfx::B2DRange* SvgPatternNode::getViewBox() const
+        {
+            if(mpViewBox)
+            {
+                return mpViewBox.get();
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getViewBox();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return nullptr;
+        }
+
+        const SvgAspectRatio& SvgPatternNode::getSvgAspectRatio() const
+        {
+            if(maSvgAspectRatio.isSet())
+            {
+                return maSvgAspectRatio;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                const SvgAspectRatio& ret = mpXLink->getSvgAspectRatio();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return maSvgAspectRatio;
+        }
+
+        const SvgNumber& SvgPatternNode::getX() const
+        {
+            if(maX.isSet())
+            {
+                return maX;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                const SvgNumber& ret = mpXLink->getX();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return maX;
+        }
+
+        const SvgNumber& SvgPatternNode::getY() const
+        {
+            if(maY.isSet())
+            {
+                return maY;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                const SvgNumber& ret = mpXLink->getY();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return maY;
+        }
+
+        const SvgNumber& SvgPatternNode::getWidth() const
+        {
+            if(maWidth.isSet())
+            {
+                return maWidth;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                const SvgNumber& ret = mpXLink->getWidth();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return maWidth;
+        }
+
+        const SvgNumber& SvgPatternNode::getHeight() const
+        {
+            if(maHeight.isSet())
+            {
+                return maHeight;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                const SvgNumber& ret = mpXLink->getHeight();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return maHeight;
+        }
+
+        const SvgUnits* SvgPatternNode::getPatternUnits() const
+        {
+            if(moPatternUnits)
+            {
+                return &*moPatternUnits;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getPatternUnits();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return nullptr;
+        }
+
+        const SvgUnits* SvgPatternNode::getPatternContentUnits() const
+        {
+            if(moPatternContentUnits)
+            {
+                return &*moPatternContentUnits;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getPatternContentUnits();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return nullptr;
+        }
+
+        std::optional<basegfx::B2DHomMatrix> SvgPatternNode::getPatternTransform() const
+        {
+            if(mpaPatternTransform)
+            {
+                return mpaPatternTransform;
+            }
+
+            const_cast< SvgPatternNode* >(this)->tryToFindLink();
+
+            if (mpXLink && !mbResolvingLink)
+            {
+                mbResolvingLink = true;
+                auto ret = mpXLink->getPatternTransform();
+                mbResolvingLink = false;
+                return ret;
+            }
+
+            return std::nullopt;
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgpolynode.cxx b/svgio/source/svgreader/svgpolynode.cxx
new file mode 100644
index 0000000000..30ab7ed311
--- /dev/null
+++ b/svgio/source/svgreader/svgpolynode.cxx
@@ -0,0 +1,114 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgpolynode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+namespace svgio::svgreader
+{
+        SvgPolyNode::SvgPolyNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(aType, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgPolyNode::~SvgPolyNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgPolyNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgPolyNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Points:
+                {
+                    basegfx::B2DPolygon aPath;
+
+                    if(basegfx::utils::importFromSvgPoints(aPath, aContent))
+                    {
+                        if(aPath.count())
+                        {
+                            if(getType() == SVGToken::Polygon)
+                            {
+                                aPath.setClosed(true);
+                            }
+
+                            setPolygon(aPath);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgPolyNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(pStyle && mpPolygon)
+            {
+                drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                pStyle->add_path(basegfx::B2DPolyPolygon(*mpPolygon), aNewTarget, nullptr);
+
+                if(!aNewTarget.empty())
+                {
+                    pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+                }
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgrectnode.cxx b/svgio/source/svgreader/svgrectnode.cxx
new file mode 100644
index 0000000000..3829f21a67
--- /dev/null
+++ b/svgio/source/svgreader/svgrectnode.cxx
@@ -0,0 +1,210 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgrectnode.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolypolygon.hxx>
+
+namespace svgio::svgreader
+{
+        SvgRectNode::SvgRectNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Rect, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            maX(0),
+            maY(0),
+            maWidth(0),
+            maHeight(0)
+        {
+        }
+
+        SvgRectNode::~SvgRectNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgRectNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgRectNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Rx:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maRx = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Ry:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maRy = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgRectNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            // get size range and create path
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!(pStyle && getWidth().isSet() && getHeight().isSet()))
+                return;
+
+            const double fWidth(getWidth().solve(*this, NumberType::xcoordinate));
+            const double fHeight(getHeight().solve(*this, NumberType::ycoordinate));
+
+            if(fWidth <= 0.0 || fHeight <= 0.0)
+                return;
+
+            const double fX(getX().isSet() ? getX().solve(*this, NumberType::xcoordinate) : 0.0);
+            const double fY(getY().isSet() ? getY().solve(*this, NumberType::ycoordinate) : 0.0);
+            const basegfx::B2DRange aRange(fX, fY, fX + fWidth, fY + fHeight);
+            basegfx::B2DPolygon aPath;
+
+            if(getRx().isSet() || getRy().isSet())
+            {
+                double frX(getRx().isSet() ? getRx().solve(*this, NumberType::xcoordinate) : 0.0);
+                double frY(getRy().isSet() ? getRy().solve(*this, NumberType::ycoordinate) : 0.0);
+
+                if(!getRy().isSet() && 0.0 == frY && frX > 0.0)
+                {
+                    frY = frX;
+                }
+                else if(!getRx().isSet() && 0.0 == frX && frY > 0.0)
+                {
+                    frX = frY;
+                }
+
+                frX /= fWidth;
+                frY /= fHeight;
+
+                frX = std::min(0.5, frX);
+                frY = std::min(0.5, frY);
+
+                aPath = basegfx::utils::createPolygonFromRect(aRange, frX * 2.0, frY * 2.0);
+            }
+            else
+            {
+                aPath = basegfx::utils::createPolygonFromRect(aRange);
+            }
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+            pStyle->add_path(basegfx::B2DPolyPolygon(aPath), aNewTarget, nullptr);
+
+            if(!aNewTarget.empty())
+            {
+                pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+            }
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgstyleattributes.cxx b/svgio/source/svgreader/svgstyleattributes.cxx
new file mode 100644
index 0000000000..869b071dad
--- /dev/null
+++ b/svgio/source/svgreader/svgstyleattributes.cxx
@@ -0,0 +1,3128 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <algorithm>
+
+#include <svgstyleattributes.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
+#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
+#include <svgnode.hxx>
+#include <svgdocument.hxx>
+#include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
+#include <svggradientnode.hxx>
+#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
+#include <basegfx/vector/b2enums.hxx>
+#include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
+#include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
+#include <basegfx/polygon/b2dpolypolygoncutter.hxx>
+#include <svgclippathnode.hxx>
+#include <svgfilternode.hxx>
+#include <svgmasknode.hxx>
+#include <basegfx/polygon/b2dpolypolygontools.hxx>
+#include <svgmarkernode.hxx>
+#include <svgpatternnode.hxx>
+#include <drawinglayer/primitive2d/patternfillprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <drawinglayer/primitive2d/pagehierarchyprimitive2d.hxx>
+#include <o3tl/string_view.hxx>
+#include <o3tl/unit_conversion.hxx>
+
+const int nStyleDepthLimit = 1024;
+
+namespace svgio::svgreader
+{
+        static basegfx::B2DLineJoin StrokeLinejoinToB2DLineJoin(StrokeLinejoin aStrokeLinejoin)
+        {
+            if(StrokeLinejoin::round == aStrokeLinejoin)
+            {
+                return basegfx::B2DLineJoin::Round;
+            }
+            else if(StrokeLinejoin::bevel == aStrokeLinejoin)
+            {
+                return basegfx::B2DLineJoin::Bevel;
+            }
+
+            return basegfx::B2DLineJoin::Miter;
+        }
+
+        static css::drawing::LineCap StrokeLinecapToDrawingLineCap(StrokeLinecap aStrokeLinecap)
+        {
+            switch(aStrokeLinecap)
+            {
+                default: /* StrokeLinecap::notset, StrokeLinecap::butt */
+                {
+                    return css::drawing::LineCap_BUTT;
+                }
+                case StrokeLinecap::round:
+                {
+                    return css::drawing::LineCap_ROUND;
+                }
+                case StrokeLinecap::square:
+                {
+                    return css::drawing::LineCap_SQUARE;
+                }
+            }
+        }
+
+        FontStretch getWider(FontStretch aSource)
+        {
+            switch(aSource)
+            {
+                case FontStretch::ultra_condensed: aSource = FontStretch::extra_condensed; break;
+                case FontStretch::extra_condensed: aSource = FontStretch::condensed; break;
+                case FontStretch::condensed: aSource = FontStretch::semi_condensed; break;
+                case FontStretch::semi_condensed: aSource = FontStretch::normal; break;
+                case FontStretch::normal: aSource = FontStretch::semi_expanded; break;
+                case FontStretch::semi_expanded: aSource = FontStretch::expanded; break;
+                case FontStretch::expanded: aSource = FontStretch::extra_expanded; break;
+                case FontStretch::extra_expanded: aSource = FontStretch::ultra_expanded; break;
+                default: break;
+            }
+
+            return aSource;
+        }
+
+        FontStretch getNarrower(FontStretch aSource)
+        {
+            switch(aSource)
+            {
+                case FontStretch::extra_condensed: aSource = FontStretch::ultra_condensed; break;
+                case FontStretch::condensed: aSource = FontStretch::extra_condensed; break;
+                case FontStretch::semi_condensed: aSource = FontStretch::condensed; break;
+                case FontStretch::normal: aSource = FontStretch::semi_condensed; break;
+                case FontStretch::semi_expanded: aSource = FontStretch::normal; break;
+                case FontStretch::expanded: aSource = FontStretch::semi_expanded; break;
+                case FontStretch::extra_expanded: aSource = FontStretch::expanded; break;
+                case FontStretch::ultra_expanded: aSource = FontStretch::extra_expanded; break;
+                default: break;
+            }
+
+            return aSource;
+        }
+
+        FontWeight getBolder(FontWeight aSource)
+        {
+            switch(aSource)
+            {
+                case FontWeight::N100: aSource = FontWeight::N200; break;
+                case FontWeight::N200: aSource = FontWeight::N300; break;
+                case FontWeight::N300: aSource = FontWeight::N400; break;
+                case FontWeight::N400: aSource = FontWeight::N500; break;
+                case FontWeight::N500: aSource = FontWeight::N600; break;
+                case FontWeight::N600: aSource = FontWeight::N700; break;
+                case FontWeight::N700: aSource = FontWeight::N800; break;
+                case FontWeight::N800: aSource = FontWeight::N900; break;
+                default: break;
+            }
+
+            return aSource;
+        }
+
+        FontWeight getLighter(FontWeight aSource)
+        {
+            switch(aSource)
+            {
+                case FontWeight::N200: aSource = FontWeight::N100; break;
+                case FontWeight::N300: aSource = FontWeight::N200; break;
+                case FontWeight::N400: aSource = FontWeight::N300; break;
+                case FontWeight::N500: aSource = FontWeight::N400; break;
+                case FontWeight::N600: aSource = FontWeight::N500; break;
+                case FontWeight::N700: aSource = FontWeight::N600; break;
+                case FontWeight::N800: aSource = FontWeight::N700; break;
+                case FontWeight::N900: aSource = FontWeight::N800; break;
+                default: break;
+            }
+
+            return aSource;
+        }
+
+        ::FontWeight getVclFontWeight(FontWeight aSource)
+        {
+            ::FontWeight nRetval(WEIGHT_NORMAL);
+
+            switch(aSource)
+            {
+                case FontWeight::N100: nRetval = WEIGHT_ULTRALIGHT; break;
+                case FontWeight::N200: nRetval = WEIGHT_LIGHT; break;
+                case FontWeight::N300: nRetval = WEIGHT_SEMILIGHT; break;
+                case FontWeight::N400: nRetval = WEIGHT_NORMAL; break;
+                case FontWeight::N500: nRetval = WEIGHT_MEDIUM; break;
+                case FontWeight::N600: nRetval = WEIGHT_SEMIBOLD; break;
+                case FontWeight::N700: nRetval = WEIGHT_BOLD; break;
+                case FontWeight::N800: nRetval = WEIGHT_ULTRABOLD; break;
+                case FontWeight::N900: nRetval = WEIGHT_BLACK; break;
+                default: break;
+            }
+
+            return nRetval;
+        }
+
+        void SvgStyleAttributes::readCssStyle(std::u16string_view rCandidate)
+        {
+            const sal_Int32 nLen(rCandidate.size());
+            sal_Int32 nPos(0);
+
+            while(nPos < nLen)
+            {
+                // get TokenName
+                OUStringBuffer aTokenName;
+                skip_char(rCandidate, u' ', nPos, nLen);
+                copyString(rCandidate, nPos, aTokenName, nLen);
+
+                if (aTokenName.isEmpty())
+                {
+                    // if no TokenName advance one by force to avoid death loop, continue
+                    OSL_ENSURE(false, "Could not interpret on current position, advancing one byte (!)");
+                    nPos++;
+                    continue;
+                }
+
+                // get TokenValue
+                OUStringBuffer aTokenValue;
+                skip_char(rCandidate, u' ', u':', nPos, nLen);
+                copyToLimiter(rCandidate, u';', nPos, aTokenValue, nLen);
+                skip_char(rCandidate, u' ', u';', nPos, nLen);
+
+                if (aTokenValue.isEmpty())
+                {
+                    // no value - continue
+                    continue;
+                }
+
+                // generate OUStrings
+                const OUString aOUTokenName(aTokenName.makeStringAndClear());
+                OUString aOUTokenValue(aTokenValue.makeStringAndClear());
+
+                // check for '!important' CssStyle mark, currently not supported
+                // but needs to be extracted for correct parsing
+                OUString aTokenImportant("!important");
+                const sal_Int32 nIndexTokenImportant(aOUTokenValue.indexOf(aTokenImportant));
+
+                if(-1 != nIndexTokenImportant)
+                {
+                    // if there currently just remove it and remove spaces to have the value only
+                    OUString aNewOUTokenValue;
+
+                    if(nIndexTokenImportant > 0)
+                    {
+                        // copy content before token
+                        aNewOUTokenValue += aOUTokenValue.subView(0, nIndexTokenImportant);
+                    }
+
+                    if(aOUTokenValue.getLength() > nIndexTokenImportant + aTokenImportant.getLength())
+                    {
+                        // copy content after token
+                        aNewOUTokenValue += aOUTokenValue.subView(nIndexTokenImportant + aTokenImportant.getLength());
+                    }
+
+                    // remove spaces
+                    aOUTokenValue = aNewOUTokenValue.trim();
+                }
+
+                // valid token-value pair, parse it
+                parseStyleAttribute(StrToSVGToken(aOUTokenName, true), aOUTokenValue);
+            }
+        }
+
+        const SvgStyleAttributes* SvgStyleAttributes::getParentStyle() const
+        {
+            if(getCssStyleParent())
+            {
+                return getCssStyleParent();
+            }
+
+            if(mrOwner.supportsParentStyle() && mrOwner.getParent())
+            {
+                return mrOwner.getParent()->getSvgStyleAttributes();
+            }
+
+            return nullptr;
+        }
+
+        void SvgStyleAttributes::add_text(
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            drawinglayer::primitive2d::Primitive2DContainer&& rSource) const
+        {
+            if(rSource.empty())
+                return;
+
+            // at this point the primitives in rSource are of type TextSimplePortionPrimitive2D
+            // or TextDecoratedPortionPrimitive2D and have the Fill Color (pAttributes->getFill())
+            // set. When another fill is used and also evtl. stroke is set it gets necessary to
+            // dismantle to geometry and add needed primitives
+            const basegfx::BColor* pFill = getFill();
+            const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
+            const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
+            const basegfx::BColor* pStroke = getStroke();
+            const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
+            const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
+            basegfx::B2DPolyPolygon aMergedArea;
+
+            if(pFillGradient || pFillPattern || pStroke || pStrokeGradient || pStrokePattern)
+            {
+                // text geometry is needed, create
+                // use neutral ViewInformation and create LineGeometryExtractor2D
+                const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
+                drawinglayer::processor2d::TextAsPolygonExtractor2D aExtractor(aViewInformation2D);
+
+                // process
+                aExtractor.process(rSource);
+
+                // get results
+                const drawinglayer::processor2d::TextAsPolygonDataNodeVector& rResult = aExtractor.getTarget();
+                const sal_uInt32 nResultCount(rResult.size());
+                basegfx::B2DPolyPolygonVector aTextFillVector;
+                aTextFillVector.reserve(nResultCount);
+
+                for(sal_uInt32 a(0); a < nResultCount; a++)
+                {
+                    const drawinglayer::processor2d::TextAsPolygonDataNode& rCandidate = rResult[a];
+
+                    if(rCandidate.getIsFilled())
+                    {
+                        aTextFillVector.push_back(rCandidate.getB2DPolyPolygon());
+                    }
+                }
+
+                if(!aTextFillVector.empty())
+                {
+                    aMergedArea = basegfx::utils::mergeToSinglePolyPolygon(aTextFillVector);
+                }
+            }
+
+            const bool bStrokeUsed(pStroke || pStrokeGradient || pStrokePattern);
+
+            // add fill. Use geometry even for simple color fill when stroke
+            // is used, else text rendering and the geometry-based stroke will
+            // normally not really match optically due to diverse system text
+            // renderers
+            if(aMergedArea.count() && (pFillGradient || pFillPattern || bStrokeUsed))
+            {
+                // create text fill content based on geometry
+                add_fill(aMergedArea, rTarget, aMergedArea.getB2DRange());
+            }
+            else if(pFill)
+            {
+                // add the already prepared primitives for single color fill
+                rTarget.append(std::move(rSource));
+            }
+
+            // add stroke
+            if(aMergedArea.count() && bStrokeUsed)
+            {
+                // create text stroke content
+                add_stroke(aMergedArea, rTarget, aMergedArea.getB2DRange());
+            }
+        }
+
+        void SvgStyleAttributes::add_fillGradient(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const SvgGradientNode& rFillGradient,
+            const basegfx::B2DRange& rGeoRange) const
+        {
+            // create fill content
+            drawinglayer::primitive2d::SvgGradientEntryVector aSvgGradientEntryVector;
+
+            // get the color stops
+            rFillGradient.collectGradientEntries(aSvgGradientEntryVector);
+
+            if(aSvgGradientEntryVector.empty())
+                return;
+
+            basegfx::B2DHomMatrix aGeoToUnit;
+            basegfx::B2DHomMatrix aGradientTransform;
+
+            if(rFillGradient.getGradientTransform())
+            {
+                aGradientTransform = *rFillGradient.getGradientTransform();
+            }
+
+            if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
+            {
+                aGeoToUnit.translate(-rGeoRange.getMinX(), -rGeoRange.getMinY());
+                aGeoToUnit.scale(1.0 / rGeoRange.getWidth(), 1.0 / rGeoRange.getHeight());
+            }
+
+            if(SVGToken::LinearGradient == rFillGradient.getType())
+            {
+                basegfx::B2DPoint aStart(0.0, 0.0);
+                basegfx::B2DPoint aEnd(1.0, 0.0);
+
+                if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
+                {
+                    // all possible units
+                    aStart.setX(rFillGradient.getX1().solve(mrOwner, NumberType::xcoordinate));
+                    aStart.setY(rFillGradient.getY1().solve(mrOwner, NumberType::ycoordinate));
+                    aEnd.setX(rFillGradient.getX2().solve(mrOwner, NumberType::xcoordinate));
+                    aEnd.setY(rFillGradient.getY2().solve(mrOwner, NumberType::ycoordinate));
+                }
+                else
+                {
+                    // fractions or percent relative to object bounds
+                    const SvgNumber X1(rFillGradient.getX1());
+                    const SvgNumber Y1(rFillGradient.getY1());
+                    const SvgNumber X2(rFillGradient.getX2());
+                    const SvgNumber Y2(rFillGradient.getY2());
+
+                    aStart.setX(SvgUnit::percent == X1.getUnit() ? X1.getNumber() * 0.01 : X1.getNumber());
+                    aStart.setY(SvgUnit::percent == Y1.getUnit() ? Y1.getNumber() * 0.01 : Y1.getNumber());
+                    aEnd.setX(SvgUnit::percent == X2.getUnit() ? X2.getNumber() * 0.01 : X2.getNumber());
+                    aEnd.setY(SvgUnit::percent == Y2.getUnit() ? Y2.getNumber() * 0.01 : Y2.getNumber());
+                }
+
+                if(!aGeoToUnit.isIdentity())
+                {
+                    aStart *= aGeoToUnit;
+                    aEnd *= aGeoToUnit;
+                }
+
+                rTarget.push_back(
+                    new drawinglayer::primitive2d::SvgLinearGradientPrimitive2D(
+                        aGradientTransform,
+                        rPath,
+                        std::move(aSvgGradientEntryVector),
+                        aStart,
+                        aEnd,
+                        SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
+                        rFillGradient.getSpreadMethod()));
+            }
+            else
+            {
+                basegfx::B2DPoint aStart(0.5, 0.5);
+                basegfx::B2DPoint aFocal;
+                double fRadius(0.5);
+                const SvgNumber* pFx = rFillGradient.getFx();
+                const SvgNumber* pFy = rFillGradient.getFy();
+                const bool bFocal(pFx || pFy);
+
+                if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
+                {
+                    // all possible units
+                    aStart.setX(rFillGradient.getCx().solve(mrOwner, NumberType::xcoordinate));
+                    aStart.setY(rFillGradient.getCy().solve(mrOwner, NumberType::ycoordinate));
+                    fRadius = rFillGradient.getR().solve(mrOwner);
+
+                    if(bFocal)
+                    {
+                        aFocal.setX(pFx ? pFx->solve(mrOwner, NumberType::xcoordinate) : aStart.getX());
+                        aFocal.setY(pFy ? pFy->solve(mrOwner, NumberType::ycoordinate) : aStart.getY());
+                    }
+                }
+                else
+                {
+                    // fractions or percent relative to object bounds
+                    const SvgNumber Cx(rFillGradient.getCx());
+                    const SvgNumber Cy(rFillGradient.getCy());
+                    const SvgNumber R(rFillGradient.getR());
+
+                    aStart.setX(SvgUnit::percent == Cx.getUnit() ? Cx.getNumber() * 0.01 : Cx.getNumber());
+                    aStart.setY(SvgUnit::percent == Cy.getUnit() ? Cy.getNumber() * 0.01 : Cy.getNumber());
+                    fRadius = (SvgUnit::percent == R.getUnit()) ? R.getNumber() * 0.01 : R.getNumber();
+
+                    if(bFocal)
+                    {
+                        aFocal.setX(pFx ? (SvgUnit::percent == pFx->getUnit() ? pFx->getNumber() * 0.01 : pFx->getNumber()) : aStart.getX());
+                        aFocal.setY(pFy ? (SvgUnit::percent == pFy->getUnit() ? pFy->getNumber() * 0.01 : pFy->getNumber()) : aStart.getY());
+                    }
+                }
+
+                if(!aGeoToUnit.isIdentity())
+                {
+                    aStart *= aGeoToUnit;
+                    fRadius = (aGeoToUnit * basegfx::B2DVector(fRadius, 0.0)).getLength();
+
+                    if(bFocal)
+                    {
+                        aFocal *= aGeoToUnit;
+                    }
+                }
+
+                rTarget.push_back(
+                    new drawinglayer::primitive2d::SvgRadialGradientPrimitive2D(
+                        aGradientTransform,
+                        rPath,
+                        std::move(aSvgGradientEntryVector),
+                        aStart,
+                        fRadius,
+                        SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
+                        rFillGradient.getSpreadMethod(),
+                        bFocal ? &aFocal : nullptr));
+            }
+        }
+
+        void SvgStyleAttributes::add_fillPatternTransform(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const SvgPatternNode& rFillPattern,
+            const basegfx::B2DRange& rGeoRange) const
+        {
+            // prepare fill polyPolygon with given pattern, check for patternTransform
+            if(rFillPattern.getPatternTransform() && !rFillPattern.getPatternTransform()->isIdentity())
+            {
+                // PatternTransform is active; Handle by filling the inverse transformed
+                // path and back-transforming the result
+                basegfx::B2DPolyPolygon aPath(rPath);
+                basegfx::B2DHomMatrix aInv(*rFillPattern.getPatternTransform());
+                drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                aInv.invert();
+                aPath.transform(aInv);
+                add_fillPattern(aPath, aNewTarget, rFillPattern, aPath.getB2DRange());
+
+                if(!aNewTarget.empty())
+                {
+                    rTarget.push_back(
+                        new drawinglayer::primitive2d::TransformPrimitive2D(
+                            *rFillPattern.getPatternTransform(),
+                            std::move(aNewTarget)));
+                }
+            }
+            else
+            {
+                // no patternTransform, create fillPattern directly
+                add_fillPattern(rPath, rTarget, rFillPattern, rGeoRange);
+            }
+        }
+
+        void SvgStyleAttributes::add_fillPattern(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const SvgPatternNode& rFillPattern,
+            const basegfx::B2DRange& rGeoRange) const
+        {
+            // fill polyPolygon with given pattern
+            const drawinglayer::primitive2d::Primitive2DContainer& rPrimitives = rFillPattern.getPatternPrimitives();
+
+            if(rPrimitives.empty())
+                return;
+
+            double fTargetWidth(rGeoRange.getWidth());
+            double fTargetHeight(rGeoRange.getHeight());
+
+            if(fTargetWidth <= 0.0 || fTargetHeight <= 0.0)
+                return;
+
+            // get relative values from pattern
+            double fX(0.0);
+            double fY(0.0);
+            double fW(0.0);
+            double fH(0.0);
+
+            rFillPattern.getValuesRelative(fX, fY, fW, fH, rGeoRange, mrOwner);
+
+            if(fW <= 0.0 || fH <= 0.0)
+                return;
+
+            // build the reference range relative to the rGeoRange
+            const basegfx::B2DRange aReferenceRange(fX, fY, fX + fW, fY + fH);
+
+            // find out how the content is mapped to the reference range
+            basegfx::B2DHomMatrix aMapPrimitivesToUnitRange;
+            const basegfx::B2DRange* pViewBox = rFillPattern.getViewBox();
+
+            if(pViewBox)
+            {
+                // use viewBox/preserveAspectRatio
+                const SvgAspectRatio& rRatio = rFillPattern.getSvgAspectRatio();
+                const basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
+
+                if(rRatio.isSet())
+                {
+                    // let mapping be created from SvgAspectRatio
+                    aMapPrimitivesToUnitRange = rRatio.createMapping(aUnitRange, *pViewBox);
+                }
+                else
+                {
+                    // choose default mapping
+                    aMapPrimitivesToUnitRange = SvgAspectRatio::createLinearMapping(aUnitRange, *pViewBox);
+                }
+            }
+            else
+            {
+                // use patternContentUnits
+                const SvgUnits aPatternContentUnits(rFillPattern.getPatternContentUnits() ? *rFillPattern.getPatternContentUnits() : SvgUnits::userSpaceOnUse);
+
+                if (SvgUnits::userSpaceOnUse == aPatternContentUnits)
+                {
+                    // create relative mapping to unit coordinates
+                    aMapPrimitivesToUnitRange.scale(1.0 / (fW * fTargetWidth), 1.0 / (fH * fTargetHeight));
+                }
+                else
+                {
+                    aMapPrimitivesToUnitRange.scale(1.0 / fW, 1.0 / fH);
+                }
+            }
+
+            // apply aMapPrimitivesToUnitRange to content when used
+            drawinglayer::primitive2d::Primitive2DContainer aPrimitives(rPrimitives);
+
+            if(!aMapPrimitivesToUnitRange.isIdentity())
+            {
+                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                        aMapPrimitivesToUnitRange,
+                        std::move(aPrimitives)));
+
+                aPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+            }
+
+            // embed in PatternFillPrimitive2D
+            rTarget.push_back(
+                new drawinglayer::primitive2d::PatternFillPrimitive2D(
+                    rPath,
+                    std::move(aPrimitives),
+                    aReferenceRange));
+        }
+
+        void SvgStyleAttributes::add_fill(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const basegfx::B2DRange& rGeoRange) const
+        {
+            const basegfx::BColor* pFill = getFill();
+            const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
+            const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
+
+            if(!(pFill || pFillGradient || pFillPattern))
+                return;
+
+            const double fFillOpacity(getFillOpacity().solve(mrOwner));
+
+            if(!basegfx::fTools::more(fFillOpacity, 0.0))
+                return;
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewFill;
+
+            if(pFillGradient)
+            {
+                // create fill content with SVG gradient primitive
+                add_fillGradient(rPath, aNewFill, *pFillGradient, rGeoRange);
+            }
+            else if(pFillPattern)
+            {
+                // create fill content with SVG pattern primitive
+                add_fillPatternTransform(rPath, aNewFill, *pFillPattern, rGeoRange);
+            }
+            else // if(pFill)
+            {
+                // create fill content
+                aNewFill.resize(1);
+                aNewFill[0] = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                    rPath,
+                    *pFill);
+            }
+
+            if(aNewFill.empty())
+                return;
+
+            if(basegfx::fTools::less(fFillOpacity, 1.0))
+            {
+                // embed in UnifiedTransparencePrimitive2D
+                rTarget.push_back(
+                    new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
+                        std::move(aNewFill),
+                        1.0 - fFillOpacity));
+            }
+            else
+            {
+                // append
+                rTarget.append(aNewFill);
+            }
+        }
+
+        void SvgStyleAttributes::add_stroke(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const basegfx::B2DRange& rGeoRange) const
+        {
+            const basegfx::BColor* pStroke = getStroke();
+            const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
+            const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
+
+            if(!(pStroke || pStrokeGradient || pStrokePattern))
+                return;
+
+            drawinglayer::primitive2d::Primitive2DContainer aNewStroke;
+            const double fStrokeOpacity(getStrokeOpacity().solve(mrOwner));
+
+            if(!basegfx::fTools::more(fStrokeOpacity, 0.0))
+                return;
+
+            // get stroke width; SVG does not use 0.0 == hairline, so 0.0 is no line at all
+            const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
+
+            if(!basegfx::fTools::more(fStrokeWidth, 0.0))
+                return;
+
+            drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
+
+            // if we have a line with two identical points it is not really a line,
+            // but used by SVG sometimes to paint a single dot.In that case, create
+            // the geometry for a single dot
+            if(1 == rPath.count())
+            {
+                const basegfx::B2DPolygon& aSingle(rPath.getB2DPolygon(0));
+
+                if(2 == aSingle.count() && aSingle.getB2DPoint(0).equal(aSingle.getB2DPoint(1)))
+                {
+                    aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
+                        basegfx::B2DPolyPolygon(
+                            basegfx::utils::createPolygonFromCircle(
+                                aSingle.getB2DPoint(0),
+                                fStrokeWidth * (1.44 * 0.5))),
+                        pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0));
+                }
+            }
+
+            if(!aNewLinePrimitive.is())
+            {
+                // get LineJoin, LineCap and stroke array
+                const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
+                const css::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
+                ::std::vector< double > aDashArray;
+
+                if(!getStrokeDasharray().empty())
+                {
+                    aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner);
+                }
+
+                // convert svg:stroke-miterlimit to LineAttrute:mfMiterMinimumAngle
+                // The default needs to be set explicitly, because svg default <> Draw default
+                double fMiterMinimumAngle;
+                if (getStrokeMiterLimit().isSet())
+                {
+                    fMiterMinimumAngle = 2.0 * asin(1.0/getStrokeMiterLimit().getNumber());
+                }
+                else
+                {
+                    fMiterMinimumAngle = 2.0 * asin(0.25); // 1.0/default 4.0
+                }
+
+                // todo: Handle getStrokeDashOffset()
+
+                // prepare line attribute
+                const drawinglayer::attribute::LineAttribute aLineAttribute(
+                    pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
+                    fStrokeWidth,
+                    aB2DLineJoin,
+                    aLineCap,
+                    fMiterMinimumAngle);
+
+                if(aDashArray.empty())
+                {
+                    aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
+                        rPath,
+                        aLineAttribute);
+                }
+                else
+                {
+                    drawinglayer::attribute::StrokeAttribute aStrokeAttribute(std::move(aDashArray));
+
+                    aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
+                        rPath,
+                        aLineAttribute,
+                        std::move(aStrokeAttribute));
+                }
+            }
+
+            if(pStrokeGradient || pStrokePattern)
+            {
+                // put primitive into Primitive2DReference and Primitive2DSequence
+                const drawinglayer::primitive2d::Primitive2DContainer aSeq { aNewLinePrimitive };
+
+                // use neutral ViewInformation and create LineGeometryExtractor2D
+                const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
+                drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
+
+                // process
+                aExtractor.process(aSeq);
+
+                // check for fill rsults
+                const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
+
+                if(!rLineFillVector.empty())
+                {
+                    const basegfx::B2DPolyPolygon aMergedArea(
+                        basegfx::utils::mergeToSinglePolyPolygon(
+                            rLineFillVector));
+
+                    if(aMergedArea.count())
+                    {
+                        if(pStrokeGradient)
+                        {
+                            // create fill content with SVG gradient primitive. Use original GeoRange,
+                            // e.g. from circle without LineWidth
+                            add_fillGradient(aMergedArea, aNewStroke, *pStrokeGradient, rGeoRange);
+                        }
+                        else // if(pStrokePattern)
+                        {
+                            // create fill content with SVG pattern primitive. Use GeoRange
+                            // from the expanded data, e.g. circle with extended geo by half linewidth
+                            add_fillPatternTransform(aMergedArea, aNewStroke, *pStrokePattern, aMergedArea.getB2DRange());
+                        }
+                    }
+                }
+            }
+            else // if(pStroke)
+            {
+                aNewStroke.push_back(aNewLinePrimitive);
+            }
+
+            if(aNewStroke.empty())
+                return;
+
+            if(basegfx::fTools::less(fStrokeOpacity, 1.0))
+            {
+                // embed in UnifiedTransparencePrimitive2D
+                rTarget.push_back(
+                    new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
+                        std::move(aNewStroke),
+                        1.0 - fStrokeOpacity));
+            }
+            else
+            {
+                // append
+                rTarget.append(aNewStroke);
+            }
+        }
+
+        bool SvgStyleAttributes::prepare_singleMarker(
+            drawinglayer::primitive2d::Primitive2DContainer& rMarkerPrimitives,
+            basegfx::B2DHomMatrix& rMarkerTransform,
+            basegfx::B2DRange& rClipRange,
+            const SvgMarkerNode& rMarker) const
+        {
+            // reset return values
+            rMarkerTransform.identity();
+            rClipRange.reset();
+
+            // get marker primitive representation
+            rMarkerPrimitives = rMarker.getMarkerPrimitives();
+
+            if(!rMarkerPrimitives.empty())
+            {
+                basegfx::B2DRange aPrimitiveRange(0.0, 0.0, 1.0, 1.0);
+                const basegfx::B2DRange* pViewBox = rMarker.getViewBox();
+
+                if(pViewBox)
+                {
+                    aPrimitiveRange = *pViewBox;
+                }
+
+                if(aPrimitiveRange.getWidth() > 0.0 && aPrimitiveRange.getHeight() > 0.0)
+                {
+                    double fTargetWidth(rMarker.getMarkerWidth().isSet() ? rMarker.getMarkerWidth().solve(mrOwner, NumberType::xcoordinate) : 3.0);
+                    double fTargetHeight(rMarker.getMarkerHeight().isSet() ? rMarker.getMarkerHeight().solve(mrOwner, NumberType::xcoordinate) : 3.0);
+                    const bool bStrokeWidth(SvgMarkerNode::MarkerUnits::strokeWidth == rMarker.getMarkerUnits());
+                    const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
+
+                    if(bStrokeWidth)
+                    {
+                        // relative to strokeWidth
+                        fTargetWidth *= fStrokeWidth;
+                        fTargetHeight *= fStrokeWidth;
+                    }
+
+                    if(fTargetWidth > 0.0 && fTargetHeight > 0.0)
+                    {
+                        // create mapping
+                        const basegfx::B2DRange aTargetRange(0.0, 0.0, fTargetWidth, fTargetHeight);
+                        const SvgAspectRatio& rRatio = rMarker.getSvgAspectRatio();
+
+                        if(rRatio.isSet())
+                        {
+                            // let mapping be created from SvgAspectRatio
+                            rMarkerTransform = rRatio.createMapping(aTargetRange, aPrimitiveRange);
+
+                            if(rRatio.isMeetOrSlice())
+                            {
+                                // need to clip
+                                rClipRange = aPrimitiveRange;
+                            }
+                        }
+                        else
+                        {
+                            if(!pViewBox)
+                            {
+                                if(bStrokeWidth)
+                                {
+                                    // adapt to strokewidth if needed
+                                    rMarkerTransform.scale(fStrokeWidth, fStrokeWidth);
+                                }
+                            }
+                            else
+                            {
+                                // choose default mapping
+                                rMarkerTransform = SvgAspectRatio::createLinearMapping(aTargetRange, aPrimitiveRange);
+                            }
+                        }
+
+                        // get and apply reference point. Initially it's in marker local coordinate system
+                        basegfx::B2DPoint aRefPoint(
+                            rMarker.getRefX().isSet() ? rMarker.getRefX().solve(mrOwner, NumberType::xcoordinate) : 0.0,
+                            rMarker.getRefY().isSet() ? rMarker.getRefY().solve(mrOwner, NumberType::ycoordinate) : 0.0);
+
+                        // apply MarkerTransform to have it in mapped coordinates
+                        aRefPoint *= rMarkerTransform;
+
+                        // apply by moving RepPoint to (0.0)
+                        rMarkerTransform.translate(-aRefPoint.getX(), -aRefPoint.getY());
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        void SvgStyleAttributes::add_markers(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const basegfx::utils::PointIndexSet* pHelpPointIndices) const
+        {
+            // try to access linked markers
+            const SvgMarkerNode* pStart = accessMarkerStartXLink();
+            const SvgMarkerNode* pMid = accessMarkerMidXLink();
+            const SvgMarkerNode* pEnd = accessMarkerEndXLink();
+
+            if(!(pStart || pMid || pEnd))
+                return;
+
+            const sal_uInt32 nSubPathCount(rPath.count());
+
+            if(!nSubPathCount)
+                return;
+
+            // remember prepared marker; pStart, pMid and pEnd may all be equal when
+            // only 'marker' was used instead of 'marker-start', 'marker-mid' or 'marker-end',
+            // see 'case SVGToken::Marker' in this file; thus in this case only one common
+            // marker in primitive form will be prepared
+            const SvgMarkerNode* pPrepared = nullptr;
+
+            // values for the prepared marker, results of prepare_singleMarker
+            drawinglayer::primitive2d::Primitive2DContainer aPreparedMarkerPrimitives;
+            basegfx::B2DHomMatrix aPreparedMarkerTransform;
+            basegfx::B2DRange aPreparedMarkerClipRange;
+
+            for (sal_uInt32 a(0); a < nSubPathCount; a++)
+            {
+                // iterate over sub-paths
+                const basegfx::B2DPolygon& aSubPolygonPath(rPath.getB2DPolygon(a));
+                const sal_uInt32 nSubPolygonPointCount(aSubPolygonPath.count());
+                const bool bSubPolygonPathIsClosed(aSubPolygonPath.isClosed());
+
+                if(nSubPolygonPointCount)
+                {
+                    // for each sub-path, create one marker per point (when closed, two markers
+                    // need to pe created for the 1st point)
+                    const sal_uInt32 nTargetMarkerCount(bSubPolygonPathIsClosed ? nSubPolygonPointCount + 1 : nSubPolygonPointCount);
+
+                    for (sal_uInt32 b(0); b < nTargetMarkerCount; b++)
+                    {
+                        const bool bIsFirstMarker(!a && !b);
+                        const bool bIsLastMarker(nSubPathCount - 1 == a && nTargetMarkerCount - 1 == b);
+                        const SvgMarkerNode* pNeeded = nullptr;
+
+                        if(bIsFirstMarker)
+                        {
+                            // 1st point in 1st sub-polygon, use pStart
+                            pNeeded = pStart;
+                        }
+                        else if(bIsLastMarker)
+                        {
+                            // last point in last sub-polygon, use pEnd
+                            pNeeded = pEnd;
+                        }
+                        else
+                        {
+                            // anything in-between, use pMid
+                            pNeeded = pMid;
+                        }
+
+                        if(pHelpPointIndices && !pHelpPointIndices->empty())
+                        {
+                            const basegfx::utils::PointIndexSet::const_iterator aFound(
+                                pHelpPointIndices->find(basegfx::utils::PointIndex(a, b)));
+
+                            if(aFound != pHelpPointIndices->end())
+                            {
+                                // this point is a pure helper point; do not create a marker for it
+                                continue;
+                            }
+                        }
+
+                        if(!pNeeded)
+                        {
+                            // no marker needs to be created for this point
+                            continue;
+                        }
+
+                        if(pPrepared != pNeeded)
+                        {
+                            // if needed marker is not yet prepared, do it now
+                            if(prepare_singleMarker(aPreparedMarkerPrimitives, aPreparedMarkerTransform, aPreparedMarkerClipRange, *pNeeded))
+                            {
+                                pPrepared = pNeeded;
+                            }
+                            else
+                            {
+                                // error: could not prepare given marker
+                                OSL_ENSURE(false, "OOps, could not prepare given marker as primitives (!)");
+                                pPrepared = nullptr;
+                                continue;
+                            }
+                        }
+
+                        // prepare complete transform
+                        basegfx::B2DHomMatrix aCombinedTransform(aPreparedMarkerTransform);
+
+                        // get rotation
+                        if(pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start ||
+                            pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
+                        {
+                            const sal_uInt32 nPointIndex(b % nSubPolygonPointCount);
+
+                            // get entering and leaving tangents; this will search backward/forward
+                            // in the polygon to find tangents unequal to zero, skipping empty edges
+                            // see basegfx descriptions)
+                            // Hint: Mozilla, Inkscape and others use only leaving tangent for start marker
+                            // and entering tangent for end marker. To achieve this (if wanted) it is possible
+                            // to make the fetch of aEntering/aLeaving dependent on bIsFirstMarker/bIsLastMarker.
+                            // This is not done here, see comment 14 in task #1232379#
+                            // or http://www.w3.org/TR/SVG/painting.html#OrientAttribute
+                            basegfx::B2DVector aEntering(
+                                basegfx::utils::getTangentEnteringPoint(
+                                    aSubPolygonPath,
+                                    nPointIndex));
+                            basegfx::B2DVector aLeaving(
+                                basegfx::utils::getTangentLeavingPoint(
+                                    aSubPolygonPath,
+                                    nPointIndex));
+                            const bool bEntering(!aEntering.equalZero());
+                            const bool bLeaving(!aLeaving.equalZero());
+
+                            if(bEntering || bLeaving)
+                            {
+                                basegfx::B2DVector aSum(0.0, 0.0);
+
+                                if(bEntering)
+                                {
+                                    if(bIsFirstMarker && pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
+                                        aSum -= aEntering.normalize();
+                                    else
+                                        aSum += aEntering.normalize();
+                                }
+
+                                if(bLeaving)
+                                {
+                                    if(bIsFirstMarker && pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
+                                        aSum -= aLeaving.normalize();
+                                    else
+                                        aSum += aLeaving.normalize();
+                                }
+
+                                if(!aSum.equalZero())
+                                {
+                                    const double fAngle(atan2(aSum.getY(), aSum.getX()));
+
+                                    // apply rotation
+                                    aCombinedTransform.rotate(fAngle);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // apply rotation
+                            aCombinedTransform.rotate(pPrepared->getAngle());
+                        }
+
+                        // get and apply target position
+                        const basegfx::B2DPoint aPoint(aSubPolygonPath.getB2DPoint(b % nSubPolygonPointCount));
+
+                        aCombinedTransform.translate(aPoint.getX(), aPoint.getY());
+
+                        // prepare marker
+                        drawinglayer::primitive2d::Primitive2DReference xMarker(
+                            new drawinglayer::primitive2d::TransformPrimitive2D(
+                                aCombinedTransform,
+                                drawinglayer::primitive2d::Primitive2DContainer(aPreparedMarkerPrimitives)));
+
+                        if(!aPreparedMarkerClipRange.isEmpty())
+                        {
+                            // marker needs to be clipped, it's bigger as the mapping
+                            basegfx::B2DPolyPolygon aClipPolygon(basegfx::utils::createPolygonFromRect(aPreparedMarkerClipRange));
+
+                            aClipPolygon.transform(aCombinedTransform);
+                            xMarker = new drawinglayer::primitive2d::MaskPrimitive2D(
+                                std::move(aClipPolygon),
+                                drawinglayer::primitive2d::Primitive2DContainer { xMarker });
+                        }
+
+                        // add marker
+                        rTarget.push_back(xMarker);
+                    }
+                }
+            }
+        }
+
+        void SvgStyleAttributes::add_path(
+            const basegfx::B2DPolyPolygon& rPath,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const basegfx::utils::PointIndexSet* pHelpPointIndices) const
+        {
+            if(!rPath.count())
+            {
+                // no geometry at all
+                return;
+            }
+
+            const basegfx::B2DRange aGeoRange(rPath.getB2DRange());
+
+            if(aGeoRange.isEmpty())
+            {
+                // no geometry range
+                return;
+            }
+
+            const double fOpacity(getOpacity().solve(mrOwner));
+
+            if(basegfx::fTools::equalZero(fOpacity))
+            {
+                // not visible
+                return;
+            }
+
+            // check if it's a line
+            const bool bNoWidth(basegfx::fTools::equalZero(aGeoRange.getWidth()));
+            const bool bNoHeight(basegfx::fTools::equalZero(aGeoRange.getHeight()));
+            const bool bIsTwoPointLine(1 == rPath.count()
+                && !rPath.areControlPointsUsed()
+                && 2 == rPath.getB2DPolygon(0).count());
+            const bool bIsLine(bIsTwoPointLine || bNoWidth || bNoHeight);
+
+            if(!bIsLine)
+            {
+                // create fill
+                basegfx::B2DPolyPolygon aPath(rPath);
+
+                if(SVGToken::Path == mrOwner.getType() || SVGToken::Polygon == mrOwner.getType())
+                {
+                    if(FillRule::evenodd != getClipRule() && FillRule::evenodd != getFillRule())
+                    {
+                        if(getFill() || getSvgGradientNodeFill() || getSvgPatternNodeFill())
+                        {
+                            // nonzero is wanted, solve geometrically (see description on basegfx)
+                            // basegfx::utils::createNonzeroConform() is expensive for huge paths
+                            // and is only needed if path will be filled later on
+                            aPath = basegfx::utils::createNonzeroConform(aPath);
+                        }
+                    }
+                }
+
+                add_fill(aPath, rTarget, aGeoRange);
+            }
+
+            // create stroke
+            add_stroke(rPath, rTarget, aGeoRange);
+
+            // Svg supports markers for path, polygon, polyline and line
+            if(SVGToken::Path == mrOwner.getType() ||         // path
+                SVGToken::Polygon == mrOwner.getType() ||     // polygon
+                SVGToken::Polyline == mrOwner.getType() ||     // polyline
+                SVGToken::Line == mrOwner.getType() ||        // line
+                SVGToken::Style == mrOwner.getType())        // tdf#150323
+            {
+                // try to add markers
+                add_markers(rPath, rTarget, pHelpPointIndices);
+            }
+        }
+
+        void SvgStyleAttributes::add_postProcess(
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            drawinglayer::primitive2d::Primitive2DContainer&& rSource,
+            const std::optional<basegfx::B2DHomMatrix>& pTransform) const
+        {
+            const double fOpacity(getOpacity().solve(mrOwner));
+
+            if(basegfx::fTools::equalZero(fOpacity))
+            {
+                return;
+            }
+
+            drawinglayer::primitive2d::Primitive2DContainer aSource(std::move(rSource));
+
+            if(basegfx::fTools::less(fOpacity, 1.0))
+            {
+                // embed in UnifiedTransparencePrimitive2D
+                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
+                        std::move(aSource),
+                        1.0 - fOpacity));
+
+                aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+            }
+
+            if(pTransform)
+            {
+                // create embedding group element with transformation. This applies the given
+                // transformation to the graphical content, but *not* to mask and/or clip (as needed)
+                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                        *pTransform,
+                        std::move(aSource)));
+
+                aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+            }
+
+            const SvgClipPathNode* pClip = accessClipPathXLink();
+            while(pClip)
+            {
+                // #i124852# transform may be needed when SvgUnits::userSpaceOnUse
+                pClip->apply(aSource, pTransform);
+                pClip = pClip->getSvgStyleAttributes()->accessClipPathXLink();
+            }
+
+            if(!aSource.empty()) // test again, applied clipPath may have lead to empty geometry
+            {
+                const SvgFilterNode* pFilter = accessFilterXLink();
+                if(pFilter)
+                {
+                    pFilter->apply(aSource);
+                }
+            }
+
+            if(!aSource.empty()) // test again, applied filter may have lead to empty geometry
+            {
+
+                const SvgMaskNode* pMask = accessMaskXLink();
+                if(pMask)
+                {
+                    // #i124852# transform may be needed when SvgUnits::userSpaceOnUse
+                    pMask->apply(aSource, pTransform);
+                }
+            }
+
+            // This is part of the SVG import of self-written SVGs from
+            // Draw/Impress containing multiple Slides/Pages. To be able
+            // to later 'break' these to multiple Pages if wanted, embed
+            // each Page-Content in an identifiable Primitive Grouping
+            // Object.
+            // This is the case when the current Node is a GroupNode, has
+            // class="Page" set, has a parent that also is a GroupNode
+            // at which class="Slide" is set.
+            // Multiple Slides/Pages are possible for Draw and Impress.
+            if(SVGToken::G == mrOwner.getType() && mrOwner.getClass())
+            {
+                const OUString aOwnerClass(*mrOwner.getClass());
+
+                if("Page" == aOwnerClass)
+                {
+                    const SvgNode* pParent(mrOwner.getParent());
+
+                    if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
+                    {
+                        const OUString aParentClass(*pParent->getClass());
+
+                        if("Slide" == aParentClass)
+                        {
+                            // embed to grouping primitive to identify the
+                            // Slide/Page information
+                            const drawinglayer::primitive2d::Primitive2DReference xRef(
+                                new drawinglayer::primitive2d::PageHierarchyPrimitive2D(
+                                    std::move(aSource)));
+
+                            aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
+                        }
+                    }
+                }
+            }
+
+            if(!aSource.empty()) // test again, applied mask may have lead to empty geometry
+            {
+                // append to current target
+                rTarget.append(aSource);
+            }
+        }
+
+        SvgStyleAttributes::SvgStyleAttributes(SvgNode& rOwner)
+        :   mrOwner(rOwner),
+            mpCssStyleParent(nullptr),
+            maStopColor(basegfx::BColor(0.0, 0.0, 0.0), true),
+            maStrokeLinecap(StrokeLinecap::notset),
+            maStrokeLinejoin(StrokeLinejoin::notset),
+            maFontSize(),
+            maFontStretch(FontStretch::notset),
+            maFontStyle(FontStyle::notset),
+            maFontWeight(FontWeight::notset),
+            maTextAlign(TextAlign::notset),
+            maTextDecoration(TextDecoration::notset),
+            maTextAnchor(TextAnchor::notset),
+            maVisibility(Visibility::notset),
+            maFillRule(FillRule::notset),
+            maClipRule(FillRule::notset),
+            maBaselineShift(BaselineShift::Baseline),
+            maBaselineShiftNumber(0),
+            maDominantBaseline(DominantBaseline::Auto),
+            maResolvingParent(31, 0),
+            mbIsClipPathContent(SVGToken::ClipPathNode == mrOwner.getType()),
+            mbStrokeDasharraySet(false)
+        {
+            const SvgStyleAttributes* pParentStyle = getParentStyle();
+            if(!mbIsClipPathContent)
+            {
+                if(pParentStyle)
+                {
+                    mbIsClipPathContent = pParentStyle->mbIsClipPathContent;
+                }
+            }
+        }
+
+        SvgStyleAttributes::~SvgStyleAttributes()
+        {
+        }
+
+        void SvgStyleAttributes::parseStyleAttribute(
+            SVGToken aSVGToken,
+            const OUString& aContent)
+        {
+            switch(aSVGToken)
+            {
+                case SVGToken::Fill:
+                {
+                    SvgPaint aSvgPaint;
+                    OUString aURL;
+                    SvgNumber aOpacity;
+
+                    if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+                    {
+                        setFill(aSvgPaint);
+                        if(aOpacity.isSet())
+                        {
+                            setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
+                        }
+                    }
+                    else if(!aURL.isEmpty())
+                    {
+                       maNodeFillURL = aURL;
+                    }
+                    break;
+                }
+                case SVGToken::FillOpacity:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maFillOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
+                    }
+                    break;
+                }
+                case SVGToken::FillRule:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrNonzero))
+                        {
+                            maFillRule = FillRule::nonzero;
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrEvenOdd))
+                        {
+                            maFillRule = FillRule::evenodd;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Stroke:
+                {
+                    SvgPaint aSvgPaint;
+                    OUString aURL;
+                    SvgNumber aOpacity;
+
+                    if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+                    {
+                        maStroke = aSvgPaint;
+                        if(aOpacity.isSet())
+                        {
+                            setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
+                        }
+                    }
+                    else if(!aURL.isEmpty())
+                    {
+                        maNodeStrokeURL = aURL;
+                    }
+                    break;
+                }
+                case SVGToken::StrokeDasharray:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        SvgNumberVector aVector;
+
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
+                        {
+                            // #121221# The special value 'none' needs to be handled
+                            // in the sense that *when* it is set, the parent shall not
+                            // be used. Before this was only dependent on the array being
+                            // empty
+                            mbStrokeDasharraySet = true;
+                        }
+                        else if(readSvgNumberVector(aContent, aVector))
+                        {
+                            maStrokeDasharray = aVector;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StrokeDashoffset:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maStrokeDashOffset = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StrokeLinecap:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"butt"))
+                        {
+                            setStrokeLinecap(StrokeLinecap::butt);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"round"))
+                        {
+                            setStrokeLinecap(StrokeLinecap::round);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"square"))
+                        {
+                            setStrokeLinecap(StrokeLinecap::square);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StrokeLinejoin:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"miter"))
+                        {
+                            setStrokeLinejoin(StrokeLinejoin::miter);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"round"))
+                        {
+                            setStrokeLinejoin(StrokeLinejoin::round);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bevel"))
+                        {
+                            setStrokeLinejoin(StrokeLinejoin::bevel);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StrokeMiterlimit:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(basegfx::fTools::moreOrEqual(aNum.getNumber(), 1.0))
+                        { //readSingleNumber sets SvgUnit::px as default, if unit is missing. Correct it here.
+                            maStrokeMiterLimit = SvgNumber(aNum.getNumber(), SvgUnit::none);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StrokeOpacity:
+                {
+
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maStrokeOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
+                    }
+                    break;
+                }
+                case SVGToken::StrokeWidth:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maStrokeWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StopColor:
+                {
+                    SvgPaint aSvgPaint;
+                    OUString aURL;
+                    SvgNumber aOpacity;
+
+                    if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+                    {
+                        maStopColor = aSvgPaint;
+                        if(aOpacity.isSet())
+                        {
+                            setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::StopOpacity:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maStopOpacity = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Font:
+                {
+                    break;
+                }
+                case SVGToken::FontFamily:
+                {
+                    SvgStringVector aSvgStringVector;
+
+                    if(readSvgStringVector(aContent, aSvgStringVector))
+                    {
+                        maFontFamily = aSvgStringVector;
+                    }
+                    break;
+                }
+                case SVGToken::FontSize:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"xx-small"))
+                        {
+                            setFontSize(FontSize::xx_small);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"x-small"))
+                        {
+                            setFontSize(FontSize::x_small);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"small"))
+                        {
+                            setFontSize(FontSize::small);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"smaller"))
+                        {
+                            setFontSize(FontSize::smaller);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"medium"))
+                        {
+                            setFontSize(FontSize::medium);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"larger"))
+                        {
+                            setFontSize(FontSize::larger);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"large"))
+                        {
+                            setFontSize(FontSize::large);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"x-large"))
+                        {
+                            setFontSize(FontSize::x_large);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"xx-large"))
+                        {
+                            setFontSize(FontSize::xx_large);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"initial"))
+                        {
+                            setFontSize(FontSize::initial);
+                        }
+                        else
+                        {
+                            SvgNumber aNum;
+
+                            if(readSingleNumber(aContent, aNum))
+                            {
+                                maFontSizeNumber = aNum;
+                            }
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::FontSizeAdjust:
+                {
+                    break;
+                }
+                case SVGToken::FontStretch:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
+                        {
+                            setFontStretch(FontStretch::normal);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"wider"))
+                        {
+                            setFontStretch(FontStretch::wider);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"narrower"))
+                        {
+                            setFontStretch(FontStretch::narrower);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"ultra-condensed"))
+                        {
+                            setFontStretch(FontStretch::ultra_condensed);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"extra-condensed"))
+                        {
+                            setFontStretch(FontStretch::extra_condensed);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"condensed"))
+                        {
+                            setFontStretch(FontStretch::condensed);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"semi-condensed"))
+                        {
+                            setFontStretch(FontStretch::semi_condensed);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"semi-expanded"))
+                        {
+                            setFontStretch(FontStretch::semi_expanded);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"expanded"))
+                        {
+                            setFontStretch(FontStretch::expanded);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"extra-expanded"))
+                        {
+                            setFontStretch(FontStretch::extra_expanded);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"ultra-expanded"))
+                        {
+                            setFontStretch(FontStretch::ultra_expanded);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::FontStyle:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
+                        {
+                            setFontStyle(FontStyle::normal);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"italic"))
+                        {
+                            setFontStyle(FontStyle::italic);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"oblique"))
+                        {
+                            setFontStyle(FontStyle::oblique);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::FontVariant:
+                {
+                    break;
+                }
+                case SVGToken::FontWeight:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"100"))
+                        {
+                            setFontWeight(FontWeight::N100);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"200"))
+                        {
+                            setFontWeight(FontWeight::N200);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"300"))
+                        {
+                            setFontWeight(FontWeight::N300);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"400") || o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
+                        {
+                            setFontWeight(FontWeight::N400);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"500"))
+                        {
+                            setFontWeight(FontWeight::N500);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"600"))
+                        {
+                            setFontWeight(FontWeight::N600);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"700") || o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bold"))
+                        {
+                            setFontWeight(FontWeight::N700);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"800"))
+                        {
+                            setFontWeight(FontWeight::N800);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"900"))
+                        {
+                            setFontWeight(FontWeight::N900);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bolder"))
+                        {
+                            setFontWeight(FontWeight::bolder);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"lighter"))
+                        {
+                            setFontWeight(FontWeight::lighter);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Direction:
+                {
+                    break;
+                }
+                case SVGToken::LetterSpacing:
+                {
+                    break;
+                }
+                case SVGToken::TextDecoration:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
+                        {
+                            setTextDecoration(TextDecoration::none);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"underline"))
+                        {
+                            setTextDecoration(TextDecoration::underline);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"overline"))
+                        {
+                            setTextDecoration(TextDecoration::overline);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"line-through"))
+                        {
+                            setTextDecoration(TextDecoration::line_through);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"blink"))
+                        {
+                            setTextDecoration(TextDecoration::blink);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::UnicodeBidi:
+                {
+                    break;
+                }
+                case SVGToken::WordSpacing:
+                {
+                    break;
+                }
+                case SVGToken::TextAnchor:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"start"))
+                        {
+                            setTextAnchor(TextAnchor::start);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"middle"))
+                        {
+                            setTextAnchor(TextAnchor::middle);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"end"))
+                        {
+                            setTextAnchor(TextAnchor::end);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::TextAlign:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"left"))
+                        {
+                            setTextAlign(TextAlign::left);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"right"))
+                        {
+                            setTextAlign(TextAlign::right);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"center"))
+                        {
+                            setTextAlign(TextAlign::center);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"justify"))
+                        {
+                            setTextAlign(TextAlign::justify);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Color:
+                {
+                    SvgPaint aSvgPaint;
+                    OUString aURL;
+                    SvgNumber aOpacity;
+
+                    if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
+                    {
+                        maColor = aSvgPaint;
+                        if(aOpacity.isSet())
+                        {
+                            setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Opacity:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        setOpacity(SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet()));
+                    }
+                    break;
+                }
+                case SVGToken::Visibility:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"visible"))
+                        {
+                            setVisibility(Visibility::visible);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hidden"))
+                        {
+                            setVisibility(Visibility::hidden);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"collapse"))
+                        {
+                            setVisibility(Visibility::collapse);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inherit"))
+                        {
+                            setVisibility(Visibility::inherit);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Title:
+                {
+                    maTitle = aContent;
+                    break;
+                }
+                case SVGToken::Desc:
+                {
+                    maDesc = aContent;
+                    break;
+                }
+                case SVGToken::ClipPathProperty:
+                {
+                    readLocalUrl(aContent, maClipPathXLink);
+                    break;
+                }
+                case SVGToken::Filter:
+                {
+                    readLocalUrl(aContent, maFilterXLink);
+                    break;
+                }
+                case SVGToken::Mask:
+                {
+                    readLocalUrl(aContent, maMaskXLink);
+                    break;
+                }
+                case SVGToken::ClipRule:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrNonzero))
+                        {
+                            maClipRule = FillRule::nonzero;
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrEvenOdd))
+                        {
+                            maClipRule = FillRule::evenodd;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Marker:
+                {
+                    // tdf#155819: Using the marker property from a style sheet is equivalent to using all three (start, mid, end).
+                    if(mrOwner.getType() == SVGToken::Style)
+                    {
+                        readLocalUrl(aContent, maMarkerEndXLink);
+                        maMarkerStartXLink = maMarkerMidXLink = maMarkerEndXLink;
+                    }
+                    break;
+                }
+                case SVGToken::MarkerStart:
+                {
+                    readLocalUrl(aContent, maMarkerStartXLink);
+                    break;
+                }
+                case SVGToken::MarkerMid:
+                {
+                    readLocalUrl(aContent, maMarkerMidXLink);
+                    break;
+                }
+                case SVGToken::MarkerEnd:
+                {
+                    readLocalUrl(aContent, maMarkerEndXLink);
+                    break;
+                }
+                case SVGToken::Display:
+                {
+                    // There may be display:none statements inside of style defines, e.g. the following line:
+                    // style="display:none"
+                    // taken from a svg example; this needs to be parsed and set at the owning node. Do not call
+                    // mrOwner.parseAttribute(...) here, this would lead to a recursion
+                    if(!aContent.isEmpty())
+                    {
+                        mrOwner.setDisplay(getDisplayFromContent(aContent));
+                    }
+                    break;
+                }
+                case SVGToken::BaselineShift:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        SvgNumber aNum;
+
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"sub"))
+                        {
+                            setBaselineShift(BaselineShift::Sub);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"super"))
+                        {
+                            setBaselineShift(BaselineShift::Super);
+                        }
+                        else if(readSingleNumber(aContent, aNum))
+                        {
+                            maBaselineShiftNumber = aNum;
+
+                            if(SvgUnit::percent == aNum.getUnit())
+                            {
+                                setBaselineShift(BaselineShift::Percentage);
+                            }
+                            else
+                            {
+                                setBaselineShift(BaselineShift::Length);
+                            }
+                        }
+                        else
+                        {
+                            // no BaselineShift or inherit (which is automatically)
+                            setBaselineShift(BaselineShift::Baseline);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::DominantBaseline:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"middle"))
+                        {
+                            setDominantBaseline(DominantBaseline::Middle);
+                        }
+                        else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hanging"))
+                        {
+                            setDominantBaseline(DominantBaseline::Hanging);
+                        }
+                        else
+                        {
+                            // no DominantBaseline
+                            setDominantBaseline(DominantBaseline::Auto);
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        // #i125258# ask if fill is a direct hard attribute (no hierarchy)
+        bool SvgStyleAttributes::isFillSet() const
+        {
+            if(mbIsClipPathContent)
+            {
+                return false;
+            }
+            else if(maFill.isSet())
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        const basegfx::BColor* SvgStyleAttributes::getCurrentColor() const
+        {
+            static basegfx::BColor aBlack(0.0, 0.0, 0.0);
+            const basegfx::BColor *aColor = getColor();
+            if( aColor )
+                return aColor;
+            else
+                return &aBlack;
+        }
+
+        const basegfx::BColor* SvgStyleAttributes::getFill() const
+        {
+            if(maFill.isSet())
+            {
+                if(maFill.isCurrent())
+                {
+                    return getCurrentColor();
+                }
+                else if(maFill.isOn())
+                {
+                    return &maFill.getBColor();
+                }
+                else if(mbIsClipPathContent)
+                {
+                    const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                    if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
+                    {
+                        ++maResolvingParent[0];
+                        const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
+                        --maResolvingParent[0];
+
+                        return pFill;
+                    }
+                }
+            }
+            else if (maNodeFillURL.isEmpty())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[0];
+                    const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
+                    --maResolvingParent[0];
+
+                    if(mbIsClipPathContent)
+                    {
+                        if (pFill)
+                        {
+                            return pFill;
+                        }
+                        else
+                        {
+                            static basegfx::BColor aBlack(0.0, 0.0, 0.0);
+                            return &aBlack;
+                        }
+                    }
+                    else
+                    {
+                        return pFill;
+                    }
+                }
+            }
+
+            return nullptr;
+        }
+
+        const basegfx::BColor* SvgStyleAttributes::getStroke() const
+        {
+            if(maStroke.isSet())
+            {
+                if(maStroke.isCurrent())
+                {
+                    return getCurrentColor();
+                }
+                else if(maStroke.isOn())
+                {
+                    return &maStroke.getBColor();
+                }
+            }
+            else if (maNodeStrokeURL.isEmpty())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[1] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[1];
+                    auto ret = pSvgStyleAttributes->getStroke();
+                    --maResolvingParent[1];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        const basegfx::BColor& SvgStyleAttributes::getStopColor() const
+        {
+            if(maStopColor.isCurrent())
+            {
+                return *getCurrentColor();
+            }
+            else
+            {
+                return maStopColor.getBColor();
+            }
+        }
+
+        const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeFill() const
+        {
+            if (!maFill.isSet())
+            {
+                if (!maNodeFillURL.isEmpty())
+                {
+                    const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
+
+                    if(pNode)
+                    {
+                        if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient == pNode->getType())
+                        {
+                            return static_cast< const SvgGradientNode* >(pNode);
+                        }
+                    }
+                }
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[2] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[2];
+                    auto ret = pSvgStyleAttributes->getSvgGradientNodeFill();
+                    --maResolvingParent[2];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeStroke() const
+        {
+            if (!maStroke.isSet())
+            {
+                if(!maNodeStrokeURL.isEmpty())
+                {
+                    const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
+
+                    if(pNode)
+                    {
+                        if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient  == pNode->getType())
+                        {
+                            return static_cast< const SvgGradientNode* >(pNode);
+                        }
+                    }
+                }
+
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[3] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[3];
+                    auto ret = pSvgStyleAttributes->getSvgGradientNodeStroke();
+                    --maResolvingParent[3];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeFill() const
+        {
+            if (!maFill.isSet())
+            {
+                if (!maNodeFillURL.isEmpty())
+                {
+                    const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
+
+                    if(pNode)
+                    {
+                        if(SVGToken::Pattern == pNode->getType())
+                        {
+                            return static_cast< const SvgPatternNode* >(pNode);
+                        }
+                    }
+                }
+
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[4] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[4];
+                    auto ret = pSvgStyleAttributes->getSvgPatternNodeFill();
+                    --maResolvingParent[4];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeStroke() const
+        {
+            if (!maStroke.isSet())
+            {
+                if(!maNodeStrokeURL.isEmpty())
+                {
+                    const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
+
+                    if(pNode)
+                    {
+                        if(SVGToken::Pattern == pNode->getType())
+                        {
+                            return static_cast< const SvgPatternNode* >(pNode);
+                        }
+                    }
+                }
+
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[5] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[5];
+                    auto ret = pSvgStyleAttributes->getSvgPatternNodeStroke();
+                    --maResolvingParent[5];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        SvgNumber SvgStyleAttributes::getStrokeWidth() const
+        {
+            if(maStrokeWidth.isSet())
+            {
+                return maStrokeWidth;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[6] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[6];
+                auto ret = pSvgStyleAttributes->getStrokeWidth();
+                --maResolvingParent[6];
+                return ret;
+            }
+
+            if(mbIsClipPathContent)
+            {
+                return SvgNumber(0.0);
+            }
+
+            // default is 1
+            return SvgNumber(1.0);
+        }
+
+        SvgNumber SvgStyleAttributes::getStopOpacity() const
+        {
+            if(maStopOpacity.isSet())
+            {
+                return maStopOpacity;
+            }
+
+            // default is 1
+            return SvgNumber(1.0);
+        }
+
+        SvgNumber SvgStyleAttributes::getFillOpacity() const
+        {
+            if(maFillOpacity.isSet())
+            {
+                return maFillOpacity;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[7] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[7];
+                auto ret = pSvgStyleAttributes->getFillOpacity();
+                --maResolvingParent[7];
+                return ret;
+            }
+
+            // default is 1
+            return SvgNumber(1.0);
+        }
+
+        SvgNumber SvgStyleAttributes::getOpacity() const
+        {
+            if(maOpacity.isSet())
+            {
+                return maOpacity;
+            }
+
+            // This is called from add_postProcess so only check the parent style
+            // if it has a local css style, because it's the first in the stack
+            if(mrOwner.hasLocalCssStyle())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && pSvgStyleAttributes->maOpacity.isSet())
+                {
+                    return pSvgStyleAttributes->maOpacity;
+                }
+            }
+
+            // default is 1
+            return SvgNumber(1.0);
+        }
+
+        Visibility SvgStyleAttributes::getVisibility() const
+        {
+            if(Visibility::notset == maVisibility || Visibility::inherit == maVisibility)
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[9] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[9];
+                    auto ret = pSvgStyleAttributes->getVisibility();
+                    --maResolvingParent[9];
+                    return ret;
+                }
+                //default is Visible
+                return Visibility::visible;
+            }
+
+            // Visibility correction/exception for self-exported SVGs:
+            // When Impress exports single or multi-page SVGs, it puts the
+            // single slides into <g visibility="hidden">. Not sure why
+            // this happens, but this leads (correctly) to empty imported
+            // Graphics.
+            // Thus, if Visibility::hidden is active and owner is a SVGToken::G
+            // and it's parent is also a SVGToken::G and it has a Class 'SlideGroup'
+            // set, check if we are an Impress export.
+            // We are an Impress export if an SVG-Node titled 'ooo:meta_slides'
+            // exists.
+            // All together gives:
+            if(Visibility::hidden == maVisibility
+                && SVGToken::G == mrOwner.getType()
+                && nullptr != mrOwner.getDocument().findSvgNodeById("ooo:meta_slides"))
+            {
+                const SvgNode* pParent(mrOwner.getParent());
+
+                if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
+                {
+                    const OUString aClass(*pParent->getClass());
+
+                    if("SlideGroup" == aClass)
+                    {
+                        // if we detect this exception,
+                        // override Visibility::hidden -> Visibility::visible
+                        return Visibility::visible;
+                    }
+                }
+            }
+
+            return maVisibility;
+        }
+
+        FillRule SvgStyleAttributes::getFillRule() const
+        {
+            if(FillRule::notset != maFillRule)
+            {
+                return maFillRule;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[10] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[10];
+                auto ret = pSvgStyleAttributes->getFillRule();
+                --maResolvingParent[10];
+                return ret;
+            }
+
+            // default is NonZero
+            return FillRule::nonzero;
+        }
+
+        FillRule SvgStyleAttributes::getClipRule() const
+        {
+            if(FillRule::notset != maClipRule)
+            {
+                return maClipRule;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[25] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[25];
+                auto ret = pSvgStyleAttributes->getClipRule();
+                --maResolvingParent[25];
+                return ret;
+            }
+
+            // default is NonZero
+            return FillRule::nonzero;
+        }
+
+        const SvgNumberVector& SvgStyleAttributes::getStrokeDasharray() const
+        {
+            if(!maStrokeDasharray.empty())
+            {
+                return maStrokeDasharray;
+            }
+            else if(mbStrokeDasharraySet)
+            {
+                // #121221# is set to empty *by purpose*, do not visit parent styles
+                return maStrokeDasharray;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[11] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[11];
+                const SvgNumberVector& ret = pSvgStyleAttributes->getStrokeDasharray();
+                --maResolvingParent[11];
+                return ret;
+            }
+
+            // default empty
+            return maStrokeDasharray;
+        }
+
+        SvgNumber SvgStyleAttributes::getStrokeDashOffset() const
+        {
+            if(maStrokeDashOffset.isSet())
+            {
+                return maStrokeDashOffset;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[12] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[12];
+                auto ret = pSvgStyleAttributes->getStrokeDashOffset();
+                --maResolvingParent[12];
+                return ret;
+            }
+
+            // default is 0
+            return SvgNumber(0.0);
+        }
+
+        StrokeLinecap SvgStyleAttributes::getStrokeLinecap() const
+        {
+            if(maStrokeLinecap != StrokeLinecap::notset)
+            {
+                return maStrokeLinecap;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[13] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[13];
+                auto ret = pSvgStyleAttributes->getStrokeLinecap();
+                --maResolvingParent[13];
+                return ret;
+            }
+
+            // default is StrokeLinecap::butt
+            return StrokeLinecap::butt;
+        }
+
+        StrokeLinejoin SvgStyleAttributes::getStrokeLinejoin() const
+        {
+            if(maStrokeLinejoin != StrokeLinejoin::notset)
+            {
+                return maStrokeLinejoin;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[14] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[14];
+                auto ret = pSvgStyleAttributes->getStrokeLinejoin();
+                --maResolvingParent[14];
+                return ret;
+            }
+
+            // default is StrokeLinejoin::butt
+            return StrokeLinejoin::miter;
+        }
+
+        SvgNumber SvgStyleAttributes::getStrokeMiterLimit() const
+        {
+            if(maStrokeMiterLimit.isSet())
+            {
+                return maStrokeMiterLimit;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[15] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[15];
+                auto ret = pSvgStyleAttributes->getStrokeMiterLimit();
+                --maResolvingParent[15];
+                return ret;
+            }
+
+            // default is 4
+            return SvgNumber(4.0, SvgUnit::none);
+        }
+
+        SvgNumber SvgStyleAttributes::getStrokeOpacity() const
+        {
+            if(maStrokeOpacity.isSet())
+            {
+                return maStrokeOpacity;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[16] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[16];
+                auto ret = pSvgStyleAttributes->getStrokeOpacity();
+                --maResolvingParent[16];
+                return ret;
+            }
+
+            // default is 1
+            return SvgNumber(1.0);
+        }
+
+        const SvgStringVector& SvgStyleAttributes::getFontFamily() const
+        {
+            if(!maFontFamily.empty() && !o3tl::equalsIgnoreAsciiCase(o3tl::trim(maFontFamily[0]), u"inherit"))
+            {
+                return maFontFamily;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[17] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[17];
+                const SvgStringVector& ret = pSvgStyleAttributes->getFontFamily();
+                --maResolvingParent[17];
+                return ret;
+            }
+
+            // default is empty
+            return maFontFamily;
+        }
+
+        SvgNumber SvgStyleAttributes::getFontSizeNumber() const
+        {
+            // default size is 'medium', i.e. 12 pt, or 16px
+            constexpr double aDefaultSize = o3tl::convert(12.0, o3tl::Length::pt, o3tl::Length::px);
+
+            if(maFontSizeNumber.isSet())
+            {
+                if(!maFontSizeNumber.isPositive())
+                    return aDefaultSize;
+
+                // #122524# Handle SvgUnit::percent relative to parent FontSize (see SVG1.1
+                // spec 10.10 Font selection properties \91font-size\92, lastline (click 'normative
+                // definition of the property')
+                if(SvgUnit::percent == maFontSizeNumber.getUnit())
+                {
+                    const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                    if(pSvgStyleAttributes)
+                    {
+                        const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
+
+                        return SvgNumber(
+                            aParentNumber.getNumber() * maFontSizeNumber.getNumber() * 0.01,
+                            aParentNumber.getUnit(),
+                            true);
+                    }
+                    // if there's no parent style, set the font size based on the default size
+                    // 100% = 16px
+                    return SvgNumber(
+                        maFontSizeNumber.getNumber() * aDefaultSize / 100.0, SvgUnit::px, true);
+                }
+                else if((SvgUnit::em == maFontSizeNumber.getUnit()) || (SvgUnit::ex == maFontSizeNumber.getUnit()))
+                {
+                    const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                    if(pSvgStyleAttributes)
+                    {
+                        const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
+
+                        return SvgNumber(
+                            aParentNumber.getNumber() * maFontSizeNumber.getNumber(),
+                            aParentNumber.getUnit(),
+                            true);
+                    }
+                }
+
+                return maFontSizeNumber;
+            }
+
+            //In CSS2, the suggested scaling factor between adjacent indexes is 1.2
+            switch(maFontSize)
+            {
+                case FontSize::notset:
+                    break;
+                case FontSize::xx_small:
+                {
+                    return SvgNumber(aDefaultSize / 1.728);
+                }
+                case FontSize::x_small:
+                {
+                    return SvgNumber(aDefaultSize / 1.44);
+                }
+                case FontSize::small:
+                {
+                    return SvgNumber(aDefaultSize / 1.2);
+                }
+                case FontSize::smaller:
+                {
+                    const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+                    if(pSvgStyleAttributes)
+                    {
+                        const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
+                        return SvgNumber(aParentNumber.getNumber() / 1.2, aParentNumber.getUnit());
+                    }
+                    [[fallthrough]];
+                }
+                case FontSize::medium:
+                case FontSize::initial:
+                {
+                    return SvgNumber(aDefaultSize);
+                }
+                case FontSize::large:
+                {
+                    return SvgNumber(aDefaultSize * 1.2);
+                }
+                case FontSize::larger:
+                {
+                    const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+                    if(pSvgStyleAttributes)
+                    {
+                        const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
+                        return SvgNumber(aParentNumber.getNumber() * 1.2, aParentNumber.getUnit());
+                    }
+                    [[fallthrough]];
+                }
+                case FontSize::x_large:
+                {
+                    return SvgNumber(aDefaultSize * 1.44);
+                }
+                case FontSize::xx_large:
+                {
+                    return SvgNumber(aDefaultSize * 1.728);
+                }
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if(pSvgStyleAttributes)
+            {
+                return pSvgStyleAttributes->getFontSizeNumber();
+            }
+
+            return SvgNumber(aDefaultSize);
+        }
+
+        FontStretch SvgStyleAttributes::getFontStretch() const
+        {
+            if(maFontStretch != FontStretch::notset)
+            {
+                if(FontStretch::wider != maFontStretch && FontStretch::narrower != maFontStretch)
+                {
+                    return maFontStretch;
+                }
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[18] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[18];
+                FontStretch aInherited = pSvgStyleAttributes->getFontStretch();
+                --maResolvingParent[18];
+
+                if(FontStretch::wider == maFontStretch)
+                {
+                    aInherited = getWider(aInherited);
+                }
+                else if(FontStretch::narrower == maFontStretch)
+                {
+                    aInherited = getNarrower(aInherited);
+                }
+
+                return aInherited;
+            }
+
+            // default is FontStretch::normal
+            return FontStretch::normal;
+        }
+
+        FontStyle SvgStyleAttributes::getFontStyle() const
+        {
+            if(maFontStyle != FontStyle::notset)
+            {
+                return maFontStyle;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[19] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[19];
+                auto ret = pSvgStyleAttributes->getFontStyle();
+                --maResolvingParent[19];
+                return ret;
+            }
+
+            // default is FontStyle::normal
+            return FontStyle::normal;
+        }
+
+        FontWeight SvgStyleAttributes::getFontWeight() const
+        {
+            if(maFontWeight != FontWeight::notset)
+            {
+                if(FontWeight::bolder != maFontWeight && FontWeight::lighter != maFontWeight)
+                {
+                    return maFontWeight;
+                }
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[20] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[20];
+                FontWeight aInherited = pSvgStyleAttributes->getFontWeight();
+                --maResolvingParent[20];
+
+                if(FontWeight::bolder == maFontWeight)
+                {
+                    aInherited = getBolder(aInherited);
+                }
+                else if(FontWeight::lighter == maFontWeight)
+                {
+                    aInherited = getLighter(aInherited);
+                }
+
+                return aInherited;
+            }
+
+            // default is FontWeight::N400 (FontWeight::normal)
+            return FontWeight::N400;
+        }
+
+        TextAlign SvgStyleAttributes::getTextAlign() const
+        {
+            if(maTextAlign != TextAlign::notset)
+            {
+                return maTextAlign;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[21] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[21];
+                auto ret = pSvgStyleAttributes->getTextAlign();
+                --maResolvingParent[21];
+                return ret;
+            }
+
+            // default is TextAlign::left
+            return TextAlign::left;
+        }
+
+        const SvgStyleAttributes* SvgStyleAttributes::getTextDecorationDefiningSvgStyleAttributes() const
+        {
+            if(maTextDecoration != TextDecoration::notset)
+            {
+                return this;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[22] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[22];
+                auto ret = pSvgStyleAttributes->getTextDecorationDefiningSvgStyleAttributes();
+                --maResolvingParent[22];
+                return ret;
+            }
+
+            // default is 0
+            return nullptr;
+        }
+
+        TextDecoration SvgStyleAttributes::getTextDecoration() const
+        {
+            const SvgStyleAttributes* pDefining = getTextDecorationDefiningSvgStyleAttributes();
+
+            if(pDefining)
+            {
+                return pDefining->maTextDecoration;
+            }
+            else
+            {
+                // default is TextDecoration::none
+                return TextDecoration::none;
+            }
+        }
+
+        TextAnchor SvgStyleAttributes::getTextAnchor() const
+        {
+            if(maTextAnchor != TextAnchor::notset)
+            {
+                return maTextAnchor;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[23] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[23];
+                auto ret = pSvgStyleAttributes->getTextAnchor();
+                --maResolvingParent[23];
+                return ret;
+            }
+
+            // default is TextAnchor::start
+            return TextAnchor::start;
+        }
+
+        const basegfx::BColor* SvgStyleAttributes::getColor() const
+        {
+            if(maColor.isSet())
+            {
+                if(maColor.isCurrent())
+                {
+                    OSL_ENSURE(false, "Svg error: current color uses current color (!)");
+                    return nullptr;
+                }
+                else if(maColor.isOn())
+                {
+                    return &maColor.getBColor();
+                }
+            }
+            else
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[24] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[24];
+                    auto ret = pSvgStyleAttributes->getColor();
+                    --maResolvingParent[24];
+                    return ret;
+                }
+            }
+
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getClipPathXLink() const
+        {
+            if(!maClipPathXLink.isEmpty())
+            {
+                return maClipPathXLink;
+            }
+
+            // This is called from add_postProcess so only check the parent style
+            // if it has a local css style, because it's the first in the stack
+            if(mrOwner.hasLocalCssStyle())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes)
+                {
+                    return pSvgStyleAttributes->maClipPathXLink;
+                }
+            }
+
+            return OUString();
+        }
+
+        const SvgClipPathNode* SvgStyleAttributes::accessClipPathXLink() const
+        {
+            const OUString aClipPath(getClipPathXLink());
+
+            if(!aClipPath.isEmpty())
+            {
+                return dynamic_cast< const SvgClipPathNode* >(mrOwner.getDocument().findSvgNodeById(aClipPath));
+            }
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getFilterXLink() const
+        {
+            if(!maFilterXLink.isEmpty())
+            {
+                return maFilterXLink;
+            }
+
+            // This is called from add_postProcess so only check the parent style
+            // if it has a local css style, because it's the first in the stack
+            if(mrOwner.hasLocalCssStyle())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes)
+                {
+                    return pSvgStyleAttributes->maFilterXLink;
+                }
+            }
+
+            return OUString();
+        }
+
+        const SvgFilterNode* SvgStyleAttributes::accessFilterXLink() const
+        {
+            const OUString aFilter(getFilterXLink());
+
+            if(!aFilter.isEmpty())
+            {
+                return dynamic_cast< const SvgFilterNode* >(mrOwner.getDocument().findSvgNodeById(aFilter));
+            }
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getMaskXLink() const
+        {
+            if(!maMaskXLink.isEmpty())
+            {
+                return maMaskXLink;
+            }
+
+            // This is called from add_postProcess so only check the parent style
+            // if it has a local css style, because it's the first in the stack
+            if(mrOwner.hasLocalCssStyle())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes)
+                {
+                    return pSvgStyleAttributes->maMaskXLink;
+                }
+            }
+
+            return OUString();
+        }
+
+        const SvgMaskNode* SvgStyleAttributes::accessMaskXLink() const
+        {
+            const OUString aMask(getMaskXLink());
+
+            if(!aMask.isEmpty())
+            {
+                return dynamic_cast< const SvgMaskNode* >(mrOwner.getDocument().findSvgNodeById(aMask));
+            }
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getMarkerStartXLink() const
+        {
+            if(!maMarkerStartXLink.isEmpty())
+            {
+                return maMarkerStartXLink;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[26] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[26];
+                auto ret = pSvgStyleAttributes->getMarkerStartXLink();
+                --maResolvingParent[26];
+                return ret;
+            }
+
+            return OUString();
+        }
+
+        const SvgMarkerNode* SvgStyleAttributes::accessMarkerStartXLink() const
+        {
+            const OUString aMarker(getMarkerStartXLink());
+
+            if(!aMarker.isEmpty())
+            {
+                return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerStartXLink()));
+            }
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getMarkerMidXLink() const
+        {
+            if(!maMarkerMidXLink.isEmpty())
+            {
+                return maMarkerMidXLink;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[27] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[27];
+                auto ret = pSvgStyleAttributes->getMarkerMidXLink();
+                --maResolvingParent[27];
+                return ret;
+            }
+
+            return OUString();
+        }
+
+        const SvgMarkerNode* SvgStyleAttributes::accessMarkerMidXLink() const
+        {
+            const OUString aMarker(getMarkerMidXLink());
+
+            if(!aMarker.isEmpty())
+            {
+                return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerMidXLink()));
+            }
+            return nullptr;
+        }
+
+        OUString SvgStyleAttributes::getMarkerEndXLink() const
+        {
+            if(!maMarkerEndXLink.isEmpty())
+            {
+                return maMarkerEndXLink;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[28] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[28];
+                auto ret = pSvgStyleAttributes->getMarkerEndXLink();
+                --maResolvingParent[28];
+                return ret;
+            }
+
+            return OUString();
+        }
+
+        const SvgMarkerNode* SvgStyleAttributes::accessMarkerEndXLink() const
+        {
+            const OUString aMarker(getMarkerEndXLink());
+
+            if(!aMarker.isEmpty())
+            {
+                return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerEndXLink()));
+            }
+            return nullptr;
+        }
+
+        SvgNumber SvgStyleAttributes::getBaselineShiftNumber() const
+        {
+            // #122524# Handle SvgUnit::percent relative to parent BaselineShift
+            if(SvgUnit::percent == maBaselineShiftNumber.getUnit())
+            {
+                const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+                if (pSvgStyleAttributes && maResolvingParent[8] < nStyleDepthLimit)
+                {
+                    ++maResolvingParent[8];
+                    const SvgNumber aParentNumber = pSvgStyleAttributes->getBaselineShiftNumber();
+                    --maResolvingParent[8];
+
+                    return SvgNumber(
+                        aParentNumber.getNumber() * maBaselineShiftNumber.getNumber() * 0.01,
+                        aParentNumber.getUnit(),
+                        true);
+                }
+            }
+
+            return maBaselineShiftNumber;
+        }
+
+        BaselineShift SvgStyleAttributes::getBaselineShift() const
+        {
+            if(maBaselineShift != BaselineShift::Baseline)
+            {
+                return maBaselineShift;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[29] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[29];
+                auto ret = pSvgStyleAttributes->getBaselineShift();
+                --maResolvingParent[29];
+                return ret;
+            }
+
+            return BaselineShift::Baseline;
+        }
+
+        DominantBaseline SvgStyleAttributes::getDominantBaseline() const
+        {
+            if(maDominantBaseline != DominantBaseline::Auto)
+            {
+                return maDominantBaseline;
+            }
+
+            const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
+
+            if (pSvgStyleAttributes && maResolvingParent[30] < nStyleDepthLimit)
+            {
+                ++maResolvingParent[30];
+                auto ret = pSvgStyleAttributes->getDominantBaseline();
+                --maResolvingParent[30];
+                return ret;
+            }
+
+            return DominantBaseline::Auto;
+        }
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
+
diff --git a/svgio/source/svgreader/svgstylenode.cxx b/svgio/source/svgreader/svgstylenode.cxx
new file mode 100644
index 0000000000..88b380cf3b
--- /dev/null
+++ b/svgio/source/svgreader/svgstylenode.cxx
@@ -0,0 +1,231 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgstylenode.hxx>
+#include <svgdocument.hxx>
+#include <o3tl/string_view.hxx>
+#include <osl/diagnose.h>
+
+namespace svgio::svgreader
+{
+        SvgStyleNode::SvgStyleNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Style, rDocument, pParent),
+            mbTextCss(true)
+        {
+        }
+
+        // #i125258# no parent when we are a CssStyle holder to break potential loops because
+        // when using CssStyles we jump uncontrolled inside the node tree hierarchy
+        bool SvgStyleNode::supportsParentStyle() const
+        {
+            if(isTextCss())
+            {
+                return false;
+            }
+
+            // call parent
+            return SvgNode::supportsParentStyle();
+        }
+
+        void SvgStyleNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Type:
+                {
+                    if(!aContent.isEmpty())
+                    {
+                        if(!o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"text/css"))
+                        {
+                            setTextCss(false);
+                        }
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgStyleNode::addCssStyleSheet(std::u16string_view aSelectors, const SvgStyleAttributes& rNewStyle)
+        {
+            // aSelectors: CssStyle selectors, any combination, no comma separations, no spaces at start/end
+            // rNewStyle: the already prepared style to register on that name
+            if(aSelectors.empty())
+                return;
+
+            std::vector< OUString > aSelectorParts;
+            const sal_Int32 nLen(aSelectors.size());
+            sal_Int32 nPos(0);
+            OUStringBuffer aToken;
+
+            // split into single tokens (currently only space separator)
+            while(nPos < nLen)
+            {
+                const sal_Int32 nInitPos(nPos);
+                copyToLimiter(aSelectors, u' ', nPos, aToken, nLen);
+                skip_char(aSelectors, u' ', nPos, nLen);
+                const OUString aSelectorPart(o3tl::trim(aToken));
+                aToken.setLength(0);
+
+                if(!aSelectorPart.isEmpty())
+                {
+                    aSelectorParts.push_back(aSelectorPart);
+                }
+
+                if(nInitPos == nPos)
+                {
+                    OSL_ENSURE(false, "Could not interpret on current position (!)");
+                    nPos++;
+                }
+            }
+
+            if(aSelectorParts.empty())
+                return;
+
+            OUStringBuffer aConcatenatedSelector;
+
+            // re-combine without spaces, create a unique name (for now)
+            for(const auto &a : aSelectorParts)
+            {
+                aConcatenatedSelector.append(a);
+            }
+
+            // CssStyles in SVG are currently not completely supported; the current idea for
+            // supporting the needed minimal set is to register CssStyles associated to a string
+            // which is just the space-char cleaned, concatenated Selectors. The part to 'match'
+            // these is in fillCssStyleVectorUsingHierarchyAndSelectors. There, the same string is
+            // built up using the priorities of local CssStyle, Id, Class and other info combined
+            // with the existing hierarchy. This creates a specificity and priority-sorted local
+            // list for each node which is then chained using get/setCssStyleParent.
+            // The current solution is capable of solving space-separated selectors which can be
+            // mixed between Id, Class and type specifiers.
+            // When CssStyles need more specific solving, the start point is here; remember the
+            // needed infos not in maIdStyleTokenMapperList at the document, but select evtl.
+            // more specific infos there in a class capable of handling more complex matchings.
+            // Additionally fillCssStyleVector (or the mechanism above that when a linked list of
+            // SvgStyleAttributes will not do it) will have to be adapted to make use of it.
+
+            // register new style at document for (evtl. concatenated) stylename
+            const_cast< SvgDocument& >(getDocument()).addSvgStyleAttributesToMapper(aConcatenatedSelector.makeStringAndClear(), rNewStyle);
+        }
+
+        void SvgStyleNode::addCssStyleSheet(std::u16string_view aSelectors, std::u16string_view aContent)
+        {
+            // aSelectors: possible comma-separated list of CssStyle definitions, no spaces at start/end
+            // aContent: the svg style definitions as string
+            if(aSelectors.empty() || aContent.empty())
+                return;
+
+            // comma-separated split (Css abbreviation for same style for multiple selectors)
+            const sal_Int32 nLen(aSelectors.size());
+            sal_Int32 nPos(0);
+            OUStringBuffer aToken;
+
+            while(nPos < nLen)
+            {
+                const sal_Int32 nInitPos(nPos);
+                copyToLimiter(aSelectors, u',', nPos, aToken, nLen);
+                skip_char(aSelectors, u' ', u',', nPos, nLen);
+
+                const OUString aSingleName(o3tl::trim(aToken));
+                aToken.setLength(0);
+
+                // add the current css class only if wasn't previously added
+                auto [aIterator, bIsNew] = maSvgStyleAttributes.try_emplace(aSingleName);
+                if (bIsNew)
+                {
+                    // create new style and add to local list (for ownership control) and
+                    // in case it's written to again in future classes to prevent overwrites
+                    aIterator->second = std::make_unique<SvgStyleAttributes>(*this);
+                }
+                const std::unique_ptr<SvgStyleAttributes>& pCurrentStyle = aIterator->second;
+
+                // fill with content
+                pCurrentStyle->readCssStyle(aContent);
+
+                if(aSingleName.getLength())
+                {
+                    addCssStyleSheet(aSingleName, *pCurrentStyle);
+                }
+
+                if(nInitPos == nPos)
+                {
+                    OSL_ENSURE(false, "Could not interpret on current position (!)");
+                    nPos++;
+                }
+            }
+        }
+
+        void SvgStyleNode::addCssStyleSheet(std::u16string_view aSelectorsAndContent)
+        {
+            const sal_Int32 nLen(aSelectorsAndContent.size());
+
+            if(!nLen)
+                return;
+
+            sal_Int32 nPos(0);
+            OUStringBuffer aToken;
+
+            while(nPos < nLen)
+            {
+                // read the full selectors (may be multiple, comma-separated)
+                const sal_Int32 nInitPos(nPos);
+                skip_char(aSelectorsAndContent, u' ', nPos, nLen);
+                copyToLimiter(aSelectorsAndContent, u'{', nPos, aToken, nLen);
+                skip_char(aSelectorsAndContent, u' ', u'{', nPos, nLen);
+
+                const OUString aSelectors(o3tl::trim(aToken));
+                aToken.setLength(0);
+                OUString aContent;
+
+                if(!aSelectors.isEmpty() && nPos < nLen)
+                {
+                    // isolate content as text, embraced by '{' and '}'
+                    copyToLimiter(aSelectorsAndContent, u'}', nPos, aToken, nLen);
+                    skip_char(aSelectorsAndContent, u' ', u'}', nPos, nLen);
+
+                    aContent = o3tl::trim(aToken);
+                    aToken.setLength(0);
+                }
+
+                if(!aSelectors.isEmpty() && !aContent.isEmpty())
+                {
+                    addCssStyleSheet(aSelectors, aContent);
+                }
+
+                if(nInitPos == nPos)
+                {
+                    OSL_ENSURE(false, "Could not interpret on current position (!)");
+                    nPos++;
+                }
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgsvgnode.cxx b/svgio/source/svgreader/svgsvgnode.cxx
new file mode 100644
index 0000000000..09c0810698
--- /dev/null
+++ b/svgio/source/svgreader/svgsvgnode.cxx
@@ -0,0 +1,826 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgsvgnode.hxx>
+#include <drawinglayer/geometry/viewinformation2d.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <drawinglayer/primitive2d/PolygonHairlinePrimitive2D.hxx>
+#include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
+#include <o3tl/unit_conversion.hxx>
+#include <svgdocument.hxx>
+
+namespace svgio::svgreader
+{
+        SvgSvgNode::SvgSvgNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Svg, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            mbStyleAttributesInitialized(false) // #i125258#
+        {
+        }
+
+        // #i125258#
+        void SvgSvgNode::initializeStyleAttributes()
+        {
+            if(mbStyleAttributesInitialized)
+                return;
+
+            // #i125258# determine if initial values need to be initialized with hard values
+            // for the case that this is the outmost SVG statement and it has no parent
+            // stale (CssStyle for svg may be defined)
+            bool bSetInitialValues(true);
+
+            if(getParent())
+            {
+                // #i125258# no initial values when it's a SVG element embedded in SVG
+                bSetInitialValues = false;
+            }
+
+            if(bSetInitialValues)
+            {
+                const SvgStyleAttributes* pStyles = getSvgStyleAttributes();
+
+                if(pStyles && pStyles->getParentStyle())
+                {
+                    // SVG has a parent style (probably CssStyle), check if fill is set there anywhere
+                    // already. If yes, do not set the default fill (black)
+                    bool bFillSet(false);
+                    const SvgStyleAttributes* pParentStyle = pStyles->getParentStyle();
+
+                    while(pParentStyle && !bFillSet)
+                    {
+                        bFillSet = pParentStyle->isFillSet();
+                        pParentStyle = pParentStyle->getParentStyle();
+                    }
+
+                    if(bFillSet)
+                    {
+                        // #125258# no initial values when SVG has a parent style at which a fill
+                        // is already set
+                        bSetInitialValues = false;
+                    }
+                }
+            }
+
+            if(bSetInitialValues)
+            {
+                // #i125258# only set if not yet initialized (SvgSvgNode::parseAttribute is already done,
+                // just setting may revert an already set valid value)
+                if(!maSvgStyleAttributes.isFillSet())
+                {
+                    // #i125258# initial fill is black (see SVG1.1 spec)
+                    maSvgStyleAttributes.setFill(SvgPaint(basegfx::BColor(0.0, 0.0, 0.0), true, true));
+                }
+            }
+
+            mbStyleAttributesInitialized = true;
+        }
+
+        SvgSvgNode::~SvgSvgNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgSvgNode::getSvgStyleAttributes() const
+        {
+            // #i125258# svg node can have CssStyles, too, so check for it here
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgSvgNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::ViewBox:
+                {
+                    const basegfx::B2DRange aRange(readViewBox(aContent, *this));
+
+                    if(!aRange.isEmpty())
+                    {
+                        setViewBox(&aRange);
+                    }
+                    break;
+                }
+                case SVGToken::PreserveAspectRatio:
+                {
+                    maSvgAspectRatio = readSvgAspectRatio(aContent);
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Version:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maVersion = aNum;
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgSvgNode::seekReferenceWidth(double& fWidth, bool& bHasFound) const
+        {
+            if (!getParent() || bHasFound)
+            {
+                return;
+            }
+            const SvgSvgNode* pParentSvgSvgNode = nullptr;
+            // enclosing svg might have relative width, need to cumulate them till they are
+            // resolved somewhere up in the node tree
+            double fPercentage(1.0);
+            for(const SvgNode* pParent = getParent(); pParent && !bHasFound; pParent = pParent->getParent())
+            {
+                // dynamic_cast results Null-pointer for not SvgSvgNode and so skips them in if condition
+                pParentSvgSvgNode = dynamic_cast< const SvgSvgNode* >(pParent);
+                if (pParentSvgSvgNode)
+                {
+                    if (pParentSvgSvgNode->getViewBox())
+                    {
+                        // viewbox values are already in 'user unit'.
+                        fWidth = pParentSvgSvgNode->getViewBox()->getWidth() * fPercentage;
+                        bHasFound = true;
+                    }
+                    else
+                    {
+                        // take absolute value or cumulate percentage
+                        if (pParentSvgSvgNode->getWidth().isSet())
+                        {
+                            if (SvgUnit::percent == pParentSvgSvgNode->getWidth().getUnit())
+                            {
+                                fPercentage *= pParentSvgSvgNode->getWidth().getNumber() * 0.01;
+                            }
+                            else
+                            {
+                                fWidth = pParentSvgSvgNode->getWidth().solveNonPercentage(*pParentSvgSvgNode) * fPercentage;
+                                bHasFound = true;
+                            }
+                        } // not set => width=100% => factor 1, no need for else
+                    }
+                }
+            }
+        }
+
+        void SvgSvgNode::seekReferenceHeight(double& fHeight, bool& bHasFound) const
+        {
+            if (!getParent() || bHasFound)
+            {
+                return;
+            }
+            const SvgSvgNode* pParentSvgSvgNode = nullptr;
+            // enclosing svg might have relative width and height, need to cumulate them till they are
+            // resolved somewhere up in the node tree
+            double fPercentage(1.0);
+            for(const SvgNode* pParent = getParent(); pParent && !bHasFound; pParent = pParent->getParent())
+            {
+                // dynamic_cast results Null-pointer for not SvgSvgNode and so skips them in if condition
+                pParentSvgSvgNode = dynamic_cast< const SvgSvgNode* >(pParent);
+                if (pParentSvgSvgNode)
+                {
+                    if (pParentSvgSvgNode->getViewBox())
+                    {
+                        // viewbox values are already in 'user unit'.
+                        fHeight = pParentSvgSvgNode->getViewBox()->getHeight() * fPercentage;
+                        bHasFound = true;
+                    }
+                    else
+                    {
+                        // take absolute value or cumulate percentage
+                        if (pParentSvgSvgNode->getHeight().isSet())
+                        {
+                            if (SvgUnit::percent == pParentSvgSvgNode->getHeight().getUnit())
+                            {
+                                fPercentage *= pParentSvgSvgNode->getHeight().getNumber() * 0.01;
+                            }
+                            else
+                            {
+                                fHeight = pParentSvgSvgNode->getHeight().solveNonPercentage(*pParentSvgSvgNode) * fPercentage;
+                                bHasFound = true;
+                            }
+                        } // not set => height=100% => factor 1, no need for else
+                    }
+                }
+            }
+        }
+
+// ToDo: Consider attribute overflow in method decomposeSvgNode
+        void SvgSvgNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool bReferenced) const
+        {
+            drawinglayer::primitive2d::Primitive2DContainer aSequence;
+
+            // #i125258# check now if we need to init some style settings locally. Do not do this
+            // in the constructor, there is not yet information e.g. about existing CssStyles.
+            // Here all nodes are read and interpreted
+            const_cast< SvgSvgNode* >(this)->initializeStyleAttributes();
+
+            // decompose children
+            SvgNode::decomposeSvgNode(aSequence, bReferenced);
+
+            if(!aSequence.empty())
+            {
+                if(getParent())
+                {
+                    // #i122594# if width/height is not given, it's 100% (see 5.1.2 The 'svg' element in SVG1.1 spec).
+                    // If it is relative, the question is to what. The previous implementation assumed relative to the
+                    // local ViewBox which is implied by (4.2 Basic data types):
+
+                    // "Note that the non-property <length> definition also allows a percentage unit identifier.
+                    // The meaning of a percentage length value depends on the attribute for which the percentage
+                    // length value has been specified. Two common cases are: (a) when a percentage length value
+                    // represents a percentage of the viewport width or height (refer to the section that discusses
+                    // units in general), and (b) when a percentage length value represents a percentage of the
+                    // bounding box width or height on a given object (refer to the section that describes object
+                    // bounding box units)."
+
+                    // Comparisons with common browsers show that it's mostly interpreted relative to the viewport
+                    // of the parent, and so does the new implementation.
+
+                    // Extract known viewport data
+                    // bXXXIsAbsolute tracks whether relative values could be resolved to absolute values
+
+                    // If width or height is not provided, the default 100% is used, see SVG 1.1 section 5.1.2
+                    // value 0.0 here is only to initialize variable
+                    bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
+                    double fW( bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : 0.0);
+
+                    bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
+                    double fH( bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : 0.0);
+
+                    // If x or y not provided, then default 0.0 is used, see SVG 1.1 Section 5.1.2
+                    bool bXIsAbsolute((getX().isSet() && SvgUnit::percent != getX().getUnit()) || !getX().isSet());
+                    double fX( bXIsAbsolute && getX().isSet() ? getX().solveNonPercentage(*this) : 0.0);
+
+                    bool bYIsAbsolute((getY().isSet() && SvgUnit::percent != getY().getUnit()) || !getY().isSet());
+                    double fY( bYIsAbsolute && getY().isSet() ? getY().solveNonPercentage(*this) : 0.0);
+
+                    if ( !bXIsAbsolute || !bWidthIsAbsolute)
+                    {
+                        // get width of enclosing svg and resolve percentage in x and width;
+                        double fWReference(0.0);
+                        bool bHasFoundWidth(false);
+                        seekReferenceWidth(fWReference, bHasFoundWidth);
+                        if (!bHasFoundWidth)
+                        {
+                            if (getViewBox())
+                            {
+                                fWReference = getViewBox()->getWidth();
+                            }
+                            else
+                            {
+                                // Even outermost svg has not all information to resolve relative values,
+                                // I use content itself as fallback to set missing values for viewport
+                                // Any better idea for such ill structured svg documents?
+                                const basegfx::B2DRange aChildRange(
+                                            aSequence.getB2DRange(
+                                                drawinglayer::geometry::ViewInformation2D()));
+                                fWReference = aChildRange.getWidth();
+                            }
+                        }
+                        // referenced values are already in 'user unit'
+                        if (!bXIsAbsolute)
+                        {
+                            fX = getX().getNumber() * 0.01 * fWReference;
+                        }
+                        if (!bWidthIsAbsolute)
+                        {
+                            fW = (getWidth().isSet() ? getWidth().getNumber() *0.01 : 1.0) * fWReference;
+                        }
+                    }
+
+                    if ( !bYIsAbsolute || !bHeightIsAbsolute)
+                    {
+                        // get height of enclosing svg and resolve percentage in y and height
+                        double fHReference(0.0);
+                        bool bHasFoundHeight(false);
+                        seekReferenceHeight(fHReference, bHasFoundHeight);
+                        if (!bHasFoundHeight)
+                        {
+                            if (getViewBox())
+                            {
+                                fHReference = getViewBox()->getHeight();
+                            }
+                            else
+                            {
+                            // Even outermost svg has not all information to resolve relative values,
+                                // I use content itself as fallback to set missing values for viewport
+                                // Any better idea for such ill structured svg documents?
+                                const basegfx::B2DRange aChildRange(
+                                        aSequence.getB2DRange(
+                                            drawinglayer::geometry::ViewInformation2D()));
+                                fHReference = aChildRange.getHeight();
+                            }
+                        }
+
+                        // referenced values are already in 'user unit'
+                        if (!bYIsAbsolute)
+                        {
+                            fY = getY().getNumber() * 0.01 * fHReference;
+                        }
+                        if (!bHeightIsAbsolute)
+                        {
+                            fH = (getHeight().isSet() ? getHeight().getNumber() *0.01 : 1.0) * fHReference;
+                        }
+                    }
+
+                    if(getViewBox())
+                    {
+                        // SVG 1.1 defines in section 7.7 that a negative value for width or height
+                        // in viewBox is an error and that 0.0 disables rendering
+                        if(basegfx::fTools::more(getViewBox()->getWidth(),0.0) && basegfx::fTools::more(getViewBox()->getHeight(),0.0))
+                        {
+                            // create target range homing x,y, width and height as calculated above
+                            const basegfx::B2DRange aTarget(fX, fY, fX + fW, fY + fH);
+
+                            if(aTarget.equal(*getViewBox()))
+                            {
+                                // no mapping needed, append
+                                rTarget.append(aSequence);
+                            }
+                            else
+                            {
+                                // create mapping
+                                // #i122610 SVG 1.1 defines in section 5.1.2 that if the attribute preserveAspectRatio is not specified,
+                                // then the effect is as if a value of 'xMidYMid meet' were specified.
+                                SvgAspectRatio aRatioDefault(SvgAlign::xMidYMid,true);
+                                const SvgAspectRatio& rRatio = getSvgAspectRatio().isSet()? getSvgAspectRatio() : aRatioDefault;
+
+                                // let mapping be created from SvgAspectRatio
+                                const basegfx::B2DHomMatrix aEmbeddingTransform(
+                                    rRatio.createMapping(aTarget, *getViewBox()));
+
+                                // prepare embedding in transformation
+                                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                                        aEmbeddingTransform,
+                                        drawinglayer::primitive2d::Primitive2DContainer(aSequence)));
+
+                                if(rRatio.isMeetOrSlice())
+                                {
+                                    // embed in transformation
+                                    rTarget.push_back(xRef);
+                                }
+                                else
+                                {
+                                    // need to embed in MaskPrimitive2D, too
+                                    const drawinglayer::primitive2d::Primitive2DReference xMask(
+                                        new drawinglayer::primitive2d::MaskPrimitive2D(
+                                            basegfx::B2DPolyPolygon(basegfx::utils::createPolygonFromRect(aTarget)),
+                                            drawinglayer::primitive2d::Primitive2DContainer { xRef }));
+
+                                    rTarget.push_back(xMask);
+                                }
+                            }
+                        }
+                    }
+                    else // no viewBox attribute
+                    {
+                        // Svg defines that a negative value is an error and that 0.0 disables rendering
+                        if(basegfx::fTools::more(fW, 0.0) && basegfx::fTools::more(fH, 0.0))
+                        {
+                            if(!basegfx::fTools::equalZero(fX) || !basegfx::fTools::equalZero(fY))
+                            {
+                                // embed in transform
+                                const drawinglayer::primitive2d::Primitive2DReference xRef(
+                                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                                        basegfx::utils::createTranslateB2DHomMatrix(fX, fY),
+                                        std::move(aSequence)));
+
+                                aSequence = drawinglayer::primitive2d::Primitive2DContainer { xRef, };
+                            }
+
+                            // embed in MaskPrimitive2D to clip
+                            const drawinglayer::primitive2d::Primitive2DReference xMask(
+                                new drawinglayer::primitive2d::MaskPrimitive2D(
+                                    basegfx::B2DPolyPolygon(
+                                        basegfx::utils::createPolygonFromRect(
+                                            basegfx::B2DRange(fX, fY, fX + fW, fY + fH))),
+                                    drawinglayer::primitive2d::Primitive2DContainer(aSequence)));
+
+                            // append
+                            rTarget.push_back(xMask);
+                        }
+                    }
+                }
+                else // Outermost SVG element
+                {
+                    // Svg defines that a negative value is an error and that 0.0 disables rendering
+                    // isPositive() not usable because it allows 0.0 in contrast to mathematical definition of 'positive'
+                    const bool bWidthInvalid(getWidth().isSet() && basegfx::fTools::lessOrEqual(getWidth().getNumber(), 0.0));
+                    const bool bHeightInvalid(getHeight().isSet() && basegfx::fTools::lessOrEqual(getHeight().getNumber(), 0.0));
+                    if(!bWidthInvalid && !bHeightInvalid)
+                    {
+                        basegfx::B2DRange aSvgCanvasRange; // viewport
+                        double fW = 0.0; // dummy values
+                        double fH = 0.0;
+                        if (const basegfx::B2DRange* pBox = getViewBox())
+                        {
+                            // SVG 1.1 defines in section 7.7 that a negative value for width or height
+                            // in viewBox is an error and that 0.0 disables rendering
+                            const double fViewBoxWidth = pBox->getWidth();
+                            const double fViewBoxHeight = pBox->getHeight();
+                            if(basegfx::fTools::more(fViewBoxWidth,0.0) && basegfx::fTools::more(fViewBoxHeight,0.0))
+                            {
+                                // The intrinsic aspect ratio of the svg element is given by absolute values of svg width and svg height
+                                // or by the width and height of the viewBox, if svg width or svg height is relative.
+                                // see SVG 1.1 section 7.12
+                                bool bNeedsMapping(true);
+                                const bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
+                                const bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
+                                const double fViewBoxRatio(fViewBoxWidth/fViewBoxHeight);
+                                if(bWidthIsAbsolute && bHeightIsAbsolute)
+                                {
+                                    fW = getWidth().solveNonPercentage(*this);
+                                    fH = getHeight().solveNonPercentage(*this);
+                                    aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
+                                }
+                                else if (bWidthIsAbsolute)
+                                {
+                                    fW = getWidth().solveNonPercentage(*this);
+                                    fH = fW / fViewBoxRatio ;
+                                    aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
+                                }
+                                else if (bHeightIsAbsolute)
+                                {
+                                    fH = getHeight().solveNonPercentage(*this);
+                                    fW = fH * fViewBoxRatio ;
+                                    aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
+                                }
+                                else
+                                {
+                                    // There exists no parent to resolve relative width or height.
+                                    // Use child size as fallback and expand to aspect ratio given
+                                    // by the viewBox. No mapping.
+                                    // We get viewport >= content, therefore no clipping.
+                                    bNeedsMapping = false;
+
+                                    const double fChildWidth(pBox->getWidth());
+                                    const double fChildHeight(pBox->getHeight());
+                                    const double fLeft(pBox->getMinX());
+                                    const double fTop(pBox->getMinY());
+                                    if ( fChildWidth / fViewBoxWidth > fChildHeight / fViewBoxHeight )
+                                    {  // expand y
+                                        fW = fChildWidth;
+                                        fH = fChildWidth / fViewBoxRatio;
+                                    }
+                                    else
+                                    {  // expand x
+                                        fH = fChildHeight;
+                                        fW = fChildHeight * fViewBoxRatio;
+                                    }
+                                    aSvgCanvasRange = basegfx::B2DRange(fLeft, fTop, fLeft + fW, fTop + fH);
+                                }
+
+                                if (bNeedsMapping)
+                                {
+                                    // create mapping
+                                    // SVG 1.1 defines in section 5.1.2 that if the attribute preserveAspectRatio is not specified,
+                                    // then the effect is as if a value of 'xMidYMid meet' were specified.
+                                    SvgAspectRatio aRatioDefault(SvgAlign::xMidYMid, true);
+                                    const SvgAspectRatio& rRatio = getSvgAspectRatio().isSet()? getSvgAspectRatio() : aRatioDefault;
+
+                                    basegfx::B2DHomMatrix aViewBoxMapping = rRatio.createMapping(aSvgCanvasRange, *pBox);
+                                    // no need to check ratio here for slice, the outermost Svg will
+                                    // be clipped anyways (see below)
+
+                                    // scale content to viewBox definitions
+                                    const drawinglayer::primitive2d::Primitive2DReference xTransform(
+                                        new drawinglayer::primitive2d::TransformPrimitive2D(
+                                            aViewBoxMapping,
+                                            std::move(aSequence)));
+
+                                    aSequence = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
+                                }
+                            }
+                        }
+                        else // no viewbox => no mapping
+                        {
+                            const bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
+                            const bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
+                            if (bWidthIsAbsolute && bHeightIsAbsolute)
+                            {
+                                fW =getWidth().solveNonPercentage(*this);
+                                fH =getHeight().solveNonPercentage(*this);
+                                aSvgCanvasRange = basegfx::B2DRange(0.0, 0.0, fW, fH);
+                            }
+                            else
+                            {
+                                // There exists no parent to resolve relative width or height.
+                                // Use child size as fallback. We get viewport >= content, therefore no clipping.
+                                const basegfx::B2DRange aChildRange(
+                                     aSequence.getB2DRange(
+                                         drawinglayer::geometry::ViewInformation2D()));
+                                const double fChildWidth(aChildRange.getWidth());
+                                const double fChildHeight(aChildRange.getHeight());
+                                const double fChildLeft(aChildRange.getMinX());
+                                const double fChildTop(aChildRange.getMinY());
+                                fW = bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : fChildWidth;
+                                fH = bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : fChildHeight;
+                                const double fLeft(bWidthIsAbsolute ? 0.0 : fChildLeft);
+                                const double fTop(bHeightIsAbsolute ? 0.0 : fChildTop);
+                                aSvgCanvasRange = basegfx::B2DRange(fLeft, fTop, fLeft+fW, fTop+fH);
+                            }
+
+                        }
+
+                        // to be completely correct in Svg sense it is necessary to clip
+                        // the whole content to the given canvas. I choose here to do this
+                        // initially despite I found various examples of Svg files out there
+                        // which have no correct values for this clipping. It's correct
+                        // due to the Svg spec.
+
+                        // different from Svg we have the possibility with primitives to get
+                        // a correct bounding box for the geometry. Get it for evtl. taking action
+                        const basegfx::B2DRange aContentRange(
+                            aSequence.getB2DRange(
+                                drawinglayer::geometry::ViewInformation2D()));
+
+                        if(aSvgCanvasRange.isInside(aContentRange))
+                        {
+                            // no clip needed, but an invisible HiddenGeometryPrimitive2D
+                            // to allow getting the full Svg range using the primitive mechanisms.
+                            // This is needed since e.g. an SdrObject using this as graphic will
+                            // create a mapping transformation to exactly map the content to its
+                            // real life size
+                            const drawinglayer::primitive2d::Primitive2DReference xLine(
+                                new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
+                                    basegfx::utils::createPolygonFromRect(
+                                        aSvgCanvasRange),
+                                    basegfx::BColor(0.0, 0.0, 0.0)));
+                            const drawinglayer::primitive2d::Primitive2DReference xHidden(
+                                new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(
+                                    drawinglayer::primitive2d::Primitive2DContainer { xLine }));
+
+                            aSequence.push_back(xHidden);
+                        }
+                        else if(aSvgCanvasRange.overlaps(aContentRange))
+                        {
+                            // Clip is necessary. This will make Svg images evtl. smaller
+                            // than wanted from Svg (the free space which may be around it is
+                            // conform to the Svg spec), but avoids an expensive and unnecessary
+                            // clip. Keep the full Svg range here to get the correct mappings
+                            // to objects using this. Optimizations can be done in the processors
+                            const drawinglayer::primitive2d::Primitive2DReference xMask(
+                                new drawinglayer::primitive2d::MaskPrimitive2D(
+                                    basegfx::B2DPolyPolygon(
+                                        basegfx::utils::createPolygonFromRect(
+                                            aSvgCanvasRange)),
+                                    std::move(aSequence)));
+
+                            aSequence = drawinglayer::primitive2d::Primitive2DContainer { xMask };
+                        }
+                        else
+                        {
+                            // not inside, no overlap. Empty Svg
+                            aSequence.clear();
+                        }
+
+                        if(!aSequence.empty())
+                        {
+                            // Another correction:
+                            // If no Width/Height is set (usually done in
+                            // <svg ... width="215.9mm" height="279.4mm" >) which
+                            // is the case for own-Impress-exports, assume that
+                            // the Units are already 100ThMM.
+                            // Maybe only for own-Impress-exports, thus may need to be
+                            // &&ed with getDocument().findSvgNodeById("ooo:meta_slides"),
+                            // but does not need to be.
+                            bool bEmbedInFinalTransformPxTo100ThMM(true);
+
+                            if(getDocument().findSvgNodeById("ooo:meta_slides")
+                                && !getWidth().isSet()
+                                && !getHeight().isSet())
+                            {
+                                bEmbedInFinalTransformPxTo100ThMM = false;
+                            }
+
+                            if(bEmbedInFinalTransformPxTo100ThMM)
+                            {
+                                // embed in transform primitive to scale to 1/100th mm
+                                // to get from Svg coordinates (px) to drawinglayer coordinates
+                                constexpr double fScaleTo100thmm(o3tl::convert(1.0, o3tl::Length::px, o3tl::Length::mm100));
+                                const basegfx::B2DHomMatrix aTransform(
+                                    basegfx::utils::createScaleB2DHomMatrix(
+                                        fScaleTo100thmm,
+                                        fScaleTo100thmm));
+
+                                const drawinglayer::primitive2d::Primitive2DReference xTransform(
+                                    new drawinglayer::primitive2d::TransformPrimitive2D(
+                                        aTransform,
+                                        std::move(aSequence)));
+
+                                aSequence = drawinglayer::primitive2d::Primitive2DContainer { xTransform };
+                            }
+
+                            // append to result
+                            rTarget.append(aSequence);
+                        }
+                    }
+                }
+            }
+
+            if(!(aSequence.empty() && !getParent() && getViewBox()))
+                return;
+
+            // tdf#118232 No geometry, Outermost SVG element and we have a ViewBox.
+            // Create a HiddenGeometry Primitive containing an expanded
+            // hairline geometry to have the size contained
+            const drawinglayer::primitive2d::Primitive2DReference xLine(
+                new drawinglayer::primitive2d::PolygonHairlinePrimitive2D(
+                    basegfx::utils::createPolygonFromRect(
+                        *getViewBox()),
+                    basegfx::BColor(0.0, 0.0, 0.0)));
+            const drawinglayer::primitive2d::Primitive2DReference xHidden(
+                new drawinglayer::primitive2d::HiddenGeometryPrimitive2D(
+                    drawinglayer::primitive2d::Primitive2DContainer { xLine }));
+
+            rTarget.push_back(xHidden);
+        }
+
+        basegfx::B2DRange SvgSvgNode::getCurrentViewPort() const
+        {
+            if(getViewBox())
+            {
+                return *(getViewBox());
+            }
+            else // viewport should be given by x, y, width, and height
+            {
+                // Extract known viewport data
+                // bXXXIsAbsolute tracks whether relative values could be resolved to absolute values
+                if (getParent())
+                {
+                    // If width or height is not provided, the default 100% is used, see SVG 1.1 section 5.1.2
+                    // value 0.0 here is only to initialize variable
+                    bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
+                    double fW( bWidthIsAbsolute ? getWidth().solveNonPercentage(*this) : 0.0);
+                    bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
+                    double fH( bHeightIsAbsolute ? getHeight().solveNonPercentage(*this) : 0.0);
+
+                    // If x or y not provided, then default 0.0 is used, see SVG 1.1 Section 5.1.2
+                    bool bXIsAbsolute((getX().isSet() && SvgUnit::percent != getX().getUnit()) || !getX().isSet());
+                    double fX( bXIsAbsolute && getX().isSet() ? getX().solveNonPercentage(*this) : 0.0);
+
+                    bool bYIsAbsolute((getY().isSet() && SvgUnit::percent != getY().getUnit()) || !getY().isSet());
+                    double fY( bYIsAbsolute && getY().isSet() ? getY().solveNonPercentage(*this) : 0.0);
+
+                    if (bXIsAbsolute && bYIsAbsolute && bWidthIsAbsolute && bHeightIsAbsolute)
+                    {
+                        return basegfx::B2DRange(fX, fY, fX+fW, fY+fH);
+                    }
+                    else // try to resolve relative values
+                    {
+                        if (!bXIsAbsolute || !bWidthIsAbsolute)
+                        {
+                            // get width of enclosing svg and resolve percentage in x and width
+                            double fWReference(0.0);
+                            bool bHasFoundWidth(false);
+                            seekReferenceWidth(fWReference, bHasFoundWidth);
+                            // referenced values are already in 'user unit'
+                            if (!bXIsAbsolute && bHasFoundWidth)
+                            {
+                                fX = getX().getNumber() * 0.01 * fWReference;
+                                bXIsAbsolute = true;
+                            }
+                            if (!bWidthIsAbsolute && bHasFoundWidth)
+                            {
+                                fW = (getWidth().isSet() ? getWidth().getNumber() *0.01 : 1.0) * fWReference;
+                                bWidthIsAbsolute = true;
+                            }
+                        }
+                        if (!bYIsAbsolute || !bHeightIsAbsolute)
+                        {
+                            // get height of enclosing svg and resolve percentage in y and height
+                            double fHReference(0.0);
+                            bool bHasFoundHeight(false);
+                            seekReferenceHeight(fHReference, bHasFoundHeight);
+                            // referenced values are already in 'user unit'
+                            if (!bYIsAbsolute && bHasFoundHeight)
+                            {
+                                fY = getY().getNumber() * 0.01 * fHReference;
+                                bYIsAbsolute = true;
+                            }
+                            if (!bHeightIsAbsolute && bHasFoundHeight)
+                            {
+                                fH = (getHeight().isSet() ? getHeight().getNumber() *0.01 : 1.0) * fHReference;
+                                bHeightIsAbsolute = true;
+                            }
+                        }
+
+                        if (bXIsAbsolute && bYIsAbsolute && bWidthIsAbsolute && bHeightIsAbsolute)
+                        {
+                            return basegfx::B2DRange(fX, fY, fX+fW, fY+fH);
+                        }
+                        else // relative values could not be resolved, there exists no fallback
+                        {
+                            return SvgNode::getCurrentViewPort();
+                        }
+                    }
+                }
+                else //outermost svg
+                {
+                    // If width or height is not provided, the default would be 100%, see SVG 1.1 section 5.1.2
+                    // But here it cannot be resolved and no fallback exists.
+                    // SVG 1.1 defines in section 5.1.2 that x,y has no meaning for the outermost SVG element.
+                    bool bWidthIsAbsolute(getWidth().isSet() && SvgUnit::percent != getWidth().getUnit());
+                    bool bHeightIsAbsolute(getHeight().isSet() && SvgUnit::percent != getHeight().getUnit());
+                    if (bWidthIsAbsolute && bHeightIsAbsolute)
+                    {
+                        double fW( getWidth().solveNonPercentage(*this) );
+                        double fH( getHeight().solveNonPercentage(*this) );
+                        return basegfx::B2DRange(0.0, 0.0, fW, fH);
+                    }
+                    else // no fallback exists
+                    {
+                            return SvgNode::getCurrentViewPort();
+                    }
+                }
+// TODO: Is it possible to decompose and use the bounding box of the children, if even the
+//       outermost svg has no information to resolve percentage? Is it worth, how expensive is it?
+
+            }
+        }
+
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgsymbolnode.cxx b/svgio/source/svgreader/svgsymbolnode.cxx
new file mode 100644
index 0000000000..6e18d4bca0
--- /dev/null
+++ b/svgio/source/svgreader/svgsymbolnode.cxx
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgsymbolnode.hxx>
+
+namespace svgio::svgreader
+{
+        SvgSymbolNode::SvgSymbolNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Symbol, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgSymbolNode::~SvgSymbolNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgSymbolNode::getSvgStyleAttributes() const
+        {
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgSymbolNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::ViewBox:
+                {
+                    readViewBox(aContent, *this);
+                    break;
+                }
+                case SVGToken::PreserveAspectRatio:
+                {
+                    maSvgAspectRatio = readSvgAspectRatio(aContent);
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtextnode.cxx b/svgio/source/svgreader/svgtextnode.cxx
new file mode 100644
index 0000000000..ca17c2fc42
--- /dev/null
+++ b/svgio/source/svgreader/svgtextnode.cxx
@@ -0,0 +1,243 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtextnode.hxx>
+#include <svgcharacternode.hxx>
+#include <svgstyleattributes.hxx>
+#include <svgtrefnode.hxx>
+#include <svgtextpathnode.hxx>
+#include <svgtspannode.hxx>
+#include <osl/diagnose.h>
+
+namespace svgio::svgreader
+{
+        SvgTextNode::SvgTextNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgTspanNode(SVGToken::Text, rDocument, pParent)
+        {
+        }
+
+        SvgTextNode::~SvgTextNode()
+        {
+        }
+
+        void SvgTextNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgTspanNode::parseAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgTextNode::addTextPrimitives(
+            const SvgNode& rCandidate,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            drawinglayer::primitive2d::Primitive2DContainer&& rSource)
+        {
+            if(rSource.empty())
+                return;
+
+            const SvgStyleAttributes* pAttributes = rCandidate.getSvgStyleAttributes();
+
+            if(pAttributes)
+            {
+                // add text with taking all Fill/Stroke attributes into account
+                pAttributes->add_text(rTarget, std::move(rSource));
+            }
+            else
+            {
+                // should not happen, every subnode from SvgTextNode will at least
+                // return the attributes from SvgTextNode. Nonetheless, add text
+                rTarget.append(std::move(rSource));
+            }
+        }
+
+        void SvgTextNode::DecomposeChild(const SvgNode& rCandidate, drawinglayer::primitive2d::Primitive2DContainer& rTarget, SvgTextPosition& rSvgTextPosition) const
+        {
+            switch(rCandidate.getType())
+            {
+                case SVGToken::Character:
+                {
+                    // direct SvgTextPathNode derivates, decompose them
+                    const SvgCharacterNode& rSvgCharacterNode = static_cast< const SvgCharacterNode& >(rCandidate);
+                    rSvgCharacterNode.decomposeText(rTarget, rSvgTextPosition);
+                    break;
+                }
+                case SVGToken::TextPath:
+                {
+                    // direct TextPath decompose
+                    const SvgTextPathNode& rSvgTextPathNode = static_cast< const SvgTextPathNode& >(rCandidate);
+                    const auto& rChildren = rSvgTextPathNode.getChildren();
+                    const sal_uInt32 nCount(rChildren.size());
+
+                    if(nCount && rSvgTextPathNode.isValid())
+                    {
+                        // remember original TextStart to later detect hor/ver offsets
+                        const basegfx::B2DPoint aTextStart(rSvgTextPosition.getPosition());
+                        drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                        // decompose to regular TextPrimitives
+                        for(sal_uInt32 a(0); a < nCount; a++)
+                        {
+                            DecomposeChild(*rChildren[a], aNewTarget, rSvgTextPosition);
+                        }
+
+                        if(!aNewTarget.empty())
+                        {
+                            const drawinglayer::primitive2d::Primitive2DContainer aPathContent(aNewTarget);
+                            aNewTarget.clear();
+
+                            // dismantle TextPrimitives and map them on curve/path
+                            rSvgTextPathNode.decomposePathNode(aPathContent, aNewTarget, aTextStart);
+                        }
+
+                        if(!aNewTarget.empty())
+                        {
+                            addTextPrimitives(rCandidate, rTarget, std::move(aNewTarget));
+                        }
+                    }
+
+                    break;
+                }
+                case SVGToken::Tspan:
+                {
+                    // Tspan may have children, call recursively
+                    const SvgTspanNode& rSvgTspanNode = static_cast< const SvgTspanNode& >(rCandidate);
+                    const auto& rChildren = rSvgTspanNode.getChildren();
+                    const sal_uInt32 nCount(rChildren.size());
+
+                    if(nCount)
+                    {
+                        SvgTextPosition aSvgTextPosition(&rSvgTextPosition, rSvgTspanNode);
+                        drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                        for(sal_uInt32 a(0); a < nCount; a++)
+                        {
+                            DecomposeChild(*rChildren[a], aNewTarget, aSvgTextPosition);
+                        }
+
+                        rSvgTextPosition.setPosition(aSvgTextPosition.getPosition());
+
+                        if(!aNewTarget.empty())
+                        {
+                            addTextPrimitives(rCandidate, rTarget, std::move(aNewTarget));
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Tref:
+                {
+                    const SvgTrefNode& rSvgTrefNode = static_cast< const SvgTrefNode& >(rCandidate);
+                    const SvgTextNode* pRefText = rSvgTrefNode.getReferencedSvgTextNode();
+
+                    if(pRefText)
+                    {
+                        const auto& rChildren = pRefText->getChildren();
+                        const sal_uInt32 nCount(rChildren.size());
+                        drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+
+                        if(nCount)
+                        {
+                            for(sal_uInt32 a(0); a < nCount; a++)
+                            {
+                                const SvgNode& rChildCandidate = *rChildren[a];
+                                const_cast< SvgNode& >(rChildCandidate).setAlternativeParent(this);
+
+                                DecomposeChild(rChildCandidate, aNewTarget, rSvgTextPosition);
+                                const_cast< SvgNode& >(rChildCandidate).setAlternativeParent();
+                            }
+
+                            if(!aNewTarget.empty())
+                            {
+                                addTextPrimitives(rCandidate, rTarget, std::move(aNewTarget));
+                            }
+                        }
+                    }
+
+                    break;
+                }
+                default:
+                {
+                    OSL_ENSURE(false, "Unexpected node in text token (!)");
+                    break;
+                }
+            }
+        }
+
+        void SvgTextNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced`*/) const
+        {
+            // text has a group of child nodes, allowed are SVGToken::Character, SVGToken::Tspan,
+            // SVGToken::Tref and SVGToken::TextPath. These increase a given current text position
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(!pStyle || getChildren().empty())
+                return;
+
+            const double fOpacity(pStyle->getOpacity().getNumber());
+
+            if(fOpacity <= 0.0)
+                return;
+
+            SvgTextPosition aSvgTextPosition(nullptr, *this);
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+            const auto& rChildren = getChildren();
+            const sal_uInt32 nCount(rChildren.size());
+
+            for(sal_uInt32 a(0); a < nCount; a++)
+            {
+                const SvgNode& rCandidate = *rChildren[a];
+
+                DecomposeChild(rCandidate, aNewTarget, aSvgTextPosition);
+            }
+
+            if(!aNewTarget.empty())
+            {
+                drawinglayer::primitive2d::Primitive2DContainer aNewTarget2;
+
+                addTextPrimitives(*this, aNewTarget2, std::move(aNewTarget));
+                aNewTarget = aNewTarget2;
+            }
+
+            if(!aNewTarget.empty())
+            {
+                pStyle->add_postProcess(rTarget, std::move(aNewTarget), getTransform());
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtextpathnode.cxx b/svgio/source/svgreader/svgtextpathnode.cxx
new file mode 100644
index 0000000000..9ccdb93f59
--- /dev/null
+++ b/svgio/source/svgreader/svgtextpathnode.cxx
@@ -0,0 +1,436 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtextpathnode.hxx>
+#include <svgstyleattributes.hxx>
+#include <svgpathnode.hxx>
+#include <svgdocument.hxx>
+#include <basegfx/polygon/b2dpolygon.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
+#include <drawinglayer/primitive2d/textbreakuphelper.hxx>
+#include <drawinglayer/primitive2d/textprimitive2d.hxx>
+#include <basegfx/curve/b2dcubicbezier.hxx>
+#include <basegfx/curve/b2dbeziertools.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        namespace {
+
+        class pathTextBreakupHelper : public drawinglayer::primitive2d::TextBreakupHelper
+        {
+        private:
+            const basegfx::B2DPolygon&      mrPolygon;
+            const double                    mfBasegfxPathLength;
+            double                          mfPosition;
+            const basegfx::B2DPoint&        mrTextStart;
+
+            const sal_uInt32                mnMaxIndex;
+            sal_uInt32                      mnIndex;
+            basegfx::B2DCubicBezier         maCurrentSegment;
+            std::unique_ptr<basegfx::B2DCubicBezierHelper> mpB2DCubicBezierHelper;
+            double                          mfCurrentSegmentLength;
+            double                          mfSegmentStartPosition;
+
+        protected:
+            /// allow user callback to allow changes to the new TextTransformation. Default
+            /// does nothing.
+            virtual bool allowChange(sal_uInt32 nCount, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength) override;
+
+            void freeB2DCubicBezierHelper();
+            basegfx::B2DCubicBezierHelper* getB2DCubicBezierHelper();
+            void advanceToPosition(double fNewPosition);
+
+        public:
+            pathTextBreakupHelper(
+                const drawinglayer::primitive2d::TextSimplePortionPrimitive2D& rSource,
+                const basegfx::B2DPolygon& rPolygon,
+                const double fBasegfxPathLength,
+                double fPosition,
+                const basegfx::B2DPoint& rTextStart);
+            virtual ~pathTextBreakupHelper() override;
+
+            // read access to evtl. advanced position
+            double getPosition() const { return mfPosition; }
+        };
+
+        }
+
+        void pathTextBreakupHelper::freeB2DCubicBezierHelper()
+        {
+            mpB2DCubicBezierHelper.reset();
+        }
+
+        basegfx::B2DCubicBezierHelper* pathTextBreakupHelper::getB2DCubicBezierHelper()
+        {
+            if(!mpB2DCubicBezierHelper && maCurrentSegment.isBezier())
+            {
+                mpB2DCubicBezierHelper.reset(new basegfx::B2DCubicBezierHelper(maCurrentSegment));
+            }
+
+            return mpB2DCubicBezierHelper.get();
+        }
+
+        void pathTextBreakupHelper::advanceToPosition(double fNewPosition)
+        {
+            while(mfSegmentStartPosition + mfCurrentSegmentLength < fNewPosition && mnIndex < mnMaxIndex)
+            {
+                mfSegmentStartPosition += mfCurrentSegmentLength;
+                mnIndex++;
+
+                if(mnIndex < mnMaxIndex)
+                {
+                    freeB2DCubicBezierHelper();
+                    mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
+                    maCurrentSegment.testAndSolveTrivialBezier();
+                    mfCurrentSegmentLength = getB2DCubicBezierHelper()
+                        ? getB2DCubicBezierHelper()->getLength()
+                        : maCurrentSegment.getLength();
+                }
+            }
+
+            mfPosition = fNewPosition;
+        }
+
+        pathTextBreakupHelper::pathTextBreakupHelper(
+            const drawinglayer::primitive2d::TextSimplePortionPrimitive2D& rSource,
+            const basegfx::B2DPolygon& rPolygon,
+            const double fBasegfxPathLength,
+            double fPosition,
+            const basegfx::B2DPoint& rTextStart)
+        :   drawinglayer::primitive2d::TextBreakupHelper(rSource),
+            mrPolygon(rPolygon),
+            mfBasegfxPathLength(fBasegfxPathLength),
+            mfPosition(0.0),
+            mrTextStart(rTextStart),
+            mnMaxIndex(rPolygon.isClosed() ? rPolygon.count() : rPolygon.count() - 1),
+            mnIndex(0),
+            mfCurrentSegmentLength(0.0),
+            mfSegmentStartPosition(0.0)
+        {
+            mrPolygon.getBezierSegment(mnIndex % mrPolygon.count(), maCurrentSegment);
+            mfCurrentSegmentLength = maCurrentSegment.getLength();
+
+            advanceToPosition(fPosition);
+        }
+
+        pathTextBreakupHelper::~pathTextBreakupHelper()
+        {
+            freeB2DCubicBezierHelper();
+        }
+
+        bool pathTextBreakupHelper::allowChange(sal_uInt32 /*nCount*/, basegfx::B2DHomMatrix& rNewTransform, sal_uInt32 nIndex, sal_uInt32 nLength)
+        {
+            bool bRetval(false);
+
+            if(mfPosition < mfBasegfxPathLength && nLength && mnIndex < mnMaxIndex)
+            {
+                const double fSnippetWidth(
+                    getTextLayouter().getTextWidth(
+                        getSource().getText(),
+                        nIndex,
+                        nLength));
+
+                if(basegfx::fTools::more(fSnippetWidth, 0.0))
+                {
+                    const OUString aText(getSource().getText());
+                    const std::u16string_view aTrimmedChars(o3tl::trim(aText.subView(nIndex, nLength)));
+                    const double fEndPos(mfPosition + fSnippetWidth);
+
+                    if(!aTrimmedChars.empty() && (mfPosition < mfBasegfxPathLength || fEndPos > 0.0))
+                    {
+                        const double fHalfSnippetWidth(fSnippetWidth * 0.5);
+
+                        advanceToPosition(mfPosition + fHalfSnippetWidth);
+
+                        // create representation for this snippet
+                        bRetval = true;
+
+                        // get target position and tangent in that point
+                        basegfx::B2DPoint aPosition(0.0, 0.0);
+                        basegfx::B2DVector aTangent(0.0, 1.0);
+
+                        if(mfPosition < 0.0)
+                        {
+                            // snippet center is left of first segment, but right edge is on it (SVG allows that)
+                            aTangent = maCurrentSegment.getTangent(0.0);
+                            aTangent.normalize();
+                            aPosition = maCurrentSegment.getStartPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
+                        }
+                        else if(mfPosition > mfBasegfxPathLength)
+                        {
+                            // snippet center is right of last segment, but left edge is on it (SVG allows that)
+                            aTangent = maCurrentSegment.getTangent(1.0);
+                            aTangent.normalize();
+                            aPosition = maCurrentSegment.getEndPoint() + (aTangent * (mfPosition - mfSegmentStartPosition));
+                        }
+                        else
+                        {
+                            // snippet center inside segment, interpolate
+                            double fBezierDistance(mfPosition - mfSegmentStartPosition);
+
+                            if(getB2DCubicBezierHelper())
+                            {
+                                // use B2DCubicBezierHelper to bridge the non-linear gap between
+                                // length and bezier distances (if it's a bezier segment)
+                                fBezierDistance = getB2DCubicBezierHelper()->distanceToRelative(fBezierDistance);
+                            }
+                            else
+                            {
+                                // linear relationship, make relative to segment length
+                                fBezierDistance = fBezierDistance / mfCurrentSegmentLength;
+                            }
+
+                            aPosition = maCurrentSegment.interpolatePoint(fBezierDistance);
+                            aTangent = maCurrentSegment.getTangent(fBezierDistance);
+                            aTangent.normalize();
+                        }
+
+                        // detect evtl. hor/ver translations (depends on text direction)
+                        const basegfx::B2DPoint aBasePoint(rNewTransform * basegfx::B2DPoint(0.0, 0.0));
+                        const basegfx::B2DVector aOffset(aBasePoint - mrTextStart);
+
+                        if(!basegfx::fTools::equalZero(aOffset.getY()))
+                        {
+                            // ...and apply
+                            aPosition.setY(aPosition.getY() + aOffset.getY());
+                        }
+
+                        // move target position from snippet center to left text start
+                        aPosition -= fHalfSnippetWidth * aTangent;
+
+                        // remove current translation
+                        rNewTransform.translate(-aBasePoint.getX(), -aBasePoint.getY());
+
+                        // rotate due to tangent
+                        rNewTransform.rotate(atan2(aTangent.getY(), aTangent.getX()));
+
+                        // add new translation
+                        rNewTransform.translate(aPosition.getX(), aPosition.getY());
+                    }
+
+                    // advance to end
+                    advanceToPosition(fEndPos);
+                }
+            }
+
+            return bRetval;
+        }
+
+} // end of namespace svgio::svgreader
+
+
+namespace svgio::svgreader
+{
+        SvgTextPathNode::SvgTextPathNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::TextPath, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgTextPathNode::~SvgTextPathNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgTextPathNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgTextPathNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::StartOffset:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maStartOffset = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Method:
+                {
+                    break;
+                }
+                case SVGToken::Spacing:
+                {
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    readLocalLink(aContent, maXLink);
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        bool SvgTextPathNode::isValid() const
+        {
+            const SvgPathNode* pSvgPathNode = dynamic_cast< const SvgPathNode* >(getDocument().findSvgNodeById(maXLink));
+
+            if(!pSvgPathNode)
+            {
+                return false;
+            }
+
+            const std::optional<basegfx::B2DPolyPolygon>& pPolyPolyPath = pSvgPathNode->getPath();
+
+            if(!pPolyPolyPath || !pPolyPolyPath->count())
+            {
+                return false;
+            }
+
+            const basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
+
+            if(!aPolygon.count())
+            {
+                return false;
+            }
+
+            const double fBasegfxPathLength(basegfx::utils::getLength(aPolygon));
+
+            return !basegfx::fTools::equalZero(fBasegfxPathLength);
+        }
+
+        void SvgTextPathNode::decomposePathNode(
+            const drawinglayer::primitive2d::Primitive2DContainer& rPathContent,
+            drawinglayer::primitive2d::Primitive2DContainer& rTarget,
+            const basegfx::B2DPoint& rTextStart) const
+        {
+            if(rPathContent.empty())
+                return;
+
+            const SvgPathNode* pSvgPathNode = dynamic_cast< const SvgPathNode* >(getDocument().findSvgNodeById(maXLink));
+
+            if(!pSvgPathNode)
+                return;
+
+            const std::optional<basegfx::B2DPolyPolygon>& pPolyPolyPath = pSvgPathNode->getPath();
+
+            if(!(pPolyPolyPath && pPolyPolyPath->count()))
+                return;
+
+            basegfx::B2DPolygon aPolygon(pPolyPolyPath->getB2DPolygon(0));
+
+            if(pSvgPathNode->getTransform())
+            {
+                aPolygon.transform(*pSvgPathNode->getTransform());
+            }
+
+            const double fBasegfxPathLength(basegfx::utils::getLength(aPolygon));
+
+            if(basegfx::fTools::equalZero(fBasegfxPathLength))
+                return;
+
+            double fUserToBasegfx(1.0); // multiply: user->basegfx, divide: basegfx->user
+
+            if(pSvgPathNode->getPathLength().isSet())
+            {
+                const double fUserLength(pSvgPathNode->getPathLength().solve(*this));
+
+                if(fUserLength > 0.0 && !basegfx::fTools::equal(fUserLength, fBasegfxPathLength))
+                {
+                    fUserToBasegfx = fUserLength / fBasegfxPathLength;
+                }
+            }
+
+            double fPosition(0.0);
+
+            if(getStartOffset().isSet())
+            {
+                if (SvgUnit::percent == getStartOffset().getUnit())
+                {
+                    // percent are relative to path length
+                    fPosition = getStartOffset().getNumber() * 0.01 * fBasegfxPathLength;
+                }
+                else
+                {
+                    fPosition = getStartOffset().solve(*this) * fUserToBasegfx;
+                }
+            }
+
+            if(fPosition < 0.0)
+                return;
+
+            const sal_Int32 nLength(rPathContent.size());
+            sal_Int32 nCurrent(0);
+
+            while(fPosition < fBasegfxPathLength && nCurrent < nLength)
+            {
+                const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* pCandidate = nullptr;
+                const drawinglayer::primitive2d::Primitive2DReference xReference(rPathContent[nCurrent]);
+
+                if(xReference.is())
+                {
+                    pCandidate = dynamic_cast< const drawinglayer::primitive2d::TextSimplePortionPrimitive2D* >(xReference.get());
+                }
+
+                if(pCandidate)
+                {
+                    pathTextBreakupHelper aPathTextBreakupHelper(
+                        *pCandidate,
+                        aPolygon,
+                        fBasegfxPathLength,
+                        fPosition,
+                        rTextStart);
+
+                    drawinglayer::primitive2d::Primitive2DContainer aResult =
+                        aPathTextBreakupHelper.extractResult();
+
+                    if(!aResult.empty())
+                    {
+                        rTarget.append(std::move(aResult));
+                    }
+
+                    // advance position to consumed
+                    fPosition = aPathTextBreakupHelper.getPosition();
+                }
+
+                nCurrent++;
+            }
+        }
+
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtextposition.cxx b/svgio/source/svgreader/svgtextposition.cxx
new file mode 100644
index 0000000000..50a896ba22
--- /dev/null
+++ b/svgio/source/svgreader/svgtextposition.cxx
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtextposition.hxx>
+
+using namespace drawinglayer::primitive2d;
+
+namespace svgio::svgreader
+{
+SvgTextPosition::SvgTextPosition(SvgTextPosition* pParent, const SvgTspanNode& rSvgTspanNode)
+    : mpParent(pParent)
+    , maRotate(solveSvgNumberVector(rSvgTspanNode.getRotate(), rSvgTspanNode))
+    , mfTextLength(0.0)
+    , mnRotationIndex(0)
+    , mbLengthAdjust(rSvgTspanNode.getLengthAdjust())
+    , mbAbsoluteX(false)
+{
+    const InfoProvider& rInfoProvider(rSvgTspanNode);
+
+    // get TextLength if provided
+    if (rSvgTspanNode.getTextLength().isSet())
+    {
+        mfTextLength = rSvgTspanNode.getTextLength().solve(rInfoProvider);
+    }
+
+    // SVG does not really define in which units a \91rotate\92 for Text/TSpan is given,
+    // but it seems to be degrees. Convert here to radians
+    if (!maRotate.empty())
+    {
+        for (double& f : maRotate)
+        {
+            f = basegfx::deg2rad(f);
+        }
+    }
+
+    // get text positions X
+    const sal_uInt32 nSizeX(rSvgTspanNode.getX().size());
+
+    if (nSizeX)
+    {
+        // we have absolute positions, get first one as current text position X
+        maPosition.setX(rSvgTspanNode.getX()[0].solve(rInfoProvider, NumberType::xcoordinate));
+        mbAbsoluteX = true;
+    }
+    else
+    {
+        // no absolute position, get from parent
+        if (pParent)
+        {
+            maPosition.setX(pParent->getPosition().getX());
+        }
+    }
+
+    const sal_uInt32 nSizeDx(rSvgTspanNode.getDx().size());
+    if (nSizeDx)
+    {
+        // relative positions given, translate position derived from parent
+        maPosition.setX(maPosition.getX()
+                        + rSvgTspanNode.getDx()[0].solve(rInfoProvider, NumberType::xcoordinate));
+    }
+
+    // fill deltas to maX
+    maX.reserve(nSizeX);
+
+    for (sal_uInt32 a(1); a < std::max(nSizeX, nSizeDx); ++a)
+    {
+        if (a < nSizeX)
+        {
+            double nPos = rSvgTspanNode.getX()[a].solve(rInfoProvider, NumberType::xcoordinate)
+                          - maPosition.getX();
+
+            if (a < nSizeDx)
+            {
+                nPos += rSvgTspanNode.getDx()[a].solve(rInfoProvider, NumberType::xcoordinate);
+            }
+
+            maX.push_back(nPos);
+        }
+        else
+        {
+            // Apply them later since it also needs the character width to calculate
+            // the final character position
+            maDx.push_back(rSvgTspanNode.getDx()[a].solve(rInfoProvider, NumberType::xcoordinate));
+        }
+    }
+
+    // get text positions Y
+    const sal_uInt32 nSizeY(rSvgTspanNode.getY().size());
+
+    if (nSizeY)
+    {
+        // we have absolute positions, get first one as current text position Y
+        maPosition.setY(rSvgTspanNode.getY()[0].solve(rInfoProvider, NumberType::ycoordinate));
+        mbAbsoluteX = true;
+    }
+    else
+    {
+        // no absolute position, get from parent
+        if (pParent)
+        {
+            maPosition.setY(pParent->getPosition().getY());
+        }
+    }
+
+    const sal_uInt32 nSizeDy(rSvgTspanNode.getDy().size());
+
+    if (nSizeDy)
+    {
+        // relative positions given, translate position derived from parent
+        maPosition.setY(maPosition.getY()
+                        + rSvgTspanNode.getDy()[0].solve(rInfoProvider, NumberType::ycoordinate));
+    }
+
+    // fill deltas to maY
+    maY.reserve(nSizeY);
+
+    for (sal_uInt32 a(1); a < nSizeY; a++)
+    {
+        double nPos = rSvgTspanNode.getY()[a].solve(rInfoProvider, NumberType::ycoordinate)
+                      - maPosition.getY();
+
+        if (a < nSizeDy)
+        {
+            nPos += rSvgTspanNode.getDy()[a].solve(rInfoProvider, NumberType::ycoordinate);
+        }
+
+        maY.push_back(nPos);
+    }
+}
+
+bool SvgTextPosition::isRotated() const
+{
+    if (maRotate.empty())
+    {
+        if (getParent())
+        {
+            return getParent()->isRotated();
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else
+    {
+        return true;
+    }
+}
+
+double SvgTextPosition::consumeRotation()
+{
+    double fRetval(0.0);
+
+    if (maRotate.empty())
+    {
+        if (getParent())
+        {
+            fRetval = mpParent->consumeRotation();
+        }
+        else
+        {
+            fRetval = 0.0;
+        }
+    }
+    else
+    {
+        const sal_uInt32 nSize(maRotate.size());
+
+        if (mnRotationIndex < nSize)
+        {
+            fRetval = maRotate[mnRotationIndex++];
+        }
+        else
+        {
+            fRetval = maRotate[nSize - 1];
+        }
+    }
+
+    return fRetval;
+}
+
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtitledescnode.cxx b/svgio/source/svgreader/svgtitledescnode.cxx
new file mode 100644
index 0000000000..8498762cc6
--- /dev/null
+++ b/svgio/source/svgreader/svgtitledescnode.cxx
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtitledescnode.hxx>
+#include <osl/diagnose.h>
+
+
+namespace svgio::svgreader
+{
+        SvgTitleDescNode::SvgTitleDescNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(aType, rDocument, pParent)
+        {
+            OSL_ENSURE(aType == SVGToken::Title || aType == SVGToken::Desc, "SvgTitleDescNode should only be used for Title and Desc (!)");
+        }
+
+        SvgTitleDescNode::~SvgTitleDescNode()
+        {
+        }
+
+        void SvgTitleDescNode::concatenate(std::u16string_view rChars)
+        {
+            maText += rChars;
+        }
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtoken.cxx b/svgio/source/svgreader/svgtoken.cxx
new file mode 100644
index 0000000000..fa28c8647c
--- /dev/null
+++ b/svgio/source/svgreader/svgtoken.cxx
@@ -0,0 +1,214 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtoken.hxx>
+#include <frozen/bits/defines.h>
+#include <frozen/bits/elsa_std.h>
+#include <frozen/unordered_map.h>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+
+constexpr auto aSVGTokenMap = frozen::make_unordered_map<std::u16string_view, SVGToken>(
+{
+    { u"width", SVGToken::Width },
+    { u"height", SVGToken::Height },
+    { u"viewBox", SVGToken::ViewBox },
+    { u"transform", SVGToken::Transform },
+    { u"style", SVGToken::Style },
+    { u"display", SVGToken::Display }, // #i121656#
+    { u"d", SVGToken::D },
+    { u"x", SVGToken::X },
+    { u"y", SVGToken::Y },
+    { u"xmlns", SVGToken::Xmlns },
+    { u"version", SVGToken::Version },
+    { u"id", SVGToken::Id },
+    { u"in", SVGToken::In },
+    { u"rx", SVGToken::Rx },
+    { u"ry", SVGToken::Ry },
+    { u"points", SVGToken::Points },
+    { u"dx", SVGToken::Dx },
+    { u"dy", SVGToken::Dy },
+    { u"rotate", SVGToken::Rotate },
+    { u"textLength", SVGToken::TextLength },
+    { u"lengthAdjust", SVGToken::LengthAdjust },
+    { u"font", SVGToken::Font },
+    { u"font-family", SVGToken::FontFamily },
+    { u"font-size", SVGToken::FontSize },
+    { u"font-size-adjust", SVGToken::FontSizeAdjust },
+    { u"font-stretch", SVGToken::FontStretch },
+    { u"font-style", SVGToken::FontStyle },
+    { u"font-variant", SVGToken::FontVariant },
+    { u"font-weight", SVGToken::FontWeight },
+    { u"direction", SVGToken::Direction },
+    { u"letter-spacing", SVGToken::LetterSpacing },
+    { u"text-decoration", SVGToken::TextDecoration },
+    { u"unicode-bidi", SVGToken::UnicodeBidi },
+    { u"word-spacing", SVGToken::WordSpacing },
+    { u"tspan", SVGToken::Tspan },
+    { u"tref", SVGToken::Tref },
+    { u"textPath", SVGToken::TextPath },
+    { u"startOffset", SVGToken::StartOffset },
+    { u"method", SVGToken::Method },
+    { u"spacing", SVGToken::Spacing },
+    { u"stdDeviation", SVGToken::StdDeviation },
+    { u"text-align", SVGToken::TextAlign },
+    { u"pathLength", SVGToken::PathLength },
+    { u"type", SVGToken::Type },
+    { u"class", SVGToken::Class },
+    { u"text-anchor", SVGToken::TextAnchor },
+    { u"xml:space", SVGToken::XmlSpace },
+    { u"color", SVGToken::Color },
+    { u"clipPath", SVGToken::ClipPathNode },
+    { u"clip-path", SVGToken::ClipPathProperty },
+    { u"feColorMatrix", SVGToken::FeColorMatrix },
+    { u"feDropShadow", SVGToken::FeDropShadow },
+    { u"feFlood", SVGToken::FeFlood },
+    { u"feImage", SVGToken::FeImage },
+    { u"feGaussianBlur", SVGToken::FeGaussianBlur },
+    { u"feOffset", SVGToken::FeOffset },
+    { u"filter", SVGToken::Filter },
+    { u"flood-color", SVGToken::FloodColor },
+    { u"flood-opacity", SVGToken::FloodOpacity },
+    { u"mask", SVGToken::Mask },
+    { u"clipPathUnits", SVGToken::ClipPathUnits },
+    { u"maskUnits", SVGToken::MaskUnits },
+    { u"maskContentUnits", SVGToken::MaskContentUnits },
+    { u"clip-rule", SVGToken::ClipRule },
+    { u"marker", SVGToken::Marker },
+    { u"marker-start", SVGToken::MarkerStart },
+    { u"marker-mid", SVGToken::MarkerMid },
+    { u"marker-end", SVGToken::MarkerEnd },
+    { u"refX", SVGToken::RefX },
+    { u"refY", SVGToken::RefY },
+    { u"markerUnits", SVGToken::MarkerUnits },
+    { u"markerWidth", SVGToken::MarkerWidth },
+    { u"markerHeight", SVGToken::MarkerHeight },
+    { u"orient", SVGToken::Orient },
+    { u"pattern", SVGToken::Pattern },
+    { u"patternUnits", SVGToken::PatternUnits },
+    { u"patternContentUnits", SVGToken::PatternContentUnits },
+    { u"patternTransform", SVGToken::PatternTransform },
+    { u"opacity", SVGToken::Opacity },
+    { u"visibility", SVGToken::Visibility },
+    { u"title", SVGToken::Title },
+    { u"desc", SVGToken::Desc },
+    { u"preserveAspectRatio", SVGToken::PreserveAspectRatio },
+    { u"defer", SVGToken::Defer },
+    { u"none", SVGToken::None },
+    { u"xMinYMin", SVGToken::XMinYMin },
+    { u"xMidYMin", SVGToken::XMidYMin },
+    { u"xMaxYMin", SVGToken::XMaxYMin },
+    { u"xMinYMid", SVGToken::XMinYMid },
+    { u"xMidYMid", SVGToken::XMidYMid },
+    { u"xMaxYMid", SVGToken::XMaxYMid },
+    { u"xMinYMax", SVGToken::XMinYMax },
+    { u"xMidYMax", SVGToken::XMidYMax },
+    { u"xMaxYMax", SVGToken::XMaxYMax },
+    { u"meet", SVGToken::Meet },
+    { u"slice", SVGToken::Slice },
+    { u"values", SVGToken::Values },
+
+    { u"defs", SVGToken::Defs },
+    { u"g", SVGToken::G },
+    { u"svg", SVGToken::Svg },
+    { u"symbol", SVGToken::Symbol },
+    { u"switch", SVGToken::Switch },
+    { u"use", SVGToken::Use },
+    { u"a", SVGToken::A },
+
+    { u"circle", SVGToken::Circle },
+    { u"ellipse", SVGToken::Ellipse },
+    { u"line", SVGToken::Line },
+    { u"path", SVGToken::Path },
+    { u"polygon", SVGToken::Polygon },
+    { u"polyline", SVGToken::Polyline },
+    { u"rect", SVGToken::Rect },
+    { u"image", SVGToken::Image },
+
+    { u"linearGradient", SVGToken::LinearGradient },
+    { u"radialGradient", SVGToken::RadialGradient },
+    { u"stop", SVGToken::Stop },
+    { u"offset", SVGToken::Offset },
+    { u"x1", SVGToken::X1 },
+    { u"y1", SVGToken::Y1 },
+    { u"x2", SVGToken::X2 },
+    { u"y2", SVGToken::Y2 },
+    { u"cx", SVGToken::Cx },
+    { u"cy", SVGToken::Cy },
+    { u"fx", SVGToken::Fx },
+    { u"fy", SVGToken::Fy },
+    { u"r", SVGToken::R },
+    { u"gradientUnits", SVGToken::GradientUnits },
+    { u"gradientTransform", SVGToken::GradientTransform },
+    { u"spreadMethod", SVGToken::SpreadMethod },
+    { u"href", SVGToken::Href },
+    { u"xlink:href", SVGToken::XlinkHref },
+    { u"stop-color", SVGToken::StopColor },
+    { u"stop-opacity", SVGToken::StopOpacity },
+
+    { u"fill", SVGToken::Fill },
+    { u"fill-opacity", SVGToken::FillOpacity },
+    { u"fill-rule", SVGToken::FillRule },
+
+    { u"stroke", SVGToken::Stroke },
+    { u"stroke-dasharray", SVGToken::StrokeDasharray },
+    { u"stroke-dashoffset", SVGToken::StrokeDashoffset },
+    { u"stroke-linecap", SVGToken::StrokeLinecap },
+    { u"stroke-linejoin", SVGToken::StrokeLinejoin },
+    { u"stroke-miterlimit", SVGToken::StrokeMiterlimit },
+    { u"stroke-opacity", SVGToken::StrokeOpacity },
+    { u"stroke-width", SVGToken::StrokeWidth },
+
+    { u"text", SVGToken::Text },
+    { u"baseline-shift", SVGToken::BaselineShift },
+    { u"dominant-baseline", SVGToken::DominantBaseline }
+});
+
+SVGToken StrToSVGToken(std::u16string_view rStr, bool bIgnoreCase)
+{
+    std::u16string_view aStr = rStr.starts_with(u"svg:") ? rStr.substr(4) : rStr;
+
+    // TODO: a better alternative to the bIgnoreCase would be separate maps for SVG and CSS,
+    // the latter using case-insensitive hasher and comparator, with separate search functions.
+
+    auto it = bIgnoreCase ? std::find_if(aSVGTokenMap.begin(), aSVGTokenMap.end(),
+                                         [aStr](const auto& el)
+                                         { return o3tl::equalsIgnoreAsciiCase(el.first, aStr); })
+                          : aSVGTokenMap.find(aStr);
+    if (it != aSVGTokenMap.end())
+        return it->second;
+
+    return SVGToken::Unknown;
+}
+
+OUString SVGTokenToStr(const SVGToken& rToken)
+{
+    auto it = std::find_if(aSVGTokenMap.begin(), aSVGTokenMap.end(),
+                           [rToken](const auto& el) { return el.second == rToken; });
+    if (it != aSVGTokenMap.end())
+        return OUString(it->first);
+
+    return OUString();
+}
+
+} // end of namespace svgio
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtools.cxx b/svgio/source/svgreader/svgtools.cxx
new file mode 100644
index 0000000000..999de30753
--- /dev/null
+++ b/svgio/source/svgreader/svgtools.cxx
@@ -0,0 +1,1516 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtools.hxx>
+#include <sal/log.hxx>
+#include <tools/color.hxx>
+#include <rtl/math.hxx>
+#include <o3tl/string_view.hxx>
+#include <basegfx/matrix/b2dhommatrix.hxx>
+#include <basegfx/matrix/b2dhommatrixtools.hxx>
+#include <basegfx/matrix/b3dhommatrix.hxx>
+#include <svgtoken.hxx>
+#include <frozen/bits/defines.h>
+#include <frozen/bits/elsa_std.h>
+#include <frozen/unordered_map.h>
+
+namespace svgio::svgreader
+{
+        constexpr auto aColorTokenMapperList = frozen::make_unordered_map<std::u16string_view, Color>(
+        {
+            { u"aliceblue", Color(240, 248, 255) },
+            { u"antiquewhite", Color(250, 235, 215) },
+            { u"aqua", Color( 0, 255, 255) },
+            { u"aquamarine", Color(127, 255, 212) },
+            { u"azure", Color(240, 255, 255) },
+            { u"beige", Color(245, 245, 220) },
+            { u"bisque", Color(255, 228, 196) },
+            { u"black", Color( 0, 0, 0) },
+            { u"blanchedalmond", Color(255, 235, 205) },
+            { u"blue", Color( 0, 0, 255) },
+            { u"blueviolet", Color(138, 43, 226) },
+            { u"brown", Color(165, 42, 42) },
+            { u"burlywood", Color(222, 184, 135) },
+            { u"cadetblue", Color( 95, 158, 160) },
+            { u"chartreuse", Color(127, 255, 0) },
+            { u"chocolate", Color(210, 105, 30) },
+            { u"coral", Color(255, 127, 80) },
+            { u"cornflowerblue", Color(100, 149, 237) },
+            { u"cornsilk", Color(255, 248, 220) },
+            { u"crimson", Color(220, 20, 60) },
+            { u"cyan", Color( 0, 255, 255) },
+            { u"darkblue", Color( 0, 0, 139) },
+            { u"darkcyan", Color( 0, 139, 139) },
+            { u"darkgoldenrod", Color(184, 134, 11) },
+            { u"darkgray", Color(169, 169, 169) },
+            { u"darkgreen", Color( 0, 100, 0) },
+            { u"darkgrey", Color(169, 169, 169) },
+            { u"darkkhaki", Color(189, 183, 107) },
+            { u"darkmagenta", Color(139, 0, 139) },
+            { u"darkolivegreen", Color( 85, 107, 47) },
+            { u"darkorange", Color(255, 140, 0) },
+            { u"darkorchid", Color(153, 50, 204) },
+            { u"darkred", Color(139, 0, 0) },
+            { u"darksalmon", Color(233, 150, 122) },
+            { u"darkseagreen", Color(143, 188, 143) },
+            { u"darkslateblue", Color( 72, 61, 139) },
+            { u"darkslategray", Color( 47, 79, 79) },
+            { u"darkslategrey", Color( 47, 79, 79) },
+            { u"darkturquoise", Color( 0, 206, 209) },
+            { u"darkviolet", Color(148, 0, 211) },
+            { u"deeppink", Color(255, 20, 147) },
+            { u"deepskyblue", Color( 0, 191, 255) },
+            { u"dimgray", Color(105, 105, 105) },
+            { u"dimgrey", Color(105, 105, 105) },
+            { u"dodgerblue", Color( 30, 144, 255) },
+            { u"firebrick", Color(178, 34, 34) },
+            { u"floralwhite", Color(255, 250, 240) },
+            { u"forestgreen", Color( 34, 139, 34) },
+            { u"fuchsia", Color(255, 0, 255) },
+            { u"gainsboro", Color(220, 220, 220) },
+            { u"ghostwhite", Color(248, 248, 255) },
+            { u"gold", Color(255, 215, 0) },
+            { u"goldenrod", Color(218, 165, 32) },
+            { u"gray", Color(128, 128, 128) },
+            { u"grey", Color(128, 128, 128) },
+            { u"green", Color(0, 128, 0) },
+            { u"greenyellow", Color(173, 255, 47) },
+            { u"honeydew", Color(240, 255, 240) },
+            { u"hotpink", Color(255, 105, 180) },
+            { u"indianred", Color(205, 92, 92) },
+            { u"indigo", Color( 75, 0, 130) },
+            { u"ivory", Color(255, 255, 240) },
+            { u"khaki", Color(240, 230, 140) },
+            { u"lavender", Color(230, 230, 250) },
+            { u"lavenderblush", Color(255, 240, 245) },
+            { u"lawngreen", Color(124, 252, 0) },
+            { u"lemonchiffon", Color(255, 250, 205) },
+            { u"lightblue", Color(173, 216, 230) },
+            { u"lightcoral", Color(240, 128, 128) },
+            { u"lightcyan", Color(224, 255, 255) },
+            { u"lightgoldenrodyellow", Color(250, 250, 210) },
+            { u"lightgray", Color(211, 211, 211) },
+            { u"lightgreen", Color(144, 238, 144) },
+            { u"lightgrey", Color(211, 211, 211) },
+            { u"lightpink", Color(255, 182, 193) },
+            { u"lightsalmon", Color(255, 160, 122) },
+            { u"lightseagreen", Color( 32, 178, 170) },
+            { u"lightskyblue", Color(135, 206, 250) },
+            { u"lightslategray", Color(119, 136, 153) },
+            { u"lightslategrey", Color(119, 136, 153) },
+            { u"lightsteelblue", Color(176, 196, 222) },
+            { u"lightyellow", Color(255, 255, 224) },
+            { u"lime", Color( 0, 255, 0) },
+            { u"limegreen", Color( 50, 205, 50) },
+            { u"linen", Color(250, 240, 230) },
+            { u"magenta", Color(255, 0, 255) },
+            { u"maroon", Color(128, 0, 0) },
+            { u"mediumaquamarine", Color(102, 205, 170) },
+            { u"mediumblue", Color( 0, 0, 205) },
+            { u"mediumorchid", Color(186, 85, 211) },
+            { u"mediumpurple", Color(147, 112, 219) },
+            { u"mediumseagreen", Color( 60, 179, 113) },
+            { u"mediumslateblue", Color(123, 104, 238) },
+            { u"mediumspringgreen", Color( 0, 250, 154) },
+            { u"mediumturquoise", Color( 72, 209, 204) },
+            { u"mediumvioletred", Color(199, 21, 133) },
+            { u"midnightblue", Color( 25, 25, 112) },
+            { u"mintcream", Color(245, 255, 250) },
+            { u"mistyrose", Color(255, 228, 225) },
+            { u"moccasin", Color(255, 228, 181) },
+            { u"navajowhite", Color(255, 222, 173) },
+            { u"navy", Color( 0, 0, 128) },
+            { u"oldlace", Color(253, 245, 230) },
+            { u"olive", Color(128, 128, 0) },
+            { u"olivedrab", Color(107, 142, 35) },
+            { u"orange", Color(255, 165, 0) },
+            { u"orangered", Color(255, 69, 0) },
+            { u"orchid", Color(218, 112, 214) },
+            { u"palegoldenrod", Color(238, 232, 170) },
+            { u"palegreen", Color(152, 251, 152) },
+            { u"paleturquoise", Color(175, 238, 238) },
+            { u"palevioletred", Color(219, 112, 147) },
+            { u"papayawhip", Color(255, 239, 213) },
+            { u"peachpuff", Color(255, 218, 185) },
+            { u"peru", Color(205, 133, 63) },
+            { u"pink", Color(255, 192, 203) },
+            { u"plum", Color(221, 160, 221) },
+            { u"powderblue", Color(176, 224, 230) },
+            { u"purple", Color(128, 0, 128) },
+            { u"red", Color(255, 0, 0) },
+            { u"rosybrown", Color(188, 143, 143) },
+            { u"royalblue", Color( 65, 105, 225) },
+            { u"saddlebrown", Color(139, 69, 19) },
+            { u"salmon", Color(250, 128, 114) },
+            { u"sandybrown", Color(244, 164, 96) },
+            { u"seagreen", Color( 46, 139, 87) },
+            { u"seashell", Color(255, 245, 238) },
+            { u"sienna", Color(160, 82, 45) },
+            { u"silver", Color(192, 192, 192) },
+            { u"skyblue", Color(135, 206, 235) },
+            { u"slateblue", Color(106, 90, 205) },
+            { u"slategray", Color(112, 128, 144) },
+            { u"slategrey", Color(112, 128, 144) },
+            { u"snow", Color(255, 250, 250) },
+            { u"springgreen", Color( 0, 255, 127) },
+            { u"steelblue", Color( 70, 130, 180) },
+            { u"tan", Color(210, 180, 140) },
+            { u"teal", Color( 0, 128, 128) },
+            { u"thistle", Color(216, 191, 216) },
+            { u"tomato", Color(255, 99, 71) },
+            { u"turquoise", Color( 64, 224, 208) },
+            { u"violet", Color(238, 130, 238) },
+            { u"wheat", Color(245, 222, 179) },
+            { u"white", Color(255, 255, 255) },
+            { u"whitesmoke", Color(245, 245, 245) },
+            { u"yellow", Color(255, 255, 0) },
+            { u"yellowgreen", Color(154, 205, 50) }
+        });
+
+        basegfx::B2DHomMatrix SvgAspectRatio::createLinearMapping(const basegfx::B2DRange& rTarget, const basegfx::B2DRange& rSource)
+        {
+            basegfx::B2DHomMatrix aRetval;
+            const double fSWidth(rSource.getWidth());
+            const double fSHeight(rSource.getHeight());
+            const bool bNoSWidth(basegfx::fTools::equalZero(fSWidth));
+            const bool bNoSHeight(basegfx::fTools::equalZero(fSHeight));
+
+            // transform from source state to unit range
+            aRetval.translate(-rSource.getMinX(), -rSource.getMinY());
+            aRetval.scale(
+                (bNoSWidth ? 1.0 : 1.0 / fSWidth) * rTarget.getWidth(),
+                (bNoSHeight ? 1.0 : 1.0 / fSHeight) * rTarget.getHeight());
+
+            // transform from unit rage to target range
+            aRetval.translate(rTarget.getMinX(), rTarget.getMinY());
+
+            return aRetval;
+        }
+
+        basegfx::B2DHomMatrix SvgAspectRatio::createMapping(const basegfx::B2DRange& rTarget, const basegfx::B2DRange& rSource) const
+        {
+            // removed !isSet() from below. Due to correct defaults in the constructor an instance
+            // of this class is perfectly useful without being set by any importer
+            if(SvgAlign::none == getSvgAlign())
+            {
+                // create linear mapping (default)
+                return createLinearMapping(rTarget, rSource);
+            }
+
+            basegfx::B2DHomMatrix aRetval;
+
+            const double fSWidth(rSource.getWidth());
+            const double fSHeight(rSource.getHeight());
+            const bool bNoSWidth(basegfx::fTools::equalZero(fSWidth));
+            const bool bNoSHeight(basegfx::fTools::equalZero(fSHeight));
+            const double fScaleX((bNoSWidth ? 1.0 : 1.0 / fSWidth) * rTarget.getWidth());
+            const double fScaleY((bNoSHeight ? 1.0 : 1.0 / fSHeight) * rTarget.getHeight());
+            const double fScale(isMeetOrSlice() ? std::min(fScaleX, fScaleY) : std::max(fScaleX, fScaleY));
+
+            // remove source translation, apply scale
+            aRetval.translate(-rSource.getMinX(), -rSource.getMinY());
+            aRetval.scale(fScale, fScale);
+
+            // evaluate horizontal alignment
+            const double fNewWidth(fSWidth * fScale);
+            double fTransX(0.0);
+
+            switch(getSvgAlign())
+            {
+                case SvgAlign::xMidYMin:
+                case SvgAlign::xMidYMid:
+                case SvgAlign::xMidYMax:
+                {
+                    // centerX
+                    const double fFreeSpace(rTarget.getWidth() - fNewWidth);
+                    fTransX = fFreeSpace * 0.5;
+                    break;
+                }
+                case SvgAlign::xMaxYMin:
+                case SvgAlign::xMaxYMid:
+                case SvgAlign::xMaxYMax:
+                {
+                    // Right align
+                    const double fFreeSpace(rTarget.getWidth() - fNewWidth);
+                    fTransX = fFreeSpace;
+                    break;
+                }
+                default: break;
+            }
+
+            // evaluate vertical alignment
+            const double fNewHeight(fSHeight * fScale);
+            double fTransY(0.0);
+
+            switch(getSvgAlign())
+            {
+                case SvgAlign::xMinYMid:
+                case SvgAlign::xMidYMid:
+                case SvgAlign::xMaxYMid:
+                {
+                    // centerY
+                    const double fFreeSpace(rTarget.getHeight() - fNewHeight);
+                    fTransY = fFreeSpace * 0.5;
+                    break;
+                }
+                case SvgAlign::xMinYMax:
+                case SvgAlign::xMidYMax:
+                case SvgAlign::xMaxYMax:
+                {
+                    // Bottom align
+                    const double fFreeSpace(rTarget.getHeight() - fNewHeight);
+                    fTransY = fFreeSpace;
+                    break;
+                }
+                default: break;
+            }
+
+            // add target translation
+            aRetval.translate(
+                rTarget.getMinX() + fTransX,
+                rTarget.getMinY() + fTransY);
+
+            return aRetval;
+        }
+
+        void skip_char(std::u16string_view rCandidate, sal_Unicode nChar, sal_Int32& nPos, const sal_Int32 nLen)
+        {
+            while(nPos < nLen && nChar == rCandidate[nPos])
+            {
+                nPos++;
+            }
+        }
+
+        void skip_char(std::u16string_view rCandidate, sal_Unicode nCharA, sal_Unicode nCharB, sal_Int32& nPos, const sal_Int32 nLen)
+        {
+            while(nPos < nLen && (nCharA == rCandidate[nPos] || nCharB == rCandidate[nPos]))
+            {
+                nPos++;
+            }
+        }
+
+        void copySign(std::u16string_view rCandidate, sal_Int32& nPos, OUStringBuffer& rTarget, const sal_Int32 nLen)
+        {
+            if(nPos < nLen)
+            {
+                const sal_Unicode aChar(rCandidate[nPos]);
+
+                if('+' == aChar || '-' == aChar)
+                {
+                    rTarget.append(aChar);
+                    nPos++;
+                }
+            }
+        }
+
+        void copyNumber(std::u16string_view rCandidate, sal_Int32& nPos, OUStringBuffer& rTarget, const sal_Int32 nLen)
+        {
+            bool bOnNumber(true);
+
+            while(bOnNumber && nPos < nLen)
+            {
+                const sal_Unicode aChar(rCandidate[nPos]);
+
+                bOnNumber = ('0' <= aChar && '9' >= aChar) || '.' == aChar;
+
+                if(bOnNumber)
+                {
+                    rTarget.append(aChar);
+                    nPos++;
+                }
+            }
+        }
+
+        void copyHex(std::u16string_view rCandidate, sal_Int32& nPos, OUStringBuffer& rTarget, const sal_Int32 nLen)
+        {
+            bool bOnHex(true);
+
+            while(bOnHex && nPos < nLen)
+            {
+                const sal_Unicode aChar(rCandidate[nPos]);
+
+                bOnHex = ('0' <= aChar && '9' >= aChar)
+                    || ('A' <= aChar && 'F' >= aChar)
+                    || ('a' <= aChar && 'f' >= aChar);
+
+                if(bOnHex)
+                {
+                    rTarget.append(aChar);
+                    nPos++;
+                }
+            }
+        }
+
+        void copyString(std::u16string_view rCandidate, sal_Int32& nPos, OUStringBuffer& rTarget, const sal_Int32 nLen)
+        {
+            bool bOnChar(true);
+
+            while(bOnChar && nPos < nLen)
+            {
+                const sal_Unicode aChar(rCandidate[nPos]);
+
+                bOnChar = ('a' <= aChar && 'z' >= aChar)
+                    || ('A' <= aChar && 'Z' >= aChar)
+                    || '-' == aChar;
+
+                if(bOnChar)
+                {
+                    rTarget.append(aChar);
+                    nPos++;
+                }
+            }
+        }
+
+        void copyToLimiter(std::u16string_view rCandidate, sal_Unicode nLimiter, sal_Int32& nPos, OUStringBuffer& rTarget, const sal_Int32 nLen)
+        {
+            while(nPos < nLen && nLimiter != rCandidate[nPos])
+            {
+                rTarget.append(rCandidate[nPos]);
+                nPos++;
+            }
+        }
+
+        bool readNumber(std::u16string_view rCandidate, sal_Int32& nPos, double& fNum, const sal_Int32 nLen)
+        {
+            if(nPos < nLen)
+            {
+                OUStringBuffer aNum;
+
+                copySign(rCandidate, nPos, aNum, nLen);
+                copyNumber(rCandidate, nPos, aNum, nLen);
+
+                if(nPos < nLen)
+                {
+                    const sal_Unicode aChar(rCandidate[nPos]);
+
+                    if('e' == aChar || 'E' == aChar)
+                    {
+                        // try to read exponential number, but be careful. I had
+                        // a case where dx="2em" was used, thus the 'e' was consumed
+                        // by error. First try if there are numbers after the 'e',
+                        // safe current state
+                        nPos++;
+                        const OUStringBuffer aNum2(aNum);
+                        const sal_Int32 nPosAfterE(nPos);
+
+                        aNum.append(aChar);
+                        copySign(rCandidate, nPos, aNum, nLen);
+                        copyNumber(rCandidate, nPos, aNum, nLen);
+
+                        if(nPosAfterE == nPos)
+                        {
+                            // no number after 'e', go back. Do not
+                            // return false, it's still a valid integer number
+                            aNum = aNum2;
+                            nPos--;
+                        }
+                    }
+                }
+
+                if(!aNum.isEmpty())
+                {
+                    rtl_math_ConversionStatus eStatus;
+
+                    fNum = rtl::math::stringToDouble(
+                        aNum, '.', ',',
+                        &eStatus);
+
+                    return eStatus == rtl_math_ConversionStatus_Ok;
+                }
+            }
+
+            return false;
+        }
+
+        SvgUnit readUnit(std::u16string_view rCandidate, sal_Int32& nPos, const sal_Int32 nLen)
+        {
+            SvgUnit aRetval(SvgUnit::px);
+
+            if(nPos < nLen)
+            {
+                const sal_Unicode aCharA(rCandidate[nPos]);
+
+                if('%' == aCharA)
+                {
+                    // percent used, relative to current
+                    nPos++;
+                    aRetval = SvgUnit::percent;
+                }
+                else if(nPos + 1 < nLen)
+                {
+                    const sal_Unicode aCharB(rCandidate[nPos + 1]);
+                    bool bTwoCharValid(false);
+
+                    switch(aCharA)
+                    {
+                        case u'e' :
+                        {
+                            if('m' == aCharB)
+                            {
+                                // 'em' Relative to current font size
+                                aRetval = SvgUnit::em;
+                                bTwoCharValid = true;
+                            }
+                            else if('x' == aCharB)
+                            {
+                                // 'ex' Relative to current font x-height
+                                aRetval = SvgUnit::ex;
+                                bTwoCharValid = true;
+                            }
+                            break;
+                        }
+                        case u'p' :
+                        {
+                            if('x' == aCharB)
+                            {
+                                // 'px' UserUnit (default)
+                                bTwoCharValid = true;
+                            }
+                            else if('t' == aCharB)
+                            {
+                                // 'pt' == 4/3 px
+                                aRetval = SvgUnit::pt;
+                                bTwoCharValid = true;
+                            }
+                            else if('c' == aCharB)
+                            {
+                                // 'pc' == 16 px
+                                aRetval = SvgUnit::pc;
+                                bTwoCharValid = true;
+                            }
+                            break;
+                        }
+                        case u'i' :
+                        {
+                            if('n' == aCharB)
+                            {
+                                // 'in' == 96 px, since CSS 2.1
+                                aRetval = SvgUnit::in;
+                                bTwoCharValid = true;
+                            }
+                            break;
+                        }
+                        case u'c' :
+                        {
+                            if('m' == aCharB)
+                            {
+                                // 'cm' == 37.79527559 px
+                                aRetval = SvgUnit::cm;
+                                bTwoCharValid = true;
+                            }
+                            break;
+                        }
+                        case u'm' :
+                        {
+                            if('m' == aCharB)
+                            {
+                                // 'mm' == 3.779528 px
+                                aRetval = SvgUnit::mm;
+                                bTwoCharValid = true;
+                            }
+                            break;
+                        }
+                    }
+
+                    if(bTwoCharValid)
+                    {
+                        nPos += 2;
+                    }
+                }
+            }
+
+            return aRetval;
+        }
+
+        bool readNumberAndUnit(std::u16string_view rCandidate, sal_Int32& nPos, SvgNumber& aNum, const sal_Int32 nLen)
+        {
+            double fNum(0.0);
+
+            if(readNumber(rCandidate, nPos, fNum, nLen))
+            {
+                skip_char(rCandidate, ' ', nPos, nLen);
+                aNum = SvgNumber(fNum, readUnit(rCandidate, nPos, nLen));
+
+                return true;
+            }
+
+            return false;
+        }
+
+        bool readAngle(std::u16string_view rCandidate, sal_Int32& nPos, double& fAngle, const sal_Int32 nLen)
+        {
+            if(readNumber(rCandidate, nPos, fAngle, nLen))
+            {
+                skip_char(rCandidate, ' ', nPos, nLen);
+
+                enum class DegreeType
+                {
+                    deg,
+                    grad,
+                    rad
+                } aType(DegreeType::deg); // degrees is default
+
+                if(nPos < nLen)
+                {
+                    const sal_Unicode aChar(rCandidate[nPos]);
+                    static constexpr std::u16string_view aStrGrad = u"grad";
+                    static constexpr std::u16string_view aStrRad = u"rad";
+
+                    switch(aChar)
+                    {
+                        case u'g' :
+                        case u'G' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrGrad, nPos))
+                            {
+                                // angle in grad
+                                nPos += aStrGrad.size();
+                                aType = DegreeType::grad;
+                            }
+                            break;
+                        }
+                        case u'r' :
+                        case u'R' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrRad, nPos))
+                            {
+                                // angle in radians
+                                nPos += aStrRad.size();
+                                aType = DegreeType::rad;
+                            }
+                            break;
+                        }
+                    }
+                }
+
+                // convert to radians
+                if (DegreeType::deg == aType)
+                {
+                    fAngle = basegfx::deg2rad(fAngle);
+                }
+                else if (DegreeType::grad == aType)
+                {
+                    // looks like 100 grad is 90 degrees
+                    fAngle *= M_PI / 200.0;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        sal_Int32 read_hex(sal_Unicode nChar)
+        {
+            if(nChar >= '0' && nChar <= '9')
+            {
+                return nChar - u'0';
+            }
+            else if(nChar >= 'A' && nChar <= 'F')
+            {
+                return 10 + sal_Int32(nChar - u'A');
+            }
+            else if(nChar >= 'a' && nChar <= 'f')
+            {
+                return 10 + sal_Int32(nChar - u'a');
+            }
+            else
+            {
+                // error
+                return 0;
+            }
+        }
+
+        bool match_colorKeyword(basegfx::BColor& rColor, const OUString& rName)
+        {
+            auto const aResult = aColorTokenMapperList.find(rName.toAsciiLowerCase().trim());
+
+            if(aResult == aColorTokenMapperList.end())
+            {
+                return false;
+            }
+            else
+            {
+                rColor = aResult->second.getBColor();
+                return true;
+            }
+        }
+
+        bool read_color(const OUString& rCandidate, basegfx::BColor& rColor, SvgNumber& rOpacity)
+        {
+            const sal_Int32 nLen(rCandidate.getLength());
+
+            if(nLen)
+            {
+                const sal_Unicode aChar(rCandidate[0]);
+                const double fFactor(1.0 / 255.0);
+
+                if(aChar == '#')
+                {
+                    // hex definition
+                    OUStringBuffer aNum;
+                    sal_Int32 nPos(1);
+
+                    copyHex(rCandidate, nPos, aNum, nLen);
+                    const sal_Int32 nLength(aNum.getLength());
+
+                    if(3 == nLength)
+                    {
+                        const sal_Int32 nR(read_hex(aNum[0]));
+                        const sal_Int32 nG(read_hex(aNum[1]));
+                        const sal_Int32 nB(read_hex(aNum[2]));
+
+                        rColor.setRed((nR | (nR << 4)) * fFactor);
+                        rColor.setGreen((nG | (nG << 4)) * fFactor);
+                        rColor.setBlue((nB | (nB << 4)) * fFactor);
+
+                        return true;
+                    }
+                    else if(6 == nLength)
+                    {
+                        const sal_Int32 nR1(read_hex(aNum[0]));
+                        const sal_Int32 nR2(read_hex(aNum[1]));
+                        const sal_Int32 nG1(read_hex(aNum[2]));
+                        const sal_Int32 nG2(read_hex(aNum[3]));
+                        const sal_Int32 nB1(read_hex(aNum[4]));
+                        const sal_Int32 nB2(read_hex(aNum[5]));
+
+                        rColor.setRed((nR2 | (nR1 << 4)) * fFactor);
+                        rColor.setGreen((nG2 | (nG1 << 4)) * fFactor);
+                        rColor.setBlue((nB2 | (nB1 << 4)) * fFactor);
+
+                        return true;
+                    }
+                }
+                else
+                {
+                    static const char aStrRgb[] = "rgb";
+
+                    if(rCandidate.matchIgnoreAsciiCase(aStrRgb, 0))
+                    {
+                        // rgb/rgba definition
+                        sal_Int32 nPos(strlen(aStrRgb));
+                        bool bIsRGBA = false;
+
+                        if('a' == rCandidate[nPos])
+                        {
+                            //Delete the 'a' from 'rbga'
+                            skip_char(rCandidate, 'a', nPos, nPos + 1);
+                            bIsRGBA = true;
+                        }
+
+                        skip_char(rCandidate, ' ', '(', nPos, nLen);
+                        double fR(0.0);
+
+                        if(readNumber(rCandidate, nPos, fR, nLen))
+                        {
+                            skip_char(rCandidate, ' ', nPos, nLen);
+
+                            if(nPos < nLen)
+                            {
+                                const sal_Unicode aPercentChar(rCandidate[nPos]);
+                                const bool bIsPercent('%' == aPercentChar);
+                                double fG(0.0);
+
+                                if(bIsPercent)
+                                {
+                                    skip_char(rCandidate, '%', nPos, nLen);
+                                }
+
+                                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                if(readNumber(rCandidate, nPos, fG, nLen))
+                                {
+                                    double fB(0.0);
+
+                                    if(bIsPercent)
+                                    {
+                                        skip_char(rCandidate, '%', nPos, nLen);
+                                    }
+
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    if(readNumber(rCandidate, nPos, fB, nLen))
+                                    {
+                                        double fA(1.0);
+
+                                        if(bIsPercent)
+                                        {
+                                            skip_char(rCandidate, '%', nPos, nLen);
+                                        }
+
+                                        skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                        if(readNumber(rCandidate, nPos, fA, nLen))
+                                        {
+                                            if(bIsRGBA)
+                                            {
+                                                const double fFac(bIsPercent ? 0.01 : 1);
+                                                rOpacity = SvgNumber(fA * fFac);
+
+                                                if(bIsPercent)
+                                                {
+                                                    skip_char(rCandidate, '%', nPos, nLen);
+                                                }
+                                            }
+                                            else
+                                            {
+                                                return false;
+                                            }
+                                        }
+
+                                        const double fFac(bIsPercent ? 0.01 : fFactor);
+
+                                        rColor.setRed(fR * fFac);
+                                        rColor.setGreen(fG * fFac);
+                                        rColor.setBlue(fB * fFac);
+
+                                        skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        // color keyword
+                        if(match_colorKeyword(rColor, rCandidate))
+                        {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        basegfx::B2DRange readViewBox(std::u16string_view rCandidate, InfoProvider const & rInfoProvider)
+        {
+            const sal_Int32 nLen(rCandidate.size());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                SvgNumber aMinX;
+                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                if(readNumberAndUnit(rCandidate, nPos, aMinX, nLen))
+                {
+                    SvgNumber aMinY;
+                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                    if(readNumberAndUnit(rCandidate, nPos, aMinY, nLen))
+                    {
+                        SvgNumber aWidth;
+                        skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                        if(readNumberAndUnit(rCandidate, nPos, aWidth, nLen))
+                        {
+                            SvgNumber aHeight;
+                            skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                            if(readNumberAndUnit(rCandidate, nPos, aHeight, nLen))
+                            {
+                                double fX(aMinX.solve(rInfoProvider, NumberType::xcoordinate));
+                                double fY(aMinY.solve(rInfoProvider, NumberType::ycoordinate));
+                                double fW(aWidth.solve(rInfoProvider, NumberType::xcoordinate));
+                                double fH(aHeight.solve(rInfoProvider, NumberType::ycoordinate));
+                                return basegfx::B2DRange(fX,fY,fX+fW,fY+fH);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return basegfx::B2DRange();
+        }
+
+        std::vector<double> readFilterMatrix(std::u16string_view rCandidate, InfoProvider const & rInfoProvider)
+        {
+            std::vector<double> aVector;
+            const sal_Int32 nLen(rCandidate.size());
+
+            sal_Int32 nPos(0);
+            skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+            SvgNumber aVal;
+
+            while (nPos < nLen)
+            {
+                if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                {
+                    aVector.push_back(aVal.solve(rInfoProvider));
+                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                }
+            }
+
+            return aVector;
+        }
+
+        basegfx::B2DHomMatrix readTransform(std::u16string_view rCandidate, InfoProvider const & rInfoProvider)
+        {
+            basegfx::B2DHomMatrix aMatrix;
+            const sal_Int32 nLen(rCandidate.size());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                while(nPos < nLen)
+                {
+                    const sal_Unicode aChar(rCandidate[nPos]);
+                    const sal_Int32 nInitPos(nPos);
+                    static constexpr std::u16string_view aStrMatrix = u"matrix";
+                    static constexpr std::u16string_view aStrTranslate = u"translate";
+                    static constexpr std::u16string_view aStrScale = u"scale";
+                    static constexpr std::u16string_view aStrRotate = u"rotate";
+                    static constexpr std::u16string_view aStrSkewX = u"skewX";
+                    static constexpr std::u16string_view aStrSkewY = u"skewY";
+
+                    switch(aChar)
+                    {
+                        case u'm' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrMatrix, nPos))
+                            {
+                                // matrix element
+                                nPos += aStrMatrix.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                SvgNumber aVal;
+                                basegfx::B2DHomMatrix aNew;
+
+                                if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                {
+                                    aNew.set(0, 0, aVal.solve(rInfoProvider)); // Element A
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                    {
+                                        aNew.set(1, 0, aVal.solve(rInfoProvider)); // Element B
+                                        skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                        if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                        {
+                                            aNew.set(0, 1, aVal.solve(rInfoProvider)); // Element C
+                                            skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                            if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                            {
+                                                aNew.set(1, 1, aVal.solve(rInfoProvider)); // Element D
+                                                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                                if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                                {
+                                                    aNew.set(0, 2, aVal.solve(rInfoProvider, NumberType::xcoordinate)); // Element E
+                                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                                    if(readNumberAndUnit(rCandidate, nPos, aVal, nLen))
+                                                    {
+                                                        aNew.set(1, 2, aVal.solve(rInfoProvider, NumberType::ycoordinate)); // Element F
+                                                        skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                                        skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                                        // caution: String is evaluated from left to right, but matrix multiplication
+                                                        // in SVG is right to left, so put the new transformation before the current
+                                                        // one by multiplicating from the right side
+                                                        aMatrix = aMatrix * aNew;
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                        case u't' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrTranslate, nPos))
+                            {
+                                // translate element
+                                nPos += aStrTranslate.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                SvgNumber aTransX;
+
+                                if(readNumberAndUnit(rCandidate, nPos, aTransX, nLen))
+                                {
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                                    SvgNumber aTransY;
+                                    readNumberAndUnit(rCandidate, nPos, aTransY, nLen);
+                                    skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    aMatrix = aMatrix * basegfx::utils::createTranslateB2DHomMatrix(
+                                        aTransX.solve(rInfoProvider, NumberType::xcoordinate),
+                                        aTransY.solve(rInfoProvider, NumberType::ycoordinate));
+                                }
+                            }
+                            break;
+                        }
+                        case u's' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrScale, nPos))
+                            {
+                                // scale element
+                                nPos += aStrScale.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                SvgNumber aScaleX;
+
+                                if(readNumberAndUnit(rCandidate, nPos, aScaleX, nLen))
+                                {
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                                    SvgNumber aScaleY(aScaleX);
+                                    readNumberAndUnit(rCandidate, nPos, aScaleY, nLen);
+                                    skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    aMatrix = aMatrix * basegfx::utils::createScaleB2DHomMatrix(
+                                        aScaleX.solve(rInfoProvider),
+                                        aScaleY.solve(rInfoProvider));
+                                }
+                            }
+                            else if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrSkewX, nPos))
+                            {
+                                // skewx element
+                                nPos += aStrSkewX.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                double fSkewX(0.0);
+
+                                if(readAngle(rCandidate, nPos, fSkewX, nLen))
+                                {
+                                    skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    aMatrix = aMatrix * basegfx::utils::createShearXB2DHomMatrix(tan(fSkewX));
+                                }
+                            }
+                            else if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrSkewY, nPos))
+                            {
+                                // skewy element
+                                nPos += aStrSkewY.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                double fSkewY(0.0);
+
+                                if(readAngle(rCandidate, nPos, fSkewY, nLen))
+                                {
+                                    skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    aMatrix = aMatrix * basegfx::utils::createShearYB2DHomMatrix(tan(fSkewY));
+                                }
+                            }
+                            break;
+                        }
+                        case u'r' :
+                        {
+                            if(o3tl::matchIgnoreAsciiCase(rCandidate, aStrRotate, nPos))
+                            {
+                                // rotate element
+                                nPos += aStrRotate.size();
+                                skip_char(rCandidate, ' ', '(', nPos, nLen);
+                                double fAngle(0.0);
+
+                                if(readAngle(rCandidate, nPos, fAngle, nLen))
+                                {
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                                    SvgNumber aX;
+                                    readNumberAndUnit(rCandidate, nPos, aX, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                                    SvgNumber aY;
+                                    readNumberAndUnit(rCandidate, nPos, aY, nLen);
+                                    skip_char(rCandidate, ' ', ')', nPos, nLen);
+                                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                                    const double fX(aX.isSet() ? aX.solve(rInfoProvider, NumberType::xcoordinate) : 0.0);
+                                    const double fY(aY.isSet() ? aY.solve(rInfoProvider, NumberType::ycoordinate) : 0.0);
+
+                                    if(!basegfx::fTools::equalZero(fX) || !basegfx::fTools::equalZero(fY))
+                                    {
+                                        // rotate around point
+                                        aMatrix = aMatrix * basegfx::utils::createRotateAroundPoint(fX, fY, fAngle);
+                                    }
+                                    else
+                                    {
+                                        // rotate
+                                        aMatrix = aMatrix * basegfx::utils::createRotateB2DHomMatrix(fAngle);
+                                    }
+                                }
+                            }
+                            break;
+                        }
+                    }
+
+                    if(nInitPos == nPos)
+                    {
+                        SAL_WARN("svgio", "Could not interpret on current position (!)");
+                        nPos++;
+                    }
+                }
+            }
+
+            return aMatrix;
+        }
+
+        bool readSingleNumber(std::u16string_view rCandidate, SvgNumber& aNum)
+        {
+            const sal_Int32 nLen(rCandidate.size());
+            sal_Int32 nPos(0);
+
+            return readNumberAndUnit(rCandidate, nPos, aNum, nLen);
+        }
+
+        bool readLocalLink(std::u16string_view rCandidate, OUString& rURL)
+        {
+            sal_Int32 nPos(0);
+            const sal_Int32 nLen(rCandidate.size());
+
+            skip_char(rCandidate, ' ', nPos, nLen);
+
+            if (nLen && nPos < nLen && '#' == rCandidate[nPos])
+            {
+                ++nPos;
+                rURL = rCandidate.substr(nPos);
+
+                return true;
+            }
+
+            return false;
+        }
+
+        bool readLocalUrl(const OUString& rCandidate, OUString& rURL)
+        {
+            static const char aStrUrl[] = "url(";
+
+            if(rCandidate.startsWithIgnoreAsciiCase(aStrUrl))
+            {
+                const sal_Int32 nLen(rCandidate.getLength());
+                sal_Int32 nPos(strlen(aStrUrl));
+                sal_Unicode aLimiter(')');
+
+                skip_char(rCandidate, ' ', nPos, nLen);
+
+                if('"' == rCandidate[nPos])
+                {
+                    aLimiter = '"';
+                    ++nPos;
+                }
+                else if('\'' == rCandidate[nPos])
+                {
+                    aLimiter = '\'';
+                    ++nPos;
+                }
+
+                skip_char(rCandidate, ' ', nPos, nLen);
+                skip_char(rCandidate, '#', nPos, nPos + 1);
+                OUStringBuffer aTokenValue;
+
+                copyToLimiter(rCandidate, aLimiter, nPos, aTokenValue, nLen);
+
+                rURL = aTokenValue.makeStringAndClear();
+
+                return true;
+            }
+
+            return false;
+        }
+
+        bool readSvgPaint(const OUString& rCandidate, SvgPaint& rSvgPaint,
+            OUString& rURL, SvgNumber& rOpacity)
+        {
+            if( !rCandidate.isEmpty() )
+            {
+                basegfx::BColor aColor;
+
+                if(read_color(rCandidate, aColor, rOpacity))
+                {
+                    rSvgPaint = SvgPaint(aColor, true, true);
+                    return true;
+                }
+                else
+                {
+                    if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(rCandidate), u"none"))
+                    {
+                        rSvgPaint = SvgPaint(aColor, true, false, false);
+                        return true;
+                    }
+                    else if(readLocalUrl(rCandidate, rURL))
+                    {
+                        /// Url is copied to rURL, but needs to be solved outside this helper
+                        return false;
+                    }
+                    else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(rCandidate), u"currentColor"))
+                    {
+                        rSvgPaint = SvgPaint(aColor, true, true, true);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        bool readSvgNumberVector(std::u16string_view rCandidate, SvgNumberVector& rSvgNumberVector)
+        {
+            const sal_Int32 nLen(rCandidate.size());
+            rSvgNumberVector.clear();
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                SvgNumber aNum;
+                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                while(readNumberAndUnit(rCandidate, nPos, aNum, nLen))
+                {
+                    rSvgNumberVector.push_back(aNum);
+                    skip_char(rCandidate, ' ', ',', nPos, nLen);
+                }
+
+                return !rSvgNumberVector.empty();
+            }
+
+            return false;
+        }
+
+        SvgAspectRatio readSvgAspectRatio(std::u16string_view rCandidate)
+        {
+            const sal_Int32 nLen(rCandidate.size());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                SvgAlign aSvgAlign(SvgAlign::xMidYMid);
+                bool bMeetOrSlice(true);
+                bool bChanged(false);
+
+                while(nPos < nLen)
+                {
+                    const sal_Int32 nInitPos(nPos);
+                    skip_char(rCandidate, ' ', nPos, nLen);
+                    OUStringBuffer aTokenName;
+                    copyString(rCandidate, nPos, aTokenName, nLen);
+
+                    if(!aTokenName.isEmpty())
+                    {
+                        switch(StrToSVGToken(aTokenName.makeStringAndClear(), false))
+                        {
+                            case SVGToken::Defer:
+                            {
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::None:
+                            {
+                                aSvgAlign = SvgAlign::none;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMinYMin:
+                            {
+                                aSvgAlign = SvgAlign::xMinYMin;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMidYMin:
+                            {
+                                aSvgAlign = SvgAlign::xMidYMin;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMaxYMin:
+                            {
+                                aSvgAlign = SvgAlign::xMaxYMin;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMinYMid:
+                            {
+                                aSvgAlign = SvgAlign::xMinYMid;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMidYMid:
+                            {
+                                aSvgAlign = SvgAlign::xMidYMid;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMaxYMid:
+                            {
+                                aSvgAlign = SvgAlign::xMaxYMid;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMinYMax:
+                            {
+                                aSvgAlign = SvgAlign::xMinYMax;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMidYMax:
+                            {
+                                aSvgAlign = SvgAlign::xMidYMax;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::XMaxYMax:
+                            {
+                                aSvgAlign = SvgAlign::xMaxYMax;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::Meet:
+                            {
+                                bMeetOrSlice = true;
+                                bChanged = true;
+                                break;
+                            }
+                            case SVGToken::Slice:
+                            {
+                                bMeetOrSlice = false;
+                                bChanged = true;
+                                break;
+                            }
+                            default:
+                            {
+                                break;
+                            }
+                        }
+                    }
+
+                    if(nInitPos == nPos)
+                    {
+                        SAL_WARN("svgio", "Could not interpret on current position (!)");
+                        nPos++;
+                    }
+                }
+
+                if(bChanged)
+                {
+                    return SvgAspectRatio(aSvgAlign, bMeetOrSlice);
+                }
+            }
+
+            return SvgAspectRatio();
+        }
+
+        bool readSvgStringVector(std::u16string_view rCandidate, SvgStringVector& rSvgStringVector)
+        {
+            rSvgStringVector.clear();
+            const sal_Int32 nLen(rCandidate.size());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                OUStringBuffer aTokenValue;
+                skip_char(rCandidate, ' ', ',', nPos, nLen);
+
+                while(nPos < nLen)
+                {
+                    copyToLimiter(rCandidate, ',', nPos, aTokenValue, nLen);
+                    skip_char(rCandidate, ',', ' ', nPos, nLen);
+                    const OUString aString = aTokenValue.makeStringAndClear();
+
+                    if(!aString.isEmpty())
+                    {
+                        rSvgStringVector.push_back(aString);
+                    }
+                }
+            }
+
+            return !rSvgStringVector.empty();
+        }
+
+        void readImageLink(const OUString& rCandidate, OUString& rXLink, OUString& rUrl, OUString& rData)
+        {
+            rXLink.clear();
+            rUrl.clear();
+            rData.clear();
+
+            if(!readLocalLink(rCandidate, rXLink))
+            {
+                static const char aStrData[] = "data:";
+
+                if(rCandidate.matchIgnoreAsciiCase(aStrData, 0))
+                {
+                    // embedded data
+                    sal_Int32 nPos(strlen(aStrData));
+                    sal_Int32 nLen(rCandidate.getLength());
+                    OUStringBuffer aBuffer;
+
+                    // read mime type
+                    skip_char(rCandidate, ' ', nPos, nLen);
+                    copyToLimiter(rCandidate, ';', nPos, aBuffer, nLen);
+                    skip_char(rCandidate, ' ', ';', nPos, nLen);
+                    const OUString aMimeType = aBuffer.makeStringAndClear();
+
+                    if(!aMimeType.isEmpty() && nPos < nLen)
+                    {
+                        if(aMimeType.startsWith("image"))
+                        {
+                            // image data
+                            std::u16string_view aData(rCandidate.subView(nPos));
+                            static constexpr std::u16string_view aStrBase64 = u"base64";
+
+                            if(o3tl::starts_with(aData, aStrBase64))
+                            {
+                                // base64 encoded
+                                nPos = aStrBase64.size();
+                                nLen = aData.size();
+
+                                skip_char(aData, ' ', ',', nPos, nLen);
+
+                                if(nPos < nLen)
+                                {
+                                    rData = aData.substr(nPos);
+                                }
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    // Url (path and filename)
+                    rUrl = rCandidate;
+                }
+            }
+        }
+
+        // #i125325#
+        OUString removeBlockComments(const OUString& rCandidate)
+        {
+            const sal_Int32 nLen(rCandidate.getLength());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                OUStringBuffer aBuffer;
+                bool bChanged(false);
+                sal_Int32 nInsideComment(0);
+                const sal_Unicode aCommentSlash('/');
+                const sal_Unicode aCommentStar('*');
+
+                while(nPos < nLen)
+                {
+                    const sal_Unicode aChar(rCandidate[nPos]);
+                    const bool bStart(aCommentSlash == aChar && nPos + 1 < nLen && aCommentStar == rCandidate[nPos + 1]);
+                    const bool bEnd(aCommentStar == aChar && nPos + 1 < nLen && aCommentSlash == rCandidate[nPos + 1]);
+
+                    if(bStart)
+                    {
+                        nPos += 2;
+                        nInsideComment++;
+                        bChanged = true;
+                    }
+                    else if(bEnd)
+                    {
+                        nPos += 2;
+                        nInsideComment--;
+                    }
+                    else
+                    {
+                        if(!nInsideComment)
+                        {
+                            aBuffer.append(aChar);
+                        }
+
+                        nPos++;
+                    }
+                }
+
+                if(bChanged)
+                {
+                    return aBuffer.makeStringAndClear();
+                }
+            }
+
+            return rCandidate;
+        }
+
+        OUString consolidateContiguousSpace(const OUString& rCandidate)
+        {
+            const sal_Int32 nLen(rCandidate.getLength());
+
+            if(nLen)
+            {
+                sal_Int32 nPos(0);
+                OUStringBuffer aBuffer;
+                bool bInsideSpace(false);
+                const sal_Unicode aSpace(' ');
+
+                while(nPos < nLen)
+                {
+                    const sal_Unicode aChar(rCandidate[nPos]);
+
+                    if(aSpace == aChar)
+                    {
+                        bInsideSpace = true;
+                    }
+                    else
+                    {
+                        if(bInsideSpace)
+                        {
+                            bInsideSpace = false;
+                            aBuffer.append(aSpace);
+                        }
+
+                        aBuffer.append(aChar);
+                    }
+
+                    nPos++;
+                }
+
+                if(bInsideSpace)
+                {
+                    aBuffer.append(aSpace);
+                }
+
+                if(aBuffer.getLength() != nLen)
+                {
+                    return aBuffer.makeStringAndClear();
+                }
+            }
+
+            return rCandidate;
+        }
+
+        ::std::vector< double > solveSvgNumberVector(const SvgNumberVector& rInput, const InfoProvider& rInfoProvider)
+        {
+            ::std::vector< double > aRetval;
+
+            if(!rInput.empty())
+            {
+                const double nCount(rInput.size());
+                aRetval.reserve(nCount);
+
+                for(sal_uInt32 a(0); a < nCount; a++)
+                {
+                    aRetval.push_back(rInput[a].solve(rInfoProvider));
+                }
+            }
+
+            return aRetval;
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtrefnode.cxx b/svgio/source/svgreader/svgtrefnode.cxx
new file mode 100644
index 0000000000..eb59acfec9
--- /dev/null
+++ b/svgio/source/svgreader/svgtrefnode.cxx
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtrefnode.hxx>
+#include <svgdocument.hxx>
+
+namespace svgio::svgreader
+{
+        SvgTrefNode::SvgTrefNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Tref, rDocument, pParent),
+            maSvgStyleAttributes(*this)
+        {
+        }
+
+        SvgTrefNode::~SvgTrefNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgTrefNode::getSvgStyleAttributes() const
+        {
+            return &maSvgStyleAttributes;
+        }
+
+        void SvgTrefNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    readLocalLink(aContent, maXLink);
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        const SvgTextNode* SvgTrefNode::getReferencedSvgTextNode() const
+        {
+            return dynamic_cast< const SvgTextNode* >(getDocument().findSvgNodeById(maXLink));
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgtspannode.cxx b/svgio/source/svgreader/svgtspannode.cxx
new file mode 100644
index 0000000000..27d714e66a
--- /dev/null
+++ b/svgio/source/svgreader/svgtspannode.cxx
@@ -0,0 +1,151 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgtspannode.hxx>
+#include <o3tl/string_view.hxx>
+
+namespace svgio::svgreader
+{
+        SvgTspanNode::SvgTspanNode(
+            SVGToken aType,
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(aType, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            mbLengthAdjust(true),
+            mnTextLineWidth(0.0)
+        {
+        }
+
+        SvgTspanNode::~SvgTspanNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgTspanNode::getSvgStyleAttributes() const
+        {
+            // #i125293# Need to support CssStyles in tspan text sections
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgTspanNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumberVector aVector;
+
+                    if(readSvgNumberVector(aContent, aVector))
+                    {
+                        setX(std::move(aVector));
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumberVector aVector;
+
+                    if(readSvgNumberVector(aContent, aVector))
+                    {
+                        setY(std::move(aVector));
+                    }
+                    break;
+                }
+                case SVGToken::Dx:
+                {
+                    SvgNumberVector aVector;
+
+                    if(readSvgNumberVector(aContent, aVector))
+                    {
+                        setDx(std::move(aVector));
+                    }
+                    break;
+                }
+                case SVGToken::Dy:
+                {
+                    SvgNumberVector aVector;
+
+                    if(readSvgNumberVector(aContent, aVector))
+                    {
+                        setDy(std::move(aVector));
+                    }
+                    break;
+                }
+                case SVGToken::Rotate:
+                {
+                    SvgNumberVector aVector;
+
+                    if(readSvgNumberVector(aContent, aVector))
+                    {
+                        setRotate(std::move(aVector));
+                    }
+                    break;
+                }
+                case SVGToken::TextLength:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            setTextLength(aNum);
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::LengthAdjust:
+                {
+                    if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"spacing"))
+                    {
+                        setLengthAdjust(true);
+                    }
+                    else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"spacingAndGlyphs"))
+                    {
+                        setLengthAdjust(false);
+                    }
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        double SvgTspanNode::getCurrentFontSize() const
+        {
+            return getCurrentFontSizeInherited();
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgusenode.cxx b/svgio/source/svgreader/svgusenode.cxx
new file mode 100644
index 0000000000..d34e94427e
--- /dev/null
+++ b/svgio/source/svgreader/svgusenode.cxx
@@ -0,0 +1,180 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svgusenode.hxx>
+#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
+#include <svgdocument.hxx>
+
+namespace svgio::svgreader
+{
+        SvgUseNode::SvgUseNode(
+            SvgDocument& rDocument,
+            SvgNode* pParent)
+        :   SvgNode(SVGToken::Use, rDocument, pParent),
+            maSvgStyleAttributes(*this),
+            mbDecomposingSvgNode(false)
+        {
+        }
+
+        SvgUseNode::~SvgUseNode()
+        {
+        }
+
+        const SvgStyleAttributes* SvgUseNode::getSvgStyleAttributes() const
+        {
+            return checkForCssStyle(maSvgStyleAttributes);
+        }
+
+        void SvgUseNode::parseAttribute(SVGToken aSVGToken, const OUString& aContent)
+        {
+            // call parent
+            SvgNode::parseAttribute(aSVGToken, aContent);
+
+            // read style attributes
+            maSvgStyleAttributes.parseStyleAttribute(aSVGToken, aContent);
+
+            // parse own
+            switch(aSVGToken)
+            {
+                case SVGToken::Style:
+                {
+                    readLocalCssStyle(aContent);
+                    break;
+                }
+                case SVGToken::Transform:
+                {
+                    const basegfx::B2DHomMatrix aMatrix(readTransform(aContent, *this));
+
+                    if(!aMatrix.isIdentity())
+                    {
+                        setTransform(aMatrix);
+                    }
+                    break;
+                }
+                case SVGToken::X:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maX = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Y:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        maY = aNum;
+                    }
+                    break;
+                }
+                case SVGToken::Width:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maWidth = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Height:
+                {
+                    SvgNumber aNum;
+
+                    if(readSingleNumber(aContent, aNum))
+                    {
+                        if(aNum.isPositive())
+                        {
+                            maHeight = aNum;
+                        }
+                    }
+                    break;
+                }
+                case SVGToken::Href:
+                case SVGToken::XlinkHref:
+                {
+                    readLocalLink(aContent, maXLink);
+                    break;
+                }
+                default:
+                {
+                    break;
+                }
+            }
+        }
+
+        void SvgUseNode::decomposeSvgNode(drawinglayer::primitive2d::Primitive2DContainer& rTarget, bool /*bReferenced*/) const
+        {
+            drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
+            basegfx::B2DHomMatrix aTransform;
+
+            // try to access link to content
+            const SvgNode* pXLink = getDocument().findSvgNodeById(maXLink);
+
+            if (pXLink)
+            {
+                if (Display::None == pXLink->getDisplay() || mbDecomposingSvgNode)
+                    return;
+
+                // todo: in case mpXLink is a SVGToken::Svg or SVGToken::Symbol the
+                // SVG docs want the getWidth() and getHeight() from this node
+                // to be valid for the subtree.
+                mbDecomposingSvgNode = true;
+                const_cast< SvgNode* >(pXLink)->setAlternativeParent(this);
+                pXLink->decomposeSvgNode(aNewTarget, true);
+                const_cast< SvgNode* >(pXLink)->setAlternativeParent();
+                mbDecomposingSvgNode = false;
+
+                if(aNewTarget.empty())
+                    return;
+
+                if(getX().isSet() || getY().isSet())
+                {
+                    aTransform.translate(
+                        getX().solve(*this, NumberType::xcoordinate),
+                        getY().solve(*this, NumberType::ycoordinate));
+                }
+
+                if(getTransform())
+                {
+                    aTransform = *getTransform() * aTransform;
+                }
+            }
+
+            const SvgStyleAttributes* pStyle = getSvgStyleAttributes();
+
+            if(pStyle)
+            {
+                if(Display::None != getDisplay())
+                {
+                    pStyle->add_postProcess(rTarget, std::move(aNewTarget), aTransform);
+                }
+            }
+        }
+
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svgio/source/svgreader/svgvisitor.cxx b/svgio/source/svgreader/svgvisitor.cxx
new file mode 100644
index 0000000000..8ad5395f1c
--- /dev/null
+++ b/svgio/source/svgreader/svgvisitor.cxx
@@ -0,0 +1,150 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ */
+
+#include <sal/config.h>
+
+#include <svgrectnode.hxx>
+#include <svgsvgnode.hxx>
+#include <svgpathnode.hxx>
+#include <svggradientnode.hxx>
+
+#include <svgvisitor.hxx>
+
+namespace svgio::svgreader
+{
+SvgDrawVisitor::SvgDrawVisitor()
+    : mpDrawRoot(std::make_shared<gfx::DrawRoot>())
+    , mpCurrent(mpDrawRoot)
+{
+}
+
+void SvgDrawVisitor::visit(svgio::svgreader::SvgNode const& rNode)
+{
+    switch (rNode.getType())
+    {
+        case svgio::svgreader::SVGToken::Svg:
+        {
+            auto const& rSvgNode = static_cast<svgio::svgreader::SvgSvgNode const&>(rNode);
+
+            basegfx::B2DRange aRange = rSvgNode.getCurrentViewPort();
+
+            static_cast<gfx::DrawRoot*>(mpCurrent.get())->maRectangle = aRange;
+        }
+        break;
+        case svgio::svgreader::SVGToken::Rect:
+        {
+            auto const& rRectNode = static_cast<svgio::svgreader::SvgRectNode const&>(rNode);
+
+            double x = rRectNode.getX().getNumber();
+            double y = rRectNode.getY().getNumber();
+            double w = rRectNode.getWidth().getNumber();
+            double h = rRectNode.getHeight().getNumber();
+
+            auto pRectangle
+                = std::make_shared<gfx::DrawRectangle>(basegfx::B2DRange(x, y, x + w, y + h));
+            pRectangle->mnRx = rRectNode.getRx().getNumber();
+            pRectangle->mnRy = rRectNode.getRy().getNumber();
+
+            pRectangle->mnStrokeWidth
+                = rRectNode.getSvgStyleAttributes()->getStrokeWidth().getNumber();
+
+            pRectangle->mnOpacity = rRectNode.getSvgStyleAttributes()->getOpacity().getNumber();
+
+            const basegfx::BColor* pFillColor = rRectNode.getSvgStyleAttributes()->getFill();
+            const SvgGradientNode* pFillGradient
+                = rRectNode.getSvgStyleAttributes()->getSvgGradientNodeFill();
+            if (pFillColor)
+            {
+                pRectangle->mpFillColor = std::make_shared<basegfx::BColor>(*pFillColor);
+            }
+            else if (pFillGradient)
+            {
+                drawinglayer::primitive2d::SvgGradientEntryVector aSvgGradientEntryVector;
+                pFillGradient->collectGradientEntries(aSvgGradientEntryVector);
+                if (!aSvgGradientEntryVector.empty())
+                {
+                    auto aGradientInfo = std::make_shared<gfx::LinearGradientInfo>();
+
+                    aGradientInfo->x1 = pFillGradient->getX1().getNumber();
+                    aGradientInfo->y1 = pFillGradient->getY1().getNumber();
+                    aGradientInfo->x2 = pFillGradient->getX2().getNumber();
+                    aGradientInfo->y2 = pFillGradient->getY2().getNumber();
+
+                    std::optional<basegfx::B2DHomMatrix> pGradientTransform
+                        = pFillGradient->getGradientTransform();
+                    if (pGradientTransform)
+                    {
+                        aGradientInfo->maMatrix = *pGradientTransform;
+                    }
+
+                    pRectangle->mpFillGradient = aGradientInfo;
+
+                    for (auto const& rEntry : aSvgGradientEntryVector)
+                    {
+                        gfx::GradientStop aStop;
+                        aStop.maColor = rEntry.getColor();
+                        aStop.mfOffset = rEntry.getOffset();
+                        aStop.mfOpacity = rEntry.getOpacity();
+                        pRectangle->mpFillGradient->maGradientStops.push_back(aStop);
+                    }
+                }
+            }
+
+            const basegfx::BColor* pStrokeColor = rRectNode.getSvgStyleAttributes()->getStroke();
+            if (pStrokeColor)
+                pRectangle->mpStrokeColor = std::make_shared<basegfx::BColor>(*pStrokeColor);
+
+            mpCurrent->maChildren.push_back(pRectangle);
+        }
+        break;
+        case svgio::svgreader::SVGToken::Path:
+        {
+            auto const& rPathNode = static_cast<svgio::svgreader::SvgPathNode const&>(rNode);
+
+            auto pPath = rPathNode.getPath();
+            if (pPath)
+            {
+                auto pDrawPath = std::make_shared<gfx::DrawPath>(*pPath);
+
+                pDrawPath->mnStrokeWidth
+                    = rPathNode.getSvgStyleAttributes()->getStrokeWidth().getNumber();
+
+                pDrawPath->mnOpacity = rPathNode.getSvgStyleAttributes()->getOpacity().getNumber();
+
+                const basegfx::BColor* pFillColor = rPathNode.getSvgStyleAttributes()->getFill();
+                if (pFillColor)
+                    pDrawPath->mpFillColor = std::make_shared<basegfx::BColor>(*pFillColor);
+
+                const basegfx::BColor* pStrokeColor
+                    = rPathNode.getSvgStyleAttributes()->getStroke();
+                if (pStrokeColor)
+                    pDrawPath->mpStrokeColor = std::make_shared<basegfx::BColor>(*pStrokeColor);
+
+                mpCurrent->maChildren.push_back(pDrawPath);
+            }
+        }
+        break;
+
+        default:
+            break;
+    }
+    goToChildren(rNode);
+}
+
+void SvgDrawVisitor::goToChildren(svgio::svgreader::SvgNode const& rNode)
+{
+    for (auto& rChild : rNode.getChildren())
+    {
+        rChild->accept(*this);
+    }
+}
+} // end of namespace svgio::svgreader
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */