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.
2281 Commits
9 Branches
794MB
Tree: b3556f720e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b3556f720e'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1247 lines
44KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

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

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

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

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

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

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. class SVGState

  27. {

  28. public:

  29.     //==============================================================================

  30.     SVGState (const XmlElement* const topLevel)

  31.         : topLevelXml (topLevel),

  32.           elementX (0), elementY (0),

  33.           width (512), height (512),

  34.           viewBoxW (0), viewBoxH (0)

  35.     {

  36.     }

  37. 

  38.     //==============================================================================

  39.     Drawable* parseSVGElement (const XmlElement& xml)

  40.     {

  41.         if (! xml.hasTagName ("svg"))

  42.             return nullptr;

  43. 

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

  45. 

  46.         drawable->setName (xml.getStringAttribute ("id"));

  47. 

  48.         SVGState newState (*this);

  49. 

  50.         if (xml.hasAttribute ("transform"))

  51.             newState.addTransform (xml);

  52. 

  53.         newState.elementX = getCoordLength (xml.getStringAttribute ("x", String (newState.elementX)), viewBoxW);

  54.         newState.elementY = getCoordLength (xml.getStringAttribute ("y", String (newState.elementY)), viewBoxH);

  55.         newState.width    = getCoordLength (xml.getStringAttribute ("width", String (newState.width)), viewBoxW);

  56.         newState.height   = getCoordLength (xml.getStringAttribute ("height", String (newState.height)), viewBoxH);

  57. 

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

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

  60. 

  61.         if (xml.hasAttribute ("viewBox"))

  62.         {

  63.             const String viewBoxAtt (xml.getStringAttribute ("viewBox"));

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

  65.             Point<float> vxy, vwh;

  66. 

  67.             if (parseCoords (viewParams, vxy, true)

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

  69.                  && vwh.x > 0

  70.                  && vwh.y > 0)

  71.             {

  72.                 newState.viewBoxW = vwh.x;

  73.                 newState.viewBoxH = vwh.y;

  74. 

  75.                 int placementFlags = 0;

  76. 

  77.                 const String aspect (xml.getStringAttribute ("preserveAspectRatio"));

  78. 

  79.                 if (aspect.containsIgnoreCase ("none"))

  80.                 {

  81.                     placementFlags = RectanglePlacement::stretchToFit;

  82.                 }

  83.                 else

  84.                 {

  85.                     if (aspect.containsIgnoreCase ("slice"))

  86.                         placementFlags |= RectanglePlacement::fillDestination;

  87. 

  88.                     if (aspect.containsIgnoreCase ("xMin"))

  89.                         placementFlags |= RectanglePlacement::xLeft;

  90.                     else if (aspect.containsIgnoreCase ("xMax"))

  91.                         placementFlags |= RectanglePlacement::xRight;

  92.                     else

  93.                         placementFlags |= RectanglePlacement::xMid;

  94. 

  95.                     if (aspect.containsIgnoreCase ("yMin"))

  96.                         placementFlags |= RectanglePlacement::yTop;

  97.                     else if (aspect.containsIgnoreCase ("yMax"))

  98.                         placementFlags |= RectanglePlacement::yBottom;

  99.                     else

  100.                         placementFlags |= RectanglePlacement::yMid;

  101.                 }

  102. 

  103.                 const RectanglePlacement placement (placementFlags);

  104. 

  105.                 newState.transform

  106.                     = placement.getTransformToFit (Rectangle<float> (vxy.x, vxy.y, vwh.x, vwh.y),

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

  108.                                .followedBy (newState.transform);

  109.             }

  110.         }

  111.         else

  112.         {

  113.             if (viewBoxW == 0)

  114.                 newState.viewBoxW = newState.width;

  115. 

  116.             if (viewBoxH == 0)

  117.                 newState.viewBoxH = newState.height;

  118.         }

  119. 

  120.         newState.parseSubElements (xml, drawable);

  121. 

  122.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  123.         return drawable;

  124.     }

  125. 

  126. private:

  127.     //==============================================================================

  128.     const XmlElement* const topLevelXml;

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

  130.     AffineTransform transform;

  131.     String cssStyleText;

  132. 

  133.     //==============================================================================

  134.     void parseSubElements (const XmlElement& xml, DrawableComposite* const parentDrawable)

  135.     {

  136.         forEachXmlChildElement (xml, e)

  137.         {

  138.             Drawable* d = nullptr;

  139. 

  140.             if (e->hasTagName ("g"))                d = parseGroupElement (*e);

  141.             else if (e->hasTagName ("svg"))         d = parseSVGElement (*e);

  142.             else if (e->hasTagName ("path"))        d = parsePath (*e);

  143.             else if (e->hasTagName ("rect"))        d = parseRect (*e);

  144.             else if (e->hasTagName ("circle"))      d = parseCircle (*e);

  145.             else if (e->hasTagName ("ellipse"))     d = parseEllipse (*e);

  146.             else if (e->hasTagName ("line"))        d = parseLine (*e);

  147.             else if (e->hasTagName ("polyline"))    d = parsePolygon (*e, true);

  148.             else if (e->hasTagName ("polygon"))     d = parsePolygon (*e, false);

  149.             else if (e->hasTagName ("text"))        d = parseText (*e);

  150.             else if (e->hasTagName ("switch"))      d = parseSwitch (*e);

  151.             else if (e->hasTagName ("style"))       parseCSSStyle (*e);

  152. 

  153.             parentDrawable->addAndMakeVisible (d);

  154.         }

  155.     }

  156. 

  157.     DrawableComposite* parseSwitch (const XmlElement& xml)

  158.     {

  159.         const XmlElement* const group = xml.getChildByName ("g");

  160. 

  161.         if (group != nullptr)

  162.             return parseGroupElement (*group);

  163. 

  164.         return nullptr;

  165.     }

  166. 

  167.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  168.     {

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

  170. 

  171.         drawable->setName (xml.getStringAttribute ("id"));

  172. 

  173.         if (xml.hasAttribute ("transform"))

  174.         {

  175.             SVGState newState (*this);

  176.             newState.addTransform (xml);

  177. 

  178.             newState.parseSubElements (xml, drawable);

  179.         }

  180.         else

  181.         {

  182.             parseSubElements (xml, drawable);

  183.         }

  184. 

  185.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  186.         return drawable;

  187.     }

  188. 

  189.     //==============================================================================

  190.     Drawable* parsePath (const XmlElement& xml) const

  191.     {

  192.         const String dAttribute (xml.getStringAttribute ("d").trimStart());

  193.         String::CharPointerType d (dAttribute.getCharPointer());

  194.         Path path;

  195. 

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

  197.             path.setUsingNonZeroWinding (false);

  198. 

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

  200.         juce_wchar lastCommandChar = 0;

  201.         bool isRelative = true;

  202.         bool carryOn = true;

  203. 

  204.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  205. 

  206.         while (! d.isEmpty())

  207.         {

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

  209.             {

  210.                 lastCommandChar = d.getAndAdvance();

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

  212.             }

  213. 

  214.             switch (lastCommandChar)

  215.             {

  216.             case 'M':

  217.             case 'm':

  218.             case 'L':

  219.             case 'l':

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

  221.                 {

  222.                     if (isRelative)

  223.                         p1 += last;

  224. 

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

  226.                     {

  227.                         subpathStart = p1;

  228.                         path.startNewSubPath (p1);

  229.                         lastCommandChar = 'l';

  230.                     }

  231.                     else

  232.                         path.lineTo (p1);

  233. 

  234.                     last2 = last;

  235.                     last = p1;

  236.                 }

  237.                 break;

  238. 

  239.             case 'H':

  240.             case 'h':

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

  242.                 {

  243.                     if (isRelative)

  244.                         p1.x += last.x;

  245. 

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

  247. 

  248.                     last2.x = last.x;

  249.                     last.x = p1.x;

  250.                 }

  251.                 else

  252.                 {

  253.                     ++d;

  254.                 }

  255.                 break;

  256. 

  257.             case 'V':

  258.             case 'v':

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

  260.                 {

  261.                     if (isRelative)

  262.                         p1.y += last.y;

  263. 

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

  265. 

  266.                     last2.y = last.y;

  267.                     last.y = p1.y;

  268.                 }

  269.                 else

  270.                 {

  271.                     ++d;

  272.                 }

  273.                 break;

  274. 

  275.             case 'C':

  276.             case 'c':

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

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

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

  280.                 {

  281.                     if (isRelative)

  282.                     {

  283.                         p1 += last;

  284.                         p2 += last;

  285.                         p3 += last;

  286.                     }

  287. 

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

  289. 

  290.                     last2 = p2;

  291.                     last = p3;

  292.                 }

  293.                 break;

  294. 

  295.             case 'S':

  296.             case 's':

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

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

  299.                 {

  300.                     if (isRelative)

  301.                     {

  302.                         p1 += last;

  303.                         p3 += last;

  304.                     }

  305. 

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

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

  308. 

  309.                     last2 = p1;

  310.                     last = p3;

  311.                 }

  312.                 break;

  313. 

  314.             case 'Q':

  315.             case 'q':

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

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

  318.                 {

  319.                     if (isRelative)

  320.                     {

  321.                         p1 += last;

  322.                         p2 += last;

  323.                     }

  324. 

  325.                     path.quadraticTo (p1, p2);

  326. 

  327.                     last2 = p1;

  328.                     last = p2;

  329.                 }

  330.                 break;

  331. 

  332.             case 'T':

  333.             case 't':

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

  335.                 {

  336.                     if (isRelative)

  337.                         p1 += last;

  338. 

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

  340.                     path.quadraticTo (p2, p1);

  341. 

  342.                     last2 = p2;

  343.                     last = p1;

  344.                 }

  345.                 break;

  346. 

  347.             case 'A':

  348.             case 'a':

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

  350.                 {

  351.                     String num;

  352. 

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

  354.                     {

  355.                         const float angle = num.getFloatValue() * (180.0f / float_Pi);

  356. 

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

  358.                         {

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

  360. 

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

  362.                             {

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

  364. 

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

  366.                                 {

  367.                                     if (isRelative)

  368.                                         p2 += last;

  369. 

  370.                                     if (last != p2)

  371.                                     {

  372.                                         double centreX, centreY, startAngle, deltaAngle;

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

  374. 

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

  376.                                                                     angle, largeArc, sweep,

  377.                                                                     rx, ry, centreX, centreY,

  378.                                                                     startAngle, deltaAngle);

  379. 

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

  381.                                                             (float) rx, (float) ry,

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

  383.                                                             false);

  384. 

  385.                                         path.lineTo (p2);

  386.                                     }

  387. 

  388.                                     last2 = last;

  389.                                     last = p2;

  390.                                 }

  391.                             }

  392.                         }

  393.                     }

  394.                 }

  395. 

  396.                 break;

  397. 

  398.             case 'Z':

  399.             case 'z':

  400.                 path.closeSubPath();

  401.                 last = last2 = subpathStart;

  402.                 d = d.findEndOfWhitespace();

  403.                 break;

  404. 

  405.             default:

  406.                 carryOn = false;

  407.                 break;

  408.             }

  409. 

  410.             if (! carryOn)

  411.                 break;

  412.         }

  413. 

  414.         return parseShape (xml, path);

  415.     }

  416. 

  417.     Drawable* parseRect (const XmlElement& xml) const

  418.     {

  419.         Path rect;

  420. 

  421.         const bool hasRX = xml.hasAttribute ("rx");

  422.         const bool hasRY = xml.hasAttribute ("ry");

  423. 

  424.         if (hasRX || hasRY)

  425.         {

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

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

  428. 

  429.             if (! hasRX)

  430.                 rx = ry;

  431.             else if (! hasRY)

  432.                 ry = rx;

  433. 

  434.             rect.addRoundedRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  435.                                       getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  436.                                       getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  437.                                       getCoordLength (xml.getStringAttribute ("height"), viewBoxH),

  438.                                       rx, ry);

  439.         }

  440.         else

  441.         {

  442.             rect.addRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  443.                                getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  444.                                getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  445.                                getCoordLength (xml.getStringAttribute ("height"), viewBoxH));

  446.         }

  447. 

  448.         return parseShape (xml, rect);

  449.     }

  450. 

  451.     Drawable* parseCircle (const XmlElement& xml) const

  452.     {

  453.         Path circle;

  454. 

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

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

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

  458. 

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

  460. 

  461.         return parseShape (xml, circle);

  462.     }

  463. 

  464.     Drawable* parseEllipse (const XmlElement& xml) const

  465.     {

  466.         Path ellipse;

  467. 

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

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

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

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

  472. 

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

  474. 

  475.         return parseShape (xml, ellipse);

  476.     }

  477. 

  478.     Drawable* parseLine (const XmlElement& xml) const

  479.     {

  480.         Path line;

  481. 

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

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

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

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

  486. 

  487.         line.startNewSubPath (x1, y1);

  488.         line.lineTo (x2, y2);

  489. 

  490.         return parseShape (xml, line);

  491.     }

  492. 

  493.     Drawable* parsePolygon (const XmlElement& xml, const bool isPolyline) const

  494.     {

  495.         const String pointsAtt (xml.getStringAttribute ("points"));

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

  497.         Path path;

  498.         Point<float> p;

  499. 

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

  501.         {

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

  503. 

  504.             path.startNewSubPath (first);

  505. 

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

  507.             {

  508.                 last = p;

  509.                 path.lineTo (p);

  510.             }

  511. 

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

  513.                 path.closeSubPath();

  514.         }

  515. 

  516.         return parseShape (xml, path);

  517.     }

  518. 

  519.     //==============================================================================

  520.     Drawable* parseShape (const XmlElement& xml, Path& path,

  521.                           const bool shouldParseTransform = true) const

  522.     {

  523.         if (shouldParseTransform && xml.hasAttribute ("transform"))

  524.         {

  525.             SVGState newState (*this);

  526.             newState.addTransform (xml);

  527. 

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

  529.         }

  530. 

  531.         DrawablePath* dp = new DrawablePath();

  532.         dp->setName (xml.getStringAttribute ("id"));

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

  534. 

  535.         path.applyTransform (transform);

  536.         dp->setPath (path);

  537. 

  538.         Path::Iterator iter (path);

  539. 

  540.         bool containsClosedSubPath = false;

  541.         while (iter.next())

  542.         {

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

  544.             {

  545.                 containsClosedSubPath = true;

  546.                 break;

  547.             }

  548.         }

  549. 

  550.         dp->setFill (getPathFillType (path,

  551.                                       getStyleAttribute (&xml, "fill"),

  552.                                       getStyleAttribute (&xml, "fill-opacity"),

  553.                                       getStyleAttribute (&xml, "opacity"),

  554.                                       containsClosedSubPath ? Colours::black

  555.                                                             : Colours::transparentBlack));

  556. 

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

  558. 

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

  560.         {

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

  562.                                                 getStyleAttribute (&xml, "stroke-opacity"),

  563.                                                 getStyleAttribute (&xml, "opacity"),

  564.                                                 Colours::transparentBlack));

  565. 

  566.             dp->setStrokeType (getStrokeFor (&xml));

  567.         }

  568. 

  569.         return dp;

  570.     }

  571. 

  572.     const XmlElement* findLinkedElement (const XmlElement* e) const

  573.     {

  574.         const String id (e->getStringAttribute ("xlink:href"));

  575. 

  576.         if (! id.startsWithChar ('#'))

  577.             return nullptr;

  578. 

  579.         return findElementForId (topLevelXml, id.substring (1));

  580.     }

  581. 

  582.     void addGradientStopsIn (ColourGradient& cg, const XmlElement* const fillXml) const

  583.     {

  584.         if (fillXml == 0)

  585.             return;

  586. 

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

  588.         {

  589.             int index = 0;

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

  591. 

  592.             const String opacity (getStyleAttribute (e, "stop-opacity", "1"));

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

  594. 

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

  596. 

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

  598.                 offset *= 0.01;

  599. 

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

  601.         }

  602.     }

  603. 

  604.     FillType getPathFillType (const Path& path,

  605.                               const String& fill,

  606.                               const String& fillOpacity,

  607.                               const String& overallOpacity,

  608.                               const Colour& defaultColour) const

  609.     {

  610.         float opacity = 1.0f;

  611. 

  612.         if (overallOpacity.isNotEmpty())

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

  614. 

  615.         if (fillOpacity.isNotEmpty())

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

  617. 

  618.         if (fill.startsWithIgnoreCase ("url"))

  619.         {

  620.             const String id (fill.fromFirstOccurrenceOf ("#", false, false)

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

  622. 

  623.             const XmlElement* const fillXml = findElementForId (topLevelXml, id);

  624. 

  625.             if (fillXml != nullptr

  626.                  && (fillXml->hasTagName ("linearGradient")

  627.                       || fillXml->hasTagName ("radialGradient")))

  628.             {

  629.                 const XmlElement* inheritedFrom = findLinkedElement (fillXml);

  630. 

  631.                 ColourGradient gradient;

  632. 

  633.                 addGradientStopsIn (gradient, inheritedFrom);

  634.                 addGradientStopsIn (gradient, fillXml);

  635. 

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

  637.                 {

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

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

  640.                 }

  641.                 else

  642.                 {

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

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

  645.                 }

  646. 

  647.                 if (overallOpacity.isNotEmpty())

  648.                     gradient.multiplyOpacity (overallOpacity.getFloatValue());

  649. 

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

  651. 

  652.                 gradient.isRadial = fillXml->hasTagName ("radialGradient");

  653. 

  654.                 float gradientWidth = viewBoxW;

  655.                 float gradientHeight = viewBoxH;

  656.                 float dx = 0.0f;

  657.                 float dy = 0.0f;

  658. 

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

  660. 

  661.                 if (! userSpace)

  662.                 {

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

  664.                     dx = bounds.getX();

  665.                     dy = bounds.getY();

  666.                     gradientWidth = bounds.getWidth();

  667.                     gradientHeight = bounds.getHeight();

  668.                 }

  669. 

  670.                 if (gradient.isRadial)

  671.                 {

  672.                     if (userSpace)

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

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

  675.                     else

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

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

  678. 

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

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

  681. 

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

  683.                 }

  684.                 else

  685.                 {

  686.                     if (userSpace)

  687.                     {

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

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

  690. 

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

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

  693.                     }

  694.                     else

  695.                     {

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

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

  698. 

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

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

  701.                     }

  702. 

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

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

  705.                 }

  706. 

  707.                 FillType type (gradient);

  708.                 type.transform = parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  709.                                    .followedBy (transform);

  710.                 return type;

  711.             }

  712.         }

  713. 

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

  715.             return Colours::transparentBlack;

  716. 

  717.         int i = 0;

  718.         const Colour colour (parseColour (fill, i, defaultColour));

  719.         return colour.withMultipliedAlpha (opacity);

  720.     }

  721. 

  722.     PathStrokeType getStrokeFor (const XmlElement* const xml) const

  723.     {

  724.         const String strokeWidth (getStyleAttribute (xml, "stroke-width"));

  725.         const String cap (getStyleAttribute (xml, "stroke-linecap"));

  726.         const String join (getStyleAttribute (xml, "stroke-linejoin"));

  727. 

  728.         //const String mitreLimit (getStyleAttribute (xml, "stroke-miterlimit"));

  729.         //const String dashArray (getStyleAttribute (xml, "stroke-dasharray"));

  730.         //const String dashOffset (getStyleAttribute (xml, "stroke-dashoffset"));

  731. 

  732.         PathStrokeType::JointStyle joinStyle = PathStrokeType::mitered;

  733.         PathStrokeType::EndCapStyle capStyle = PathStrokeType::butt;

  734. 

  735.         if (join.equalsIgnoreCase ("round"))

  736.             joinStyle = PathStrokeType::curved;

  737.         else if (join.equalsIgnoreCase ("bevel"))

  738.             joinStyle = PathStrokeType::beveled;

  739. 

  740.         if (cap.equalsIgnoreCase ("round"))

  741.             capStyle = PathStrokeType::rounded;

  742.         else if (cap.equalsIgnoreCase ("square"))

  743.             capStyle = PathStrokeType::square;

  744. 

  745.         float ox = 0.0f, oy = 0.0f;

  746.         float x = getCoordLength (strokeWidth, viewBoxW), y = 0.0f;

  747.         transform.transformPoints (ox, oy, x, y);

  748. 

  749.         return PathStrokeType (strokeWidth.isNotEmpty() ? juce_hypot (x - ox, y - oy) : 1.0f,

  750.                                joinStyle, capStyle);

  751.     }

  752. 

  753.     //==============================================================================

  754.     Drawable* parseText (const XmlElement& xml)

  755.     {

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

  757. 

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

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

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

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

  762. 

  763. 

  764.         //xxx not done text yet!

  765. 

  766. 

  767.         forEachXmlChildElement (xml, e)

  768.         {

  769.             if (e->isTextElement())

  770.             {

  771.                 const String text (e->getText());

  772. 

  773.                 Path path;

  774.                 Drawable* s = parseShape (*e, path);

  775.                 delete s;  // xxx not finished!

  776.             }

  777.             else if (e->hasTagName ("tspan"))

  778.             {

  779.                 Drawable* s = parseText (*e);

  780.                 delete s;  // xxx not finished!

  781.             }

  782.         }

  783. 

  784.         return nullptr;

  785.     }

  786. 

  787.     //==============================================================================

  788.     void addTransform (const XmlElement& xml)

  789.     {

  790.         transform = parseTransform (xml.getStringAttribute ("transform"))

  791.                         .followedBy (transform);

  792.     }

  793. 

  794.     //==============================================================================

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

  796.     {

  797.         String number;

  798. 

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

  800.         {

  801.             value = 0;

  802.             return false;

  803.         }

  804. 

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

  806.         return true;

  807.     }

  808. 

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

  810.     {

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

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

  813.     }

  814. 

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

  816.     {

  817.         const bool b = parseCoords (s, p, allowUnits);

  818.         if (! b)

  819.             ++s;

  820. 

  821.         return b;

  822.     }

  823. 

  824.     float getCoordLength (const String& s, const float sizeForProportions) const

  825.     {

  826.         float n = s.getFloatValue();

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

  828. 

  829.         if (len > 2)

  830.         {

  831.             const float dpi = 96.0f;

  832. 

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

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

  835. 

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

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

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

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

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

  841.         }

  842. 

  843.         return n;

  844.     }

  845. 

  846.     void getCoordList (Array <float>& coords, const String& list,

  847.                        const bool allowUnits, const bool isX) const

  848.     {

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

  850.         float value;

  851. 

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

  853.             coords.add (value);

  854.     }

  855. 

  856.     //==============================================================================

  857.     void parseCSSStyle (const XmlElement& xml)

  858.     {

  859.         cssStyleText = xml.getAllSubText() + "\n" + cssStyleText;

  860.     }

  861. 

  862.     String getStyleAttribute (const XmlElement* xml, const String& attributeName,

  863.                               const String& defaultValue = String::empty) const

  864.     {

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

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

  867. 

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

  869. 

  870.         if (styleAtt.isNotEmpty())

  871.         {

  872.             const String value (getAttributeFromStyleList (styleAtt, attributeName, String::empty));

  873. 

  874.             if (value.isNotEmpty())

  875.                 return value;

  876.         }

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

  878.         {

  879.             const String className ("." + xml->getStringAttribute ("class"));

  880. 

  881.             int index = cssStyleText.indexOfIgnoreCase (className + " ");

  882. 

  883.             if (index < 0)

  884.                 index = cssStyleText.indexOfIgnoreCase (className + "{");

  885. 

  886.             if (index >= 0)

  887.             {

  888.                 const int openBracket = cssStyleText.indexOfChar (index, '{');

  889. 

  890.                 if (openBracket > index)

  891.                 {

  892.                     const int closeBracket = cssStyleText.indexOfChar (openBracket, '}');

  893. 

  894.                     if (closeBracket > openBracket)

  895.                     {

  896.                         const String value (getAttributeFromStyleList (cssStyleText.substring (openBracket + 1, closeBracket), attributeName, defaultValue));

  897. 

  898.                         if (value.isNotEmpty())

  899.                             return value;

  900.                     }

  901.                 }

  902.             }

  903.         }

  904. 

  905.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  906. 

  907.         if (xml != nullptr)

  908.             return getStyleAttribute (xml, attributeName, defaultValue);

  909. 

  910.         return defaultValue;

  911.     }

  912. 

  913.     String getInheritedAttribute (const XmlElement* xml, const String& attributeName) const

  914.     {

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

  916.             return xml->getStringAttribute (attributeName);

  917. 

  918.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  919. 

  920.         if (xml != nullptr)

  921.             return getInheritedAttribute  (xml, attributeName);

  922. 

  923.         return String::empty;

  924.     }

  925. 

  926.     //==============================================================================

  927.     static bool isIdentifierChar (const juce_wchar c)

  928.     {

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

  930.     }

  931. 

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

  933.     {

  934.         int i = 0;

  935. 

  936.         for (;;)

  937.         {

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

  939. 

  940.             if (i < 0)

  941.                 break;

  942. 

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

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

  945.             {

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

  947. 

  948.                 if (i < 0)

  949.                     break;

  950. 

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

  952. 

  953.                 if (end < 0)

  954.                     end = 0x7ffff;

  955. 

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

  957.             }

  958. 

  959.             ++i;

  960.         }

  961. 

  962.         return defaultValue;

  963.     }

  964. 

  965.     //==============================================================================

  966.     static bool parseNextNumber (String::CharPointerType& s, String& value, const bool allowUnits)

  967.     {

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

  969.             ++s;

  970. 

  971.         String::CharPointerType start (s);

  972.         int numChars = 0;

  973. 

  974.         if (s.isDigit() || *s == '.' || *s == '-')

  975.         {

  976.             ++numChars;

  977.             ++s;

  978.         }

  979. 

  980.         while (s.isDigit() || *s == '.')

  981.         {

  982.             ++numChars;

  983.             ++s;

  984.         }

  985. 

  986.         if ((*s == 'e' || *s == 'E')

  987.              && ((s + 1).isDigit() || s[1] == '-' || s[1] == '+'))

  988.         {

  989.             s += 2;

  990.             numChars += 2;

  991. 

  992.             while (s.isDigit())

  993.             {

  994.                 ++numChars;

  995.                 ++s;

  996.             }

  997.         }

  998. 

  999.         if (allowUnits)

  1000.         {

  1001.             while (s.isLetter())

  1002.             {

  1003.                 ++numChars;

  1004.                 ++s;

  1005.             }

  1006.         }

  1007. 

  1008.         if (numChars == 0)

  1009.             return false;

  1010. 

  1011.         value = String (start, (size_t) numChars);

  1012. 

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

  1014.             ++s;

  1015. 

  1016.         return true;

  1017.     }

  1018. 

  1019.     //==============================================================================

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

  1021.     {

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

  1023.         {

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

  1025.             int numChars = 0;

  1026. 

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

  1028.             {

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

  1030. 

  1031.                 if (hexValue >= 0)

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

  1033.                 else

  1034.                     break;

  1035.             }

  1036. 

  1037.             if (numChars <= 3)

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

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

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

  1041.             else

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

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

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

  1045.         }

  1046.         else if (s [index] == 'r'

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

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

  1049.         {

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

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

  1052. 

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

  1054.             {

  1055.                 index = closeBracket;

  1056. 

  1057.                 StringArray tokens;

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

  1059.                 tokens.trim();

  1060.                 tokens.removeEmptyStrings();

  1061. 

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

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

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

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

  1066.                 else

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

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

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

  1070.             }

  1071.         }

  1072. 

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

  1074.     }

  1075. 

  1076.     static const AffineTransform parseTransform (String t)

  1077.     {

  1078.         AffineTransform result;

  1079. 

  1080.         while (t.isNotEmpty())

  1081.         {

  1082.             StringArray tokens;

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

  1084.                                .upToFirstOccurrenceOf (")", false, false),

  1085.                               ", ", String::empty);

  1086. 

  1087.             tokens.removeEmptyStrings (true);

  1088. 

  1089.             float numbers [6];

  1090. 

  1091.             for (int i = 0; i < 6; ++i)

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

  1093. 

  1094.             AffineTransform trans;

  1095. 

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

  1097.             {

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

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

  1100.             }

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

  1102.             {

  1103.                 jassert (tokens.size() == 2);

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

  1105.             }

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

  1107.             {

  1108.                 if (tokens.size() == 1)

  1109.                     trans = AffineTransform::scale (numbers[0], numbers[0]);

  1110.                 else

  1111.                     trans = AffineTransform::scale (numbers[0], numbers[1]);

  1112.             }

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

  1114.             {

  1115.                 if (tokens.size() != 3)

  1116.                     trans = AffineTransform::rotation (numbers[0] / (180.0f / float_Pi));

  1117.                 else

  1118.                     trans = AffineTransform::rotation (numbers[0] / (180.0f / float_Pi),

  1119.                                                        numbers[1], numbers[2]);

  1120.             }

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

  1122.             {

  1123.                 trans = AffineTransform (1.0f, std::tan (numbers[0] * (float_Pi / 180.0f)), 0.0f,

  1124.                                          0.0f, 1.0f, 0.0f);

  1125.             }

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

  1127.             {

  1128.                 trans = AffineTransform (1.0f, 0.0f, 0.0f,

  1129.                                          std::tan (numbers[0] * (float_Pi / 180.0f)), 1.0f, 0.0f);

  1130.             }

  1131. 

  1132.             result = trans.followedBy (result);

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

  1134.         }

  1135. 

  1136.         return result;

  1137.     }

  1138. 

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

  1140.                                             const double x2, const double y2,

  1141.                                             const double angle,

  1142.                                             const bool largeArc, const bool sweep,

  1143.                                             double& rx, double& ry,

  1144.                                             double& centreX, double& centreY,

  1145.                                             double& startAngle, double& deltaAngle)

  1146.     {

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

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

  1149. 

  1150.         const double cosAngle = cos (angle);

  1151.         const double sinAngle = sin (angle);

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

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

  1154.         const double xp2 = xp * xp;

  1155.         const double yp2 = yp * yp;

  1156. 

  1157.         double rx2 = rx * rx;

  1158.         double ry2 = ry * ry;

  1159. 

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

  1161.         double c;

  1162. 

  1163.         if (s <= 1.0)

  1164.         {

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

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

  1167. 

  1168.             if (largeArc == sweep)

  1169.                 c = -c;

  1170.         }

  1171.         else

  1172.         {

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

  1174.             rx *= s2;

  1175.             ry *= s2;

  1176.             rx2 = rx * rx;

  1177.             ry2 = ry * ry;

  1178.             c = 0;

  1179.         }

  1180. 

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

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

  1183. 

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

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

  1186. 

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

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

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

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

  1191. 

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

  1193. 

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

  1195. 

  1196.         if (uy < 0)

  1197.             startAngle = -startAngle;

  1198. 

  1199.         startAngle += double_Pi * 0.5;

  1200. 

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

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

  1203. 

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

  1205.             deltaAngle = -deltaAngle;

  1206. 

  1207.         if (sweep)

  1208.         {

  1209.             if (deltaAngle < 0)

  1210.                 deltaAngle += double_Pi * 2.0;

  1211.         }

  1212.         else

  1213.         {

  1214.             if (deltaAngle > 0)

  1215.                 deltaAngle -= double_Pi * 2.0;

  1216.         }

  1217. 

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

  1219.     }

  1220. 

  1221.     static const XmlElement* findElementForId (const XmlElement* const parent, const String& id)

  1222.     {

  1223.         forEachXmlChildElement (*parent, e)

  1224.         {

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

  1226.                 return e;

  1227. 

  1228.             const XmlElement* const found = findElementForId (e, id);

  1229. 

  1230.             if (found != nullptr)

  1231.                 return found;

  1232.         }

  1233. 

  1234.         return nullptr;

  1235.     }

  1236. 

  1237.     SVGState& operator= (const SVGState&);

  1238. };

  1239. 

  1240. 

  1241. //==============================================================================

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

  1243. {

  1244.     SVGState state (&svgDocument);

  1245.     return state.parseSVGElement (svgDocument);

  1246. }