/* -*- 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 <rtl/uri.hxx>

#include <tools/color.hxx>

#include <rtl/character.hxx>

#include <tools/urlobj.hxx>

#include <unotools/securityoptions.hxx>

#include <rtl/math.hxx>

#include <o3tl/numeric.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"rebeccapurple", Color(102, 51, 153) },

            { 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 range 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)

        {

            for (; nPos < nLen && rtl::isAsciiHexDigit(rCandidate[nPos]); ++nPos)

            {

                rTarget.append(rCandidate[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 OUString 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;

        }

        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(o3tl::convertToHex<sal_Int32, 0>(aNum[0]));

                        const sal_Int32 nG(o3tl::convertToHex<sal_Int32, 0>(aNum[1]));

                        const sal_Int32 nB(o3tl::convertToHex<sal_Int32, 0>(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(o3tl::convertToHex<sal_Int32, 0>(aNum[0]));

                        const sal_Int32 nR2(o3tl::convertToHex<sal_Int32, 0>(aNum[1]));

                        const sal_Int32 nG1(o3tl::convertToHex<sal_Int32, 0>(aNum[2]));

                        const sal_Int32 nG2(o3tl::convertToHex<sal_Int32, 0>(aNum[3]));

                        const sal_Int32 nB1(o3tl::convertToHex<sal_Int32, 0>(aNum[4]));

                        const sal_Int32 nB2(o3tl::convertToHex<sal_Int32, 0>(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 multiplying 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(0);

                                    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;