DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5802 Commits
9 Branches
401MB
Tree: 606e7be12f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '606e7be12f'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1483 lines
52KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. class SVGState

  26. {

  27. public:

  28.     //==============================================================================

  29.     explicit SVGState (const XmlElement* const topLevel)

  30.         : topLevelXml (topLevel, nullptr),

  31.           elementX (0), elementY (0),

  32.           width (512), height (512),

  33.           viewBoxW (0), viewBoxH (0)

  34.     {

  35.     }

  36. 

  37.     struct XmlPath

  38.     {

  39.         XmlPath (const XmlElement* e, const XmlPath* p) noexcept : xml (e), parent (p)  {}

  40. 

  41.         const XmlElement& operator*() const noexcept            { jassert (xml != nullptr); return *xml; }

  42.         const XmlElement* operator->() const noexcept           { return xml; }

  43.         XmlPath getChild (const XmlElement* e) const noexcept   { return XmlPath (e, this); }

  44. 

  45.         template <typename OperationType>

  46.         bool applyOperationToChildWithID (const String& id, OperationType& op) const

  47.         {

  48.             forEachXmlChildElement (*xml, e)

  49.             {

  50.                 XmlPath child (e, this);

  51. 

  52.                 if (e->compareAttribute ("id", id))

  53.                 {

  54.                     op (child);

  55.                     return true;

  56.                 }

  57. 

  58.                 if (child.applyOperationToChildWithID (id, op))

  59.                     return true;

  60.             }

  61. 

  62.             return false;

  63.         }

  64. 

  65.         const XmlElement* xml;

  66.         const XmlPath* parent;

  67.     };

  68. 

  69.     //==============================================================================

  70.     Drawable* parseSVGElement (const XmlPath& xml)

  71.     {

  72.         if (! xml->hasTagNameIgnoringNamespace ("svg"))

  73.             return nullptr;

  74. 

  75.         DrawableComposite* const drawable = new DrawableComposite();

  76. 

  77.         setCommonAttributes (*drawable, xml);

  78. 

  79.         SVGState newState (*this);

  80. 

  81.         if (xml->hasAttribute ("transform"))

  82.             newState.addTransform (xml);

  83. 

  84.         newState.elementX = getCoordLength (xml->getStringAttribute ("x",      String (newState.elementX)), viewBoxW);

  85.         newState.elementY = getCoordLength (xml->getStringAttribute ("y",      String (newState.elementY)), viewBoxH);

  86.         newState.width    = getCoordLength (xml->getStringAttribute ("width",  String (newState.width)),    viewBoxW);

  87.         newState.height   = getCoordLength (xml->getStringAttribute ("height", String (newState.height)),   viewBoxH);

  88. 

  89.         if (newState.width  <= 0) newState.width  = 100;

  90.         if (newState.height <= 0) newState.height = 100;

  91. 

  92.         Point<float> viewboxXY;

  93. 

  94.         if (xml->hasAttribute ("viewBox"))

  95.         {

  96.             const String viewBoxAtt (xml->getStringAttribute ("viewBox"));

  97.             String::CharPointerType viewParams (viewBoxAtt.getCharPointer());

  98.             Point<float> vwh;

  99. 

  100.             if (parseCoords (viewParams, viewboxXY, true)

  101.                  && parseCoords (viewParams, vwh, true)

  102.                  && vwh.x > 0

  103.                  && vwh.y > 0)

  104.             {

  105.                 newState.viewBoxW = vwh.x;

  106.                 newState.viewBoxH = vwh.y;

  107. 

  108.                 const int placementFlags = parsePlacementFlags (xml->getStringAttribute ("preserveAspectRatio").trim());

  109. 

  110.                 if (placementFlags != 0)

  111.                     newState.transform = RectanglePlacement (placementFlags)

  112.                                             .getTransformToFit (Rectangle<float> (viewboxXY.x, viewboxXY.y, vwh.x, vwh.y),

  113.                                                                 Rectangle<float> (newState.width, newState.height))

  114.                                             .followedBy (newState.transform);

  115.             }

  116.         }

  117.         else

  118.         {

  119.             if (viewBoxW == 0)  newState.viewBoxW = newState.width;

  120.             if (viewBoxH == 0)  newState.viewBoxH = newState.height;

  121.         }

  122. 

  123.         newState.parseSubElements (xml, *drawable);

  124. 

  125.         drawable->setContentArea (RelativeRectangle (RelativeCoordinate (viewboxXY.x),

  126.                                                      RelativeCoordinate (viewboxXY.x + newState.viewBoxW),

  127.                                                      RelativeCoordinate (viewboxXY.y),

  128.                                                      RelativeCoordinate (viewboxXY.y + newState.viewBoxH)));

  129.         drawable->resetBoundingBoxToContentArea();

  130. 

  131.         return drawable;

  132.     }

  133. 

  134.     //==============================================================================

  135.     void parsePathString (Path& path, const String& pathString) const

  136.     {

  137.         String::CharPointerType d (pathString.getCharPointer().findEndOfWhitespace());

  138. 

  139.         Point<float> subpathStart, last, last2, p1, p2, p3;

  140.         juce_wchar lastCommandChar = 0;

  141.         bool isRelative = true;

  142.         bool carryOn = true;

  143. 

  144.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  145. 

  146.         while (! d.isEmpty())

  147.         {

  148.             if (validCommandChars.indexOf (*d) >= 0)

  149.             {

  150.                 lastCommandChar = d.getAndAdvance();

  151.                 isRelative = (lastCommandChar >= 'a' && lastCommandChar <= 'z');

  152.             }

  153. 

  154.             switch (lastCommandChar)

  155.             {

  156.             case 'M':

  157.             case 'm':

  158.             case 'L':

  159.             case 'l':

  160.                 if (parseCoordsOrSkip (d, p1, false))

  161.                 {

  162.                     if (isRelative)

  163.                         p1 += last;

  164. 

  165.                     if (lastCommandChar == 'M' || lastCommandChar == 'm')

  166.                     {

  167.                         subpathStart = p1;

  168.                         path.startNewSubPath (p1);

  169.                         lastCommandChar = 'l';

  170.                     }

  171.                     else

  172.                         path.lineTo (p1);

  173. 

  174.                     last2 = last;

  175.                     last = p1;

  176.                 }

  177.                 break;

  178. 

  179.             case 'H':

  180.             case 'h':

  181.                 if (parseCoord (d, p1.x, false, true))

  182.                 {

  183.                     if (isRelative)

  184.                         p1.x += last.x;

  185. 

  186.                     path.lineTo (p1.x, last.y);

  187. 

  188.                     last2.x = last.x;

  189.                     last.x = p1.x;

  190.                 }

  191.                 else

  192.                 {

  193.                     ++d;

  194.                 }

  195.                 break;

  196. 

  197.             case 'V':

  198.             case 'v':

  199.                 if (parseCoord (d, p1.y, false, false))

  200.                 {

  201.                     if (isRelative)

  202.                         p1.y += last.y;

  203. 

  204.                     path.lineTo (last.x, p1.y);

  205. 

  206.                     last2.y = last.y;

  207.                     last.y = p1.y;

  208.                 }

  209.                 else

  210.                 {

  211.                     ++d;

  212.                 }

  213.                 break;

  214. 

  215.             case 'C':

  216.             case 'c':

  217.                 if (parseCoordsOrSkip (d, p1, false)

  218.                      && parseCoordsOrSkip (d, p2, false)

  219.                      && parseCoordsOrSkip (d, p3, false))

  220.                 {

  221.                     if (isRelative)

  222.                     {

  223.                         p1 += last;

  224.                         p2 += last;

  225.                         p3 += last;

  226.                     }

  227. 

  228.                     path.cubicTo (p1, p2, p3);

  229. 

  230.                     last2 = p2;

  231.                     last = p3;

  232.                 }

  233.                 break;

  234. 

  235.             case 'S':

  236.             case 's':

  237.                 if (parseCoordsOrSkip (d, p1, false)

  238.                      && parseCoordsOrSkip (d, p3, false))

  239.                 {

  240.                     if (isRelative)

  241.                     {

  242.                         p1 += last;

  243.                         p3 += last;

  244.                     }

  245. 

  246.                     p2 = last + (last - last2);

  247.                     path.cubicTo (p2, p1, p3);

  248. 

  249.                     last2 = p1;

  250.                     last = p3;

  251.                 }

  252.                 break;

  253. 

  254.             case 'Q':

  255.             case 'q':

  256.                 if (parseCoordsOrSkip (d, p1, false)

  257.                      && parseCoordsOrSkip (d, p2, false))

  258.                 {

  259.                     if (isRelative)

  260.                     {

  261.                         p1 += last;

  262.                         p2 += last;

  263.                     }

  264. 

  265.                     path.quadraticTo (p1, p2);

  266. 

  267.                     last2 = p1;

  268.                     last = p2;

  269.                 }

  270.                 break;

  271. 

  272.             case 'T':

  273.             case 't':

  274.                 if (parseCoordsOrSkip (d, p1, false))

  275.                 {

  276.                     if (isRelative)

  277.                         p1 += last;

  278. 

  279.                     p2 = last + (last - last2);

  280.                     path.quadraticTo (p2, p1);

  281. 

  282.                     last2 = p2;

  283.                     last = p1;

  284.                 }

  285.                 break;

  286. 

  287.             case 'A':

  288.             case 'a':

  289.                 if (parseCoordsOrSkip (d, p1, false))

  290.                 {

  291.                     String num;

  292. 

  293.                     if (parseNextNumber (d, num, false))

  294.                     {

  295.                         const float angle = degreesToRadians (num.getFloatValue());

  296. 

  297.                         if (parseNextNumber (d, num, false))

  298.                         {

  299.                             const bool largeArc = num.getIntValue() != 0;

  300. 

  301.                             if (parseNextNumber (d, num, false))

  302.                             {

  303.                                 const bool sweep = num.getIntValue() != 0;

  304. 

  305.                                 if (parseCoordsOrSkip (d, p2, false))

  306.                                 {

  307.                                     if (isRelative)

  308.                                         p2 += last;

  309. 

  310.                                     if (last != p2)

  311.                                     {

  312.                                         double centreX, centreY, startAngle, deltaAngle;

  313.                                         double rx = p1.x, ry = p1.y;

  314. 

  315.                                         endpointToCentreParameters (last.x, last.y, p2.x, p2.y,

  316.                                                                     angle, largeArc, sweep,

  317.                                                                     rx, ry, centreX, centreY,

  318.                                                                     startAngle, deltaAngle);

  319. 

  320.                                         path.addCentredArc ((float) centreX, (float) centreY,

  321.                                                             (float) rx, (float) ry,

  322.                                                             angle, (float) startAngle, (float) (startAngle + deltaAngle),

  323.                                                             false);

  324. 

  325.                                         path.lineTo (p2);

  326.                                     }

  327. 

  328.                                     last2 = last;

  329.                                     last = p2;

  330.                                 }

  331.                             }

  332.                         }

  333.                     }

  334.                 }

  335. 

  336.                 break;

  337. 

  338.             case 'Z':

  339.             case 'z':

  340.                 path.closeSubPath();

  341.                 last = last2 = subpathStart;

  342.                 d = d.findEndOfWhitespace();

  343.                 lastCommandChar = 'M';

  344.                 break;

  345. 

  346.             default:

  347.                 carryOn = false;

  348.                 break;

  349.             }

  350. 

  351.             if (! carryOn)

  352.                 break;

  353.         }

  354. 

  355.         // paths that finish back at their start position often seem to be

  356.         // left without a 'z', so need to be closed explicitly..

  357.         if (path.getCurrentPosition() == subpathStart)

  358.             path.closeSubPath();

  359.     }

  360. 

  361. private:

  362.     //==============================================================================

  363.     const XmlPath topLevelXml;

  364.     float elementX, elementY, width, height, viewBoxW, viewBoxH;

  365.     AffineTransform transform;

  366.     String cssStyleText;

  367. 

  368.     static void setCommonAttributes (Drawable& d, const XmlPath& xml)

  369.     {

  370.         String compID (xml->getStringAttribute ("id"));

  371.         d.setName (compID);

  372.         d.setComponentID (compID);

  373. 

  374.         if (xml->getStringAttribute ("display") == "none")

  375.             d.setVisible (false);

  376.     }

  377. 

  378.     //==============================================================================

  379.     void parseSubElements (const XmlPath& xml, DrawableComposite& parentDrawable)

  380.     {

  381.         forEachXmlChildElement (*xml, e)

  382.             parentDrawable.addAndMakeVisible (parseSubElement (xml.getChild (e)));

  383.     }

  384. 

  385.     Drawable* parseSubElement (const XmlPath& xml)

  386.     {

  387.         {

  388.             Path path;

  389.             if (parsePathElement (xml, path))

  390.                 return parseShape (xml, path);

  391.         }

  392. 

  393.         const String tag (xml->getTagNameWithoutNamespace());

  394. 

  395.         if (tag == "g")         return parseGroupElement (xml);

  396.         if (tag == "svg")       return parseSVGElement (xml);

  397.         if (tag == "text")      return parseText (xml, true);

  398.         if (tag == "switch")    return parseSwitch (xml);

  399.         if (tag == "a")         return parseLinkElement (xml);

  400.         if (tag == "style")     parseCSSStyle (xml);

  401. 

  402.         return nullptr;

  403.     }

  404. 

  405.     bool parsePathElement (const XmlPath& xml, Path& path) const

  406.     {

  407.         const String tag (xml->getTagNameWithoutNamespace());

  408. 

  409.         if (tag == "path")      { parsePath (xml, path);           return true; }

  410.         if (tag == "rect")      { parseRect (xml, path);           return true; }

  411.         if (tag == "circle")    { parseCircle (xml, path);         return true; }

  412.         if (tag == "ellipse")   { parseEllipse (xml, path);        return true; }

  413.         if (tag == "line")      { parseLine (xml, path);           return true; }

  414.         if (tag == "polyline")  { parsePolygon (xml, true, path);  return true; }

  415.         if (tag == "polygon")   { parsePolygon (xml, false, path); return true; }

  416.         if (tag == "use")       { parseUse (xml, path);            return true; }

  417. 

  418.         return false;

  419.     }

  420. 

  421.     DrawableComposite* parseSwitch (const XmlPath& xml)

  422.     {

  423.         if (const XmlElement* const group = xml->getChildByName ("g"))

  424.             return parseGroupElement (xml.getChild (group));

  425. 

  426.         return nullptr;

  427.     }

  428. 

  429.     DrawableComposite* parseGroupElement (const XmlPath& xml)

  430.     {

  431.         DrawableComposite* const drawable = new DrawableComposite();

  432. 

  433.         setCommonAttributes (*drawable, xml);

  434. 

  435.         if (xml->hasAttribute ("transform"))

  436.         {

  437.             SVGState newState (*this);

  438.             newState.addTransform (xml);

  439. 

  440.             newState.parseSubElements (xml, *drawable);

  441.         }

  442.         else

  443.         {

  444.             parseSubElements (xml, *drawable);

  445.         }

  446. 

  447.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  448.         return drawable;

  449.     }

  450. 

  451.     DrawableComposite* parseLinkElement (const XmlPath& xml)

  452.     {

  453.         return parseGroupElement (xml); // TODO: support for making this clickable

  454.     }

  455. 

  456.     //==============================================================================

  457.     void parsePath (const XmlPath& xml, Path& path) const

  458.     {

  459.         parsePathString (path, xml->getStringAttribute ("d"));

  460. 

  461.         if (getStyleAttribute (xml, "fill-rule").trim().equalsIgnoreCase ("evenodd"))

  462.             path.setUsingNonZeroWinding (false);

  463.     }

  464. 

  465.     void parseRect (const XmlPath& xml, Path& rect) const

  466.     {

  467.         const bool hasRX = xml->hasAttribute ("rx");

  468.         const bool hasRY = xml->hasAttribute ("ry");

  469. 

  470.         if (hasRX || hasRY)

  471.         {

  472.             float rx = getCoordLength (xml, "rx", viewBoxW);

  473.             float ry = getCoordLength (xml, "ry", viewBoxH);

  474. 

  475.             if (! hasRX)

  476.                 rx = ry;

  477.             else if (! hasRY)

  478.                 ry = rx;

  479. 

  480.             rect.addRoundedRectangle (getCoordLength (xml, "x", viewBoxW),

  481.                                       getCoordLength (xml, "y", viewBoxH),

  482.                                       getCoordLength (xml, "width", viewBoxW),

  483.                                       getCoordLength (xml, "height", viewBoxH),

  484.                                       rx, ry);

  485.         }

  486.         else

  487.         {

  488.             rect.addRectangle (getCoordLength (xml, "x", viewBoxW),

  489.                                getCoordLength (xml, "y", viewBoxH),

  490.                                getCoordLength (xml, "width", viewBoxW),

  491.                                getCoordLength (xml, "height", viewBoxH));

  492.         }

  493.     }

  494. 

  495.     void parseCircle (const XmlPath& xml, Path& circle) const

  496.     {

  497.         const float cx = getCoordLength (xml, "cx", viewBoxW);

  498.         const float cy = getCoordLength (xml, "cy", viewBoxH);

  499.         const float radius = getCoordLength (xml, "r", viewBoxW);

  500. 

  501.         circle.addEllipse (cx - radius, cy - radius, radius * 2.0f, radius * 2.0f);

  502.     }

  503. 

  504.     void parseEllipse (const XmlPath& xml, Path& ellipse) const

  505.     {

  506.         const float cx      = getCoordLength (xml, "cx", viewBoxW);

  507.         const float cy      = getCoordLength (xml, "cy", viewBoxH);

  508.         const float radiusX = getCoordLength (xml, "rx", viewBoxW);

  509.         const float radiusY = getCoordLength (xml, "ry", viewBoxH);

  510. 

  511.         ellipse.addEllipse (cx - radiusX, cy - radiusY, radiusX * 2.0f, radiusY * 2.0f);

  512.     }

  513. 

  514.     void parseLine (const XmlPath& xml, Path& line) const

  515.     {

  516.         const float x1 = getCoordLength (xml, "x1", viewBoxW);

  517.         const float y1 = getCoordLength (xml, "y1", viewBoxH);

  518.         const float x2 = getCoordLength (xml, "x2", viewBoxW);

  519.         const float y2 = getCoordLength (xml, "y2", viewBoxH);

  520. 

  521.         line.startNewSubPath (x1, y1);

  522.         line.lineTo (x2, y2);

  523.     }

  524. 

  525.     void parsePolygon (const XmlPath& xml, const bool isPolyline, Path& path) const

  526.     {

  527.         const String pointsAtt (xml->getStringAttribute ("points"));

  528.         String::CharPointerType points (pointsAtt.getCharPointer());

  529.         Point<float> p;

  530. 

  531.         if (parseCoords (points, p, true))

  532.         {

  533.             Point<float> first (p), last;

  534. 

  535.             path.startNewSubPath (first);

  536. 

  537.             while (parseCoords (points, p, true))

  538.             {

  539.                 last = p;

  540.                 path.lineTo (p);

  541.             }

  542. 

  543.             if ((! isPolyline) || first == last)

  544.                 path.closeSubPath();

  545.         }

  546.     }

  547. 

  548.     void parseUse (const XmlPath& xml, Path& path) const

  549.     {

  550.         const String link (xml->getStringAttribute ("xlink:href"));

  551. 

  552.         if (link.startsWithChar ('#'))

  553.         {

  554.             const String linkedID = link.substring (1);

  555. 

  556.             struct UsePathOp

  557.             {

  558.                 const SVGState* state;

  559.                 Path* targetPath;

  560. 

  561.                 void operator() (const XmlPath& xmlPath)

  562.                 {

  563.                     state->parsePathElement (xmlPath, *targetPath);

  564.                 }

  565.             };

  566. 

  567.             UsePathOp op = { this, &path };

  568.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  569.         }

  570.     }

  571. 

  572.     static String parseURL (const String& str)

  573.     {

  574.         if (str.startsWithIgnoreCase ("url"))

  575.             return str.fromFirstOccurrenceOf ("#", false, false)

  576.                       .upToLastOccurrenceOf (")", false, false).trim();

  577. 

  578.         return String();

  579.     }

  580. 

  581.     //==============================================================================

  582.     Drawable* parseShape (const XmlPath& xml, Path& path,

  583.                           const bool shouldParseTransform = true) const

  584.     {

  585.         if (shouldParseTransform && xml->hasAttribute ("transform"))

  586.         {

  587.             SVGState newState (*this);

  588.             newState.addTransform (xml);

  589. 

  590.             return newState.parseShape (xml, path, false);

  591.         }

  592. 

  593.         DrawablePath* dp = new DrawablePath();

  594.         setCommonAttributes (*dp, xml);

  595.         dp->setFill (Colours::transparentBlack);

  596. 

  597.         path.applyTransform (transform);

  598.         dp->setPath (path);

  599. 

  600.         dp->setFill (getPathFillType (path,

  601.                                       getStyleAttribute (xml, "fill"),

  602.                                       getStyleAttribute (xml, "fill-opacity"),

  603.                                       getStyleAttribute (xml, "opacity"),

  604.                                       pathContainsClosedSubPath (path) ? Colours::black

  605.                                                                        : Colours::transparentBlack));

  606. 

  607.         const String strokeType (getStyleAttribute (xml, "stroke"));

  608. 

  609.         if (strokeType.isNotEmpty() && ! strokeType.equalsIgnoreCase ("none"))

  610.         {

  611.             dp->setStrokeFill (getPathFillType (path, strokeType,

  612.                                                 getStyleAttribute (xml, "stroke-opacity"),

  613.                                                 getStyleAttribute (xml, "opacity"),

  614.                                                 Colours::transparentBlack));

  615. 

  616.             dp->setStrokeType (getStrokeFor (xml));

  617.         }

  618. 

  619.         const String strokeDashArray (getStyleAttribute (xml, "stroke-dasharray"));

  620. 

  621.         if (strokeDashArray.isNotEmpty())

  622.             parseDashArray (strokeDashArray.getCharPointer(), *dp);

  623. 

  624.         parseClipPath (xml, *dp);

  625. 

  626.         return dp;

  627.     }

  628. 

  629.     static bool pathContainsClosedSubPath (const Path& path) noexcept

  630.     {

  631.         for (Path::Iterator iter (path); iter.next();)

  632.             if (iter.elementType == Path::Iterator::closePath)

  633.                 return true;

  634. 

  635.         return false;

  636.     }

  637. 

  638.     void parseDashArray (String::CharPointerType t, DrawablePath& dp) const

  639.     {

  640.         Array<float> dashLengths;

  641. 

  642.         for (;;)

  643.         {

  644.             float value;

  645.             if (! parseCoord (t, value, true, true))

  646.                 break;

  647. 

  648.             dashLengths.add (value);

  649. 

  650.             t = t.findEndOfWhitespace();

  651. 

  652.             if (*t == ',')

  653.                 ++t;

  654.         }

  655. 

  656.         float* const dashes = dashLengths.getRawDataPointer();

  657. 

  658.         for (int i = 0; i < dashLengths.size(); ++i)

  659.         {

  660.             if (dashes[i] <= 0)  // SVG uses zero-length dashes to mean a dotted line

  661.             {

  662.                 const float nonZeroLength = 0.001f;

  663.                 dashes[i] = nonZeroLength;

  664. 

  665.                 const int pairedIndex = i ^ 1;

  666. 

  667.                 if (isPositiveAndBelow (pairedIndex, dashLengths.size())

  668.                       && dashes[pairedIndex] > nonZeroLength)

  669.                     dashes[pairedIndex] -= nonZeroLength;

  670.             }

  671.         }

  672. 

  673.         dp.setDashLengths (dashLengths);

  674.     }

  675. 

  676.     void parseClipPath (const XmlPath& xml, Drawable& d) const

  677.     {

  678.         const String clipPath (getStyleAttribute (xml, "clip-path"));

  679. 

  680.         if (clipPath.isNotEmpty())

  681.         {

  682.             String urlID = parseURL (clipPath);

  683. 

  684.             if (urlID.isNotEmpty())

  685.             {

  686.                 struct GetClipPathOp

  687.                 {

  688.                     const SVGState* state;

  689.                     Drawable* target;

  690. 

  691.                     void operator() (const XmlPath& xmlPath)

  692.                     {

  693.                         state->applyClipPath (*target, xmlPath);

  694.                     }

  695.                 };

  696. 

  697.                 GetClipPathOp op = { this, &d };

  698.                 topLevelXml.applyOperationToChildWithID (urlID, op);

  699.             }

  700.         }

  701.     }

  702. 

  703.     void applyClipPath (Drawable& target, const XmlPath& xmlPath) const

  704.     {

  705.         if (xmlPath->hasTagNameIgnoringNamespace ("clippath"))

  706.         {

  707.             // TODO: implement clipping..

  708.             ignoreUnused (target);

  709.         }

  710.     }

  711. 

  712.     void addGradientStopsIn (ColourGradient& cg, const XmlPath& fillXml) const

  713.     {

  714.         if (fillXml.xml != nullptr)

  715.         {

  716.             forEachXmlChildElementWithTagName (*fillXml, e, "stop")

  717.             {

  718.                 int index = 0;

  719.                 Colour col (parseColour (getStyleAttribute (fillXml.getChild (e), "stop-color"), index, Colours::black));

  720. 

  721.                 const String opacity (getStyleAttribute (fillXml.getChild (e), "stop-opacity", "1"));

  722.                 col = col.withMultipliedAlpha (jlimit (0.0f, 1.0f, opacity.getFloatValue()));

  723. 

  724.                 double offset = e->getDoubleAttribute ("offset");

  725. 

  726.                 if (e->getStringAttribute ("offset").containsChar ('%'))

  727.                     offset *= 0.01;

  728. 

  729.                 cg.addColour (jlimit (0.0, 1.0, offset), col);

  730.             }

  731.         }

  732.     }

  733. 

  734.     FillType getGradientFillType (const XmlPath& fillXml,

  735.                                   const Path& path,

  736.                                   const float opacity) const

  737.     {

  738.         ColourGradient gradient;

  739. 

  740.         {

  741.             const String id (fillXml->getStringAttribute ("xlink:href"));

  742. 

  743.             if (id.startsWithChar ('#'))

  744.             {

  745.                 struct SetGradientStopsOp

  746.                 {

  747.                     const SVGState* state;

  748.                     ColourGradient* gradient;

  749. 

  750.                     void operator() (const XmlPath& xml)

  751.                     {

  752.                         state->addGradientStopsIn (*gradient, xml);

  753.                     }

  754.                 };

  755. 

  756.                 SetGradientStopsOp op = { this, &gradient, };

  757.                 topLevelXml.applyOperationToChildWithID (id.substring (1), op);

  758.             }

  759.         }

  760. 

  761.         addGradientStopsIn (gradient, fillXml);

  762. 

  763.         if (gradient.getNumColours() > 0)

  764.         {

  765.             gradient.addColour (0.0, gradient.getColour (0));

  766.             gradient.addColour (1.0, gradient.getColour (gradient.getNumColours() - 1));

  767.         }

  768.         else

  769.         {

  770.             gradient.addColour (0.0, Colours::black);

  771.             gradient.addColour (1.0, Colours::black);

  772.         }

  773. 

  774.         if (opacity < 1.0f)

  775.             gradient.multiplyOpacity (opacity);

  776. 

  777.         jassert (gradient.getNumColours() > 0);

  778. 

  779.         gradient.isRadial = fillXml->hasTagNameIgnoringNamespace ("radialGradient");

  780. 

  781.         float gradientWidth = viewBoxW;

  782.         float gradientHeight = viewBoxH;

  783.         float dx = 0.0f;

  784.         float dy = 0.0f;

  785. 

  786.         const bool userSpace = fillXml->getStringAttribute ("gradientUnits").equalsIgnoreCase ("userSpaceOnUse");

  787. 

  788.         if (! userSpace)

  789.         {

  790.             const Rectangle<float> bounds (path.getBounds());

  791.             dx = bounds.getX();

  792.             dy = bounds.getY();

  793.             gradientWidth = bounds.getWidth();

  794.             gradientHeight = bounds.getHeight();

  795.         }

  796. 

  797.         if (gradient.isRadial)

  798.         {

  799.             if (userSpace)

  800.                 gradient.point1.setXY (dx + getCoordLength (fillXml->getStringAttribute ("cx", "50%"), gradientWidth),

  801.                                        dy + getCoordLength (fillXml->getStringAttribute ("cy", "50%"), gradientHeight));

  802.             else

  803.                 gradient.point1.setXY (dx + gradientWidth  * getCoordLength (fillXml->getStringAttribute ("cx", "50%"), 1.0f),

  804.                                        dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("cy", "50%"), 1.0f));

  805. 

  806.             const float radius = getCoordLength (fillXml->getStringAttribute ("r", "50%"), gradientWidth);

  807.             gradient.point2 = gradient.point1 + Point<float> (radius, 0.0f);

  808. 

  809.             //xxx (the fx, fy focal point isn't handled properly here..)

  810.         }

  811.         else

  812.         {

  813.             if (userSpace)

  814.             {

  815.                 gradient.point1.setXY (dx + getCoordLength (fillXml->getStringAttribute ("x1", "0%"), gradientWidth),

  816.                                        dy + getCoordLength (fillXml->getStringAttribute ("y1", "0%"), gradientHeight));

  817. 

  818.                 gradient.point2.setXY (dx + getCoordLength (fillXml->getStringAttribute ("x2", "100%"), gradientWidth),

  819.                                        dy + getCoordLength (fillXml->getStringAttribute ("y2", "0%"), gradientHeight));

  820.             }

  821.             else

  822.             {

  823.                 gradient.point1.setXY (dx + gradientWidth  * getCoordLength (fillXml->getStringAttribute ("x1", "0%"), 1.0f),

  824.                                        dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("y1", "0%"), 1.0f));

  825. 

  826.                 gradient.point2.setXY (dx + gradientWidth  * getCoordLength (fillXml->getStringAttribute ("x2", "100%"), 1.0f),

  827.                                        dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("y2", "0%"), 1.0f));

  828.             }

  829. 

  830.             if (gradient.point1 == gradient.point2)

  831.                 return Colour (gradient.getColour (gradient.getNumColours() - 1));

  832.         }

  833. 

  834.         FillType type (gradient);

  835. 

  836.         const AffineTransform gradientTransform (parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  837.                                                     .followedBy (transform));

  838. 

  839.         if (gradient.isRadial)

  840.         {

  841.             type.transform = gradientTransform;

  842.         }

  843.         else

  844.         {

  845.             // Transform the perpendicular vector into the new coordinate space for the gradient.

  846.             // This vector is now the slope of the linear gradient as it should appear in the new coord space

  847.             const Point<float> perpendicular (Point<float> (gradient.point2.y - gradient.point1.y,

  848.                                                             gradient.point1.x - gradient.point2.x)

  849.                                                   .transformedBy (gradientTransform.withAbsoluteTranslation (0, 0)));

  850. 

  851.             const Point<float> newGradPoint1 (gradient.point1.transformedBy (gradientTransform));

  852.             const Point<float> newGradPoint2 (gradient.point2.transformedBy (gradientTransform));

  853. 

  854.             // Project the transformed gradient vector onto the transformed slope of the linear

  855.             // gradient as it should appear in the new coordinate space

  856.             const float scale = perpendicular.getDotProduct (newGradPoint2 - newGradPoint1)

  857.                                   / perpendicular.getDotProduct (perpendicular);

  858. 

  859.             type.gradient->point1 = newGradPoint1;

  860.             type.gradient->point2 = newGradPoint2 - perpendicular * scale;

  861.         }

  862. 

  863.         return type;

  864.     }

  865. 

  866.     FillType getPathFillType (const Path& path,

  867.                               const String& fill,

  868.                               const String& fillOpacity,

  869.                               const String& overallOpacity,

  870.                               const Colour defaultColour) const

  871.     {

  872.         float opacity = 1.0f;

  873. 

  874.         if (overallOpacity.isNotEmpty())

  875.             opacity = jlimit (0.0f, 1.0f, overallOpacity.getFloatValue());

  876. 

  877.         if (fillOpacity.isNotEmpty())

  878.             opacity *= (jlimit (0.0f, 1.0f, fillOpacity.getFloatValue()));

  879. 

  880.         String urlID = parseURL (fill);

  881. 

  882.         if (urlID.isNotEmpty())

  883.         {

  884.             struct GetFillTypeOp

  885.             {

  886.                 const SVGState* state;

  887.                 const Path* path;

  888.                 float opacity;

  889.                 FillType fillType;

  890. 

  891.                 void operator() (const XmlPath& xml)

  892.                 {

  893.                     if (xml->hasTagNameIgnoringNamespace ("linearGradient")

  894.                          || xml->hasTagNameIgnoringNamespace ("radialGradient"))

  895.                         fillType = state->getGradientFillType (xml, *path, opacity);

  896.                 }

  897.             };

  898. 

  899.             GetFillTypeOp op = { this, &path, opacity };

  900. 

  901.             if (topLevelXml.applyOperationToChildWithID (urlID, op))

  902.                 return op.fillType;

  903.         }

  904. 

  905.         if (fill.equalsIgnoreCase ("none"))

  906.             return Colours::transparentBlack;

  907. 

  908.         int i = 0;

  909.         return parseColour (fill, i, defaultColour).withMultipliedAlpha (opacity);

  910.     }

  911. 

  912.     static PathStrokeType::JointStyle getJointStyle (const String& join) noexcept

  913.     {

  914.         if (join.equalsIgnoreCase ("round"))  return PathStrokeType::curved;

  915.         if (join.equalsIgnoreCase ("bevel"))  return PathStrokeType::beveled;

  916. 

  917.         return PathStrokeType::mitered;

  918.     }

  919. 

  920.     static PathStrokeType::EndCapStyle getEndCapStyle (const String& cap) noexcept

  921.     {

  922.         if (cap.equalsIgnoreCase ("round"))   return PathStrokeType::rounded;

  923.         if (cap.equalsIgnoreCase ("square"))  return PathStrokeType::square;

  924. 

  925.         return PathStrokeType::butt;

  926.     }

  927. 

  928.     float getStrokeWidth (const String& strokeWidth) const noexcept

  929.     {

  930.         return transform.getScaleFactor() * getCoordLength (strokeWidth, viewBoxW);

  931.     }

  932. 

  933.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  934.     {

  935.         return PathStrokeType (getStrokeWidth (getStyleAttribute (xml, "stroke-width", "1")),

  936.                                getJointStyle  (getStyleAttribute (xml, "stroke-linejoin")),

  937.                                getEndCapStyle (getStyleAttribute (xml, "stroke-linecap")));

  938.     }

  939. 

  940.     //==============================================================================

  941.     Drawable* parseText (const XmlPath& xml, bool shouldParseTransform)

  942.     {

  943.         if (shouldParseTransform && xml->hasAttribute ("transform"))

  944.         {

  945.             SVGState newState (*this);

  946.             newState.addTransform (xml);

  947. 

  948.             return newState.parseText (xml, false);

  949.         }

  950. 

  951.         Array<float> xCoords, yCoords, dxCoords, dyCoords;

  952. 

  953.         getCoordList (xCoords,  getInheritedAttribute (xml, "x"),  true, true);

  954.         getCoordList (yCoords,  getInheritedAttribute (xml, "y"),  true, false);

  955.         getCoordList (dxCoords, getInheritedAttribute (xml, "dx"), true, true);

  956.         getCoordList (dyCoords, getInheritedAttribute (xml, "dy"), true, false);

  957. 

  958.         const Font font (getFont (xml));

  959.         const String anchorStr = getStyleAttribute(xml, "text-anchor");

  960. 

  961.         DrawableComposite* dc = new DrawableComposite();

  962.         setCommonAttributes (*dc, xml);

  963. 

  964.         forEachXmlChildElement (*xml, e)

  965.         {

  966.             if (e->isTextElement())

  967.             {

  968.                 const String text (e->getText().trim());

  969. 

  970.                 DrawableText* dt = new DrawableText();

  971.                 dc->addAndMakeVisible (dt);

  972. 

  973.                 dt->setText (text);

  974.                 dt->setFont (font, true);

  975.                 dt->setTransform (transform);

  976. 

  977.                 int i = 0;

  978.                 dt->setColour (parseColour (getStyleAttribute (xml, "fill"), i, Colours::black)

  979.                                  .withMultipliedAlpha (getStyleAttribute (xml, "fill-opacity", "1").getFloatValue()));

  980. 

  981.                 Rectangle<float> bounds (xCoords[0], yCoords[0] - font.getAscent(),

  982.                                          font.getStringWidthFloat (text), font.getHeight());

  983. 

  984.                 if (anchorStr == "middle")   bounds.setX (bounds.getX() - bounds.getWidth() / 2.0f);

  985.                 else if (anchorStr == "end") bounds.setX (bounds.getX() - bounds.getWidth());

  986. 

  987.                 dt->setBoundingBox (bounds);

  988.             }

  989.             else if (e->hasTagNameIgnoringNamespace ("tspan"))

  990.             {

  991.                 dc->addAndMakeVisible (parseText (xml.getChild (e), true));

  992.             }

  993.         }

  994. 

  995.         return dc;

  996.     }

  997. 

  998.     Font getFont (const XmlPath& xml) const

  999.     {

  1000.         const float fontSize = getCoordLength (getStyleAttribute (xml, "font-size"), 1.0f);

  1001. 

  1002.         int style = getStyleAttribute (xml, "font-style").containsIgnoreCase ("italic") ? Font::italic : Font::plain;

  1003. 

  1004.         if (getStyleAttribute (xml, "font-weight").containsIgnoreCase ("bold"))

  1005.             style |= Font::bold;

  1006. 

  1007.         const String family (getStyleAttribute (xml, "font-family"));

  1008. 

  1009.         return family.isEmpty() ? Font (fontSize, style)

  1010.                                 : Font (family, fontSize, style);

  1011.     }

  1012. 

  1013.     //==============================================================================

  1014.     void addTransform (const XmlPath& xml)

  1015.     {

  1016.         transform = parseTransform (xml->getStringAttribute ("transform"))

  1017.                         .followedBy (transform);

  1018.     }

  1019. 

  1020.     //==============================================================================

  1021.     bool parseCoord (String::CharPointerType& s, float& value, const bool allowUnits, const bool isX) const

  1022.     {

  1023.         String number;

  1024. 

  1025.         if (! parseNextNumber (s, number, allowUnits))

  1026.         {

  1027.             value = 0;

  1028.             return false;

  1029.         }

  1030. 

  1031.         value = getCoordLength (number, isX ? viewBoxW : viewBoxH);

  1032.         return true;

  1033.     }

  1034. 

  1035.     bool parseCoords (String::CharPointerType& s, Point<float>& p, const bool allowUnits) const

  1036.     {

  1037.         return parseCoord (s, p.x, allowUnits, true)

  1038.             && parseCoord (s, p.y, allowUnits, false);

  1039.     }

  1040. 

  1041.     bool parseCoordsOrSkip (String::CharPointerType& s, Point<float>& p, const bool allowUnits) const

  1042.     {

  1043.         if (parseCoords (s, p, allowUnits))

  1044.             return true;

  1045. 

  1046.         if (! s.isEmpty()) ++s;

  1047.         return false;

  1048.     }

  1049. 

  1050.     float getCoordLength (const String& s, const float sizeForProportions) const noexcept

  1051.     {

  1052.         float n = s.getFloatValue();

  1053.         const int len = s.length();

  1054. 

  1055.         if (len > 2)

  1056.         {

  1057.             const float dpi = 96.0f;

  1058. 

  1059.             const juce_wchar n1 = s [len - 2];

  1060.             const juce_wchar n2 = s [len - 1];

  1061. 

  1062.             if (n1 == 'i' && n2 == 'n')         n *= dpi;

  1063.             else if (n1 == 'm' && n2 == 'm')    n *= dpi / 25.4f;

  1064.             else if (n1 == 'c' && n2 == 'm')    n *= dpi / 2.54f;

  1065.             else if (n1 == 'p' && n2 == 'c')    n *= 15.0f;

  1066.             else if (n2 == '%')                 n *= 0.01f * sizeForProportions;

  1067.         }

  1068. 

  1069.         return n;

  1070.     }

  1071. 

  1072.     float getCoordLength (const XmlPath& xml, const char* attName, const float sizeForProportions) const noexcept

  1073.     {

  1074.         return getCoordLength (xml->getStringAttribute (attName), sizeForProportions);

  1075.     }

  1076. 

  1077.     void getCoordList (Array<float>& coords, const String& list, bool allowUnits, const bool isX) const

  1078.     {

  1079.         String::CharPointerType text (list.getCharPointer());

  1080.         float value;

  1081. 

  1082.         while (parseCoord (text, value, allowUnits, isX))

  1083.             coords.add (value);

  1084.     }

  1085. 

  1086.     //==============================================================================

  1087.     void parseCSSStyle (const XmlPath& xml)

  1088.     {

  1089.         cssStyleText = xml->getAllSubText() + "\n" + cssStyleText;

  1090.     }

  1091. 

  1092.     static String::CharPointerType findStyleItem (String::CharPointerType source, String::CharPointerType name)

  1093.     {

  1094.         const int nameLength = (int) name.length();

  1095. 

  1096.         while (! source.isEmpty())

  1097.         {

  1098.             if (source.getAndAdvance() == '.'

  1099.                  && CharacterFunctions::compareIgnoreCaseUpTo (source, name, nameLength) == 0)

  1100.             {

  1101.                 String::CharPointerType endOfName ((source + nameLength).findEndOfWhitespace());

  1102. 

  1103.                 if (*endOfName == '{')

  1104.                     return endOfName;

  1105.             }

  1106.         }

  1107. 

  1108.         return source;

  1109.     }

  1110. 

  1111.     String getStyleAttribute (const XmlPath& xml, StringRef attributeName,

  1112.                               const String& defaultValue = String()) const

  1113.     {

  1114.         if (xml->hasAttribute (attributeName))

  1115.             return xml->getStringAttribute (attributeName, defaultValue);

  1116. 

  1117.         const String styleAtt (xml->getStringAttribute ("style"));

  1118. 

  1119.         if (styleAtt.isNotEmpty())

  1120.         {

  1121.             const String value (getAttributeFromStyleList (styleAtt, attributeName, String()));

  1122. 

  1123.             if (value.isNotEmpty())

  1124.                 return value;

  1125.         }

  1126.         else if (xml->hasAttribute ("class"))

  1127.         {

  1128.             String::CharPointerType openBrace = findStyleItem (cssStyleText.getCharPointer(),

  1129.                                                                xml->getStringAttribute ("class").getCharPointer());

  1130. 

  1131.             if (! openBrace.isEmpty())

  1132.             {

  1133.                 String::CharPointerType closeBrace = CharacterFunctions::find (openBrace, (juce_wchar) '}');

  1134. 

  1135.                 if (closeBrace != openBrace)

  1136.                 {

  1137.                     const String value (getAttributeFromStyleList (String (openBrace + 1, closeBrace),

  1138.                                                                    attributeName, defaultValue));

  1139.                     if (value.isNotEmpty())

  1140.                         return value;

  1141.                 }

  1142.             }

  1143.         }

  1144. 

  1145.         if (xml.parent != nullptr)

  1146.             return getStyleAttribute (*xml.parent, attributeName, defaultValue);

  1147. 

  1148.         return defaultValue;

  1149.     }

  1150. 

  1151.     String getInheritedAttribute (const XmlPath& xml, StringRef attributeName) const

  1152.     {

  1153.         if (xml->hasAttribute (attributeName))

  1154.             return xml->getStringAttribute (attributeName);

  1155. 

  1156.         if (xml.parent != nullptr)

  1157.             return getInheritedAttribute  (*xml.parent, attributeName);

  1158. 

  1159.         return String();

  1160.     }

  1161. 

  1162.     static int parsePlacementFlags (const String& align) noexcept

  1163.     {

  1164.         if (align.isEmpty())

  1165.             return 0;

  1166. 

  1167.         if (align.containsIgnoreCase ("none"))

  1168.             return RectanglePlacement::stretchToFit;

  1169. 

  1170.         return (align.containsIgnoreCase ("slice") ? RectanglePlacement::fillDestination : 0)

  1171.              | (align.containsIgnoreCase ("xMin")  ? RectanglePlacement::xLeft

  1172.                                                    : (align.containsIgnoreCase ("xMax") ? RectanglePlacement::xRight

  1173.                                                                                         : RectanglePlacement::xMid))

  1174.              | (align.containsIgnoreCase ("yMin")  ? RectanglePlacement::yTop

  1175.                                                    : (align.containsIgnoreCase ("yMax") ? RectanglePlacement::yBottom

  1176.                                                                                         : RectanglePlacement::yMid));

  1177.     }

  1178. 

  1179.     //==============================================================================

  1180.     static bool isIdentifierChar (const juce_wchar c)

  1181.     {

  1182.         return CharacterFunctions::isLetter (c) || c == '-';

  1183.     }

  1184. 

  1185.     static String getAttributeFromStyleList (const String& list, StringRef attributeName, const String& defaultValue)

  1186.     {

  1187.         int i = 0;

  1188. 

  1189.         for (;;)

  1190.         {

  1191.             i = list.indexOf (i, attributeName);

  1192. 

  1193.             if (i < 0)

  1194.                 break;

  1195. 

  1196.             if ((i == 0 || (i > 0 && ! isIdentifierChar (list [i - 1])))

  1197.                  && ! isIdentifierChar (list [i + attributeName.length()]))

  1198.             {

  1199.                 i = list.indexOfChar (i, ':');

  1200. 

  1201.                 if (i < 0)

  1202.                     break;

  1203. 

  1204.                 int end = list.indexOfChar (i, ';');

  1205. 

  1206.                 if (end < 0)

  1207.                     end = 0x7ffff;

  1208. 

  1209.                 return list.substring (i + 1, end).trim();

  1210.             }

  1211. 

  1212.             ++i;

  1213.         }

  1214. 

  1215.         return defaultValue;

  1216.     }

  1217. 

  1218.     //==============================================================================

  1219.     static bool isStartOfNumber (juce_wchar c) noexcept

  1220.     {

  1221.         return CharacterFunctions::isDigit (c) || c == '-' || c == '+';

  1222.     }

  1223. 

  1224.     static bool parseNextNumber (String::CharPointerType& text, String& value, const bool allowUnits)

  1225.     {

  1226.         String::CharPointerType s (text);

  1227. 

  1228.         while (s.isWhitespace() || *s == ',')

  1229.             ++s;

  1230. 

  1231.         String::CharPointerType start (s);

  1232. 

  1233.         if (isStartOfNumber (*s))

  1234.             ++s;

  1235. 

  1236.         while (s.isDigit())

  1237.             ++s;

  1238. 

  1239.         if (*s == '.')

  1240.         {

  1241.             ++s;

  1242. 

  1243.             while (s.isDigit())

  1244.                 ++s;

  1245.         }

  1246. 

  1247.         if ((*s == 'e' || *s == 'E') && isStartOfNumber (s[1]))

  1248.         {

  1249.             s += 2;

  1250. 

  1251.             while (s.isDigit())

  1252.                 ++s;

  1253.         }

  1254. 

  1255.         if (allowUnits)

  1256.             while (s.isLetter())

  1257.                 ++s;

  1258. 

  1259.         if (s == start)

  1260.         {

  1261.             text = s;

  1262.             return false;

  1263.         }

  1264. 

  1265.         value = String (start, s);

  1266. 

  1267.         while (s.isWhitespace() || *s == ',')

  1268.             ++s;

  1269. 

  1270.         text = s;

  1271.         return true;

  1272.     }

  1273. 

  1274.     //==============================================================================

  1275.     static Colour parseColour (const String& s, int& index, const Colour defaultColour)

  1276.     {

  1277.         if (s [index] == '#')

  1278.         {

  1279.             uint32 hex[6] = { 0 };

  1280.             int numChars = 0;

  1281. 

  1282.             for (int i = 6; --i >= 0;)

  1283.             {

  1284.                 const int hexValue = CharacterFunctions::getHexDigitValue (s [++index]);

  1285. 

  1286.                 if (hexValue >= 0)

  1287.                     hex [numChars++] = (uint32) hexValue;

  1288.                 else

  1289.                     break;

  1290.             }

  1291. 

  1292.             if (numChars <= 3)

  1293.                 return Colour ((uint8) (hex [0] * 0x11),

  1294.                                (uint8) (hex [1] * 0x11),

  1295.                                (uint8) (hex [2] * 0x11));

  1296. 

  1297.             return Colour ((uint8) ((hex [0] << 4) + hex [1]),

  1298.                            (uint8) ((hex [2] << 4) + hex [3]),

  1299.                            (uint8) ((hex [4] << 4) + hex [5]));

  1300.         }

  1301. 

  1302.         if (s [index] == 'r'

  1303.               && s [index + 1] == 'g'

  1304.               && s [index + 2] == 'b')

  1305.         {

  1306.             const int openBracket = s.indexOfChar (index, '(');

  1307.             const int closeBracket = s.indexOfChar (openBracket, ')');

  1308. 

  1309.             if (openBracket >= 3 && closeBracket > openBracket)

  1310.             {

  1311.                 index = closeBracket;

  1312. 

  1313.                 StringArray tokens;

  1314.                 tokens.addTokens (s.substring (openBracket + 1, closeBracket), ",", "");

  1315.                 tokens.trim();

  1316.                 tokens.removeEmptyStrings();

  1317. 

  1318.                 if (tokens[0].containsChar ('%'))

  1319.                     return Colour ((uint8) roundToInt (2.55 * tokens[0].getDoubleValue()),

  1320.                                    (uint8) roundToInt (2.55 * tokens[1].getDoubleValue()),

  1321.                                    (uint8) roundToInt (2.55 * tokens[2].getDoubleValue()));

  1322.                 else

  1323.                     return Colour ((uint8) tokens[0].getIntValue(),

  1324.                                    (uint8) tokens[1].getIntValue(),

  1325.                                    (uint8) tokens[2].getIntValue());

  1326.             }

  1327.         }

  1328. 

  1329.         return Colours::findColourForName (s, defaultColour);

  1330.     }

  1331. 

  1332.     static AffineTransform parseTransform (String t)

  1333.     {

  1334.         AffineTransform result;

  1335. 

  1336.         while (t.isNotEmpty())

  1337.         {

  1338.             StringArray tokens;

  1339.             tokens.addTokens (t.fromFirstOccurrenceOf ("(", false, false)

  1340.                                .upToFirstOccurrenceOf (")", false, false),

  1341.                               ", ", "");

  1342. 

  1343.             tokens.removeEmptyStrings (true);

  1344. 

  1345.             float numbers[6];

  1346. 

  1347.             for (int i = 0; i < numElementsInArray (numbers); ++i)

  1348.                 numbers[i] = tokens[i].getFloatValue();

  1349. 

  1350.             AffineTransform trans;

  1351. 

  1352.             if (t.startsWithIgnoreCase ("matrix"))

  1353.             {

  1354.                 trans = AffineTransform (numbers[0], numbers[2], numbers[4],

  1355.                                          numbers[1], numbers[3], numbers[5]);

  1356.             }

  1357.             else if (t.startsWithIgnoreCase ("translate"))

  1358.             {

  1359.                 trans = AffineTransform::translation (numbers[0], numbers[1]);

  1360.             }

  1361.             else if (t.startsWithIgnoreCase ("scale"))

  1362.             {

  1363.                 trans = AffineTransform::scale (numbers[0], numbers[tokens.size() > 1 ? 1 : 0]);

  1364.             }

  1365.             else if (t.startsWithIgnoreCase ("rotate"))

  1366.             {

  1367.                 trans = AffineTransform::rotation (degreesToRadians (numbers[0]), numbers[1], numbers[2]);

  1368.             }

  1369.             else if (t.startsWithIgnoreCase ("skewX"))

  1370.             {

  1371.                 trans = AffineTransform::shear (std::tan (degreesToRadians (numbers[0])), 0.0f);

  1372.             }

  1373.             else if (t.startsWithIgnoreCase ("skewY"))

  1374.             {

  1375.                 trans = AffineTransform::shear (0.0f, std::tan (degreesToRadians (numbers[0])));

  1376.             }

  1377. 

  1378.             result = trans.followedBy (result);

  1379.             t = t.fromFirstOccurrenceOf (")", false, false).trimStart();

  1380.         }

  1381. 

  1382.         return result;

  1383.     }

  1384. 

  1385.     static void endpointToCentreParameters (const double x1, const double y1,

  1386.                                             const double x2, const double y2,

  1387.                                             const double angle,

  1388.                                             const bool largeArc, const bool sweep,

  1389.                                             double& rx, double& ry,

  1390.                                             double& centreX, double& centreY,

  1391.                                             double& startAngle, double& deltaAngle) noexcept

  1392.     {

  1393.         const double midX = (x1 - x2) * 0.5;

  1394.         const double midY = (y1 - y2) * 0.5;

  1395. 

  1396.         const double cosAngle = std::cos (angle);

  1397.         const double sinAngle = std::sin (angle);

  1398.         const double xp = cosAngle * midX + sinAngle * midY;

  1399.         const double yp = cosAngle * midY - sinAngle * midX;

  1400.         const double xp2 = xp * xp;

  1401.         const double yp2 = yp * yp;

  1402. 

  1403.         double rx2 = rx * rx;

  1404.         double ry2 = ry * ry;

  1405. 

  1406.         const double s = (xp2 / rx2) + (yp2 / ry2);

  1407.         double c;

  1408. 

  1409.         if (s <= 1.0)

  1410.         {

  1411.             c = std::sqrt (jmax (0.0, ((rx2 * ry2) - (rx2 * yp2) - (ry2 * xp2))

  1412.                                          / (( rx2 * yp2) + (ry2 * xp2))));

  1413. 

  1414.             if (largeArc == sweep)

  1415.                 c = -c;

  1416.         }

  1417.         else

  1418.         {

  1419.             const double s2 = std::sqrt (s);

  1420.             rx *= s2;

  1421.             ry *= s2;

  1422.             c = 0;

  1423.         }

  1424. 

  1425.         const double cpx = ((rx * yp) / ry) * c;

  1426.         const double cpy = ((-ry * xp) / rx) * c;

  1427. 

  1428.         centreX = ((x1 + x2) * 0.5) + (cosAngle * cpx) - (sinAngle * cpy);

  1429.         centreY = ((y1 + y2) * 0.5) + (sinAngle * cpx) + (cosAngle * cpy);

  1430. 

  1431.         const double ux = (xp - cpx) / rx;

  1432.         const double uy = (yp - cpy) / ry;

  1433.         const double vx = (-xp - cpx) / rx;

  1434.         const double vy = (-yp - cpy) / ry;

  1435. 

  1436.         const double length = juce_hypot (ux, uy);

  1437. 

  1438.         startAngle = acos (jlimit (-1.0, 1.0, ux / length));

  1439. 

  1440.         if (uy < 0)

  1441.             startAngle = -startAngle;

  1442. 

  1443.         startAngle += double_Pi * 0.5;

  1444. 

  1445.         deltaAngle = acos (jlimit (-1.0, 1.0, ((ux * vx) + (uy * vy))

  1446.                                                 / (length * juce_hypot (vx, vy))));

  1447. 

  1448.         if ((ux * vy) - (uy * vx) < 0)

  1449.             deltaAngle = -deltaAngle;

  1450. 

  1451.         if (sweep)

  1452.         {

  1453.             if (deltaAngle < 0)

  1454.                 deltaAngle += double_Pi * 2.0;

  1455.         }

  1456.         else

  1457.         {

  1458.             if (deltaAngle > 0)

  1459.                 deltaAngle -= double_Pi * 2.0;

  1460.         }

  1461. 

  1462.         deltaAngle = fmod (deltaAngle, double_Pi * 2.0);

  1463.     }

  1464. 

  1465.     SVGState& operator= (const SVGState&) JUCE_DELETED_FUNCTION;

  1466. };

  1467. 

  1468. 

  1469. //==============================================================================

  1470. Drawable* Drawable::createFromSVG (const XmlElement& svgDocument)

  1471. {

  1472.     SVGState state (&svgDocument);

  1473.     return state.parseSVGElement (SVGState::XmlPath (&svgDocument, nullptr));

  1474. }

  1475. 

  1476. Path Drawable::parseSVGPath (const String& svgPath)

  1477. {

  1478.     SVGState state (nullptr);

  1479.     Path p;

  1480.     state.parsePathString (p, svgPath);

  1481.     return p;

  1482. }