filter/source/svg/parserfragments.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include "parserfragments.hxx"
  11 #include "spirit_supplements.hxx"
  12 #include "gfxtypes.hxx"
  13
  14 #include <basegfx/tools/canvastools.hxx>
  15 #include <com/sun/star/geometry/AffineMatrix2D.hpp>
  16
  17 #include <string.h>
  18 #include <limits.h>
  19 #include <boost/bind.hpp>
  20 #include <boost/spirit/include/classic.hpp>
  21 #include <boost/spirit/include/classic_while.hpp>
  22 #include <numeric>
  23 #include <algorithm>
  24
  25 #include "units.hxx"
  26 #include "tokenmap.hxx"
  27 #include "sal/log.hxx"
  28
  29 using namespace ::com::sun::star;
  30
  31 namespace svgi
  32 {
  33
  34 inline sal_uInt8 hex2int( char val )
  35 {
  36     return val <= '9' ? val-'0' : (val < 'a' ? val+10-'A' : val+10-'a');
  37 }
  38
  39 void setFourBitColor( double& rChannel, char nChar )
  40 {
  41     const sal_uInt8 nVal(hex2int(nChar));
  42     OSL_TRACE( "setFourBitCOlor %d color", nVal );
  43     rChannel = (nVal*16+nVal)/255.0;
  44 }
  45
  46 void setEightBitColor( double& rChannel, const char* pStart, const char* )
  47 {
  48     const sal_uInt8 nVal0(hex2int(pStart[0]));
  49     const sal_uInt8 nVal1(hex2int(pStart[1]));
  50     OSL_TRACE( "setEightbitCOlor %d, %d color", nVal0, nVal1 );
  51     rChannel = (nVal0*16+nVal1)/255.0;
  52 }
  53
  54 void setIntColor( double& rChannel, sal_uInt8 nVal )
  55 {
  56     OSL_TRACE( "setIntColor %d color", nVal );
  57     rChannel = nVal/255.0;
  58 }
  59
  60 void setPercentColor( double& rChannel, double nVal )
  61 {
  62     rChannel = nVal/100.0;
  63     SAL_INFO("svg", "setPercentColor " << nVal << " " << rChannel);
  64 }
  65
  66 void calcRotation(std::vector<geometry::AffineMatrix2D>& rTransforms,
  67                   geometry::AffineMatrix2D&              rCurrTransform,
  68                   double                                 fRotationAngle)
  69 {
  70     ::basegfx::B2DHomMatrix aCurr;
  71     aCurr.translate(-rCurrTransform.m02,-rCurrTransform.m12);
  72     aCurr.rotate(fRotationAngle*M_PI/180);
  73     aCurr.translate(rCurrTransform.m02,rCurrTransform.m12);
  74
  75     OSL_TRACE("calcRotation - fRotationAngle - %f", fRotationAngle);
  76     rTransforms.push_back(
  77         basegfx::unotools::affineMatrixFromHomMatrix(
  78             rCurrTransform,
  79             aCurr));
  80 }
  81
  82 void calcSkewX(std::vector<geometry::AffineMatrix2D>& rTransforms,
  83                double                                 fSkewAngle)
  84 {
  85     geometry::AffineMatrix2D aMat(1.0,tan(fSkewAngle*M_PI/180),0.0,
  86                                   0.0,1.0,0.0);
  87     rTransforms.push_back(aMat);
  88 }
  89
  90 void calcSkewY(std::vector<geometry::AffineMatrix2D>& rTransforms,
  91                double                                 fSkewAngle)
  92 {
  93     geometry::AffineMatrix2D aMat(1.0,0.0,0.0,
  94                                   tan(fSkewAngle*M_PI/180),1.0,0.0);
  95     rTransforms.push_back(aMat);
  96 }
  97
  98 void assign_twice(double& r_oVal1, double& r_oVal2, const double& rInVal )
  99 {
 100     r_oVal1 = r_oVal2 = rInVal;
 101 }
 102
 103 geometry::AffineMatrix2D multiplyMatrix( const geometry::AffineMatrix2D& rLHS,
 104                                          const geometry::AffineMatrix2D& rRHS )
 105 {
 106     basegfx::B2DHomMatrix aLHS;
 107     basegfx::B2DHomMatrix aRHS;
 108
 109     basegfx::unotools::homMatrixFromAffineMatrix(aLHS,rLHS);
 110     basegfx::unotools::homMatrixFromAffineMatrix(aRHS,rRHS);
 111
 112     aRHS*=aLHS;
 113
 114     geometry::AffineMatrix2D aRet;
 115     return basegfx::unotools::affineMatrixFromHomMatrix(aRet,aRHS);
 116 }
 117
 118 namespace
 119 {
 120     struct ColorGrammar : public ::boost::spirit::classic::grammar< ColorGrammar >
 121     {
 122     public:
 123         ARGBColor& m_rColor;
 124         explicit ColorGrammar( ARGBColor& rColor ) : m_rColor(rColor) {}
 125         template< typename ScannerT >
 126         struct definition
 127         {
 128             ::boost::spirit::classic::rule< ScannerT > colorExpression;
 129             definition( const ColorGrammar& self )
 130             {
 131                 using namespace ::boost::spirit::classic;
 132
 133                 int_parser<sal_uInt8,10,1,3> byte_p;
 134                 colorExpression =
 135                     (
 136                         // the #rrggbb form
 137                         ('#' >> (xdigit_p >> xdigit_p)[boost::bind(&setEightBitColor,
 138                                                                    boost::ref(self.m_rColor.r),_1,_2)]
 139                              >> (xdigit_p >> xdigit_p)[boost::bind(&setEightBitColor,
 140                                                                    boost::ref(self.m_rColor.g),_1,_2)]
 141                              >> (xdigit_p >> xdigit_p)[boost::bind(&setEightBitColor,
 142                                                                    boost::ref(self.m_rColor.b),_1,_2)])
 143                         |
 144                         // the #rgb form
 145                         ('#' >> xdigit_p[boost::bind(&setFourBitColor,
 146                                                      boost::ref(self.m_rColor.r),_1)]
 147                              >> xdigit_p[boost::bind(&setFourBitColor,
 148                                                      boost::ref(self.m_rColor.g),_1)]
 149                              >> xdigit_p[boost::bind(&setFourBitColor,
 150                                                      boost::ref(self.m_rColor.b),_1)])
 151                         |
 152                         // rgb() form
 153                         (str_p("rgb")
 154                             >> '(' >>
 155                             (
 156                                 // rgb(int,int,int)
 157                                 (byte_p[boost::bind(&setIntColor,
 158                                                     boost::ref(self.m_rColor.r),_1)] >> ',' >>
 159                                  byte_p[boost::bind(&setIntColor,
 160                                                     boost::ref(self.m_rColor.g),_1)] >> ',' >>
 161                                  byte_p[boost::bind(&setIntColor,
 162                                                     boost::ref(self.m_rColor.b),_1)])
 163                              |
 164                                 // rgb(double,double,double)
 165                                 (real_p[assign_a(self.m_rColor.r)] >> ',' >>
 166                                  real_p[assign_a(self.m_rColor.g)] >> ',' >>
 167                                  real_p[assign_a(self.m_rColor.b)])
 168                              |
 169                                 // rgb(percent,percent,percent)
 170                                 (real_p[boost::bind(&setPercentColor,
 171                                                     boost::ref(self.m_rColor.r),_1)] >> "%," >>
 172                                  real_p[boost::bind(&setPercentColor,
 173                                                     boost::ref(self.m_rColor.g),_1)] >> "%," >>
 174                                  real_p[boost::bind(&setPercentColor,
 175                                                     boost::ref(self.m_rColor.b),_1)] >> "%")
 176                              )
 177                          >> ')')
 178                      );
 179             }
 180             ::boost::spirit::classic::rule<ScannerT> const& start() const { return colorExpression; }
 181         };
 182     };
 183 }
 184
 185 bool parseColor( const char* sColor, ARGBColor& rColor  )
 186 {
 187     using namespace ::boost::spirit::classic;
 188
 189     if( parse(sColor,
 190               ColorGrammar(rColor) >> end_p,
 191               space_p).full )
 192     {
 193         // free-form color found & parsed
 194         return true;
 195     }
 196
 197     // no free-form color - maybe a color name?
 198     // trim white space before
 199     while( *sColor &&
 200            (*sColor==' ' || *sColor=='\t' || *sColor=='\r' || *sColor=='\n') )
 201         ++sColor;
 202     // trim white space after
 203     int nLen=strlen(sColor)-1;
 204     while( nLen &&
 205            (sColor[nLen]==' ' || sColor[nLen]=='\t' || sColor[nLen]=='\r' || sColor[nLen]=='\n') )
 206         --nLen;
 207     switch (getTokenId(sColor, nLen+1))
 208     {
 209         case XML_ALICEBLUE: rColor = ARGBColor(240,248,255); return true;
 210         case XML_ANTIQUEWHITE: rColor = ARGBColor(250,235,215); return true;
 211         case XML_AQUA: rColor = ARGBColor(0,255,255); return true;
 212         case XML_AQUAMARINE: rColor = ARGBColor(127,255,212); return true;
 213         case XML_AZURE: rColor = ARGBColor(240,255,255); return true;
 214         case XML_BEIGE: rColor = ARGBColor(245,245,220); return true;
 215         case XML_BISQUE: rColor = ARGBColor(255,228,196); return true;
 216         case XML_BLACK: rColor = ARGBColor(0,0,0); return true;
 217         case XML_BLANCHEDALMOND: rColor = ARGBColor(255,235,205); return true;
 218         case XML_BLUE: rColor = ARGBColor(0,0,255); return true;
 219         case XML_BLUEVIOLET: rColor = ARGBColor(138,43,226); return true;
 220         case XML_BROWN: rColor = ARGBColor(165,42,42); return true;
 221         case XML_BURLYWOOD: rColor = ARGBColor(222,184,135); return true;
 222         case XML_CADETBLUE: rColor = ARGBColor(95,158,160); return true;
 223         case XML_CHARTREUSE: rColor = ARGBColor(127,255,0); return true;
 224         case XML_CHOCOLATE: rColor = ARGBColor(210,105,30); return true;
 225         case XML_CORAL: rColor = ARGBColor(255,127,80); return true;
 226         case XML_CORNFLOWERBLUE: rColor = ARGBColor(100,149,237); return true;
 227         case XML_CORNSILK: rColor = ARGBColor(255,248,220); return true;
 228         case XML_CRIMSON: rColor = ARGBColor(220,20,60); return true;
 229         case XML_CYAN: rColor = ARGBColor(0,255,255); return true;
 230         case XML_DARKBLUE: rColor = ARGBColor(0,0,139); return true;
 231         case XML_DARKCYAN: rColor = ARGBColor(0,139,139); return true;
 232         case XML_DARKGOLDENROD: rColor = ARGBColor(184,134,11); return true;
 233         case XML_DARKGRAY: rColor = ARGBColor(169,169,169); return true;
 234         case XML_DARKGREEN: rColor = ARGBColor(0,100,0); return true;
 235         case XML_DARKGREY: rColor = ARGBColor(169,169,169); return true;
 236         case XML_DARKKHAKI: rColor = ARGBColor(189,183,107); return true;
 237         case XML_DARKMAGENTA: rColor = ARGBColor(139,0,139); return true;
 238         case XML_DARKOLIVEGREEN: rColor = ARGBColor(85,107,47); return true;
 239         case XML_DARKORANGE: rColor = ARGBColor(255,140,0); return true;
 240         case XML_DARKORCHID: rColor = ARGBColor(153,50,204); return true;
 241         case XML_DARKRED: rColor = ARGBColor(139,0,0); return true;
 242         case XML_DARKSALMON: rColor = ARGBColor(233,150,122); return true;
 243         case XML_DARKSEAGREEN: rColor = ARGBColor(143,188,143); return true;
 244         case XML_DARKSLATEBLUE: rColor = ARGBColor(72,61,139); return true;
 245         case XML_DARKSLATEGRAY: rColor = ARGBColor(47,79,79); return true;
 246         case XML_DARKSLATEGREY: rColor = ARGBColor(47,79,79); return true;
 247         case XML_DARKTURQUOISE: rColor = ARGBColor(0,206,209); return true;
 248         case XML_DARKVIOLET: rColor = ARGBColor(148,0,211); return true;
 249         case XML_DEEPPINK: rColor = ARGBColor(255,20,147); return true;
 250         case XML_DEEPSKYBLUE: rColor = ARGBColor(0,191,255); return true;
 251         case XML_DIMGRAY: rColor = ARGBColor(105,105,105); return true;
 252         case XML_DIMGREY: rColor = ARGBColor(105,105,105); return true;
 253         case XML_DODGERBLUE: rColor = ARGBColor(30,144,255); return true;
 254         case XML_FIREBRICK: rColor = ARGBColor(178,34,34); return true;
 255         case XML_FLORALWHITE: rColor = ARGBColor(255,250,240); return true;
 256         case XML_FORESTGREEN: rColor = ARGBColor(34,139,34); return true;
 257         case XML_FUCHSIA: rColor = ARGBColor(255,0,255); return true;
 258         case XML_GAINSBORO: rColor = ARGBColor(220,220,220); return true;
 259         case XML_GHOSTWHITE: rColor = ARGBColor(248,248,255); return true;
 260         case XML_GOLD: rColor = ARGBColor(255,215,0); return true;
 261         case XML_GOLDENROD: rColor = ARGBColor(218,165,32); return true;
 262         case XML_GRAY: rColor = ARGBColor(128,128,128); return true;
 263         case XML_GREY: rColor = ARGBColor(128,128,128); return true;
 264         case XML_GREEN: rColor = ARGBColor(0,128,0); return true;
 265         case XML_GREENYELLOW: rColor = ARGBColor(173,255,47); return true;
 266         case XML_HONEYDEW: rColor = ARGBColor(240,255,240); return true;
 267         case XML_HOTPINK: rColor = ARGBColor(255,105,180); return true;
 268         case XML_INDIANRED: rColor = ARGBColor(205,92,92); return true;
 269         case XML_INDIGO: rColor = ARGBColor(75,0,130); return true;
 270         case XML_IVORY: rColor = ARGBColor(255,255,240); return true;
 271         case XML_KHAKI: rColor = ARGBColor(240,230,140); return true;
 272         case XML_LAVENDER: rColor = ARGBColor(230,230,250); return true;
 273         case XML_LAVENDERBLUSH: rColor = ARGBColor(255,240,245); return true;
 274         case XML_LAWNGREEN: rColor = ARGBColor(124,252,0); return true;
 275         case XML_LEMONCHIFFON: rColor = ARGBColor(255,250,205); return true;
 276         case XML_LIGHTBLUE: rColor = ARGBColor(173,216,230); return true;
 277         case XML_LIGHTCORAL: rColor = ARGBColor(240,128,128); return true;
 278         case XML_LIGHTCYAN: rColor = ARGBColor(224,255,255); return true;
 279         case XML_LIGHTGOLDENRODYELLOW: rColor = ARGBColor(250,250,210); return true;
 280         case XML_LIGHTGRAY: rColor = ARGBColor(211,211,211); return true;
 281         case XML_LIGHTGREEN: rColor = ARGBColor(144,238,144); return true;
 282         case XML_LIGHTGREY: rColor = ARGBColor(211,211,211); return true;
 283         case XML_LIGHTPINK: rColor = ARGBColor(255,182,193); return true;
 284         case XML_LIGHTSALMON: rColor = ARGBColor(255,160,122); return true;
 285         case XML_LIGHTSEAGREEN: rColor = ARGBColor(32,178,170); return true;
 286         case XML_LIGHTSKYBLUE: rColor = ARGBColor(135,206,250); return true;
 287         case XML_LIGHTSLATEGRAY: rColor = ARGBColor(119,136,153); return true;
 288         case XML_LIGHTSLATEGREY: rColor = ARGBColor(119,136,153); return true;
 289         case XML_LIGHTSTEELBLUE: rColor = ARGBColor(176,196,222); return true;
 290         case XML_LIGHTYELLOW: rColor = ARGBColor(255,255,224); return true;
 291         case XML_LIME: rColor = ARGBColor(0,255,0); return true;
 292         case XML_LIMEGREEN: rColor = ARGBColor(50,205,50); return true;
 293         case XML_LINEN: rColor = ARGBColor(250,240,230); return true;
 294         case XML_MAGENTA: rColor = ARGBColor(255,0,255); return true;
 295         case XML_MAROON: rColor = ARGBColor(128,0,0); return true;
 296         case XML_MEDIUMAQUAMARINE: rColor = ARGBColor(102,205,170); return true;
 297         case XML_MEDIUMBLUE: rColor = ARGBColor(0,0,205); return true;
 298         case XML_MEDIUMORCHID: rColor = ARGBColor(186,85,211); return true;
 299         case XML_MEDIUMPURPLE: rColor = ARGBColor(147,112,219); return true;
 300         case XML_MEDIUMSEAGREEN: rColor = ARGBColor(60,179,113); return true;
 301         case XML_MEDIUMSLATEBLUE: rColor = ARGBColor(123,104,238); return true;
 302         case XML_MEDIUMSPRINGGREEN: rColor = ARGBColor(0,250,154); return true;
 303         case XML_MEDIUMTURQUOISE: rColor = ARGBColor(72,209,204); return true;
 304         case XML_MEDIUMVIOLETRED: rColor = ARGBColor(199,21,133); return true;
 305         case XML_MIDNIGHTBLUE: rColor = ARGBColor(25,25,112); return true;
 306         case XML_MINTCREAM: rColor = ARGBColor(245,255,250); return true;
 307         case XML_MISTYROSE: rColor = ARGBColor(255,228,225); return true;
 308         case XML_MOCCASIN: rColor = ARGBColor(255,228,181); return true;
 309         case XML_NAVAJOWHITE: rColor = ARGBColor(255,222,173); return true;
 310         case XML_NAVY: rColor = ARGBColor(0,0,128); return true;
 311         case XML_OLDLACE: rColor = ARGBColor(253,245,230); return true;
 312         case XML_OLIVE: rColor = ARGBColor(128,128,0); return true;
 313         case XML_OLIVEDRAB: rColor = ARGBColor(107,142,35); return true;
 314         case XML_ORANGE: rColor = ARGBColor(255,165,0); return true;
 315         case XML_ORANGERED: rColor = ARGBColor(255,69,0); return true;
 316         case XML_ORCHID: rColor = ARGBColor(218,112,214); return true;
 317         case XML_PALEGOLDENROD: rColor = ARGBColor(238,232,170); return true;
 318         case XML_PALEGREEN: rColor = ARGBColor(152,251,152); return true;
 319         case XML_PALETURQUOISE: rColor = ARGBColor(175,238,238); return true;
 320         case XML_PALEVIOLETRED: rColor = ARGBColor(219,112,147); return true;
 321         case XML_PAPAYAWHIP: rColor = ARGBColor(255,239,213); return true;
 322         case XML_PEACHPUFF: rColor = ARGBColor(255,218,185); return true;
 323         case XML_PERU: rColor = ARGBColor(205,133,63); return true;
 324         case XML_PINK: rColor = ARGBColor(255,192,203); return true;
 325         case XML_PLUM: rColor = ARGBColor(221,160,221); return true;
 326         case XML_POWDERBLUE: rColor = ARGBColor(176,224,230); return true;
 327         case XML_PURPLE: rColor = ARGBColor(128,0,128); return true;
 328         case XML_RED: rColor = ARGBColor(255,0,0); return true;
 329         case XML_ROSYBROWN: rColor = ARGBColor(188,143,143); return true;
 330         case XML_ROYALBLUE: rColor = ARGBColor(65,105,225); return true;
 331         case XML_SADDLEBROWN: rColor = ARGBColor(139,69,19); return true;
 332         case XML_SALMON: rColor = ARGBColor(250,128,114); return true;
 333         case XML_SANDYBROWN: rColor = ARGBColor(244,164,96); return true;
 334         case XML_SEAGREEN: rColor = ARGBColor(46,139,87); return true;
 335         case XML_SEASHELL: rColor = ARGBColor(255,245,238); return true;
 336         case XML_SIENNA: rColor = ARGBColor(160,82,45); return true;
 337         case XML_SILVER: rColor = ARGBColor(192,192,192); return true;
 338         case XML_SKYBLUE: rColor = ARGBColor(135,206,235); return true;
 339         case XML_SLATEBLUE: rColor = ARGBColor(106,90,205); return true;
 340         case XML_SLATEGRAY: rColor = ARGBColor(112,128,144); return true;
 341         case XML_SLATEGREY: rColor = ARGBColor(112,128,144); return true;
 342         case XML_SNOW: rColor = ARGBColor(255,250,250); return true;
 343         case XML_SPRINGGREEN: rColor = ARGBColor(0,255,127); return true;
 344         case XML_STEELBLUE: rColor = ARGBColor(70,130,180); return true;
 345         case XML_TAN: rColor = ARGBColor(210,180,140); return true;
 346         case XML_TEAL: rColor = ARGBColor(0,128,128); return true;
 347         case XML_THISTLE: rColor = ARGBColor(216,191,216); return true;
 348         case XML_TOMATO: rColor = ARGBColor(255,99,71); return true;
 349         case XML_TURQUOISE: rColor = ARGBColor(64,224,208); return true;
 350         case XML_VIOLET: rColor = ARGBColor(238,130,238); return true;
 351         case XML_WHEAT: rColor = ARGBColor(245,222,179); return true;
 352         case XML_WHITE: rColor = ARGBColor(255,255,255); return true;
 353         case XML_WHITESMOKE: rColor = ARGBColor(245,245,245); return true;
 354         case XML_YELLOW: rColor = ARGBColor(255,255,0); return true;
 355         case XML_YELLOWGREEN: rColor = ARGBColor(154,205,50); return true;
 356
 357         default:
 358             return false; // no color at all, I'd guess.
 359     }
 360 }
 361
 362 bool parseOpacity (const char* sOpacity, ARGBColor& rColor )
 363 {
 364     using namespace ::boost::spirit::classic;
 365
 366     if( parse(sOpacity,
 367               // Begin grammar
 368               (
 369                   real_p[assign_a(rColor.a)]
 370                   ) >> end_p,
 371               // End grammar
 372               space_p).full )
 373     {
 374         return true;
 375     }
 376     return false;
 377 }
 378
 379 //////////////////////////////////////////////////////////////
 380
 381 bool parseTransform( const char* sTransform, basegfx::B2DHomMatrix& rTransform )
 382 {
 383     using namespace ::boost::spirit::classic;
 384
 385     double fRefOffsetX(0.0);
 386     double fRefOffsetY(0.0);
 387     bool   bRefTransform(false);
 388
 389     double fRotationAngle=0.0;
 390     double fSkewAngle=0.0;
 391     geometry::AffineMatrix2D aIdentityTransform;
 392     geometry::AffineMatrix2D aCurrTransform;
 393     std::vector<geometry::AffineMatrix2D> aTransforms;
 394     aIdentityTransform.m00 = 1.0; aIdentityTransform.m11 = 1.0;
 395     aCurrTransform = aIdentityTransform;
 396
 397     const bool bRes = parse(sTransform,
 398         //  Begin grammar
 399         (
 400             // identity transform
 401             str_p("none")
 402           |
 403             // the ref() form
 404             (str_p("ref")
 405              >> '('
 406              >> str_p("svg")[assign_a(bRefTransform,true)]
 407              >> !(real_p[assign_a(fRefOffsetX)] >> (',' | eps_p) >>
 408                   real_p[assign_a(fRefOffsetY)])
 409              >> ')')
 410           |
 411             // the transform-list form
 412             (list_p(
 413                (
 414                  // matrix(a,b,c,d,e,f)
 415                  (str_p("matrix")
 416                   >> '('
 417                   >> real_p[assign_a(aCurrTransform.m00)] >> (',' | eps_p)
 418                   >> real_p[assign_a(aCurrTransform.m10)] >> (',' | eps_p)
 419                   >> real_p[assign_a(aCurrTransform.m01)] >> (',' | eps_p)
 420                   >> real_p[assign_a(aCurrTransform.m11)] >> (',' | eps_p)
 421                   >> real_p[assign_a(aCurrTransform.m02)] >> (',' | eps_p)
 422                   >> real_p[assign_a(aCurrTransform.m12)]
 423                   >> ')')[push_back_a(aTransforms,aCurrTransform)]
 424                |
 425                  // translate(x,[y])
 426                  (str_p("translate")
 427                   >> '('
 428                   >> real_p[boost::bind(&assign_twice,
 429                                         boost::ref(aCurrTransform.m02),
 430                                         boost::ref(aCurrTransform.m12),_1)]
 431                   >> !((',' | eps_p) >> real_p[assign_a(aCurrTransform.m12)])
 432                   >> ')')[push_back_a(aTransforms,aCurrTransform)]
 433                |
 434                  // scale(x,[y])
 435                  (str_p("scale")
 436                   >> '('
 437                   >> real_p[boost::bind(&assign_twice,
 438                                         boost::ref(aCurrTransform.m00),
 439                                         boost::ref(aCurrTransform.m11),_1)]
 440                   >> !((',' | eps_p) >> real_p[assign_a(aCurrTransform.m11)])
 441                   >> ')')[push_back_a(aTransforms,aCurrTransform)]
 442                |
 443                  // rotate(phi,[cx, cy])
 444                  (str_p("rotate")
 445                   >> '('
 446                   >> real_p[assign_a(fRotationAngle)]
 447                   >> !((',' | eps_p) >> real_p[assign_a(aCurrTransform.m02)]
 448                        >> real_p[assign_a(aCurrTransform.m12)])
 449                   >> ')')[boost::bind(&calcRotation,
 450                                       boost::ref(aTransforms),
 451                                       boost::ref(aCurrTransform),
 452                                       boost::cref(fRotationAngle))]
 453                |
 454                  // skewX(phi)
 455                  (str_p("skewX")
 456                   >> '('
 457                   >> real_p[assign_a(fSkewAngle)]
 458                   >> ')')[boost::bind(&calcSkewX,
 459                                       boost::ref(aTransforms),
 460                                       boost::cref(fSkewAngle))]
 461                |
 462                  // skewY(phi)
 463                  (str_p("skewY")
 464                   >> '('
 465                   >> real_p[assign_a(fSkewAngle)]
 466                   >> ')')[boost::bind(&calcSkewY,
 467                                       boost::ref(aTransforms),
 468                                       boost::cref(fSkewAngle))]
 469                  // reset current transform after every push
 470                )[assign_a(aCurrTransform,aIdentityTransform)],
 471                  // list delimiter is either ',' or space
 472                ',' | eps_p ))
 473         ) >> end_p,
 474         //  End grammar
 475         space_p).full;
 476
 477     if( !bRes )
 478         return false;
 479
 480     // fold all transformations into one
 481     const geometry::AffineMatrix2D aTotalTransform(
 482         std::accumulate(aTransforms.begin(),
 483                         aTransforms.end(),
 484                         aIdentityTransform,
 485                         &multiplyMatrix));
 486
 487     basegfx::unotools::homMatrixFromAffineMatrix(
 488         rTransform,
 489         aTotalTransform);
 490
 491     // TODO(F1): handle the ref case
 492     return bRes;
 493 }
 494
 495 //////////////////////////////////////////////////////////////
 496
 497 bool parseViewBox( const char* sViewbox, basegfx::B2DRange& rRect )
 498 {
 499     using namespace ::boost::spirit::classic;
 500
 501     double x=0.0,y=0.0,w=0.0,h=0.0;
 502
 503     const bool bRes = parse(sViewbox,
 504         //  Begin grammar
 505         (
 506             // either comma- or space-delimited list of four doubles
 507             real_p[assign_a(x)] >> (',' | eps_p) >>
 508             real_p[assign_a(y)] >> (',' | eps_p) >>
 509             real_p[assign_a(w)] >> (',' | eps_p) >>
 510             real_p[assign_a(h)] >> end_p
 511         ),
 512         //  End grammar
 513         space_p).full;
 514
 515     if( !bRes )
 516         return false;
 517
 518     rRect = basegfx::B2DRange(x,y,x+w,y+h);
 519
 520     return true;
 521 }
 522
 523 //////////////////////////////////////////////////////////////
 524
 525 bool parseDashArray( const char* sDashArray, std::vector<double>& rOutputVector )
 526 {
 527     using namespace ::boost::spirit::classic;
 528
 529     rOutputVector.clear();
 530     return parse(sDashArray,
 531         //  Begin grammar
 532         (
 533             // parse comma-delimited list of doubles (have to use the
 534             // 'direct' variant, as otherwise spirit refactors our
 535             // parser to push both real num and comma to push_back_a)
 536             list_p.direct
 537             (
 538                 real_p[push_back_a(rOutputVector)],
 539                 // list delimiter is either ',' or space
 540                 ',' | eps_p
 541             )
 542         ) >> end_p,
 543         //  End grammar
 544         space_p).full;
 545 }
 546
 547 //////////////////////////////////////////////////////////////
 548
 549 bool parsePaintUri( std::pair<const char*,const char*>& o_rPaintUri,
 550                     std::pair<ARGBColor,bool>&          io_rColor,
 551                     const char*                         sPaintUri )
 552 {
 553     using namespace ::boost::spirit::classic;
 554
 555     const bool bRes = parse(sPaintUri,
 556         //  Begin grammar
 557         (
 558             str_p("url(") >> !( str_p("'") | str_p("\"") ) >> ("#") >>
 559             (+alnum_p)[assign_a(o_rPaintUri)] >>
 560             !( str_p("'") | str_p("\"") ) >> str_p(")") >>
 561             *( str_p("none")[assign_a(io_rColor.second,false)] |
 562                str_p("currentColor")[assign_a(io_rColor.second,true)] |
 563                ColorGrammar(io_rColor.first)
 564                // TODO(F1): named color
 565              )
 566         ) >> end_p,
 567         //  End grammar
 568         space_p).full;
 569
 570     return bRes;
 571 }
 572
 573 //////////////////////////////////////////////////////////////
 574
 575 bool parseXlinkHref( const char* sXlinkHref, std::string& data )
 576 {
 577     using namespace ::boost::spirit::classic;
 578
 579     data.erase(data.begin(),data.end());
 580
 581     std::string sLink(sXlinkHref);
 582
 583     if (!sLink.compare(0,5,"data:"))
 584     {
 585         // the inplace "data" uri
 586         size_t position = sLink.rfind(',');
 587         if (position > 0 && position < std::string::npos)
 588         {
 589             data = sLink.substr(position+1);
 590             OSL_TRACE("%s", data.c_str());
 591             return true;
 592         }
 593     }
 594
 595     return false;
 596 }
 597
 598 } // namespace svgi
 599
 600 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */