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