svgio/source/svgreader/svgstyleattributes.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svgio/svgreader/svgstyleattributes.hxx>
  21 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
  22 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  23 #include <svgio/svgreader/svgnode.hxx>
  24 #include <svgio/svgreader/svgdocument.hxx>
  25 #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
  26 #include <svgio/svgreader/svggradientnode.hxx>
  27 #include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
  28 #include <basegfx/vector/b2enums.hxx>
  29 #include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
  30 #include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
  31 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  32 #include <svgio/svgreader/svgclippathnode.hxx>
  33 #include <svgio/svgreader/svgmasknode.hxx>
  34 #include <basegfx/polygon/b2dpolypolygoncutter.hxx>
  35 #include <basegfx/polygon/b2dpolypolygontools.hxx>
  36 #include <svgio/svgreader/svgmarkernode.hxx>
  37 #include <basegfx/curve/b2dcubicbezier.hxx>
  38 #include <svgio/svgreader/svgpatternnode.hxx>
  39 #include <drawinglayer/primitive2d/patternfillprimitive2d.hxx>
  40 #include <basegfx/polygon/b2dpolygontools.hxx>
  41 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
  42
  43 //////////////////////////////////////////////////////////////////////////////
  44
  45 namespace svgio
  46 {
  47     namespace svgreader
  48     {
  49         basegfx::B2DLineJoin StrokeLinejoinToB2DLineJoin(StrokeLinejoin aStrokeLinejoin)
  50         {
  51             if(StrokeLinejoin_round == aStrokeLinejoin)
  52             {
  53                 return basegfx::B2DLINEJOIN_ROUND;
  54             }
  55             else if(StrokeLinejoin_bevel == aStrokeLinejoin)
  56             {
  57                 return basegfx::B2DLINEJOIN_BEVEL;
  58             }
  59
  60             return basegfx::B2DLINEJOIN_MITER;
  61         }
  62
  63         com::sun::star::drawing::LineCap StrokeLinecapToDrawingLineCap(StrokeLinecap aStrokeLinecap)
  64         {
  65             switch(aStrokeLinecap)
  66             {
  67                 default: /* StrokeLinecap_notset, StrokeLinecap_butt */
  68                 {
  69                     return com::sun::star::drawing::LineCap_BUTT;
  70                     break;
  71                 }
  72                 case StrokeLinecap_round:
  73                 {
  74                     return com::sun::star::drawing::LineCap_ROUND;
  75                     break;
  76                 }
  77                 case StrokeLinecap_square:
  78                 {
  79                     return com::sun::star::drawing::LineCap_SQUARE;
  80                     break;
  81                 }
  82             }
  83         }
  84
  85         FontStretch getWider(FontStretch aSource)
  86         {
  87             switch(aSource)
  88             {
  89                 case FontStretch_ultra_condensed: aSource = FontStretch_extra_condensed; break;
  90                 case FontStretch_extra_condensed: aSource = FontStretch_condensed; break;
  91                 case FontStretch_condensed: aSource = FontStretch_semi_condensed; break;
  92                 case FontStretch_semi_condensed: aSource = FontStretch_normal; break;
  93                 case FontStretch_normal: aSource = FontStretch_semi_expanded; break;
  94                 case FontStretch_semi_expanded: aSource = FontStretch_expanded; break;
  95                 case FontStretch_expanded: aSource = FontStretch_extra_expanded; break;
  96                 case FontStretch_extra_expanded: aSource = FontStretch_ultra_expanded; break;
  97                 default: break;
  98             }
  99
 100             return aSource;
 101         }
 102
 103         FontStretch getNarrower(FontStretch aSource)
 104         {
 105             switch(aSource)
 106             {
 107                 case FontStretch_extra_condensed: aSource = FontStretch_ultra_condensed; break;
 108                 case FontStretch_condensed: aSource = FontStretch_extra_condensed; break;
 109                 case FontStretch_semi_condensed: aSource = FontStretch_condensed; break;
 110                 case FontStretch_normal: aSource = FontStretch_semi_condensed; break;
 111                 case FontStretch_semi_expanded: aSource = FontStretch_normal; break;
 112                 case FontStretch_expanded: aSource = FontStretch_semi_expanded; break;
 113                 case FontStretch_extra_expanded: aSource = FontStretch_expanded; break;
 114                 case FontStretch_ultra_expanded: aSource = FontStretch_extra_expanded; break;
 115                 default: break;
 116             }
 117
 118             return aSource;
 119         }
 120
 121         FontWeight getBolder(FontWeight aSource)
 122         {
 123             switch(aSource)
 124             {
 125                 case FontWeight_100: aSource = FontWeight_200; break;
 126                 case FontWeight_200: aSource = FontWeight_300; break;
 127                 case FontWeight_300: aSource = FontWeight_400; break;
 128                 case FontWeight_400: aSource = FontWeight_500; break;
 129                 case FontWeight_500: aSource = FontWeight_600; break;
 130                 case FontWeight_600: aSource = FontWeight_700; break;
 131                 case FontWeight_700: aSource = FontWeight_800; break;
 132                 case FontWeight_800: aSource = FontWeight_900; break;
 133                 default: break;
 134             }
 135
 136             return aSource;
 137         }
 138
 139         FontWeight getLighter(FontWeight aSource)
 140         {
 141             switch(aSource)
 142             {
 143                 case FontWeight_200: aSource = FontWeight_100; break;
 144                 case FontWeight_300: aSource = FontWeight_200; break;
 145                 case FontWeight_400: aSource = FontWeight_300; break;
 146                 case FontWeight_500: aSource = FontWeight_400; break;
 147                 case FontWeight_600: aSource = FontWeight_500; break;
 148                 case FontWeight_700: aSource = FontWeight_600; break;
 149                 case FontWeight_800: aSource = FontWeight_700; break;
 150                 case FontWeight_900: aSource = FontWeight_800; break;
 151                 default: break;
 152             }
 153
 154             return aSource;
 155         }
 156
 157         ::FontWeight getVclFontWeight(FontWeight aSource)
 158         {
 159             ::FontWeight nRetval(WEIGHT_NORMAL);
 160
 161             switch(aSource)
 162             {
 163                 case FontWeight_100: nRetval = WEIGHT_ULTRALIGHT; break;
 164                 case FontWeight_200: nRetval = WEIGHT_LIGHT; break;
 165                 case FontWeight_300: nRetval = WEIGHT_SEMILIGHT; break;
 166                 case FontWeight_400: nRetval = WEIGHT_NORMAL; break;
 167                 case FontWeight_500: nRetval = WEIGHT_MEDIUM; break;
 168                 case FontWeight_600: nRetval = WEIGHT_SEMIBOLD; break;
 169                 case FontWeight_700: nRetval = WEIGHT_BOLD; break;
 170                 case FontWeight_800: nRetval = WEIGHT_ULTRABOLD; break;
 171                 case FontWeight_900: nRetval = WEIGHT_BLACK; break;
 172                 default: break;
 173             }
 174
 175             return nRetval;
 176         }
 177
 178         void SvgStyleAttributes::readStyle(const rtl::OUString& rCandidate)
 179         {
 180             const sal_Int32 nLen(rCandidate.getLength());
 181             sal_Int32 nPos(0);
 182
 183             while(nPos < nLen)
 184             {
 185                 const sal_Int32 nInitPos(nPos);
 186                 skip_char(rCandidate, sal_Unicode(' '), nPos, nLen);
 187                 rtl::OUStringBuffer aTokenName;
 188                 copyString(rCandidate, nPos, aTokenName, nLen);
 189
 190                 if(aTokenName.getLength())
 191                 {
 192                     skip_char(rCandidate, sal_Unicode(' '), sal_Unicode(':'), nPos, nLen);
 193                     rtl::OUStringBuffer aTokenValue;
 194                     copyToLimiter(rCandidate, sal_Unicode(';'), nPos, aTokenValue, nLen);
 195                     skip_char(rCandidate, sal_Unicode(' '), sal_Unicode(';'), nPos, nLen);
 196                     const rtl::OUString aOUTokenName(aTokenName.makeStringAndClear());
 197                     const rtl::OUString aOUTokenValue(aTokenValue.makeStringAndClear());
 198
 199                     parseStyleAttribute(aOUTokenName, StrToSVGToken(aOUTokenName), aOUTokenValue);
 200                 }
 201
 202                 if(nInitPos == nPos)
 203                 {
 204                     OSL_ENSURE(false, "Could not interpret on current position (!)");
 205                     nPos++;
 206                 }
 207             }
 208         }
 209
 210         void SvgStyleAttributes::checkForCssStyle(const rtl::OUString& rClassStr) const
 211         {
 212             if(!mpCssStyleParent)
 213             {
 214                 const SvgDocument& rDocument = mrOwner.getDocument();
 215                 const SvgStyleAttributes* pNew = 0;
 216
 217                 if(rDocument.hasSvgStyleAttributesById())
 218                 {
 219                     if(mrOwner.getClass())
 220                     {
 221                         rtl::OUString aId(rtl::OUString::createFromAscii("."));
 222                         aId = aId + *mrOwner.getClass();
 223                         pNew = rDocument.findSvgStyleAttributesById(aId);
 224
 225                         if(!pNew && rClassStr.getLength())
 226                         {
 227                             aId = rClassStr + aId;
 228
 229                             pNew = rDocument.findSvgStyleAttributesById(aId);
 230                         }
 231                     }
 232
 233                     if(!pNew && mrOwner.getId())
 234                     {
 235                         pNew = rDocument.findSvgStyleAttributesById(*mrOwner.getId());
 236                     }
 237
 238                     if(!pNew && rClassStr.getLength())
 239                     {
 240                         pNew = rDocument.findSvgStyleAttributesById(rClassStr);
 241                     }
 242
 243                     if(pNew)
 244                     {
 245                         // found css style, set as parent
 246                         const_cast< SvgStyleAttributes* >(this)->mpCssStyleParent = pNew;
 247                     }
 248                 }
 249             }
 250         }
 251
 252         const SvgStyleAttributes* SvgStyleAttributes::getParentStyle() const
 253         {
 254             if(mpCssStyleParent)
 255             {
 256                 return mpCssStyleParent;
 257             }
 258
 259             if(mrOwner.getParent())
 260             {
 261                 return mrOwner.getParent()->getSvgStyleAttributes();
 262             }
 263
 264             return 0;
 265         }
 266
 267         void SvgStyleAttributes::add_text(
 268             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 269             drawinglayer::primitive2d::Primitive2DSequence& rSource) const
 270         {
 271             if(rSource.hasElements())
 272             {
 273                 // at this point the primitives in rSource are of type TextSimplePortionPrimitive2D
 274                 // or TextDecoratedPortionPrimitive2D and have the Fill Color (pAttributes->getFill())
 275                 // set. When another fill is used and also evtl. stroke is set it gets necessary to
 276                 // dismantle to geometry and add needed primitives
 277                 const basegfx::BColor* pFill = getFill();
 278                 const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
 279                 const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
 280                 const basegfx::BColor* pStroke = getStroke();
 281                 const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
 282                 const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
 283                 basegfx::B2DPolyPolygon aMergedArea;
 284
 285                 if(pFillGradient || pFillPattern || pStroke || pStrokeGradient || pStrokePattern)
 286                 {
 287                     // text geometry is needed, create
 288                     // use neutral ViewInformation and create LineGeometryExtractor2D
 289                     const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 290                     drawinglayer::processor2d::TextAsPolygonExtractor2D aExtractor(aViewInformation2D);
 291
 292                     // proccess
 293                     aExtractor.process(rSource);
 294
 295                     // get results
 296                     const drawinglayer::processor2d::TextAsPolygonDataNodeVector& rResult = aExtractor.getTarget();
 297                     const sal_uInt32 nResultCount(rResult.size());
 298                     basegfx::B2DPolyPolygonVector aTextFillVector;
 299                     aTextFillVector.reserve(nResultCount);
 300
 301                     for(sal_uInt32 a(0); a < nResultCount; a++)
 302                     {
 303                         const drawinglayer::processor2d::TextAsPolygonDataNode& rCandidate = rResult[a];
 304
 305                         if(rCandidate.getIsFilled())
 306                         {
 307                             aTextFillVector.push_back(rCandidate.getB2DPolyPolygon());
 308                         }
 309                     }
 310
 311                     if(!aTextFillVector.empty())
 312                     {
 313                         aMergedArea = basegfx::tools::mergeToSinglePolyPolygon(aTextFillVector);
 314                     }
 315                 }
 316
 317                 const bool bStrokeUsed(pStroke || pStrokeGradient || pStrokePattern);
 318
 319                 // add fill. Use geometry even for simple color fill when stroke
 320                 // is used, else text rendering and the geometry-based stroke will
 321                 // normally not really match optically due to divrese system text
 322                 // renderers
 323                 if(aMergedArea.count() && (pFillGradient || pFillPattern || bStrokeUsed))
 324                 {
 325                     // create text fill content based on geometry
 326                     add_fill(aMergedArea, rTarget, aMergedArea.getB2DRange());
 327                 }
 328                 else if(pFill)
 329                 {
 330                     // add the already prepared primitives for single color fill
 331                     drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, rSource);
 332                 }
 333
 334                 // add stroke
 335                 if(aMergedArea.count() && bStrokeUsed)
 336                 {
 337                     // create text stroke content
 338                     add_stroke(aMergedArea, rTarget, aMergedArea.getB2DRange());
 339                 }
 340             }
 341         }
 342
 343         void SvgStyleAttributes::add_fillGradient(
 344             const basegfx::B2DPolyPolygon& rPath,
 345             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 346             const SvgGradientNode& rFillGradient,
 347             const basegfx::B2DRange& rGeoRange) const
 348         {
 349             // create fill content
 350             drawinglayer::primitive2d::SvgGradientEntryVector aSvgGradientEntryVector;
 351
 352             // get the color stops
 353             rFillGradient.collectGradientEntries(aSvgGradientEntryVector);
 354
 355             if(!aSvgGradientEntryVector.empty())
 356             {
 357                 basegfx::B2DHomMatrix aGeoToUnit;
 358
 359                 if(rFillGradient.getGradientTransform())
 360                 {
 361                     aGeoToUnit = *rFillGradient.getGradientTransform();
 362                 }
 363
 364                 if(userSpaceOnUse == rFillGradient.getGradientUnits())
 365                 {
 366                     aGeoToUnit.translate(-rGeoRange.getMinX(), -rGeoRange.getMinY());
 367                     aGeoToUnit.scale(1.0 / rGeoRange.getWidth(), 1.0 / rGeoRange.getHeight());
 368                 }
 369
 370                 if(SVGTokenLinearGradient == rFillGradient.getType())
 371                 {
 372                     basegfx::B2DPoint aStart(0.0, 0.0);
 373                     basegfx::B2DPoint aEnd(1.0, 0.0);
 374
 375                     if(userSpaceOnUse == rFillGradient.getGradientUnits())
 376                     {
 377                         // all possible units
 378                         aStart.setX(rFillGradient.getX1().solve(mrOwner, xcoordinate));
 379                         aStart.setY(rFillGradient.getY1().solve(mrOwner, ycoordinate));
 380                         aEnd.setX(rFillGradient.getX2().solve(mrOwner, xcoordinate));
 381                         aEnd.setY(rFillGradient.getY2().solve(mrOwner, ycoordinate));
 382                     }
 383                     else
 384                     {
 385                         // fractions or percent relative to object bounds
 386                         const SvgNumber X1(rFillGradient.getX1());
 387                         const SvgNumber Y1(rFillGradient.getY1());
 388                         const SvgNumber X2(rFillGradient.getX2());
 389                         const SvgNumber Y2(rFillGradient.getY2());
 390
 391                         aStart.setX(Unit_percent == X1.getUnit() ? X1.getNumber() * 0.01 : X1.getNumber());
 392                         aStart.setY(Unit_percent == Y1.getUnit() ? Y1.getNumber() * 0.01 : Y1.getNumber());
 393                         aEnd.setX(Unit_percent == X2.getUnit() ? X2.getNumber() * 0.01 : X2.getNumber());
 394                         aEnd.setY(Unit_percent == Y2.getUnit() ? Y2.getNumber() * 0.01 : Y2.getNumber());
 395                     }
 396
 397                     if(!aGeoToUnit.isIdentity())
 398                     {
 399                         aStart *= aGeoToUnit;
 400                         aEnd *= aGeoToUnit;
 401                     }
 402
 403                     drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 404                         rTarget,
 405                         new drawinglayer::primitive2d::SvgLinearGradientPrimitive2D(
 406                             rPath,
 407                             aSvgGradientEntryVector,
 408                             aStart,
 409                             aEnd,
 410                             rFillGradient.getSpreadMethod()));
 411                 }
 412                 else
 413                 {
 414                     basegfx::B2DPoint aStart(0.5, 0.5);
 415                     basegfx::B2DPoint aFocal;
 416                     double fRadius(0.5);
 417                     const SvgNumber* pFx = rFillGradient.getFx();
 418                     const SvgNumber* pFy = rFillGradient.getFy();
 419                     const bool bFocal(pFx || pFy);
 420
 421                     if(userSpaceOnUse == rFillGradient.getGradientUnits())
 422                     {
 423                         // all possible units
 424                         aStart.setX(rFillGradient.getCx().solve(mrOwner, xcoordinate));
 425                         aStart.setY(rFillGradient.getCy().solve(mrOwner, ycoordinate));
 426                         fRadius = rFillGradient.getR().solve(mrOwner, length);
 427
 428                         if(bFocal)
 429                         {
 430                             aFocal.setX(pFx ? pFx->solve(mrOwner, xcoordinate) : aStart.getX());
 431                             aFocal.setY(pFy ? pFy->solve(mrOwner, ycoordinate) : aStart.getY());
 432                         }
 433                     }
 434                     else
 435                     {
 436                         // fractions or percent relative to object bounds
 437                         const SvgNumber Cx(rFillGradient.getCx());
 438                         const SvgNumber Cy(rFillGradient.getCy());
 439                         const SvgNumber R(rFillGradient.getR());
 440
 441                         aStart.setX(Unit_percent == Cx.getUnit() ? Cx.getNumber() * 0.01 : Cx.getNumber());
 442                         aStart.setY(Unit_percent == Cy.getUnit() ? Cy.getNumber() * 0.01 : Cy.getNumber());
 443                         fRadius = (Unit_percent == R.getUnit()) ? R.getNumber() * 0.01 : R.getNumber();
 444
 445                         if(bFocal)
 446                         {
 447                             aFocal.setX(pFx ? (Unit_percent == pFx->getUnit() ? pFx->getNumber() * 0.01 : pFx->getNumber()) : aStart.getX());
 448                             aFocal.setY(pFy ? (Unit_percent == pFy->getUnit() ? pFy->getNumber() * 0.01 : pFy->getNumber()) : aStart.getY());
 449                         }
 450                     }
 451
 452                     if(!aGeoToUnit.isIdentity())
 453                     {
 454                         aStart *= aGeoToUnit;
 455                         fRadius = (aGeoToUnit * basegfx::B2DVector(fRadius, 0.0)).getLength();
 456
 457                         if(bFocal)
 458                         {
 459                             aFocal *= aGeoToUnit;
 460                         }
 461                     }
 462
 463                     drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 464                         rTarget,
 465                         new drawinglayer::primitive2d::SvgRadialGradientPrimitive2D(
 466                             rPath,
 467                             aSvgGradientEntryVector,
 468                             aStart,
 469                             fRadius,
 470                             rFillGradient.getSpreadMethod(),
 471                             bFocal ? &aFocal : 0));
 472                 }
 473             }
 474         }
 475
 476         void SvgStyleAttributes::add_fillPatternTransform(
 477             const basegfx::B2DPolyPolygon& rPath,
 478             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 479             const SvgPatternNode& rFillPattern,
 480             const basegfx::B2DRange& rGeoRange) const
 481         {
 482             // prepare fill polyPolygon with given pattern, check for patternTransform
 483             if(rFillPattern.getPatternTransform() && !rFillPattern.getPatternTransform()->isIdentity())
 484             {
 485                 // PatternTransform is active; Handle by filling the inverse transformed
 486                 // path and back-transforming the result
 487                 basegfx::B2DPolyPolygon aPath(rPath);
 488                 basegfx::B2DHomMatrix aInv(*rFillPattern.getPatternTransform());
 489                 drawinglayer::primitive2d::Primitive2DSequence aNewTarget;
 490
 491                 aInv.invert();
 492                 aPath.transform(aInv);
 493                 add_fillPattern(aPath, aNewTarget, rFillPattern, aPath.getB2DRange());
 494
 495                 if(aNewTarget.hasElements())
 496                 {
 497                     drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 498                         rTarget,
 499                         new drawinglayer::primitive2d::TransformPrimitive2D(
 500                             *rFillPattern.getPatternTransform(),
 501                             aNewTarget));
 502                 }
 503             }
 504             else
 505             {
 506                 // no patternTransform, create fillPattern directly
 507                 add_fillPattern(rPath, rTarget, rFillPattern, rGeoRange);
 508             }
 509         }
 510
 511         void SvgStyleAttributes::add_fillPattern(
 512             const basegfx::B2DPolyPolygon& rPath,
 513             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 514             const SvgPatternNode& rFillPattern,
 515             const basegfx::B2DRange& rGeoRange) const
 516         {
 517             // fill polyPolygon with given pattern
 518             const drawinglayer::primitive2d::Primitive2DSequence& rPrimitives = rFillPattern.getPatternPrimitives();
 519
 520             if(rPrimitives.hasElements())
 521             {
 522                 double fTargetWidth(rGeoRange.getWidth());
 523                 double fTargetHeight(rGeoRange.getHeight());
 524
 525                 if(fTargetWidth > 0.0 && fTargetHeight > 0.0)
 526                 {
 527                     // get relative values from pattern
 528                     double fX(0.0);
 529                     double fY(0.0);
 530                     double fW(0.0);
 531                     double fH(0.0);
 532
 533                     rFillPattern.getValuesRelative(fX, fY, fW, fH, rGeoRange, mrOwner);
 534
 535                     if(fW > 0.0 && fH > 0.0)
 536                     {
 537                         // build the reference range relative to the rGeoRange
 538                         const basegfx::B2DRange aReferenceRange(fX, fY, fX + fW, fY + fH);
 539
 540                         // find out how the content is mapped to the reference range
 541                         basegfx::B2DHomMatrix aMapPrimitivesToUnitRange;
 542                         const basegfx::B2DRange* pViewBox = rFillPattern.getViewBox();
 543
 544                         if(pViewBox)
 545                         {
 546                             // use viewBox/preserveAspectRatio
 547                             const SvgAspectRatio& rRatio = rFillPattern.getSvgAspectRatio();
 548                             const basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
 549
 550                             if(rRatio.isSet())
 551                             {
 552                                 // let mapping be created from SvgAspectRatio
 553                                 aMapPrimitivesToUnitRange = rRatio.createMapping(aUnitRange, *pViewBox);
 554                             }
 555                             else
 556                             {
 557                                 // choose default mapping
 558                                 aMapPrimitivesToUnitRange = rRatio.createLinearMapping(aUnitRange, *pViewBox);
 559                             }
 560                         }
 561                         else
 562                         {
 563                             // use patternContentUnits
 564                             const SvgUnits aPatternContentUnits(rFillPattern.getPatternContentUnits() ? *rFillPattern.getPatternContentUnits() : userSpaceOnUse);
 565
 566                             if(userSpaceOnUse == aPatternContentUnits)
 567                             {
 568                                 // create relative mapping to unit coordinates
 569                                 aMapPrimitivesToUnitRange.scale(1.0 / (fW * fTargetWidth), 1.0 / (fH * fTargetHeight));
 570                             }
 571                             else
 572                             {
 573                                 aMapPrimitivesToUnitRange.scale(1.0 / fW, 1.0 / fH);
 574                             }
 575                         }
 576
 577                         // apply aMapPrimitivesToUnitRange to content when used
 578                         drawinglayer::primitive2d::Primitive2DSequence aPrimitives(rPrimitives);
 579
 580                         if(!aMapPrimitivesToUnitRange.isIdentity())
 581                         {
 582                             const drawinglayer::primitive2d::Primitive2DReference xRef(
 583                                 new drawinglayer::primitive2d::TransformPrimitive2D(
 584                                     aMapPrimitivesToUnitRange,
 585                                     aPrimitives));
 586
 587                             aPrimitives = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
 588                         }
 589
 590                         // embed in PatternFillPrimitive2D
 591                         drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 592                             rTarget,
 593                             new drawinglayer::primitive2d::PatternFillPrimitive2D(
 594                                 rPath,
 595                                 aPrimitives,
 596                                 aReferenceRange));
 597                     }
 598                 }
 599             }
 600         }
 601
 602         void SvgStyleAttributes::add_fill(
 603             const basegfx::B2DPolyPolygon& rPath,
 604             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 605             const basegfx::B2DRange& rGeoRange) const
 606         {
 607             const basegfx::BColor* pFill = getFill();
 608             const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
 609             const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
 610
 611             if(pFill || pFillGradient || pFillPattern)
 612             {
 613                 const double fFillOpacity(getFillOpacity().solve(mrOwner, length));
 614
 615                 if(basegfx::fTools::more(fFillOpacity, 0.0))
 616                 {
 617                     drawinglayer::primitive2d::Primitive2DSequence aNewFill;
 618
 619                     if(pFillGradient)
 620                     {
 621                         // create fill content with SVG gradient primitive
 622                         add_fillGradient(rPath, aNewFill, *pFillGradient, rGeoRange);
 623                     }
 624                     else if(pFillPattern)
 625                     {
 626                         // create fill content with SVG pattern primitive
 627                         add_fillPatternTransform(rPath, aNewFill, *pFillPattern, rGeoRange);
 628                     }
 629                     else // if(pFill)
 630                     {
 631                         // create fill content
 632                         aNewFill.realloc(1);
 633                         aNewFill[0] = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
 634                             rPath,
 635                             *pFill);
 636                     }
 637
 638                     if(aNewFill.hasElements())
 639                     {
 640                         if(basegfx::fTools::less(fFillOpacity, 1.0))
 641                         {
 642                             // embed in UnifiedTransparencePrimitive2D
 643                             drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 644                                 rTarget,
 645                                 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
 646                                     aNewFill,
 647                                     1.0 - fFillOpacity));
 648                         }
 649                         else
 650                         {
 651                             // append
 652                             drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aNewFill);
 653                         }
 654                     }
 655                 }
 656             }
 657         }
 658
 659         void SvgStyleAttributes::add_stroke(
 660             const basegfx::B2DPolyPolygon& rPath,
 661             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 662             const basegfx::B2DRange& rGeoRange) const
 663         {
 664             const basegfx::BColor* pStroke = getStroke();
 665             const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
 666             const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
 667
 668             if(pStroke || pStrokeGradient || pStrokePattern)
 669             {
 670                 drawinglayer::primitive2d::Primitive2DSequence aNewStroke;
 671                 const double fStrokeOpacity(getStrokeOpacity().solve(mrOwner, length));
 672
 673                 if(basegfx::fTools::more(fStrokeOpacity, 0.0))
 674                 {
 675                     // get stroke width; SVG does not use 0.0 == hairline, so 0.0 is no line at all
 676                     const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner, length) : 1.0);
 677
 678                     if(basegfx::fTools::more(fStrokeWidth, 0.0))
 679                     {
 680                         // get LineJoin, LineCap and stroke array
 681                         const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
 682                         const com::sun::star::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
 683                         ::std::vector< double > aDashArray;
 684
 685                         if(!getStrokeDasharray().empty())
 686                         {
 687                             aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner, length);
 688                         }
 689
 690                         // todo: Handle getStrokeDashOffset()
 691
 692                         // prepare line attribute
 693                         drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
 694                         const drawinglayer::attribute::LineAttribute aLineAttribute(
 695                             pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
 696                             fStrokeWidth,
 697                             aB2DLineJoin,
 698                             aLineCap);
 699
 700                         if(aDashArray.empty())
 701                         {
 702                             aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
 703                                 rPath,
 704                                 aLineAttribute);
 705                         }
 706                         else
 707                         {
 708                             const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(aDashArray);
 709
 710                             aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
 711                                 rPath,
 712                                 aLineAttribute,
 713                                 aStrokeAttribute);
 714                         }
 715
 716                         if(pStrokeGradient || pStrokePattern)
 717                         {
 718                             // put primitive into Primitive2DReference and Primitive2DSequence
 719                             const drawinglayer::primitive2d::Primitive2DSequence aSeq(&aNewLinePrimitive, 1);
 720
 721                             // use neutral ViewInformation and create LineGeometryExtractor2D
 722                             const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
 723                             drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
 724
 725                             // proccess
 726                             aExtractor.process(aSeq);
 727
 728                             // check for fill rsults
 729                             const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
 730
 731                             if(!rLineFillVector.empty())
 732                             {
 733                                 const basegfx::B2DPolyPolygon aMergedArea(
 734                                     basegfx::tools::mergeToSinglePolyPolygon(
 735                                         rLineFillVector));
 736
 737                                 if(aMergedArea.count())
 738                                 {
 739                                     if(pStrokeGradient)
 740                                     {
 741                                         // create fill content with SVG gradient primitive. Use original GeoRange,
 742                                         // e.g. from circle without LineWidth
 743                                         add_fillGradient(aMergedArea, aNewStroke, *pStrokeGradient, rGeoRange);
 744                                     }
 745                                     else // if(pStrokePattern)
 746                                     {
 747                                         // create fill content with SVG pattern primitive. Use GeoRange
 748                                         // from the expanded data, e.g. circle with extended geo by half linewidth
 749                                         add_fillPatternTransform(aMergedArea, aNewStroke, *pStrokePattern, aMergedArea.getB2DRange());
 750                                     }
 751                                 }
 752                             }
 753                         }
 754                         else // if(pStroke)
 755                         {
 756                             drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(aNewStroke, aNewLinePrimitive);
 757                         }
 758
 759                         if(aNewStroke.hasElements())
 760                         {
 761                             if(basegfx::fTools::less(fStrokeOpacity, 1.0))
 762                             {
 763                                 // embed in UnifiedTransparencePrimitive2D
 764                                 drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(
 765                                     rTarget,
 766                                     new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
 767                                         aNewStroke,
 768                                         1.0 - fStrokeOpacity));
 769                             }
 770                             else
 771                             {
 772                                 // append
 773                                 drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aNewStroke);
 774                             }
 775                         }
 776                     }
 777                 }
 778             }
 779         }
 780
 781         double get_markerRotation(
 782             const SvgMarkerNode& rMarker,
 783             const basegfx::B2DPolygon& rPolygon,
 784             const sal_uInt32 nIndex)
 785         {
 786             double fAngle(0.0);
 787             const sal_uInt32 nPointCount(rPolygon.count());
 788
 789             if(nPointCount)
 790             {
 791                 if(rMarker.getOrientAuto())
 792                 {
 793                     const bool bPrev(rPolygon.isClosed() || nIndex > 0);
 794                     basegfx::B2DCubicBezier aSegment;
 795                     basegfx::B2DVector aPrev;
 796                     basegfx::B2DVector aNext;
 797
 798                     if(bPrev)
 799                     {
 800                         rPolygon.getBezierSegment((nIndex - 1) % nPointCount, aSegment);
 801                         aPrev = aSegment.getTangent(1.0);
 802                     }
 803
 804                     const bool bNext(rPolygon.isClosed() || nIndex + 1 < nPointCount);
 805
 806                     if(bNext)
 807                     {
 808                         rPolygon.getBezierSegment(nIndex % nPointCount, aSegment);
 809                         aNext = aSegment.getTangent(0.0);
 810                     }
 811
 812                     if(bPrev && bNext)
 813                     {
 814                         fAngle = atan2(aPrev.getY() + aNext.getY(), aPrev.getX() + aNext.getX());
 815                     }
 816                     else if(bPrev)
 817                     {
 818                         fAngle = atan2(aPrev.getY(), aPrev.getX());
 819                     }
 820                     else if(bNext)
 821                     {
 822                         fAngle = atan2(aNext.getY(), aNext.getX());
 823                     }
 824                 }
 825                 else
 826                 {
 827                     fAngle = rMarker.getAngle();
 828                 }
 829             }
 830
 831             return fAngle;
 832         }
 833
 834         bool SvgStyleAttributes::prepare_singleMarker(
 835             drawinglayer::primitive2d::Primitive2DSequence& rMarkerPrimitives,
 836             basegfx::B2DHomMatrix& rMarkerTransform,
 837             basegfx::B2DRange& rClipRange,
 838             const SvgMarkerNode& rMarker) const
 839         {
 840             // reset return values
 841             rMarkerTransform.identity();
 842             rClipRange.reset();
 843
 844             // get marker primitive representation
 845             rMarkerPrimitives = rMarker.getMarkerPrimitives();
 846
 847             if(rMarkerPrimitives.hasElements())
 848             {
 849                 basegfx::B2DRange aPrimitiveRange(0.0, 0.0, 1.0, 1.0);
 850                 const basegfx::B2DRange* pViewBox = rMarker.getViewBox();
 851
 852                 if(pViewBox)
 853                 {
 854                     aPrimitiveRange = *pViewBox;
 855                 }
 856
 857                 if(aPrimitiveRange.getWidth() > 0.0 && aPrimitiveRange.getHeight() > 0.0)
 858                 {
 859                     double fTargetWidth(rMarker.getMarkerWidth().isSet() ? rMarker.getMarkerWidth().solve(mrOwner, xcoordinate) : 3.0);
 860                     double fTargetHeight(rMarker.getMarkerHeight().isSet() ? rMarker.getMarkerHeight().solve(mrOwner, xcoordinate) : 3.0);
 861                     const bool bStrokeWidth(SvgMarkerNode::strokeWidth == rMarker.getMarkerUnits());
 862                     const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner, length) : 1.0);
 863
 864                     if(bStrokeWidth)
 865                     {
 866                         // relative to strokeWidth
 867                         fTargetWidth *= fStrokeWidth;
 868                         fTargetHeight *= fStrokeWidth;
 869                     }
 870
 871                     if(fTargetWidth > 0.0 && fTargetHeight > 0.0)
 872                     {
 873                         // create mapping
 874                         const basegfx::B2DRange aTargetRange(0.0, 0.0, fTargetWidth, fTargetHeight);
 875                         const SvgAspectRatio& rRatio = rMarker.getSvgAspectRatio();
 876
 877                         if(rRatio.isSet())
 878                         {
 879                             // let mapping be created from SvgAspectRatio
 880                             rMarkerTransform = rRatio.createMapping(aTargetRange, aPrimitiveRange);
 881
 882                             if(rRatio.isMeetOrSlice())
 883                             {
 884                                 // need to clip
 885                                 rClipRange = aPrimitiveRange;
 886                             }
 887                         }
 888                         else
 889                         {
 890                             if(!pViewBox)
 891                             {
 892                                 if(bStrokeWidth)
 893                                 {
 894                                     // adapt to strokewidth if needed
 895                                     rMarkerTransform.scale(fStrokeWidth, fStrokeWidth);
 896                                 }
 897                             }
 898                             else
 899                             {
 900                                 // choose default mapping
 901                                 rMarkerTransform = rRatio.createLinearMapping(aTargetRange, aPrimitiveRange);
 902                             }
 903                         }
 904
 905                         // get and apply reference point. Initially it's in marker local coordinate system
 906                         basegfx::B2DPoint aRefPoint(
 907                             rMarker.getRefX().isSet() ? rMarker.getRefX().solve(mrOwner, xcoordinate) : 0.0,
 908                             rMarker.getRefY().isSet() ? rMarker.getRefY().solve(mrOwner, ycoordinate) : 0.0);
 909
 910                         // apply MarkerTransform to have it in mapped coordinates
 911                         aRefPoint *= rMarkerTransform;
 912
 913                         // apply by moving RepPoint to (0.0)
 914                         rMarkerTransform.translate(-aRefPoint.getX(), -aRefPoint.getY());
 915
 916                         return true;
 917                     }
 918                 }
 919             }
 920
 921             return false;
 922         }
 923
 924         void SvgStyleAttributes::add_singleMarker(
 925             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
 926             const drawinglayer::primitive2d::Primitive2DSequence& rMarkerPrimitives,
 927             const basegfx::B2DHomMatrix& rMarkerTransform,
 928             const basegfx::B2DRange& rClipRange,
 929             const SvgMarkerNode& rMarker,
 930             const basegfx::B2DPolygon& rCandidate,
 931             const sal_uInt32 nIndex) const
 932         {
 933             const sal_uInt32 nPointCount(rCandidate.count());
 934
 935             if(nPointCount)
 936             {
 937                 // get and apply rotation
 938                 basegfx::B2DHomMatrix aCombinedTransform(rMarkerTransform);
 939                 aCombinedTransform.rotate(get_markerRotation(rMarker, rCandidate, nIndex));
 940
 941                 // get and apply target position
 942                 const basegfx::B2DPoint aPoint(rCandidate.getB2DPoint(nIndex % nPointCount));
 943                 aCombinedTransform.translate(aPoint.getX(), aPoint.getY());
 944
 945                 // prepare marker
 946                 drawinglayer::primitive2d::Primitive2DReference xMarker(
 947                     new drawinglayer::primitive2d::TransformPrimitive2D(
 948                         aCombinedTransform,
 949                         rMarkerPrimitives));
 950
 951                 if(!rClipRange.isEmpty())
 952                 {
 953                     // marker needs to be clipped, it's bigger as the mapping
 954                     basegfx::B2DPolyPolygon aClipPolygon(basegfx::tools::createPolygonFromRect(rClipRange));
 955
 956                     aClipPolygon.transform(aCombinedTransform);
 957                     xMarker = new drawinglayer::primitive2d::MaskPrimitive2D(
 958                         aClipPolygon,
 959                         drawinglayer::primitive2d::Primitive2DSequence(&xMarker, 1));
 960                 }
 961
 962                 // add marker
 963                 drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(rTarget, xMarker);
 964             }
 965         }
 966
 967         void SvgStyleAttributes::add_markers(
 968             const basegfx::B2DPolyPolygon& rPath,
 969             drawinglayer::primitive2d::Primitive2DSequence& rTarget) const
 970         {
 971             // try to access linked markers
 972             const SvgMarkerNode* pStart = accessMarkerStartXLink();
 973             const SvgMarkerNode* pMid = accessMarkerMidXLink();
 974             const SvgMarkerNode* pEnd = accessMarkerEndXLink();
 975
 976             if(pStart || pMid || pEnd)
 977             {
 978                 const sal_uInt32 nCount(rPath.count());
 979
 980                 for (sal_uInt32 a(0); a < nCount; a++)
 981                 {
 982                     const basegfx::B2DPolygon aCandidate(rPath.getB2DPolygon(a));
 983                     const sal_uInt32 nPointCount(aCandidate.count());
 984
 985                     if(nPointCount)
 986                     {
 987                         const sal_uInt32 nMarkerCount(aCandidate.isClosed() ? nPointCount + 1 : nPointCount);
 988                         drawinglayer::primitive2d::Primitive2DSequence aMarkerPrimitives;
 989                         basegfx::B2DHomMatrix aMarkerTransform;
 990                         basegfx::B2DRange aClipRange;
 991                         const SvgMarkerNode* pPrepared = 0;
 992
 993                         if(pStart)
 994                         {
 995                             if(prepare_singleMarker(aMarkerPrimitives, aMarkerTransform, aClipRange, *pStart))
 996                             {
 997                                 pPrepared = pStart;
 998                                 add_singleMarker(rTarget, aMarkerPrimitives, aMarkerTransform, aClipRange, *pPrepared, aCandidate, 0);
 999                             }
1000                         }
1001
1002                         if(pMid && nMarkerCount > 2)
1003                         {
1004                             if(pMid == pPrepared || prepare_singleMarker(aMarkerPrimitives, aMarkerTransform, aClipRange, *pMid))
1005                             {
1006                                 pPrepared = pMid;
1007
1008                                 for(sal_uInt32 b(1); b < nMarkerCount - 1; b++)
1009                                 {
1010                                     add_singleMarker(rTarget, aMarkerPrimitives, aMarkerTransform, aClipRange, *pPrepared, aCandidate, b);
1011                                 }
1012                             }
1013                         }
1014
1015                         if(pEnd)
1016                         {
1017                             if(pEnd == pPrepared || prepare_singleMarker(aMarkerPrimitives, aMarkerTransform, aClipRange, *pEnd))
1018                             {
1019                                 pPrepared = pEnd;
1020                                 add_singleMarker(rTarget, aMarkerPrimitives, aMarkerTransform, aClipRange, *pPrepared, aCandidate, nMarkerCount - 1);
1021                             }
1022                         }
1023                     }
1024                 }
1025             }
1026         }
1027
1028         void SvgStyleAttributes::add_path(
1029             const basegfx::B2DPolyPolygon& rPath,
1030             drawinglayer::primitive2d::Primitive2DSequence& rTarget) const
1031         {
1032             const bool bIsLine(1 == rPath.count()
1033                 && !rPath.areControlPointsUsed()
1034                 && 2 == rPath.getB2DPolygon(0).count());
1035
1036             if(!rPath.count())
1037             {
1038                 return;
1039             }
1040
1041             const basegfx::B2DRange aGeoRange(rPath.getB2DRange());
1042
1043             if(aGeoRange.isEmpty())
1044             {
1045                 return;
1046             }
1047
1048             if(!bIsLine && // not for lines
1049                 (basegfx::fTools::equalZero(aGeoRange.getWidth())
1050                 || basegfx::fTools::equalZero(aGeoRange.getHeight())))
1051             {
1052                 return;
1053             }
1054
1055             const double fOpacity(getOpacity().getNumber());
1056
1057             if(basegfx::fTools::equalZero(fOpacity))
1058             {
1059                 return;
1060             }
1061
1062             if(!bIsLine)
1063             {
1064                 basegfx::B2DPolyPolygon aPath(rPath);
1065                 const bool bNeedToCheckClipRule(SVGTokenPath == mrOwner.getType() || SVGTokenPolygon == mrOwner.getType());
1066                 const bool bClipPathIsNonzero(!bIsLine && bNeedToCheckClipRule && mbIsClipPathContent && mbClipRule);
1067                 const bool bFillRuleIsNonzero(!bIsLine && bNeedToCheckClipRule && !mbIsClipPathContent && getFillRule());
1068
1069                 if(bClipPathIsNonzero || bFillRuleIsNonzero)
1070                 {
1071                     // nonzero is wanted, solve geometrically (see description on basegfx)
1072                     aPath = basegfx::tools::createNonzeroConform(aPath);
1073                 }
1074
1075                 add_fill(aPath, rTarget, aGeoRange);
1076             }
1077
1078             add_stroke(rPath, rTarget, aGeoRange);
1079
1080             // Svg supports markers for path, polygon, polyline and line
1081             if(SVGTokenPath == mrOwner.getType() ||         // path
1082                 SVGTokenPolygon == mrOwner.getType() ||     // polygon, polyline
1083                 SVGTokenLine == mrOwner.getType())          // line
1084             {
1085                 // try to add markers
1086                 add_markers(rPath, rTarget);
1087             }
1088         }
1089
1090         void SvgStyleAttributes::add_postProcess(
1091             drawinglayer::primitive2d::Primitive2DSequence& rTarget,
1092             const drawinglayer::primitive2d::Primitive2DSequence& rSource,
1093             const basegfx::B2DHomMatrix* pTransform) const
1094         {
1095             if(rSource.hasElements())
1096             {
1097                 const double fOpacity(getOpacity().getNumber());
1098
1099                 if(basegfx::fTools::equalZero(fOpacity))
1100                 {
1101                     return;
1102                 }
1103
1104                 drawinglayer::primitive2d::Primitive2DSequence aSource(rSource);
1105
1106                 if(basegfx::fTools::less(fOpacity, 1.0))
1107                 {
1108                     // embed in UnifiedTransparencePrimitive2D
1109                     const drawinglayer::primitive2d::Primitive2DReference xRef(
1110                         new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
1111                             aSource,
1112                             1.0 - fOpacity));
1113
1114                     aSource = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
1115                 }
1116
1117                 if(getClipPathXLink().getLength())
1118                 {
1119                     // try to access linked ClipPath
1120                     const SvgClipPathNode* mpClip = dynamic_cast< const SvgClipPathNode* >(mrOwner.getDocument().findSvgNodeById(getClipPathXLink()));
1121
1122                     if(mpClip)
1123                     {
1124                         mpClip->apply(aSource);
1125                     }
1126                 }
1127
1128                 if(aSource.hasElements()) // test again, applied clipPath may have lead to empty geometry
1129                 {
1130                     if(getMaskXLink().getLength())
1131                     {
1132                         // try to access linked Mask
1133                         const SvgMaskNode* mpMask = dynamic_cast< const SvgMaskNode* >(mrOwner.getDocument().findSvgNodeById(getMaskXLink()));
1134
1135                         if(mpMask)
1136                         {
1137                             mpMask->apply(aSource);
1138                         }
1139                     }
1140
1141                     if(aSource.hasElements()) // test again, applied mask may have lead to empty geometry
1142                     {
1143                         if(pTransform)
1144                         {
1145                             // create embedding group element with transformation
1146                             const drawinglayer::primitive2d::Primitive2DReference xRef(
1147                                 new drawinglayer::primitive2d::TransformPrimitive2D(
1148                                     *pTransform,
1149                                     aSource));
1150
1151                             aSource = drawinglayer::primitive2d::Primitive2DSequence(&xRef, 1);
1152                         }
1153
1154                         // append to current target
1155                         drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(rTarget, aSource);
1156                     }
1157                 }
1158             }
1159         }
1160
1161         SvgStyleAttributes::SvgStyleAttributes(SvgNode& rOwner)
1162         :   mrOwner(rOwner),
1163             mpCssStyleParent(0),
1164             maFill(),
1165             maStroke(),
1166             maStopColor(basegfx::BColor(0.0, 0.0, 0.0), true),
1167             maStrokeWidth(),
1168             maStopOpacity(),
1169             mpSvgGradientNodeFill(0),
1170             mpSvgGradientNodeStroke(0),
1171             mpSvgPatternNodeFill(0),
1172             mpSvgPatternNodeStroke(0),
1173             maFillOpacity(),
1174             maStrokeDasharray(),
1175             maStrokeDashOffset(),
1176             maStrokeLinecap(StrokeLinecap_notset),
1177             maStrokeLinejoin(StrokeLinejoin_notset),
1178             maStrokeMiterLimit(),
1179             maStrokeOpacity(),
1180             maFontFamily(),
1181             maFontSize(),
1182             maFontStretch(FontStretch_notset),
1183             maFontStyle(FontStyle_notset),
1184             maFontVariant(FontVariant_notset),
1185             maFontWeight(FontWeight_notset),
1186             maTextAlign(TextAlign_notset),
1187             maTextDecoration(TextDecoration_notset),
1188             maTextAnchor(TextAnchor_notset),
1189             maColor(),
1190             maOpacity(1.0),
1191             maClipPathXLink(),
1192             maMaskXLink(),
1193             maMarkerStartXLink(),
1194             mpMarkerStartXLink(0),
1195             maMarkerMidXLink(),
1196             mpMarkerMidXLink(0),
1197             maMarkerEndXLink(),
1198             mpMarkerEndXLink(0),
1199             maFillRule(true),
1200             maFillRuleSet(false),
1201             mbIsClipPathContent(SVGTokenClipPathNode == mrOwner.getType()),
1202             mbClipRule(true)
1203         {
1204             if(!mbIsClipPathContent)
1205             {
1206                 const SvgStyleAttributes* pParentStyle = getParentStyle();
1207
1208                 if(pParentStyle)
1209                 {
1210                     mbIsClipPathContent = pParentStyle->mbIsClipPathContent;
1211                 }
1212             }
1213         }
1214
1215         SvgStyleAttributes::~SvgStyleAttributes()
1216         {
1217         }
1218
1219         void SvgStyleAttributes::parseStyleAttribute(const rtl::OUString& /*rTokenName*/, SVGToken aSVGToken, const rtl::OUString& aContent)
1220         {
1221             switch(aSVGToken)
1222             {
1223                 case SVGTokenFill:
1224                 {
1225                     SvgPaint aSvgPaint;
1226                     rtl::OUString aURL;
1227
1228                     if(readSvgPaint(aContent, aSvgPaint, aURL))
1229                     {
1230                         setFill(aSvgPaint);
1231                     }
1232                     else if(aURL.getLength())
1233                     {
1234                         const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(aURL);
1235
1236                         if(pNode)
1237                         {
1238                             if(SVGTokenLinearGradient == pNode->getType() || SVGTokenRadialGradient  == pNode->getType())
1239                             {
1240                                 setSvgGradientNodeFill(static_cast< const SvgGradientNode* >(pNode));
1241                             }
1242                             else if(SVGTokenPattern == pNode->getType())
1243                             {
1244                                 setSvgPatternNodeFill(static_cast< const SvgPatternNode* >(pNode));
1245                             }
1246                         }
1247                     }
1248                     break;
1249                 }
1250                 case SVGTokenFillOpacity:
1251                 {
1252                     SvgNumber aNum;
1253
1254                     if(readSingleNumber(aContent, aNum))
1255                     {
1256                         if(aNum.isPositive())
1257                         {
1258                             setFillOpacity(aNum);
1259                         }
1260                     }
1261                     break;
1262                 }
1263                 case SVGTokenFillRule:
1264                 {
1265                     if(aContent.getLength())
1266                     {
1267                         if(aContent.match(commonStrings::aStrNonzero))
1268                         {
1269                             maFillRule = true;
1270                             maFillRuleSet = true;
1271                         }
1272                         else if(aContent.match(commonStrings::aStrEvenOdd))
1273                         {
1274                             maFillRule = false;
1275                             maFillRuleSet = true;
1276                         }
1277                     }
1278                     break;
1279                 }
1280                 case SVGTokenStroke:
1281                 {
1282                     SvgPaint aSvgPaint;
1283                     rtl::OUString aURL;
1284
1285                     if(readSvgPaint(aContent, aSvgPaint, aURL))
1286                     {
1287                         setStroke(aSvgPaint);
1288                     }
1289                     else if(aURL.getLength())
1290                     {
1291                         const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(aURL);
1292
1293                         if(pNode)
1294                         {
1295                             if(SVGTokenLinearGradient == pNode->getType() || SVGTokenRadialGradient  == pNode->getType())
1296                             {
1297                                 setSvgGradientNodeStroke(static_cast< const SvgGradientNode* >(pNode));
1298                             }
1299                             else if(SVGTokenPattern == pNode->getType())
1300                             {
1301                                 setSvgPatternNodeStroke(static_cast< const SvgPatternNode* >(pNode));
1302                             }
1303                         }
1304                     }
1305                     break;
1306                 }
1307                 case SVGTokenStrokeDasharray:
1308                 {
1309                     if(aContent.getLength())
1310                     {
1311                         SvgNumberVector aVector;
1312
1313                         if(readSvgNumberVector(aContent, aVector))
1314                         {
1315                             setStrokeDasharray(aVector);
1316                         }
1317                     }
1318                     break;
1319                 }
1320                 case SVGTokenStrokeDashoffset:
1321                 {
1322                     SvgNumber aNum;
1323
1324                     if(readSingleNumber(aContent, aNum))
1325                     {
1326                         if(aNum.isPositive())
1327                         {
1328                             setStrokeDashOffset(aNum);
1329                         }
1330                     }
1331                     break;
1332                 }
1333                 case SVGTokenStrokeLinecap:
1334                 {
1335                     if(aContent.getLength())
1336                     {
1337                         static rtl::OUString aStrButt(rtl::OUString::createFromAscii("butt"));
1338                         static rtl::OUString aStrRound(rtl::OUString::createFromAscii("round"));
1339                         static rtl::OUString aStrSquare(rtl::OUString::createFromAscii("square"));
1340
1341                         if(aContent.match(aStrButt))
1342                         {
1343                             setStrokeLinecap(StrokeLinecap_butt);
1344                         }
1345                         else if(aContent.match(aStrRound))
1346                         {
1347                             setStrokeLinecap(StrokeLinecap_round);
1348                         }
1349                         else if(aContent.match(aStrSquare))
1350                         {
1351                             setStrokeLinecap(StrokeLinecap_square);
1352                         }
1353                     }
1354                     break;
1355                 }
1356                 case SVGTokenStrokeLinejoin:
1357                 {
1358                     if(aContent.getLength())
1359                     {
1360                         static rtl::OUString aStrMiter(rtl::OUString::createFromAscii("miter"));
1361                         static rtl::OUString aStrRound(rtl::OUString::createFromAscii("round"));
1362                         static rtl::OUString aStrBevel(rtl::OUString::createFromAscii("bevel"));
1363
1364                         if(aContent.match(aStrMiter))
1365                         {
1366                             setStrokeLinejoin(StrokeLinejoin_miter);
1367                         }
1368                         else if(aContent.match(aStrRound))
1369                         {
1370                             setStrokeLinejoin(StrokeLinejoin_round);
1371                         }
1372                         else if(aContent.match(aStrBevel))
1373                         {
1374                             setStrokeLinejoin(StrokeLinejoin_bevel);
1375                         }
1376                     }
1377                     break;
1378                 }
1379                 case SVGTokenStrokeMiterlimit:
1380                 {
1381                     SvgNumber aNum;
1382
1383                     if(readSingleNumber(aContent, aNum))
1384                     {
1385                         if(aNum.isPositive())
1386                         {
1387                             setStrokeMiterLimit(aNum);
1388                         }
1389                     }
1390                     break;
1391                 }
1392                 case SVGTokenStrokeOpacity:
1393                 {
1394                     SvgNumber aNum;
1395
1396                     if(readSingleNumber(aContent, aNum))
1397                     {
1398                         if(aNum.isPositive())
1399                         {
1400                             setStrokeOpacity(aNum);
1401                         }
1402                     }
1403                     break;
1404                 }
1405                 case SVGTokenStrokeWidth:
1406                 {
1407                     SvgNumber aNum;
1408
1409                     if(readSingleNumber(aContent, aNum))
1410                     {
1411                         if(aNum.isPositive())
1412                         {
1413                             setStrokeWidth(aNum);
1414                         }
1415                     }
1416                     break;
1417                 }
1418                 case SVGTokenStopColor:
1419                 {
1420                     SvgPaint aSvgPaint;
1421                     rtl::OUString aURL;
1422
1423                     if(readSvgPaint(aContent, aSvgPaint, aURL))
1424                     {
1425                         setStopColor(aSvgPaint);
1426                     }
1427                     break;
1428                 }
1429                 case SVGTokenStopOpacity:
1430                 {
1431                     SvgNumber aNum;
1432
1433                     if(readSingleNumber(aContent, aNum))
1434                     {
1435                         if(aNum.isPositive())
1436                         {
1437                             setStopOpacity(aNum);
1438                         }
1439                     }
1440                     break;
1441                 }
1442                 case SVGTokenFont:
1443                 {
1444                     break;
1445                 }
1446                 case SVGTokenFontFamily:
1447                 {
1448                     SvgStringVector aSvgStringVector;
1449
1450                     if(readSvgStringVector(aContent, aSvgStringVector))
1451                     {
1452                         setFontFamily(aSvgStringVector);
1453                     }
1454                     break;
1455                 }
1456                 case SVGTokenFontSize:
1457                 {
1458                     SvgNumber aNum;
1459
1460                     if(readSingleNumber(aContent, aNum))
1461                     {
1462                         setFontSize(aNum);
1463                     }
1464                     break;
1465                 }
1466                 case SVGTokenFontSizeAdjust:
1467                 {
1468                     break;
1469                 }
1470                 case SVGTokenFontStretch:
1471                 {
1472                     if(aContent.getLength())
1473                     {
1474                         static rtl::OUString aStrNormal(rtl::OUString::createFromAscii("normal"));
1475                         static rtl::OUString aStrWider(rtl::OUString::createFromAscii("wider"));
1476                         static rtl::OUString aStrNarrower(rtl::OUString::createFromAscii("narrower"));
1477                         static rtl::OUString aStrUltra_condensed(rtl::OUString::createFromAscii("ultra-condensed"));
1478                         static rtl::OUString aStrExtra_condensed(rtl::OUString::createFromAscii("extra-condensed"));
1479                         static rtl::OUString aStrCondensed(rtl::OUString::createFromAscii("condensed"));
1480                         static rtl::OUString aStrSemi_condensed(rtl::OUString::createFromAscii("semi-condensed"));
1481                         static rtl::OUString aStrSemi_expanded(rtl::OUString::createFromAscii("semi-expanded"));
1482                         static rtl::OUString aStrExpanded(rtl::OUString::createFromAscii("expanded"));
1483                         static rtl::OUString aStrExtra_expanded(rtl::OUString::createFromAscii("extra-expanded"));
1484                         static rtl::OUString aStrUltra_expanded(rtl::OUString::createFromAscii("ultra-expanded"));
1485
1486                         if(aContent.match(aStrNormal))
1487                         {
1488                             setFontStretch(FontStretch_normal);
1489                         }
1490                         else if(aContent.match(aStrWider))
1491                         {
1492                             setFontStretch(FontStretch_wider);
1493                         }
1494                         else if(aContent.match(aStrNarrower))
1495                         {
1496                             setFontStretch(FontStretch_narrower);
1497                         }
1498                         else if(aContent.match(aStrUltra_condensed))
1499                         {
1500                             setFontStretch(FontStretch_ultra_condensed);
1501                         }
1502                         else if(aContent.match(aStrExtra_condensed))
1503                         {
1504                             setFontStretch(FontStretch_extra_condensed);
1505                         }
1506                         else if(aContent.match(aStrCondensed))
1507                         {
1508                             setFontStretch(FontStretch_condensed);
1509                         }
1510                         else if(aContent.match(aStrSemi_condensed))
1511                         {
1512                             setFontStretch(FontStretch_semi_condensed);
1513                         }
1514                         else if(aContent.match(aStrSemi_expanded))
1515                         {
1516                             setFontStretch(FontStretch_semi_expanded);
1517                         }
1518                         else if(aContent.match(aStrExpanded))
1519                         {
1520                             setFontStretch(FontStretch_expanded);
1521                         }
1522                         else if(aContent.match(aStrExtra_expanded))
1523                         {
1524                             setFontStretch(FontStretch_extra_expanded);
1525                         }
1526                         else if(aContent.match(aStrUltra_expanded))
1527                         {
1528                             setFontStretch(FontStretch_ultra_expanded);
1529                         }
1530                     }
1531                     break;
1532                 }
1533                 case SVGTokenFontStyle:
1534                 {
1535                     if(aContent.getLength())
1536                     {
1537                         static rtl::OUString aStrNormal(rtl::OUString::createFromAscii("normal"));
1538                         static rtl::OUString aStrItalic(rtl::OUString::createFromAscii("italic"));
1539                         static rtl::OUString aStrOblique(rtl::OUString::createFromAscii("oblique"));
1540
1541                         if(aContent.match(aStrNormal))
1542                         {
1543                             setFontStyle(FontStyle_normal);
1544                         }
1545                         else if(aContent.match(aStrItalic))
1546                         {
1547                             setFontStyle(FontStyle_italic);
1548                         }
1549                         else if(aContent.match(aStrOblique))
1550                         {
1551                             setFontStyle(FontStyle_oblique);
1552                         }
1553                     }
1554                     break;
1555                 }
1556                 case SVGTokenFontVariant:
1557                 {
1558                     if(aContent.getLength())
1559                     {
1560                         static rtl::OUString aStrNormal(rtl::OUString::createFromAscii("normal"));
1561                         static rtl::OUString aStrSmallCaps(rtl::OUString::createFromAscii("small-caps"));
1562
1563                         if(aContent.match(aStrNormal))
1564                         {
1565                             setFontVariant(FontVariant_normal);
1566                         }
1567                         else if(aContent.match(aStrSmallCaps))
1568                         {
1569                             setFontVariant(FontVariant_small_caps);
1570                         }
1571                     }
1572                     break;
1573                 }
1574                 case SVGTokenFontWeight:
1575                 {
1576                     if(aContent.getLength())
1577                     {
1578                         static rtl::OUString aStrNormal(rtl::OUString::createFromAscii("normal"));
1579                         static rtl::OUString aStrBold(rtl::OUString::createFromAscii("bold"));
1580                         static rtl::OUString aStrBolder(rtl::OUString::createFromAscii("bolder"));
1581                         static rtl::OUString aStrLighter(rtl::OUString::createFromAscii("lighter"));
1582                         static rtl::OUString aStr100(rtl::OUString::createFromAscii("100"));
1583                         static rtl::OUString aStr200(rtl::OUString::createFromAscii("200"));
1584                         static rtl::OUString aStr300(rtl::OUString::createFromAscii("300"));
1585                         static rtl::OUString aStr400(rtl::OUString::createFromAscii("400"));
1586                         static rtl::OUString aStr500(rtl::OUString::createFromAscii("500"));
1587                         static rtl::OUString aStr600(rtl::OUString::createFromAscii("600"));
1588                         static rtl::OUString aStr700(rtl::OUString::createFromAscii("700"));
1589                         static rtl::OUString aStr800(rtl::OUString::createFromAscii("800"));
1590                         static rtl::OUString aStr900(rtl::OUString::createFromAscii("900"));
1591
1592                         if(aContent.match(aStr100))
1593                         {
1594                             setFontWeight(FontWeight_100);
1595                         }
1596                         else if(aContent.match(aStr200))
1597                         {
1598                             setFontWeight(FontWeight_200);
1599                         }
1600                         else if(aContent.match(aStr300))
1601                         {
1602                             setFontWeight(FontWeight_300);
1603                         }
1604                         else if(aContent.match(aStr400) || aContent.match(aStrNormal))
1605                         {
1606                             setFontWeight(FontWeight_400);
1607                         }
1608                         else if(aContent.match(aStr500))
1609                         {
1610                             setFontWeight(FontWeight_500);
1611                         }
1612                         else if(aContent.match(aStr600))
1613                         {
1614                             setFontWeight(FontWeight_600);
1615                         }
1616                         else if(aContent.match(aStr700) || aContent.match(aStrBold))
1617                         {
1618                             setFontWeight(FontWeight_700);
1619                         }
1620                         else if(aContent.match(aStr800))
1621                         {
1622                             setFontWeight(FontWeight_800);
1623                         }
1624                         else if(aContent.match(aStr900))
1625                         {
1626                             setFontWeight(FontWeight_900);
1627                         }
1628                         else if(aContent.match(aStrBolder))
1629                         {
1630                             setFontWeight(FontWeight_bolder);
1631                         }
1632                         else if(aContent.match(aStrLighter))
1633                         {
1634                             setFontWeight(FontWeight_lighter);
1635                         }
1636                     }
1637                     break;
1638                 }
1639                 case SVGTokenDirection:
1640                 {
1641                     break;
1642                 }
1643                 case SVGTokenLetterSpacing:
1644                 {
1645                     break;
1646                 }
1647                 case SVGTokenTextDecoration:
1648                 {
1649                     if(aContent.getLength())
1650                     {
1651                         static rtl::OUString aStrNone(rtl::OUString::createFromAscii("none"));
1652                         static rtl::OUString aStrUnderline(rtl::OUString::createFromAscii("underline"));
1653                         static rtl::OUString aStrOverline(rtl::OUString::createFromAscii("overline"));
1654                         static rtl::OUString aStrLineThrough(rtl::OUString::createFromAscii("line-through"));
1655                         static rtl::OUString aStrBlink(rtl::OUString::createFromAscii("blink"));
1656
1657                         if(aContent.match(aStrNone))
1658                         {
1659                             setTextDecoration(TextDecoration_none);
1660                         }
1661                         else if(aContent.match(aStrUnderline))
1662                         {
1663                             setTextDecoration(TextDecoration_underline);
1664                         }
1665                         else if(aContent.match(aStrOverline))
1666                         {
1667                             setTextDecoration(TextDecoration_overline);
1668                         }
1669                         else if(aContent.match(aStrLineThrough))
1670                         {
1671                             setTextDecoration(TextDecoration_line_through);
1672                         }
1673                         else if(aContent.match(aStrBlink))
1674                         {
1675                             setTextDecoration(TextDecoration_blink);
1676                         }
1677                     }
1678                     break;
1679                 }
1680                 case SVGTokenUnicodeBidi:
1681                 {
1682                     break;
1683                 }
1684                 case SVGTokenWordSpacing:
1685                 {
1686                     break;
1687                 }
1688                 case SVGTokenTextAnchor:
1689                 {
1690                     if(aContent.getLength())
1691                     {
1692                         static rtl::OUString aStrStart(rtl::OUString::createFromAscii("start"));
1693                         static rtl::OUString aStrMiddle(rtl::OUString::createFromAscii("middle"));
1694                         static rtl::OUString aStrEnd(rtl::OUString::createFromAscii("end"));
1695
1696                         if(aContent.match(aStrStart))
1697                         {
1698                             setTextAnchor(TextAnchor_start);
1699                         }
1700                         else if(aContent.match(aStrMiddle))
1701                         {
1702                             setTextAnchor(TextAnchor_middle);
1703                         }
1704                         else if(aContent.match(aStrEnd))
1705                         {
1706                             setTextAnchor(TextAnchor_end);
1707                         }
1708                     }
1709                     break;
1710                 }
1711                 case SVGTokenTextAlign:
1712                 {
1713                     if(aContent.getLength())
1714                     {
1715                         static rtl::OUString aStrLeft(rtl::OUString::createFromAscii("left"));
1716                         static rtl::OUString aStrRight(rtl::OUString::createFromAscii("right"));
1717                         static rtl::OUString aStrCenter(rtl::OUString::createFromAscii("center"));
1718                         static rtl::OUString aStrJustify(rtl::OUString::createFromAscii("justify"));
1719
1720                         if(aContent.match(aStrLeft))
1721                         {
1722                             setTextAlign(TextAlign_left);
1723                         }
1724                         else if(aContent.match(aStrRight))
1725                         {
1726                             setTextAlign(TextAlign_right);
1727                         }
1728                         else if(aContent.match(aStrCenter))
1729                         {
1730                             setTextAlign(TextAlign_center);
1731                         }
1732                         else if(aContent.match(aStrJustify))
1733                         {
1734                             setTextAlign(TextAlign_justify);
1735                         }
1736                     }
1737                     break;
1738                 }
1739                 case SVGTokenColor:
1740                 {
1741                     SvgPaint aSvgPaint;
1742                     rtl::OUString aURL;
1743
1744                     if(readSvgPaint(aContent, aSvgPaint, aURL))
1745                     {
1746                         setColor(aSvgPaint);
1747                     }
1748                     break;
1749                 }
1750                 case SVGTokenOpacity:
1751                 {
1752                     SvgNumber aNum;
1753
1754                     if(readSingleNumber(aContent, aNum))
1755                     {
1756                         setOpacity(SvgNumber(basegfx::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet()));
1757                     }
1758                     break;
1759                 }
1760                 case SVGTokenClipPathProperty:
1761                 {
1762                     readLocalUrl(aContent, maClipPathXLink);
1763                     break;
1764                 }
1765                 case SVGTokenMask:
1766                 {
1767                     readLocalUrl(aContent, maMaskXLink);
1768                     break;
1769                 }
1770                 case SVGTokenClipRule:
1771                 {
1772                     if(aContent.getLength())
1773                     {
1774                         if(aContent.match(commonStrings::aStrNonzero))
1775                         {
1776                             mbClipRule = true;
1777                         }
1778                         else if(aContent.match(commonStrings::aStrEvenOdd))
1779                         {
1780                             mbClipRule = false;
1781                         }
1782                     }
1783                     break;
1784                 }
1785                 case SVGTokenMarker:
1786                 {
1787                     readLocalUrl(aContent, maMarkerEndXLink);
1788                     maMarkerStartXLink = maMarkerMidXLink = maMarkerEndXLink;
1789                     break;
1790                 }
1791                 case SVGTokenMarkerStart:
1792                 {
1793                     readLocalUrl(aContent, maMarkerStartXLink);
1794                     break;
1795                 }
1796                 case SVGTokenMarkerMid:
1797                 {
1798                     readLocalUrl(aContent, maMarkerMidXLink);
1799                     break;
1800                 }
1801                 case SVGTokenMarkerEnd:
1802                 {
1803                     readLocalUrl(aContent, maMarkerEndXLink);
1804                     break;
1805                 }
1806                 default:
1807                 {
1808                     break;
1809                 }
1810             }
1811         }
1812
1813         const basegfx::BColor* SvgStyleAttributes::getFill() const
1814         {
1815             if(mbIsClipPathContent)
1816             {
1817                 static basegfx::BColor aBlack(0.0, 0.0, 0.0);
1818
1819                 return &aBlack;
1820             }
1821             else if(maFill.isSet())
1822             {
1823                 if(maFill.isCurrent())
1824                 {
1825                     return getColor();
1826                 }
1827                 else if(maFill.isOn())
1828                 {
1829                     return &maFill.getBColor();
1830                 }
1831             }
1832             else
1833             {
1834                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1835
1836                 if(pSvgStyleAttributes)
1837                 {
1838                     return pSvgStyleAttributes->getFill();
1839                 }
1840             }
1841
1842             return 0;
1843         }
1844
1845         const basegfx::BColor* SvgStyleAttributes::getStroke() const
1846         {
1847             if(mbIsClipPathContent)
1848             {
1849                 return 0;
1850             }
1851             else if(maStroke.isSet())
1852             {
1853                 if(maStroke.isCurrent())
1854                 {
1855                     return getColor();
1856                 }
1857                 else if(maStroke.isOn())
1858                 {
1859                     return &maStroke.getBColor();
1860                 }
1861             }
1862             else
1863             {
1864                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1865
1866                 if(pSvgStyleAttributes)
1867                 {
1868                     return pSvgStyleAttributes->getStroke();
1869                 }
1870             }
1871
1872             return 0;
1873         }
1874
1875         const basegfx::BColor& SvgStyleAttributes::getStopColor() const
1876         {
1877             if(maStopColor.isCurrent())
1878             {
1879                 return *getColor();
1880             }
1881             else
1882             {
1883                 return maStopColor.getBColor();
1884             }
1885         }
1886
1887         const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeFill() const
1888         {
1889             if(mbIsClipPathContent)
1890             {
1891                 return 0;
1892             }
1893             else if(mpSvgGradientNodeFill)
1894             {
1895                 return mpSvgGradientNodeFill;
1896             }
1897             else
1898             {
1899                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1900
1901                 if(pSvgStyleAttributes)
1902                 {
1903                     return pSvgStyleAttributes->getSvgGradientNodeFill();
1904                 }
1905             }
1906
1907             return 0;
1908         }
1909
1910         const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeStroke() const
1911         {
1912             if(mbIsClipPathContent)
1913             {
1914                 return 0;
1915             }
1916             else if(mpSvgGradientNodeStroke)
1917             {
1918                 return mpSvgGradientNodeStroke;
1919             }
1920             else
1921             {
1922                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1923
1924                 if(pSvgStyleAttributes)
1925                 {
1926                     return pSvgStyleAttributes->getSvgGradientNodeStroke();
1927                 }
1928             }
1929
1930             return 0;
1931         }
1932
1933         const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeFill() const
1934         {
1935             if(mbIsClipPathContent)
1936             {
1937                 return 0;
1938             }
1939             else if(mpSvgPatternNodeFill)
1940             {
1941                 return mpSvgPatternNodeFill;
1942             }
1943             else
1944             {
1945                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1946
1947                 if(pSvgStyleAttributes)
1948                 {
1949                     return pSvgStyleAttributes->getSvgPatternNodeFill();
1950                 }
1951             }
1952
1953             return 0;
1954         }
1955
1956         const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeStroke() const
1957         {
1958             if(mbIsClipPathContent)
1959             {
1960                 return 0;
1961             }
1962             else if(mpSvgPatternNodeStroke)
1963             {
1964                 return mpSvgPatternNodeStroke;
1965             }
1966             else
1967             {
1968                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1969
1970                 if(pSvgStyleAttributes)
1971                 {
1972                     return pSvgStyleAttributes->getSvgPatternNodeStroke();
1973                 }
1974             }
1975
1976             return 0;
1977         }
1978
1979         const SvgNumber SvgStyleAttributes::getStrokeWidth() const
1980         {
1981             if(mbIsClipPathContent)
1982             {
1983                 return SvgNumber(0.0);
1984             }
1985             else if(maStrokeWidth.isSet())
1986             {
1987                 return maStrokeWidth;
1988             }
1989
1990             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
1991
1992             if(pSvgStyleAttributes)
1993             {
1994                 return pSvgStyleAttributes->getStrokeWidth();
1995             }
1996
1997             // default is 1
1998             return SvgNumber(1.0);
1999         }
2000
2001         const SvgNumber SvgStyleAttributes::getStopOpacity() const
2002         {
2003             if(maStopOpacity.isSet())
2004             {
2005                 return maStopOpacity;
2006             }
2007
2008             // default is 1
2009             return SvgNumber(1.0);
2010         }
2011
2012         const SvgNumber SvgStyleAttributes::getFillOpacity() const
2013         {
2014             if(mbIsClipPathContent)
2015             {
2016                 return SvgNumber(1.0);
2017             }
2018             else if(maFillOpacity.isSet())
2019             {
2020                 return maFillOpacity;
2021             }
2022
2023             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2024
2025             if(pSvgStyleAttributes)
2026             {
2027                 return pSvgStyleAttributes->getFillOpacity();
2028             }
2029
2030             // default is 1
2031             return SvgNumber(1.0);
2032         }
2033
2034         bool SvgStyleAttributes::getFillRule() const
2035         {
2036             if(maFillRuleSet)
2037             {
2038                 return maFillRule;
2039             }
2040
2041             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2042
2043             if(pSvgStyleAttributes)
2044             {
2045                 return pSvgStyleAttributes->getFillRule();
2046             }
2047
2048             // default is NonZero
2049             return true;
2050         }
2051
2052         const SvgNumberVector& SvgStyleAttributes::getStrokeDasharray() const
2053         {
2054             if(!maStrokeDasharray.empty())
2055             {
2056                 return maStrokeDasharray;
2057             }
2058
2059             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2060
2061             if(pSvgStyleAttributes)
2062             {
2063                 return pSvgStyleAttributes->getStrokeDasharray();
2064             }
2065
2066             // default empty
2067             return maStrokeDasharray;
2068         }
2069
2070         const SvgNumber SvgStyleAttributes::getStrokeDashOffset() const
2071         {
2072             if(maStrokeDashOffset.isSet())
2073             {
2074                 return maStrokeDashOffset;
2075             }
2076
2077             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2078
2079             if(pSvgStyleAttributes)
2080             {
2081                 return pSvgStyleAttributes->getStrokeDashOffset();
2082             }
2083
2084             // default is 0
2085             return SvgNumber(0.0);
2086         }
2087
2088         StrokeLinecap SvgStyleAttributes::getStrokeLinecap() const
2089         {
2090             if(maStrokeLinecap != StrokeLinecap_notset)
2091             {
2092                 return maStrokeLinecap;
2093             }
2094
2095             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2096
2097             if(pSvgStyleAttributes)
2098             {
2099                 return pSvgStyleAttributes->getStrokeLinecap();
2100             }
2101
2102             // default is StrokeLinecap_butt
2103             return StrokeLinecap_butt;
2104         }
2105
2106         StrokeLinejoin SvgStyleAttributes::getStrokeLinejoin() const
2107         {
2108             if(maStrokeLinejoin != StrokeLinejoin_notset)
2109             {
2110                 return maStrokeLinejoin;
2111             }
2112
2113             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2114
2115             if(pSvgStyleAttributes)
2116             {
2117                 return pSvgStyleAttributes->getStrokeLinejoin();
2118             }
2119
2120             // default is StrokeLinejoin_butt
2121             return StrokeLinejoin_miter;
2122         }
2123
2124         const SvgNumber SvgStyleAttributes::getStrokeMiterLimit() const
2125         {
2126             if(maStrokeMiterLimit.isSet())
2127             {
2128                 return maStrokeMiterLimit;
2129             }
2130
2131             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2132
2133             if(pSvgStyleAttributes)
2134             {
2135                 return pSvgStyleAttributes->getStrokeMiterLimit();
2136             }
2137
2138             // default is 4
2139             return SvgNumber(4.0);
2140         }
2141
2142         const SvgNumber SvgStyleAttributes::getStrokeOpacity() const
2143         {
2144             if(maStrokeOpacity.isSet())
2145             {
2146                 return maStrokeOpacity;
2147             }
2148
2149             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2150
2151             if(pSvgStyleAttributes)
2152             {
2153                 return pSvgStyleAttributes->getStrokeOpacity();
2154             }
2155
2156             // default is 1
2157             return SvgNumber(1.0);
2158         }
2159
2160         const SvgStringVector& SvgStyleAttributes::getFontFamily() const
2161         {
2162             if(!maFontFamily.empty())
2163             {
2164                 return maFontFamily;
2165             }
2166
2167             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2168
2169             if(pSvgStyleAttributes)
2170             {
2171                 return pSvgStyleAttributes->getFontFamily();
2172             }
2173
2174             // default is empty
2175             return maFontFamily;
2176         }
2177
2178         const SvgNumber SvgStyleAttributes::getFontSize() const
2179         {
2180             if(maFontSize.isSet())
2181             {
2182                 return maFontSize;
2183             }
2184
2185             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2186
2187             if(pSvgStyleAttributes)
2188             {
2189                 return pSvgStyleAttributes->getFontSize();
2190             }
2191
2192             // default is 'medium'
2193             return SvgNumber(12.0);
2194         }
2195
2196         FontStretch SvgStyleAttributes::getFontStretch() const
2197         {
2198             if(maFontStretch != FontStretch_notset)
2199             {
2200                 if(FontStretch_wider != maFontStretch && FontStretch_narrower != maFontStretch)
2201                 {
2202                     return maFontStretch;
2203                 }
2204             }
2205
2206             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2207
2208             if(pSvgStyleAttributes)
2209             {
2210                 FontStretch aInherited = pSvgStyleAttributes->getFontStretch();
2211
2212                 if(FontStretch_wider == maFontStretch)
2213                 {
2214                     aInherited = getWider(aInherited);
2215                 }
2216                 else if(FontStretch_narrower == maFontStretch)
2217                 {
2218                     aInherited = getNarrower(aInherited);
2219                 }
2220
2221                 return aInherited;
2222             }
2223
2224             // default is FontStretch_normal
2225             return FontStretch_normal;
2226         }
2227
2228         FontStyle SvgStyleAttributes::getFontStyle() const
2229         {
2230             if(maFontStyle != FontStyle_notset)
2231             {
2232                 return maFontStyle;
2233             }
2234
2235             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2236
2237             if(pSvgStyleAttributes)
2238             {
2239                 return pSvgStyleAttributes->getFontStyle();
2240             }
2241
2242             // default is FontStyle_normal
2243             return FontStyle_normal;
2244         }
2245
2246         FontWeight SvgStyleAttributes::getFontWeight() const
2247         {
2248             if(maFontWeight != FontWeight_notset)
2249             {
2250                 if(FontWeight_bolder != maFontWeight && FontWeight_lighter != maFontWeight)
2251                 {
2252                     return maFontWeight;
2253                 }
2254             }
2255
2256             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2257
2258             if(pSvgStyleAttributes)
2259             {
2260                 FontWeight aInherited = pSvgStyleAttributes->getFontWeight();
2261
2262                 if(FontWeight_bolder == maFontWeight)
2263                 {
2264                     aInherited = getBolder(aInherited);
2265                 }
2266                 else if(FontWeight_lighter == maFontWeight)
2267                 {
2268                     aInherited = getLighter(aInherited);
2269                 }
2270
2271                 return aInherited;
2272             }
2273
2274             // default is FontWeight_400 (FontWeight_normal)
2275             return FontWeight_400;
2276         }
2277
2278         TextAlign SvgStyleAttributes::getTextAlign() const
2279         {
2280             if(maTextAlign != TextAlign_notset)
2281             {
2282                 return maTextAlign;
2283             }
2284
2285             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2286
2287             if(pSvgStyleAttributes)
2288             {
2289                 return pSvgStyleAttributes->getTextAlign();
2290             }
2291
2292             // default is TextAlign_left
2293             return TextAlign_left;
2294         }
2295
2296         const SvgStyleAttributes* SvgStyleAttributes::getTextDecorationDefiningSvgStyleAttributes() const
2297         {
2298             if(maTextDecoration != TextDecoration_notset)
2299             {
2300                 return this;
2301             }
2302
2303             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2304
2305             if(pSvgStyleAttributes)
2306             {
2307                 return pSvgStyleAttributes->getTextDecorationDefiningSvgStyleAttributes();
2308             }
2309
2310             // default is 0
2311             return 0;
2312         }
2313
2314         TextDecoration SvgStyleAttributes::getTextDecoration() const
2315         {
2316             const SvgStyleAttributes* pDefining = getTextDecorationDefiningSvgStyleAttributes();
2317
2318             if(pDefining)
2319             {
2320                 return pDefining->maTextDecoration;
2321             }
2322             else
2323             {
2324                 // default is TextDecoration_none
2325                 return TextDecoration_none;
2326             }
2327         }
2328
2329         TextAnchor SvgStyleAttributes::getTextAnchor() const
2330         {
2331             if(maTextAnchor != TextAnchor_notset)
2332             {
2333                 return maTextAnchor;
2334             }
2335
2336             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2337
2338             if(pSvgStyleAttributes)
2339             {
2340                 return pSvgStyleAttributes->getTextAnchor();
2341             }
2342
2343             // default is TextAnchor_start
2344             return TextAnchor_start;
2345         }
2346
2347         const basegfx::BColor* SvgStyleAttributes::getColor() const
2348         {
2349             if(maColor.isSet())
2350             {
2351                 if(maColor.isCurrent())
2352                 {
2353                     OSL_ENSURE(false, "Svg error: current color uses current color (!)");
2354                     return 0;
2355                 }
2356                 else if(maColor.isOn())
2357                 {
2358                     return &maColor.getBColor();
2359                 }
2360             }
2361             else
2362             {
2363                 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2364
2365                 if(pSvgStyleAttributes)
2366                 {
2367                     return pSvgStyleAttributes->getColor();
2368                 }
2369             }
2370
2371             return 0;
2372         }
2373
2374         const rtl::OUString SvgStyleAttributes::getMarkerStartXLink() const
2375         {
2376             if(maMarkerStartXLink.getLength())
2377             {
2378                 return maMarkerStartXLink;
2379             }
2380
2381             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2382
2383             if(pSvgStyleAttributes)
2384             {
2385                 return pSvgStyleAttributes->getMarkerStartXLink();
2386             }
2387
2388             return rtl::OUString();
2389         }
2390
2391         const SvgMarkerNode* SvgStyleAttributes::accessMarkerStartXLink() const
2392         {
2393             if(!mpMarkerStartXLink)
2394             {
2395                 const rtl::OUString aMarker(getMarkerStartXLink());
2396
2397                 if(aMarker.getLength())
2398                 {
2399                     const_cast< SvgStyleAttributes* >(this)->mpMarkerStartXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerStartXLink()));
2400                 }
2401             }
2402
2403             return mpMarkerStartXLink;
2404         }
2405
2406         const rtl::OUString SvgStyleAttributes::getMarkerMidXLink() const
2407         {
2408             if(maMarkerMidXLink.getLength())
2409             {
2410                 return maMarkerMidXLink;
2411             }
2412
2413             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2414
2415             if(pSvgStyleAttributes)
2416             {
2417                 return pSvgStyleAttributes->getMarkerMidXLink();
2418             }
2419
2420             return rtl::OUString();
2421         }
2422
2423         const SvgMarkerNode* SvgStyleAttributes::accessMarkerMidXLink() const
2424         {
2425             if(!mpMarkerMidXLink)
2426             {
2427                 const rtl::OUString aMarker(getMarkerMidXLink());
2428
2429                 if(aMarker.getLength())
2430                 {
2431                     const_cast< SvgStyleAttributes* >(this)->mpMarkerMidXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerMidXLink()));
2432                 }
2433             }
2434
2435             return mpMarkerMidXLink;
2436         }
2437
2438         const rtl::OUString SvgStyleAttributes::getMarkerEndXLink() const
2439         {
2440             if(maMarkerEndXLink.getLength())
2441             {
2442                 return maMarkerEndXLink;
2443             }
2444
2445             const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2446
2447             if(pSvgStyleAttributes)
2448             {
2449                 return pSvgStyleAttributes->getMarkerEndXLink();
2450             }
2451
2452             return rtl::OUString();
2453         }
2454
2455         const SvgMarkerNode* SvgStyleAttributes::accessMarkerEndXLink() const
2456         {
2457             if(!mpMarkerEndXLink)
2458             {
2459                 const rtl::OUString aMarker(getMarkerEndXLink());
2460
2461                 if(aMarker.getLength())
2462                 {
2463                     const_cast< SvgStyleAttributes* >(this)->mpMarkerEndXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerEndXLink()));
2464                 }
2465             }
2466
2467             return mpMarkerEndXLink;
2468         }
2469
2470     } // end of namespace svgreader
2471 } // end of namespace svgio
2472
2473 //////////////////////////////////////////////////////////////////////////////
2474 // eof
2475
2476 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */