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.
888 Commits
11 Branches
314MB
Tree: e61e8f6775
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e61e8f6775'
${ noResults }
JUCE/src/gui/graphics/drawables/juce_SVGParser.cpp

1297 lines
44KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright 2004-9 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. #include "../../../core/juce_StandardHeader.h"

  27. 

  28. BEGIN_JUCE_NAMESPACE

  29. 

  30. #include "juce_Drawable.h"

  31. #include "juce_DrawableComposite.h"

  32. #include "juce_DrawablePath.h"

  33. 

  34. 

  35. //==============================================================================

  36. class SVGState

  37. {

  38. public:

  39.     //==============================================================================

  40.     SVGState (const XmlElement* const topLevel)

  41.         : topLevelXml (topLevel),

  42.           elementX (0), elementY (0),

  43.           width (512), height (512),

  44.           viewBoxW (0), viewBoxH (0)

  45.     {

  46.     }

  47. 

  48.     ~SVGState()

  49.     {

  50.     }

  51. 

  52.     //==============================================================================

  53.     Drawable* parseSVGElement (const XmlElement& xml)

  54.     {

  55.         if (! xml.hasTagName (T("svg")))

  56.             return 0;

  57. 

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

  59. 

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

  61. 

  62.         SVGState newState (*this);

  63. 

  64.         if (xml.hasAttribute (T("transform")))

  65.             newState.addTransform (xml);

  66. 

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

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

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

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

  71. 

  72.         if (xml.hasAttribute (T("viewBox")))

  73.         {

  74.             const String viewParams (xml.getStringAttribute (T("viewBox")));

  75.             int i = 0;

  76.             float vx, vy, vw, vh;

  77. 

  78.             if (parseCoords (viewParams, vx, vy, i, true)

  79.                  && parseCoords (viewParams, vw, vh, i, true)

  80.                  && vw > 0

  81.                  && vh > 0)

  82.             {

  83.                 newState.viewBoxW = vw;

  84.                 newState.viewBoxH = vh;

  85. 

  86.                 int placementFlags = 0;

  87. 

  88.                 const String aspect (xml.getStringAttribute (T("preserveAspectRatio")));

  89. 

  90.                 if (aspect.containsIgnoreCase (T("none")))

  91.                 {

  92.                     placementFlags = RectanglePlacement::stretchToFit;

  93.                 }

  94.                 else

  95.                 {

  96.                     if (aspect.containsIgnoreCase (T("slice")))

  97.                         placementFlags |= RectanglePlacement::fillDestination;

  98. 

  99.                     if (aspect.containsIgnoreCase (T("xMin")))

  100.                         placementFlags |= RectanglePlacement::xLeft;

  101.                     else if (aspect.containsIgnoreCase (T("xMax")))

  102.                         placementFlags |= RectanglePlacement::xRight;

  103.                     else

  104.                         placementFlags |= RectanglePlacement::xMid;

  105. 

  106.                     if (aspect.containsIgnoreCase (T("yMin")))

  107.                         placementFlags |= RectanglePlacement::yTop;

  108.                     else if (aspect.containsIgnoreCase (T("yMax")))

  109.                         placementFlags |= RectanglePlacement::yBottom;

  110.                     else

  111.                         placementFlags |= RectanglePlacement::yMid;

  112.                 }

  113. 

  114.                 const RectanglePlacement placement (placementFlags);

  115. 

  116.                 newState.transform

  117.                     = placement.getTransformToFit (vx, vy, vw, vh,

  118.                                                    0.0f, 0.0f, newState.width, newState.height)

  119.                                .followedBy (newState.transform);

  120.             }

  121.         }

  122.         else

  123.         {

  124.             if (viewBoxW == 0)

  125.                 newState.viewBoxW = newState.width;

  126. 

  127.             if (viewBoxH == 0)

  128.                 newState.viewBoxH = newState.height;

  129.         }

  130. 

  131.         newState.parseSubElements (xml, drawable);

  132. 

  133.         return drawable;

  134.     }

  135. 

  136. private:

  137.     //==============================================================================

  138.     const XmlElement* const topLevelXml;

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

  140.     AffineTransform transform;

  141.     String cssStyleText;

  142. 

  143.     //==============================================================================

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

  145.     {

  146.         forEachXmlChildElement (xml, e)

  147.         {

  148.             Drawable* d = 0;

  149. 

  150.             if (e->hasTagName (T("g")))

  151.                 d = parseGroupElement (*e);

  152.             else if (e->hasTagName (T("svg")))

  153.                 d = parseSVGElement (*e);

  154.             else if (e->hasTagName (T("path")))

  155.                 d = parsePath (*e);

  156.             else if (e->hasTagName (T("rect")))

  157.                 d = parseRect (*e);

  158.             else if (e->hasTagName (T("circle")))

  159.                 d = parseCircle (*e);

  160.             else if (e->hasTagName (T("ellipse")))

  161.                 d = parseEllipse (*e);

  162.             else if (e->hasTagName (T("line")))

  163.                 d = parseLine (*e);

  164.             else if (e->hasTagName (T("polyline")))

  165.                 d = parsePolygon (*e, true);

  166.             else if (e->hasTagName (T("polygon")))

  167.                 d = parsePolygon (*e, false);

  168.             else if (e->hasTagName (T("text")))

  169.                 d = parseText (*e);

  170.             else if (e->hasTagName (T("switch")))

  171.                 d = parseSwitch (*e);

  172.             else if (e->hasTagName (T("style")))

  173.                 parseCSSStyle (*e);

  174. 

  175.             parentDrawable->insertDrawable (d);

  176.         }

  177.     }

  178. 

  179.     DrawableComposite* parseSwitch (const XmlElement& xml)

  180.     {

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

  182. 

  183.         if (group != 0)

  184.             return parseGroupElement (*group);

  185. 

  186.         return 0;

  187.     }

  188. 

  189.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  190.     {

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

  192. 

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

  194. 

  195.         if (xml.hasAttribute (T("transform")))

  196.         {

  197.             SVGState newState (*this);

  198.             newState.addTransform (xml);

  199. 

  200.             newState.parseSubElements (xml, drawable);

  201.         }

  202.         else

  203.         {

  204.             parseSubElements (xml, drawable);

  205.         }

  206. 

  207.         return drawable;

  208.     }

  209. 

  210.     //==============================================================================

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

  212.     {

  213.         const String d (xml.getStringAttribute (T("d")).trimStart());

  214.         Path path;

  215. 

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

  217.             path.setUsingNonZeroWinding (false);

  218. 

  219.         int index = 0;

  220.         float lastX = 0, lastY = 0;

  221.         float lastX2 = 0, lastY2 = 0;

  222.         tchar lastCommandChar = 0;

  223.         bool carryOn = true;

  224. 

  225.         const String validCommandChars (T("MmLlHhVvCcSsQqTtAaZz"));

  226. 

  227.         for (;;)

  228.         {

  229.             float x, y, x2, y2, x3, y3;

  230.             const bool isRelative = (d[index] >= 'a' && d[index] <= 'z');

  231. 

  232.             if (validCommandChars.containsChar (d[index]))

  233.                 lastCommandChar = d [index++];

  234. 

  235.             switch (lastCommandChar)

  236.             {

  237.             case T('M'):

  238.             case T('m'):

  239.             case T('L'):

  240.             case T('l'):

  241.                 if (parseCoords (d, x, y, index, false))

  242.                 {

  243.                     if (isRelative)

  244.                     {

  245.                         x += lastX;

  246.                         y += lastY;

  247.                     }

  248. 

  249.                     if (lastCommandChar == T('M') || lastCommandChar == T('m'))

  250.                         path.startNewSubPath (x, y);

  251.                     else

  252.                         path.lineTo (x, y);

  253. 

  254.                     lastX2 = lastX;

  255.                     lastY2 = lastY;

  256.                     lastX = x;

  257.                     lastY = y;

  258.                 }

  259.                 else

  260.                 {

  261.                     ++index;

  262.                 }

  263. 

  264.                 break;

  265. 

  266.             case T('H'):

  267.             case T('h'):

  268.                 if (parseCoord (d, x, index, false, true))

  269.                 {

  270.                     if (isRelative)

  271.                         x += lastX;

  272. 

  273.                     path.lineTo (x, lastY);

  274. 

  275.                     lastX2 = lastX;

  276.                     lastX = x;

  277.                 }

  278.                 else

  279.                 {

  280.                     ++index;

  281.                 }

  282.                 break;

  283. 

  284.             case T('V'):

  285.             case T('v'):

  286.                 if (parseCoord (d, y, index, false, false))

  287.                 {

  288.                     if (isRelative)

  289.                         y += lastY;

  290. 

  291.                     path.lineTo (lastX, y);

  292. 

  293.                     lastY2 = lastY;

  294.                     lastY = y;

  295.                 }

  296.                 else

  297.                 {

  298.                     ++index;

  299.                 }

  300.                 break;

  301. 

  302.             case T('C'):

  303.             case T('c'):

  304.                 if (parseCoords (d, x, y, index, false)

  305.                      && parseCoords (d, x2, y2, index, false)

  306.                      && parseCoords (d, x3, y3, index, false))

  307.                 {

  308.                     if (isRelative)

  309.                     {

  310.                         x += lastX;

  311.                         y += lastY;

  312.                         x2 += lastX;

  313.                         y2 += lastY;

  314.                         x3 += lastX;

  315.                         y3 += lastY;

  316.                     }

  317. 

  318.                     path.cubicTo (x, y, x2, y2, x3, y3);

  319. 

  320.                     lastX2 = x2;

  321.                     lastY2 = y2;

  322.                     lastX = x3;

  323.                     lastY = y3;

  324.                 }

  325.                 else

  326.                 {

  327.                     ++index;

  328.                 }

  329.                 break;

  330. 

  331.             case T('S'):

  332.             case T('s'):

  333.                 if (parseCoords (d, x, y, index, false)

  334.                      && parseCoords (d, x3, y3, index, false))

  335.                 {

  336.                     if (isRelative)

  337.                     {

  338.                         x += lastX;

  339.                         y += lastY;

  340.                         x3 += lastX;

  341.                         y3 += lastY;

  342.                     }

  343. 

  344.                     x2 = lastX + (lastX - lastX2);

  345.                     y2 = lastY + (lastY - lastY2);

  346.                     path.cubicTo (x2, y2, x, y, x3, y3);

  347. 

  348.                     lastX2 = x;

  349.                     lastY2 = y;

  350.                     lastX = x3;

  351.                     lastY = y3;

  352.                 }

  353.                 else

  354.                 {

  355.                     ++index;

  356.                 }

  357.                 break;

  358. 

  359.             case T('Q'):

  360.             case T('q'):

  361.                 if (parseCoords (d, x, y, index, false)

  362.                      && parseCoords (d, x2, y2, index, false))

  363.                 {

  364.                     if (isRelative)

  365.                     {

  366.                         x += lastX;

  367.                         y += lastY;

  368.                         x2 += lastX;

  369.                         y2 += lastY;

  370.                     }

  371. 

  372.                     path.quadraticTo (x, y, x2, y2);

  373. 

  374.                     lastX2 = x;

  375.                     lastY2 = y;

  376.                     lastX = x2;

  377.                     lastY = y2;

  378.                 }

  379.                 else

  380.                 {

  381.                     ++index;

  382.                 }

  383.                 break;

  384. 

  385.             case T('T'):

  386.             case T('t'):

  387.                 if (parseCoords (d, x, y, index, false))

  388.                 {

  389.                     if (isRelative)

  390.                     {

  391.                         x += lastX;

  392.                         y += lastY;

  393.                     }

  394. 

  395.                     x2 = lastX + (lastX - lastX2);

  396.                     y2 = lastY + (lastY - lastY2);

  397.                     path.quadraticTo (x2, y2, x, y);

  398. 

  399.                     lastX2 = x2;

  400.                     lastY2 = y2;

  401.                     lastX = x;

  402.                     lastY = y;

  403.                 }

  404.                 else

  405.                 {

  406.                     ++index;

  407.                 }

  408.                 break;

  409. 

  410.             case T('A'):

  411.             case T('a'):

  412.                 if (parseCoords (d, x, y, index, false))

  413.                 {

  414.                     String num;

  415. 

  416.                     if (parseNextNumber (d, num, index, false))

  417.                     {

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

  419. 

  420.                         if (parseNextNumber (d, num, index, false))

  421.                         {

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

  423. 

  424.                             if (parseNextNumber (d, num, index, false))

  425.                             {

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

  427. 

  428.                                 if (parseCoords (d, x2, y2, index, false))

  429.                                 {

  430.                                     if (isRelative)

  431.                                     {

  432.                                         x2 += lastX;

  433.                                         y2 += lastY;

  434.                                     }

  435. 

  436.                                     if (lastX != x2 || lastY != y2)

  437.                                     {

  438.                                         double centreX, centreY, startAngle, deltaAngle;

  439.                                         double rx = x, ry = y;

  440. 

  441.                                         endpointToCentreParameters (lastX, lastY, x2, y2,

  442.                                                                     angle, largeArc, sweep,

  443.                                                                     rx, ry, centreX, centreY,

  444.                                                                     startAngle, deltaAngle);

  445. 

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

  447.                                                             (float) rx, (float) ry,

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

  449.                                                             false);

  450. 

  451.                                         path.lineTo (x2, y2);

  452.                                     }

  453. 

  454.                                     lastX2 = lastX;

  455.                                     lastY2 = lastY;

  456.                                     lastX = x2;

  457.                                     lastY = y2;

  458.                                 }

  459.                             }

  460.                         }

  461.                     }

  462.                 }

  463.                 else

  464.                 {

  465.                     ++index;

  466.                 }

  467. 

  468.                 break;

  469. 

  470.             case T('Z'):

  471.             case T('z'):

  472.                 path.closeSubPath();

  473.                 while (CharacterFunctions::isWhitespace (d [index]))

  474.                     ++index;

  475. 

  476.                 break;

  477. 

  478.             default:

  479.                 carryOn = false;

  480.                 break;

  481.             }

  482. 

  483.             if (! carryOn)

  484.                 break;

  485.         }

  486. 

  487.         return parseShape (xml, path);

  488.     }

  489. 

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

  491.     {

  492.         Path rect;

  493. 

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

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

  496. 

  497.         if (hasRX || hasRY)

  498.         {

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

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

  501. 

  502.             if (! hasRX)

  503.                 rx = ry;

  504.             else if (! hasRY)

  505.                 ry = rx;

  506. 

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

  508.                                       getCoordLength (xml.getStringAttribute (T("y")), viewBoxH),

  509.                                       getCoordLength (xml.getStringAttribute (T("width")), viewBoxW),

  510.                                       getCoordLength (xml.getStringAttribute (T("height")), viewBoxH),

  511.                                       rx, ry);

  512.         }

  513.         else

  514.         {

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

  516.                                getCoordLength (xml.getStringAttribute (T("y")), viewBoxH),

  517.                                getCoordLength (xml.getStringAttribute (T("width")), viewBoxW),

  518.                                getCoordLength (xml.getStringAttribute (T("height")), viewBoxH));

  519.         }

  520. 

  521.         return parseShape (xml, rect);

  522.     }

  523. 

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

  525.     {

  526.         Path circle;

  527. 

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

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

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

  531. 

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

  533. 

  534.         return parseShape (xml, circle);

  535.     }

  536. 

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

  538.     {

  539.         Path ellipse;

  540. 

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

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

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

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

  545. 

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

  547. 

  548.         return parseShape (xml, ellipse);

  549.     }

  550. 

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

  552.     {

  553.         Path line;

  554. 

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

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

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

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

  559. 

  560.         line.startNewSubPath (x1, y1);

  561.         line.lineTo (x2, y2);

  562. 

  563.         return parseShape (xml, line);

  564.     }

  565. 

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

  567.     {

  568.         const String points (xml.getStringAttribute (T("points")));

  569.         Path path;

  570. 

  571.         int index = 0;

  572.         float x, y;

  573. 

  574.         if (parseCoords (points, x, y, index, true))

  575.         {

  576.             float firstX = x;

  577.             float firstY = y;

  578.             float lastX = 0, lastY = 0;

  579. 

  580.             path.startNewSubPath (x, y);

  581. 

  582.             while (parseCoords (points, x, y, index, true))

  583.             {

  584.                 lastX = x;

  585.                 lastY = y;

  586.                 path.lineTo (x, y);

  587.             }

  588. 

  589.             if ((! isPolyline) || (firstX == lastX && firstY == lastY))

  590.                 path.closeSubPath();

  591.         }

  592. 

  593.         return parseShape (xml, path);

  594.     }

  595. 

  596.     //==============================================================================

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

  598.                           const bool shouldParseTransform = true) const

  599.     {

  600.         if (shouldParseTransform && xml.hasAttribute (T("transform")))

  601.         {

  602.             SVGState newState (*this);

  603.             newState.addTransform (xml);

  604. 

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

  606.         }

  607. 

  608.         DrawablePath* dp = new DrawablePath();

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

  610.         dp->setFill (FillType (Colours::transparentBlack));

  611. 

  612.         path.applyTransform (transform);

  613.         dp->setPath (path);

  614. 

  615.         Path::Iterator iter (path);

  616. 

  617.         bool containsClosedSubPath = false;

  618.         while (iter.next())

  619.         {

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

  621.             {

  622.                 containsClosedSubPath = true;

  623.                 break;

  624.             }

  625.         }

  626. 

  627.         dp->setFill (getPathFillType (path,

  628.                                       getStyleAttribute (&xml, T("fill")),

  629.                                       getStyleAttribute (&xml, T("fill-opacity")),

  630.                                       getStyleAttribute (&xml, T("opacity")),

  631.                                       containsClosedSubPath ? Colours::black

  632.                                                             : Colours::transparentBlack));

  633. 

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

  635. 

  636.         if (strokeType.isNotEmpty() && ! strokeType.equalsIgnoreCase (T("none")))

  637.         {

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

  639.                                                 getStyleAttribute (&xml, T("stroke-opacity")),

  640.                                                 getStyleAttribute (&xml, T("opacity")),

  641.                                                 Colours::transparentBlack));

  642. 

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

  644.         }

  645. 

  646.         return dp;

  647.     }

  648. 

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

  650.     {

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

  652. 

  653.         if (! id.startsWithChar (T('#')))

  654.             return 0;

  655. 

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

  657.     }

  658. 

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

  660.     {

  661.         if (fillXml == 0)

  662.             return;

  663. 

  664.         forEachXmlChildElementWithTagName (*fillXml, e, T("stop"))

  665.         {

  666.             int index = 0;

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

  668. 

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

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

  671. 

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

  673. 

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

  675.                 offset *= 0.01;

  676. 

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

  678.         }

  679.     }

  680. 

  681.     const FillType getPathFillType (const Path& path,

  682.                                     const String& fill,

  683.                                     const String& fillOpacity,

  684.                                     const String& overallOpacity,

  685.                                     const Colour& defaultColour) const

  686.     {

  687.         float opacity = 1.0f;

  688. 

  689.         if (overallOpacity.isNotEmpty())

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

  691. 

  692.         if (fillOpacity.isNotEmpty())

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

  694. 

  695.         if (fill.startsWithIgnoreCase (T("url")))

  696.         {

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

  698.                                  .upToLastOccurrenceOf (T(")"), false, false).trim());

  699. 

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

  701. 

  702.             if (fillXml != 0

  703.                  && (fillXml->hasTagName (T("linearGradient"))

  704.                       || fillXml->hasTagName (T("radialGradient"))))

  705.             {

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

  707. 

  708.                 ColourGradient gradient;

  709. 

  710.                 addGradientStopsIn (gradient, inheritedFrom);

  711.                 addGradientStopsIn (gradient, fillXml);

  712. 

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

  714.                 {

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

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

  717.                 }

  718.                 else

  719.                 {

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

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

  722.                 }

  723. 

  724.                 if (overallOpacity.isNotEmpty())

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

  726. 

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

  728. 

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

  730. 

  731.                 float width = viewBoxW;

  732.                 float height = viewBoxH;

  733.                 float dx = 0.0f;

  734.                 float dy = 0.0f;

  735. 

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

  737. 

  738.                 if (! userSpace)

  739.                     path.getBounds (dx, dy, width, height);

  740. 

  741.                 if (gradient.isRadial)

  742.                 {

  743.                     gradient.x1 = dx + getCoordLength (fillXml->getStringAttribute (T("cx"), T("50%")), width);

  744.                     gradient.y1 = dy + getCoordLength (fillXml->getStringAttribute (T("cy"), T("50%")), height);

  745. 

  746.                     const float radius = getCoordLength (fillXml->getStringAttribute (T("r"), T("50%")), width);

  747. 

  748.                     gradient.x2 = gradient.x1 + radius;

  749.                     gradient.y2 = gradient.y1;

  750. 

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

  752.                 }

  753.                 else

  754.                 {

  755.                     gradient.x1 = dx + getCoordLength (fillXml->getStringAttribute (T("x1"), T("0%")), width);

  756.                     gradient.y1 = dy + getCoordLength (fillXml->getStringAttribute (T("y1"), T("0%")), height);

  757. 

  758.                     gradient.x2 = dx + getCoordLength (fillXml->getStringAttribute (T("x2"), T("100%")), width);

  759.                     gradient.y2 = dy + getCoordLength (fillXml->getStringAttribute (T("y2"), T("0%")), height);

  760. 

  761.                     if (gradient.x1 == gradient.x2 && gradient.y1 == gradient.y2)

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

  763.                 }

  764. 

  765.                 FillType type (gradient);

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

  767.                                    .followedBy (transform);

  768.                 return type;

  769.             }

  770.         }

  771. 

  772.         if (fill.equalsIgnoreCase (T("none")))

  773.             return Colours::transparentBlack;

  774. 

  775.         int i = 0;

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

  777.         return colour.withMultipliedAlpha (opacity);

  778.     }

  779. 

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

  781.     {

  782.         const String width (getStyleAttribute (xml, T("stroke-width")));

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

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

  785. 

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

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

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

  789. 

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

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

  792. 

  793.         if (join.equalsIgnoreCase (T("round")))

  794.             joinStyle = PathStrokeType::curved;

  795.         else if (join.equalsIgnoreCase (T("bevel")))

  796.             joinStyle = PathStrokeType::beveled;

  797. 

  798.         if (cap.equalsIgnoreCase (T("round")))

  799.             capStyle = PathStrokeType::rounded;

  800.         else if (cap.equalsIgnoreCase (T("square")))

  801.             capStyle = PathStrokeType::square;

  802. 

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

  804.         transform.transformPoint (ox, oy);

  805.         float x = getCoordLength (width, viewBoxW), y = 0.0f;

  806.         transform.transformPoint (x, y);

  807. 

  808.         return PathStrokeType (width.isNotEmpty() ? juce_hypotf (x - ox, y - oy) : 1.0f,

  809.                                joinStyle, capStyle);

  810.     }

  811. 

  812.     //==============================================================================

  813.     Drawable* parseText (const XmlElement& xml)

  814.     {

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

  816. 

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

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

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

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

  821. 

  822. 

  823.         //xxx not done text yet!

  824. 

  825. 

  826.         forEachXmlChildElement (xml, e)

  827.         {

  828.             if (e->isTextElement())

  829.             {

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

  831. 

  832.                 Path path;

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

  834.                 delete s;

  835.             }

  836.             else if (e->hasTagName (T("tspan")))

  837.             {

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

  839.                 delete s;

  840.             }

  841.         }

  842. 

  843.         return 0;

  844.     }

  845. 

  846.     //==============================================================================

  847.     void addTransform (const XmlElement& xml)

  848.     {

  849.         transform = parseTransform (xml.getStringAttribute (T("transform")))

  850.                         .followedBy (transform);

  851.     }

  852. 

  853.     //==============================================================================

  854.     bool parseCoord (const String& s, float& value, int& index,

  855.                      const bool allowUnits, const bool isX) const

  856.     {

  857.         String number;

  858. 

  859.         if (! parseNextNumber (s, number, index, allowUnits))

  860.         {

  861.             value = 0;

  862.             return false;

  863.         }

  864. 

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

  866.         return true;

  867.     }

  868. 

  869.     bool parseCoords (const String& s, float& x, float& y,

  870.                       int& index, const bool allowUnits) const

  871.     {

  872.         return parseCoord (s, x, index, allowUnits, true)

  873.             && parseCoord (s, y, index, allowUnits, false);

  874.     }

  875. 

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

  877.     {

  878.         float n = s.getFloatValue();

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

  880. 

  881.         if (len > 2)

  882.         {

  883.             const float dpi = 96.0f;

  884. 

  885.             const tchar n1 = s [len - 2];

  886.             const tchar n2 = s [len - 1];

  887. 

  888.             if (n1 == T('i') && n2 == T('n'))

  889.                 n *= dpi;

  890.             else if (n1 == T('m') && n2 == T('m'))

  891.                 n *= dpi / 25.4f;

  892.             else if (n1 == T('c') && n2 == T('m'))

  893.                 n *= dpi / 2.54f;

  894.             else if (n1 == T('p') && n2 == T('c'))

  895.                 n *= 15.0f;

  896.             else if (n2 == T('%'))

  897.                 n *= 0.01f * sizeForProportions;

  898.         }

  899. 

  900.         return n;

  901.     }

  902. 

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

  904.                        const bool allowUnits, const bool isX) const

  905.     {

  906.         int index = 0;

  907.         float value;

  908. 

  909.         while (parseCoord (list, value, index, allowUnits, isX))

  910.             coords.add (value);

  911.     }

  912. 

  913.     //==============================================================================

  914.     void parseCSSStyle (const XmlElement& xml)

  915.     {

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

  917.     }

  918. 

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

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

  921.     {

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

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

  924. 

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

  926. 

  927.         if (styleAtt.isNotEmpty())

  928.         {

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

  930. 

  931.             if (value.isNotEmpty())

  932.                 return value;

  933.         }

  934.         else if (xml->hasAttribute (T("class")))

  935.         {

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

  937. 

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

  939. 

  940.             if (index < 0)

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

  942. 

  943.             if (index >= 0)

  944.             {

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

  946. 

  947.                 if (openBracket > index)

  948.                 {

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

  950. 

  951.                     if (closeBracket > openBracket)

  952.                     {

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

  954. 

  955.                         if (value.isNotEmpty())

  956.                             return value;

  957.                     }

  958.                 }

  959.             }

  960.         }

  961. 

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

  963. 

  964.         if (xml != 0)

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

  966. 

  967.         return defaultValue;

  968.     }

  969. 

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

  971.     {

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

  973.             return xml->getStringAttribute (attributeName);

  974. 

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

  976. 

  977.         if (xml != 0)

  978.             return getInheritedAttribute  (xml, attributeName);

  979. 

  980.         return String::empty;

  981.     }

  982. 

  983.     //==============================================================================

  984.     static bool isIdentifierChar (const tchar c)

  985.     {

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

  987.     }

  988. 

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

  990.     {

  991.         int i = 0;

  992. 

  993.         for (;;)

  994.         {

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

  996. 

  997.             if (i < 0)

  998.                 break;

  999. 

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

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

  1002.             {

  1003.                 i = list.indexOfChar (i, T(':'));

  1004. 

  1005.                 if (i < 0)

  1006.                     break;

  1007. 

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

  1009. 

  1010.                 if (end < 0)

  1011.                     end = 0x7ffff;

  1012. 

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

  1014.             }

  1015. 

  1016.             ++i;

  1017.         }

  1018. 

  1019.         return defaultValue;

  1020.     }

  1021. 

  1022.     //==============================================================================

  1023.     static bool parseNextNumber (const String& source, String& value, int& index, const bool allowUnits)

  1024.     {

  1025.         const tchar* const s = (const tchar*) source;

  1026. 

  1027.         while (CharacterFunctions::isWhitespace (s[index]) || s[index] == T(','))

  1028.             ++index;

  1029. 

  1030.         int start = index;

  1031. 

  1032.         if (CharacterFunctions::isDigit (s[index]) || s[index] == T('.') || s[index] == T('-'))

  1033.             ++index;

  1034. 

  1035.         while (CharacterFunctions::isDigit (s[index]) || s[index] == T('.'))

  1036.             ++index;

  1037. 

  1038.         if ((s[index] == T('e') || s[index] == T('E'))

  1039.              && (CharacterFunctions::isDigit (s[index + 1])

  1040.                   || s[index + 1] == T('-')

  1041.                   || s[index + 1] == T('+')))

  1042.         {

  1043.             index += 2;

  1044. 

  1045.             while (CharacterFunctions::isDigit (s[index]))

  1046.                 ++index;

  1047.         }

  1048. 

  1049.         if (allowUnits)

  1050.         {

  1051.             while (CharacterFunctions::isLetter (s[index]))

  1052.                 ++index;

  1053.         }

  1054. 

  1055.         if (index == start)

  1056.             return false;

  1057. 

  1058.         value = String (s + start, index - start);

  1059. 

  1060.         while (CharacterFunctions::isWhitespace (s[index]) || s[index] == T(','))

  1061.             ++index;

  1062. 

  1063.         return true;

  1064.     }

  1065. 

  1066.     //==============================================================================

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

  1068.     {

  1069.         if (s [index] == T('#'))

  1070.         {

  1071.             uint32 hex [6];

  1072.             zeromem (hex, sizeof (hex));

  1073.             int numChars = 0;

  1074. 

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

  1076.             {

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

  1078. 

  1079.                 if (hexValue >= 0)

  1080.                     hex [numChars++] = hexValue;

  1081.                 else

  1082.                     break;

  1083.             }

  1084. 

  1085.             if (numChars <= 3)

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

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

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

  1089.             else

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

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

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

  1093.         }

  1094.         else if (s [index] == T('r')

  1095.                   && s [index + 1] == T('g')

  1096.                   && s [index + 2] == T('b'))

  1097.         {

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

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

  1100. 

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

  1102.             {

  1103.                 index = closeBracket;

  1104. 

  1105.                 StringArray tokens;

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

  1107.                 tokens.trim();

  1108.                 tokens.removeEmptyStrings();

  1109. 

  1110.                 if (tokens[0].containsChar (T('%')))

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

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

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

  1114.                 else

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

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

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

  1118.             }

  1119.         }

  1120. 

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

  1122.     }

  1123. 

  1124.     static const AffineTransform parseTransform (String t)

  1125.     {

  1126.         AffineTransform result;

  1127. 

  1128.         while (t.isNotEmpty())

  1129.         {

  1130.             StringArray tokens;

  1131.             tokens.addTokens (t.fromFirstOccurrenceOf (T("("), false, false)

  1132.                                .upToFirstOccurrenceOf (T(")"), false, false),

  1133.                               T(", "), 0);

  1134. 

  1135.             tokens.removeEmptyStrings (true);

  1136. 

  1137.             float numbers [6];

  1138. 

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

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

  1141. 

  1142.             AffineTransform trans;

  1143. 

  1144.             if (t.startsWithIgnoreCase (T("matrix")))

  1145.             {

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

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

  1148.             }

  1149.             else if (t.startsWithIgnoreCase (T("translate")))

  1150.             {

  1151.                 trans = trans.translated (numbers[0], numbers[1]);

  1152.             }

  1153.             else if (t.startsWithIgnoreCase (T("scale")))

  1154.             {

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

  1156.                     trans = trans.scaled (numbers[0], numbers[0]);

  1157.                 else

  1158.                     trans = trans.scaled (numbers[0], numbers[1]);

  1159.             }

  1160.             else if (t.startsWithIgnoreCase (T("rotate")))

  1161.             {

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

  1163.                     trans = trans.rotated (numbers[0] / (180.0f / float_Pi));

  1164.                 else

  1165.                     trans = trans.rotated (numbers[0] / (180.0f / float_Pi),

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

  1167.             }

  1168.             else if (t.startsWithIgnoreCase (T("skewX")))

  1169.             {

  1170.                 trans = AffineTransform (1.0f, tanf (numbers[0] * (float_Pi / 180.0f)), 0.0f,

  1171.                                          0.0f, 1.0f, 0.0f);

  1172.             }

  1173.             else if (t.startsWithIgnoreCase (T("skewY")))

  1174.             {

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

  1176.                                          tanf (numbers[0] * (float_Pi / 180.0f)), 1.0f, 0.0f);

  1177.             }

  1178. 

  1179.             result = trans.followedBy (result);

  1180.             t = t.fromFirstOccurrenceOf (T(")"), false, false).trimStart();

  1181.         }

  1182. 

  1183.         return result;

  1184.     }

  1185. 

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

  1187.                                             const double x2, const double y2,

  1188.                                             const double angle,

  1189.                                             const bool largeArc, const bool sweep,

  1190.                                             double& rx, double& ry,

  1191.                                             double& centreX, double& centreY,

  1192.                                             double& startAngle, double& deltaAngle)

  1193.     {

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

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

  1196. 

  1197.         const double cosAngle = cos (angle);

  1198.         const double sinAngle = sin (angle);

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

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

  1201.         const double xp2 = xp * xp;

  1202.         const double yp2 = yp * yp;

  1203. 

  1204.         double rx2 = rx * rx;

  1205.         double ry2 = ry * ry;

  1206. 

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

  1208.         double c;

  1209. 

  1210.         if (s <= 1.0)

  1211.         {

  1212.             c = sqrt (jmax (0.0, ((rx2 * ry2) - (rx2 * yp2) - (ry2 * xp2))

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

  1214. 

  1215.             if (largeArc == sweep)

  1216.                 c = -c;

  1217.         }

  1218.         else

  1219.         {

  1220.             const double s2 = sqrt (s);

  1221.             rx *= s2;

  1222.             ry *= s2;

  1223.             rx2 = rx * rx;

  1224.             ry2 = ry * ry;

  1225.             c = 0;

  1226.         }

  1227. 

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

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

  1230. 

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

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

  1233. 

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

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

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

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

  1238. 

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

  1240. 

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

  1242. 

  1243.         if (uy < 0)

  1244.             startAngle = -startAngle;

  1245. 

  1246.         startAngle += double_Pi * 0.5;

  1247. 

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

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

  1250. 

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

  1252.             deltaAngle = -deltaAngle;

  1253. 

  1254.         if (sweep)

  1255.         {

  1256.             if (deltaAngle < 0)

  1257.                 deltaAngle += double_Pi * 2.0;

  1258.         }

  1259.         else

  1260.         {

  1261.             if (deltaAngle > 0)

  1262.                 deltaAngle -= double_Pi * 2.0;

  1263.         }

  1264. 

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

  1266.     }

  1267. 

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

  1269.     {

  1270.         forEachXmlChildElement (*parent, e)

  1271.         {

  1272.             if (e->compareAttribute (T("id"), id))

  1273.                 return e;

  1274. 

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

  1276. 

  1277.             if (found != 0)

  1278.                 return found;

  1279.         }

  1280. 

  1281.         return 0;

  1282.     }

  1283. 

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

  1285. };

  1286. 

  1287. 

  1288. //==============================================================================

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

  1290. {

  1291.     SVGState state (&svgDocument);

  1292.     return state.parseSVGElement (svgDocument);

  1293. }

  1294. 

  1295. 

  1296. END_JUCE_NAMESPACE