?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 7.2.5.1
[LibreOffice.git] / svgio / source / svgreader / svgstyleattributes.cxx
blob8ad08b0414e292eb165c3f2fd888f61c7cf5fca2
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 <sal/config.h>
21
22 #include <algorithm>
23
24 #include <svgstyleattributes.hxx>
25 #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
26 #include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
27 #include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
28 #include <svgnode.hxx>
29 #include <svgdocument.hxx>
30 #include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
31 #include <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 <svgclippathnode.hxx>
38 #include <svgmasknode.hxx>
39 #include <basegfx/polygon/b2dpolypolygontools.hxx>
40 #include <svgmarkernode.hxx>
41 #include <svgpatternnode.hxx>
42 #include <drawinglayer/primitive2d/patternfillprimitive2d.hxx>
43 #include <basegfx/polygon/b2dpolygontools.hxx>
44 #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
45 #include <drawinglayer/primitive2d/pagehierarchyprimitive2d.hxx>
46
47 const int nStyleDepthLimit = 1024;
48
49 namespace svgio::svgreader
50 {
51 static basegfx::B2DLineJoin StrokeLinejoinToB2DLineJoin(StrokeLinejoin aStrokeLinejoin)
52 {
53 if(StrokeLinejoin::round == aStrokeLinejoin)
54 {
55 return basegfx::B2DLineJoin::Round;
56 }
57 else if(StrokeLinejoin::bevel == aStrokeLinejoin)
58 {
59 return basegfx::B2DLineJoin::Bevel;
60 }
61
62 return basegfx::B2DLineJoin::Miter;
63 }
64
65 static css::drawing::LineCap StrokeLinecapToDrawingLineCap(StrokeLinecap aStrokeLinecap)
66 {
67 switch(aStrokeLinecap)
68 {
69 default: /* StrokeLinecap::notset, StrokeLinecap::butt */
70 {
71 return css::drawing::LineCap_BUTT;
72 }
73 case StrokeLinecap::round:
74 {
75 return css::drawing::LineCap_ROUND;
76 }
77 case StrokeLinecap::square:
78 {
79 return css::drawing::LineCap_SQUARE;
80 }
81 }
82 }
83
84 FontStretch getWider(FontStretch aSource)
85 {
86 switch(aSource)
87 {
88 case FontStretch::ultra_condensed: aSource = FontStretch::extra_condensed; break;
89 case FontStretch::extra_condensed: aSource = FontStretch::condensed; break;
90 case FontStretch::condensed: aSource = FontStretch::semi_condensed; break;
91 case FontStretch::semi_condensed: aSource = FontStretch::normal; break;
92 case FontStretch::normal: aSource = FontStretch::semi_expanded; break;
93 case FontStretch::semi_expanded: aSource = FontStretch::expanded; break;
94 case FontStretch::expanded: aSource = FontStretch::extra_expanded; break;
95 case FontStretch::extra_expanded: aSource = FontStretch::ultra_expanded; break;
96 default: break;
97 }
98
99 return aSource;
100 }
101
102 FontStretch getNarrower(FontStretch aSource)
103 {
104 switch(aSource)
105 {
106 case FontStretch::extra_condensed: aSource = FontStretch::ultra_condensed; break;
107 case FontStretch::condensed: aSource = FontStretch::extra_condensed; break;
108 case FontStretch::semi_condensed: aSource = FontStretch::condensed; break;
109 case FontStretch::normal: aSource = FontStretch::semi_condensed; break;
110 case FontStretch::semi_expanded: aSource = FontStretch::normal; break;
111 case FontStretch::expanded: aSource = FontStretch::semi_expanded; break;
112 case FontStretch::extra_expanded: aSource = FontStretch::expanded; break;
113 case FontStretch::ultra_expanded: aSource = FontStretch::extra_expanded; break;
114 default: break;
115 }
116
117 return aSource;
118 }
119
120 FontWeight getBolder(FontWeight aSource)
121 {
122 switch(aSource)
123 {
124 case FontWeight::N100: aSource = FontWeight::N200; break;
125 case FontWeight::N200: aSource = FontWeight::N300; break;
126 case FontWeight::N300: aSource = FontWeight::N400; break;
127 case FontWeight::N400: aSource = FontWeight::N500; break;
128 case FontWeight::N500: aSource = FontWeight::N600; break;
129 case FontWeight::N600: aSource = FontWeight::N700; break;
130 case FontWeight::N700: aSource = FontWeight::N800; break;
131 case FontWeight::N800: aSource = FontWeight::N900; break;
132 default: break;
133 }
134
135 return aSource;
136 }
137
138 FontWeight getLighter(FontWeight aSource)
139 {
140 switch(aSource)
141 {
142 case FontWeight::N200: aSource = FontWeight::N100; break;
143 case FontWeight::N300: aSource = FontWeight::N200; break;
144 case FontWeight::N400: aSource = FontWeight::N300; break;
145 case FontWeight::N500: aSource = FontWeight::N400; break;
146 case FontWeight::N600: aSource = FontWeight::N500; break;
147 case FontWeight::N700: aSource = FontWeight::N600; break;
148 case FontWeight::N800: aSource = FontWeight::N700; break;
149 case FontWeight::N900: aSource = FontWeight::N800; break;
150 default: break;
151 }
152
153 return aSource;
154 }
155
156 ::FontWeight getVclFontWeight(FontWeight aSource)
157 {
158 ::FontWeight nRetval(WEIGHT_NORMAL);
159
160 switch(aSource)
161 {
162 case FontWeight::N100: nRetval = WEIGHT_ULTRALIGHT; break;
163 case FontWeight::N200: nRetval = WEIGHT_LIGHT; break;
164 case FontWeight::N300: nRetval = WEIGHT_SEMILIGHT; break;
165 case FontWeight::N400: nRetval = WEIGHT_NORMAL; break;
166 case FontWeight::N500: nRetval = WEIGHT_MEDIUM; break;
167 case FontWeight::N600: nRetval = WEIGHT_SEMIBOLD; break;
168 case FontWeight::N700: nRetval = WEIGHT_BOLD; break;
169 case FontWeight::N800: nRetval = WEIGHT_ULTRABOLD; break;
170 case FontWeight::N900: nRetval = WEIGHT_BLACK; break;
171 default: break;
172 }
173
174 return nRetval;
175 }
176
177 void SvgStyleAttributes::readCssStyle(const OUString& rCandidate)
178 {
179 const sal_Int32 nLen(rCandidate.getLength());
180 sal_Int32 nPos(0);
181
182 while(nPos < nLen)
183 {
184 // get TokenName
185 OUStringBuffer aTokenName;
186 skip_char(rCandidate, u' ', nPos, nLen);
187 copyString(rCandidate, nPos, aTokenName, nLen);
188
189 if (aTokenName.isEmpty())
190 {
191 // if no TokenName advance one by force to avoid death loop, continue
192 OSL_ENSURE(false, "Could not interpret on current position, advancing one byte (!)");
193 nPos++;
194 continue;
195 }
196
197 // get TokenValue
198 OUStringBuffer aTokenValue;
199 skip_char(rCandidate, u' ', u':', nPos, nLen);
200 copyToLimiter(rCandidate, u';', nPos, aTokenValue, nLen);
201 skip_char(rCandidate, u' ', u';', nPos, nLen);
202
203 if (aTokenValue.isEmpty())
204 {
205 // no value - continue
206 continue;
207 }
208
209 // generate OUStrings
210 const OUString aOUTokenName(aTokenName.makeStringAndClear());
211 OUString aOUTokenValue(aTokenValue.makeStringAndClear());
212
213 // check for '!important' CssStyle mark, currently not supported
214 // but needs to be extracted for correct parsing
215 OUString aTokenImportant("!important");
216 const sal_Int32 nIndexTokenImportant(aOUTokenValue.indexOf(aTokenImportant));
217
218 if(-1 != nIndexTokenImportant)
219 {
220 // if there currently just remove it and remove spaces to have the value only
221 OUString aNewOUTokenValue;
222
223 if(nIndexTokenImportant > 0)
224 {
225 // copy content before token
226 aNewOUTokenValue += aOUTokenValue.subView(0, nIndexTokenImportant);
227 }
228
229 if(aOUTokenValue.getLength() > nIndexTokenImportant + aTokenImportant.getLength())
230 {
231 // copy content after token
232 aNewOUTokenValue += aOUTokenValue.subView(nIndexTokenImportant + aTokenImportant.getLength());
233 }
234
235 // remove spaces
236 aOUTokenValue = aNewOUTokenValue.trim();
237 }
238
239 // valid token-value pair, parse it
240 parseStyleAttribute(StrToSVGToken(aOUTokenName, true), aOUTokenValue, true);
241 }
242 }
243
244 const SvgStyleAttributes* SvgStyleAttributes::getParentStyle() const
245 {
246 if(getCssStyleParent())
247 {
248 return getCssStyleParent();
249 }
250
251 if(mrOwner.supportsParentStyle() && mrOwner.getParent())
252 {
253 return mrOwner.getParent()->getSvgStyleAttributes();
254 }
255
256 return nullptr;
257 }
258
259 void SvgStyleAttributes::add_text(
260 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
261 drawinglayer::primitive2d::Primitive2DContainer const & rSource) const
262 {
263 if(rSource.empty())
264 return;
265
266 // at this point the primitives in rSource are of type TextSimplePortionPrimitive2D
267 // or TextDecoratedPortionPrimitive2D and have the Fill Color (pAttributes->getFill())
268 // set. When another fill is used and also evtl. stroke is set it gets necessary to
269 // dismantle to geometry and add needed primitives
270 const basegfx::BColor* pFill = getFill();
271 const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
272 const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
273 const basegfx::BColor* pStroke = getStroke();
274 const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
275 const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
276 basegfx::B2DPolyPolygon aMergedArea;
277
278 if(pFillGradient || pFillPattern || pStroke || pStrokeGradient || pStrokePattern)
279 {
280 // text geometry is needed, create
281 // use neutral ViewInformation and create LineGeometryExtractor2D
282 const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
283 drawinglayer::processor2d::TextAsPolygonExtractor2D aExtractor(aViewInformation2D);
284
285 // process
286 aExtractor.process(rSource);
287
288 // get results
289 const drawinglayer::processor2d::TextAsPolygonDataNodeVector& rResult = aExtractor.getTarget();
290 const sal_uInt32 nResultCount(rResult.size());
291 basegfx::B2DPolyPolygonVector aTextFillVector;
292 aTextFillVector.reserve(nResultCount);
293
294 for(sal_uInt32 a(0); a < nResultCount; a++)
295 {
296 const drawinglayer::processor2d::TextAsPolygonDataNode& rCandidate = rResult[a];
297
298 if(rCandidate.getIsFilled())
299 {
300 aTextFillVector.push_back(rCandidate.getB2DPolyPolygon());
301 }
302 }
303
304 if(!aTextFillVector.empty())
305 {
306 aMergedArea = basegfx::utils::mergeToSinglePolyPolygon(aTextFillVector);
307 }
308 }
309
310 const bool bStrokeUsed(pStroke || pStrokeGradient || pStrokePattern);
311
312 // add fill. Use geometry even for simple color fill when stroke
313 // is used, else text rendering and the geometry-based stroke will
314 // normally not really match optically due to diverse system text
315 // renderers
316 if(aMergedArea.count() && (pFillGradient || pFillPattern || bStrokeUsed))
317 {
318 // create text fill content based on geometry
319 add_fill(aMergedArea, rTarget, aMergedArea.getB2DRange());
320 }
321 else if(pFill)
322 {
323 // add the already prepared primitives for single color fill
324 rTarget.append(rSource);
325 }
326
327 // add stroke
328 if(aMergedArea.count() && bStrokeUsed)
329 {
330 // create text stroke content
331 add_stroke(aMergedArea, rTarget, aMergedArea.getB2DRange());
332 }
333 }
334
335 void SvgStyleAttributes::add_fillGradient(
336 const basegfx::B2DPolyPolygon& rPath,
337 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
338 const SvgGradientNode& rFillGradient,
339 const basegfx::B2DRange& rGeoRange) const
340 {
341 // create fill content
342 drawinglayer::primitive2d::SvgGradientEntryVector aSvgGradientEntryVector;
343
344 // get the color stops
345 rFillGradient.collectGradientEntries(aSvgGradientEntryVector);
346
347 if(aSvgGradientEntryVector.empty())
348 return;
349
350 basegfx::B2DHomMatrix aGeoToUnit;
351 basegfx::B2DHomMatrix aGradientTransform;
352
353 if(rFillGradient.getGradientTransform())
354 {
355 aGradientTransform = *rFillGradient.getGradientTransform();
356 }
357
358 if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
359 {
360 aGeoToUnit.translate(-rGeoRange.getMinX(), -rGeoRange.getMinY());
361 aGeoToUnit.scale(1.0 / rGeoRange.getWidth(), 1.0 / rGeoRange.getHeight());
362 }
363
364 if(SVGToken::LinearGradient == rFillGradient.getType())
365 {
366 basegfx::B2DPoint aStart(0.0, 0.0);
367 basegfx::B2DPoint aEnd(1.0, 0.0);
368
369 if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
370 {
371 // all possible units
372 aStart.setX(rFillGradient.getX1().solve(mrOwner, NumberType::xcoordinate));
373 aStart.setY(rFillGradient.getY1().solve(mrOwner, NumberType::ycoordinate));
374 aEnd.setX(rFillGradient.getX2().solve(mrOwner, NumberType::xcoordinate));
375 aEnd.setY(rFillGradient.getY2().solve(mrOwner, NumberType::ycoordinate));
376 }
377 else
378 {
379 // fractions or percent relative to object bounds
380 const SvgNumber X1(rFillGradient.getX1());
381 const SvgNumber Y1(rFillGradient.getY1());
382 const SvgNumber X2(rFillGradient.getX2());
383 const SvgNumber Y2(rFillGradient.getY2());
384
385 aStart.setX(SvgUnit::percent == X1.getUnit() ? X1.getNumber() * 0.01 : X1.getNumber());
386 aStart.setY(SvgUnit::percent == Y1.getUnit() ? Y1.getNumber() * 0.01 : Y1.getNumber());
387 aEnd.setX(SvgUnit::percent == X2.getUnit() ? X2.getNumber() * 0.01 : X2.getNumber());
388 aEnd.setY(SvgUnit::percent == Y2.getUnit() ? Y2.getNumber() * 0.01 : Y2.getNumber());
389 }
390
391 if(!aGeoToUnit.isIdentity())
392 {
393 aStart *= aGeoToUnit;
394 aEnd *= aGeoToUnit;
395 }
396
397 rTarget.push_back(
398 new drawinglayer::primitive2d::SvgLinearGradientPrimitive2D(
399 aGradientTransform,
400 rPath,
401 aSvgGradientEntryVector,
402 aStart,
403 aEnd,
404 SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
405 rFillGradient.getSpreadMethod()));
406 }
407 else
408 {
409 basegfx::B2DPoint aStart(0.5, 0.5);
410 basegfx::B2DPoint aFocal;
411 double fRadius(0.5);
412 const SvgNumber* pFx = rFillGradient.getFx();
413 const SvgNumber* pFy = rFillGradient.getFy();
414 const bool bFocal(pFx || pFy);
415
416 if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
417 {
418 // all possible units
419 aStart.setX(rFillGradient.getCx().solve(mrOwner, NumberType::xcoordinate));
420 aStart.setY(rFillGradient.getCy().solve(mrOwner, NumberType::ycoordinate));
421 fRadius = rFillGradient.getR().solve(mrOwner);
422
423 if(bFocal)
424 {
425 aFocal.setX(pFx ? pFx->solve(mrOwner, NumberType::xcoordinate) : aStart.getX());
426 aFocal.setY(pFy ? pFy->solve(mrOwner, NumberType::ycoordinate) : aStart.getY());
427 }
428 }
429 else
430 {
431 // fractions or percent relative to object bounds
432 const SvgNumber Cx(rFillGradient.getCx());
433 const SvgNumber Cy(rFillGradient.getCy());
434 const SvgNumber R(rFillGradient.getR());
435
436 aStart.setX(SvgUnit::percent == Cx.getUnit() ? Cx.getNumber() * 0.01 : Cx.getNumber());
437 aStart.setY(SvgUnit::percent == Cy.getUnit() ? Cy.getNumber() * 0.01 : Cy.getNumber());
438 fRadius = (SvgUnit::percent == R.getUnit()) ? R.getNumber() * 0.01 : R.getNumber();
439
440 if(bFocal)
441 {
442 aFocal.setX(pFx ? (SvgUnit::percent == pFx->getUnit() ? pFx->getNumber() * 0.01 : pFx->getNumber()) : aStart.getX());
443 aFocal.setY(pFy ? (SvgUnit::percent == pFy->getUnit() ? pFy->getNumber() * 0.01 : pFy->getNumber()) : aStart.getY());
444 }
445 }
446
447 if(!aGeoToUnit.isIdentity())
448 {
449 aStart *= aGeoToUnit;
450 fRadius = (aGeoToUnit * basegfx::B2DVector(fRadius, 0.0)).getLength();
451
452 if(bFocal)
453 {
454 aFocal *= aGeoToUnit;
455 }
456 }
457
458 rTarget.push_back(
459 new drawinglayer::primitive2d::SvgRadialGradientPrimitive2D(
460 aGradientTransform,
461 rPath,
462 aSvgGradientEntryVector,
463 aStart,
464 fRadius,
465 SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
466 rFillGradient.getSpreadMethod(),
467 bFocal ? &aFocal : nullptr));
468 }
469 }
470
471 void SvgStyleAttributes::add_fillPatternTransform(
472 const basegfx::B2DPolyPolygon& rPath,
473 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
474 const SvgPatternNode& rFillPattern,
475 const basegfx::B2DRange& rGeoRange) const
476 {
477 // prepare fill polyPolygon with given pattern, check for patternTransform
478 if(rFillPattern.getPatternTransform() && !rFillPattern.getPatternTransform()->isIdentity())
479 {
480 // PatternTransform is active; Handle by filling the inverse transformed
481 // path and back-transforming the result
482 basegfx::B2DPolyPolygon aPath(rPath);
483 basegfx::B2DHomMatrix aInv(*rFillPattern.getPatternTransform());
484 drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
485
486 aInv.invert();
487 aPath.transform(aInv);
488 add_fillPattern(aPath, aNewTarget, rFillPattern, aPath.getB2DRange());
489
490 if(!aNewTarget.empty())
491 {
492 rTarget.push_back(
493 new drawinglayer::primitive2d::TransformPrimitive2D(
494 *rFillPattern.getPatternTransform(),
495 aNewTarget));
496 }
497 }
498 else
499 {
500 // no patternTransform, create fillPattern directly
501 add_fillPattern(rPath, rTarget, rFillPattern, rGeoRange);
502 }
503 }
504
505 void SvgStyleAttributes::add_fillPattern(
506 const basegfx::B2DPolyPolygon& rPath,
507 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
508 const SvgPatternNode& rFillPattern,
509 const basegfx::B2DRange& rGeoRange) const
510 {
511 // fill polyPolygon with given pattern
512 const drawinglayer::primitive2d::Primitive2DContainer& rPrimitives = rFillPattern.getPatternPrimitives();
513
514 if(rPrimitives.empty())
515 return;
516
517 double fTargetWidth(rGeoRange.getWidth());
518 double fTargetHeight(rGeoRange.getHeight());
519
520 if(fTargetWidth <= 0.0 || fTargetHeight <= 0.0)
521 return;
522
523 // get relative values from pattern
524 double fX(0.0);
525 double fY(0.0);
526 double fW(0.0);
527 double fH(0.0);
528
529 rFillPattern.getValuesRelative(fX, fY, fW, fH, rGeoRange, mrOwner);
530
531 if(fW <= 0.0 || fH <= 0.0)
532 return;
533
534 // build the reference range relative to the rGeoRange
535 const basegfx::B2DRange aReferenceRange(fX, fY, fX + fW, fY + fH);
536
537 // find out how the content is mapped to the reference range
538 basegfx::B2DHomMatrix aMapPrimitivesToUnitRange;
539 const basegfx::B2DRange* pViewBox = rFillPattern.getViewBox();
540
541 if(pViewBox)
542 {
543 // use viewBox/preserveAspectRatio
544 const SvgAspectRatio& rRatio = rFillPattern.getSvgAspectRatio();
545 const basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
546
547 if(rRatio.isSet())
548 {
549 // let mapping be created from SvgAspectRatio
550 aMapPrimitivesToUnitRange = rRatio.createMapping(aUnitRange, *pViewBox);
551 }
552 else
553 {
554 // choose default mapping
555 aMapPrimitivesToUnitRange = SvgAspectRatio::createLinearMapping(aUnitRange, *pViewBox);
556 }
557 }
558 else
559 {
560 // use patternContentUnits
561 const SvgUnits aPatternContentUnits(rFillPattern.getPatternContentUnits() ? *rFillPattern.getPatternContentUnits() : SvgUnits::userSpaceOnUse);
562
563 if (SvgUnits::userSpaceOnUse == aPatternContentUnits)
564 {
565 // create relative mapping to unit coordinates
566 aMapPrimitivesToUnitRange.scale(1.0 / (fW * fTargetWidth), 1.0 / (fH * fTargetHeight));
567 }
568 else
569 {
570 aMapPrimitivesToUnitRange.scale(1.0 / fW, 1.0 / fH);
571 }
572 }
573
574 // apply aMapPrimitivesToUnitRange to content when used
575 drawinglayer::primitive2d::Primitive2DContainer aPrimitives(rPrimitives);
576
577 if(!aMapPrimitivesToUnitRange.isIdentity())
578 {
579 const drawinglayer::primitive2d::Primitive2DReference xRef(
580 new drawinglayer::primitive2d::TransformPrimitive2D(
581 aMapPrimitivesToUnitRange,
582 aPrimitives));
583
584 aPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xRef };
585 }
586
587 // embed in PatternFillPrimitive2D
588 rTarget.push_back(
589 new drawinglayer::primitive2d::PatternFillPrimitive2D(
590 rPath,
591 aPrimitives,
592 aReferenceRange));
593 }
594
595 void SvgStyleAttributes::add_fill(
596 const basegfx::B2DPolyPolygon& rPath,
597 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
598 const basegfx::B2DRange& rGeoRange) const
599 {
600 const basegfx::BColor* pFill = getFill();
601 const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
602 const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
603
604 if(!(pFill || pFillGradient || pFillPattern))
605 return;
606
607 const double fFillOpacity(getFillOpacity().solve(mrOwner));
608
609 if(!basegfx::fTools::more(fFillOpacity, 0.0))
610 return;
611
612 drawinglayer::primitive2d::Primitive2DContainer aNewFill;
613
614 if(pFillGradient)
615 {
616 // create fill content with SVG gradient primitive
617 add_fillGradient(rPath, aNewFill, *pFillGradient, rGeoRange);
618 }
619 else if(pFillPattern)
620 {
621 // create fill content with SVG pattern primitive
622 add_fillPatternTransform(rPath, aNewFill, *pFillPattern, rGeoRange);
623 }
624 else // if(pFill)
625 {
626 // create fill content
627 aNewFill.resize(1);
628 aNewFill[0] = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
629 rPath,
630 *pFill);
631 }
632
633 if(aNewFill.empty())
634 return;
635
636 if(basegfx::fTools::less(fFillOpacity, 1.0))
637 {
638 // embed in UnifiedTransparencePrimitive2D
639 rTarget.push_back(
640 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
641 aNewFill,
642 1.0 - fFillOpacity));
643 }
644 else
645 {
646 // append
647 rTarget.append(aNewFill);
648 }
649 }
650
651 void SvgStyleAttributes::add_stroke(
652 const basegfx::B2DPolyPolygon& rPath,
653 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
654 const basegfx::B2DRange& rGeoRange) const
655 {
656 const basegfx::BColor* pStroke = getStroke();
657 const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
658 const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
659
660 if(!(pStroke || pStrokeGradient || pStrokePattern))
661 return;
662
663 drawinglayer::primitive2d::Primitive2DContainer aNewStroke;
664 const double fStrokeOpacity(getStrokeOpacity().solve(mrOwner));
665
666 if(!basegfx::fTools::more(fStrokeOpacity, 0.0))
667 return;
668
669 // get stroke width; SVG does not use 0.0 == hairline, so 0.0 is no line at all
670 const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
671
672 if(!basegfx::fTools::more(fStrokeWidth, 0.0))
673 return;
674
675 drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
676
677 // if we have a line with two identical points it is not really a line,
678 // but used by SVG sometimes to paint a single dot.In that case, create
679 // the geometry for a single dot
680 if(1 == rPath.count())
681 {
682 const basegfx::B2DPolygon& aSingle(rPath.getB2DPolygon(0));
683
684 if(2 == aSingle.count() && aSingle.getB2DPoint(0).equal(aSingle.getB2DPoint(1)))
685 {
686 aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
687 basegfx::B2DPolyPolygon(
688 basegfx::utils::createPolygonFromCircle(
689 aSingle.getB2DPoint(0),
690 fStrokeWidth * (1.44 * 0.5))),
691 pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0));
692 }
693 }
694
695 if(!aNewLinePrimitive.is())
696 {
697 // get LineJoin, LineCap and stroke array
698 const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
699 const css::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
700 ::std::vector< double > aDashArray;
701
702 if(!getStrokeDasharray().empty())
703 {
704 aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner);
705 }
706
707 // convert svg:stroke-miterlimit to LineAttrute:mfMiterMinimumAngle
708 // The default needs to be set explicitly, because svg default <> Draw default
709 double fMiterMinimumAngle;
710 if (getStrokeMiterLimit().isSet())
711 {
712 fMiterMinimumAngle = 2.0 * asin(1.0/getStrokeMiterLimit().getNumber());
713 }
714 else
715 {
716 fMiterMinimumAngle = 2.0 * asin(0.25); // 1.0/default 4.0
717 }
718
719 // todo: Handle getStrokeDashOffset()
720
721 // prepare line attribute
722 const drawinglayer::attribute::LineAttribute aLineAttribute(
723 pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
724 fStrokeWidth,
725 aB2DLineJoin,
726 aLineCap,
727 fMiterMinimumAngle);
728
729 if(aDashArray.empty())
730 {
731 aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
732 rPath,
733 aLineAttribute);
734 }
735 else
736 {
737 const drawinglayer::attribute::StrokeAttribute aStrokeAttribute(aDashArray);
738
739 aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
740 rPath,
741 aLineAttribute,
742 aStrokeAttribute);
743 }
744 }
745
746 if(pStrokeGradient || pStrokePattern)
747 {
748 // put primitive into Primitive2DReference and Primitive2DSequence
749 const drawinglayer::primitive2d::Primitive2DContainer aSeq { aNewLinePrimitive };
750
751 // use neutral ViewInformation and create LineGeometryExtractor2D
752 const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
753 drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
754
755 // process
756 aExtractor.process(aSeq);
757
758 // check for fill rsults
759 const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
760
761 if(!rLineFillVector.empty())
762 {
763 const basegfx::B2DPolyPolygon aMergedArea(
764 basegfx::utils::mergeToSinglePolyPolygon(
765 rLineFillVector));
766
767 if(aMergedArea.count())
768 {
769 if(pStrokeGradient)
770 {
771 // create fill content with SVG gradient primitive. Use original GeoRange,
772 // e.g. from circle without LineWidth
773 add_fillGradient(aMergedArea, aNewStroke, *pStrokeGradient, rGeoRange);
774 }
775 else // if(pStrokePattern)
776 {
777 // create fill content with SVG pattern primitive. Use GeoRange
778 // from the expanded data, e.g. circle with extended geo by half linewidth
779 add_fillPatternTransform(aMergedArea, aNewStroke, *pStrokePattern, aMergedArea.getB2DRange());
780 }
781 }
782 }
783 }
784 else // if(pStroke)
785 {
786 aNewStroke.push_back(aNewLinePrimitive);
787 }
788
789 if(aNewStroke.empty())
790 return;
791
792 if(basegfx::fTools::less(fStrokeOpacity, 1.0))
793 {
794 // embed in UnifiedTransparencePrimitive2D
795 rTarget.push_back(
796 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
797 aNewStroke,
798 1.0 - fStrokeOpacity));
799 }
800 else
801 {
802 // append
803 rTarget.append(aNewStroke);
804 }
805 }
806
807 bool SvgStyleAttributes::prepare_singleMarker(
808 drawinglayer::primitive2d::Primitive2DContainer& rMarkerPrimitives,
809 basegfx::B2DHomMatrix& rMarkerTransform,
810 basegfx::B2DRange& rClipRange,
811 const SvgMarkerNode& rMarker) const
812 {
813 // reset return values
814 rMarkerTransform.identity();
815 rClipRange.reset();
816
817 // get marker primitive representation
818 rMarkerPrimitives = rMarker.getMarkerPrimitives();
819
820 if(!rMarkerPrimitives.empty())
821 {
822 basegfx::B2DRange aPrimitiveRange(0.0, 0.0, 1.0, 1.0);
823 const basegfx::B2DRange* pViewBox = rMarker.getViewBox();
824
825 if(pViewBox)
826 {
827 aPrimitiveRange = *pViewBox;
828 }
829
830 if(aPrimitiveRange.getWidth() > 0.0 && aPrimitiveRange.getHeight() > 0.0)
831 {
832 double fTargetWidth(rMarker.getMarkerWidth().isSet() ? rMarker.getMarkerWidth().solve(mrOwner, NumberType::xcoordinate) : 3.0);
833 double fTargetHeight(rMarker.getMarkerHeight().isSet() ? rMarker.getMarkerHeight().solve(mrOwner, NumberType::xcoordinate) : 3.0);
834 const bool bStrokeWidth(SvgMarkerNode::MarkerUnits::strokeWidth == rMarker.getMarkerUnits());
835 const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
836
837 if(bStrokeWidth)
838 {
839 // relative to strokeWidth
840 fTargetWidth *= fStrokeWidth;
841 fTargetHeight *= fStrokeWidth;
842 }
843
844 if(fTargetWidth > 0.0 && fTargetHeight > 0.0)
845 {
846 // create mapping
847 const basegfx::B2DRange aTargetRange(0.0, 0.0, fTargetWidth, fTargetHeight);
848 const SvgAspectRatio& rRatio = rMarker.getSvgAspectRatio();
849
850 if(rRatio.isSet())
851 {
852 // let mapping be created from SvgAspectRatio
853 rMarkerTransform = rRatio.createMapping(aTargetRange, aPrimitiveRange);
854
855 if(rRatio.isMeetOrSlice())
856 {
857 // need to clip
858 rClipRange = aPrimitiveRange;
859 }
860 }
861 else
862 {
863 if(!pViewBox)
864 {
865 if(bStrokeWidth)
866 {
867 // adapt to strokewidth if needed
868 rMarkerTransform.scale(fStrokeWidth, fStrokeWidth);
869 }
870 }
871 else
872 {
873 // choose default mapping
874 rMarkerTransform = SvgAspectRatio::createLinearMapping(aTargetRange, aPrimitiveRange);
875 }
876 }
877
878 // get and apply reference point. Initially it's in marker local coordinate system
879 basegfx::B2DPoint aRefPoint(
880 rMarker.getRefX().isSet() ? rMarker.getRefX().solve(mrOwner, NumberType::xcoordinate) : 0.0,
881 rMarker.getRefY().isSet() ? rMarker.getRefY().solve(mrOwner, NumberType::ycoordinate) : 0.0);
882
883 // apply MarkerTransform to have it in mapped coordinates
884 aRefPoint *= rMarkerTransform;
885
886 // apply by moving RepPoint to (0.0)
887 rMarkerTransform.translate(-aRefPoint.getX(), -aRefPoint.getY());
888
889 return true;
890 }
891 }
892 }
893
894 return false;
895 }
896
897 void SvgStyleAttributes::add_markers(
898 const basegfx::B2DPolyPolygon& rPath,
899 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
900 const basegfx::utils::PointIndexSet* pHelpPointIndices) const
901 {
902 // try to access linked markers
903 const SvgMarkerNode* pStart = accessMarkerStartXLink();
904 const SvgMarkerNode* pMid = accessMarkerMidXLink();
905 const SvgMarkerNode* pEnd = accessMarkerEndXLink();
906
907 if(!(pStart || pMid || pEnd))
908 return;
909
910 const sal_uInt32 nSubPathCount(rPath.count());
911
912 if(!nSubPathCount)
913 return;
914
915 // remember prepared marker; pStart, pMid and pEnd may all be equal when
916 // only 'marker' was used instead of 'marker-start', 'marker-mid' or 'marker-end',
917 // see 'case SVGToken::Marker' in this file; thus in this case only one common
918 // marker in primitive form will be prepared
919 const SvgMarkerNode* pPrepared = nullptr;
920
921 // values for the prepared marker, results of prepare_singleMarker
922 drawinglayer::primitive2d::Primitive2DContainer aPreparedMarkerPrimitives;
923 basegfx::B2DHomMatrix aPreparedMarkerTransform;
924 basegfx::B2DRange aPreparedMarkerClipRange;
925
926 for (sal_uInt32 a(0); a < nSubPathCount; a++)
927 {
928 // iterate over sub-paths
929 const basegfx::B2DPolygon& aSubPolygonPath(rPath.getB2DPolygon(a));
930 const sal_uInt32 nSubPolygonPointCount(aSubPolygonPath.count());
931 const bool bSubPolygonPathIsClosed(aSubPolygonPath.isClosed());
932
933 if(nSubPolygonPointCount)
934 {
935 // for each sub-path, create one marker per point (when closed, two markers
936 // need to pe created for the 1st point)
937 const sal_uInt32 nTargetMarkerCount(bSubPolygonPathIsClosed ? nSubPolygonPointCount + 1 : nSubPolygonPointCount);
938
939 for (sal_uInt32 b(0); b < nTargetMarkerCount; b++)
940 {
941 const bool bIsFirstMarker(!a && !b);
942 const bool bIsLastMarker(nSubPathCount - 1 == a && nTargetMarkerCount - 1 == b);
943 const SvgMarkerNode* pNeeded = nullptr;
944
945 if(bIsFirstMarker)
946 {
947 // 1st point in 1st sub-polygon, use pStart
948 pNeeded = pStart;
949 }
950 else if(bIsLastMarker)
951 {
952 // last point in last sub-polygon, use pEnd
953 pNeeded = pEnd;
954 }
955 else
956 {
957 // anything in-between, use pMid
958 pNeeded = pMid;
959 }
960
961 if(pHelpPointIndices && !pHelpPointIndices->empty())
962 {
963 const basegfx::utils::PointIndexSet::const_iterator aFound(
964 pHelpPointIndices->find(basegfx::utils::PointIndex(a, b)));
965
966 if(aFound != pHelpPointIndices->end())
967 {
968 // this point is a pure helper point; do not create a marker for it
969 continue;
970 }
971 }
972
973 if(!pNeeded)
974 {
975 // no marker needs to be created for this point
976 continue;
977 }
978
979 if(pPrepared != pNeeded)
980 {
981 // if needed marker is not yet prepared, do it now
982 if(prepare_singleMarker(aPreparedMarkerPrimitives, aPreparedMarkerTransform, aPreparedMarkerClipRange, *pNeeded))
983 {
984 pPrepared = pNeeded;
985 }
986 else
987 {
988 // error: could not prepare given marker
989 OSL_ENSURE(false, "OOps, could not prepare given marker as primitives (!)");
990 pPrepared = nullptr;
991 continue;
992 }
993 }
994
995 // prepare complete transform
996 basegfx::B2DHomMatrix aCombinedTransform(aPreparedMarkerTransform);
997
998 // get rotation
999 if(pPrepared->getOrientAuto())
1000 {
1001 const sal_uInt32 nPointIndex(b % nSubPolygonPointCount);
1002
1003 // get entering and leaving tangents; this will search backward/forward
1004 // in the polygon to find tangents unequal to zero, skipping empty edges
1005 // see basegfx descriptions)
1006 // Hint: Mozilla, Inkscape and others use only leaving tangent for start marker
1007 // and entering tangent for end marker. To achieve this (if wanted) it is possible
1008 // to make the fetch of aEntering/aLeaving dependent on bIsFirstMarker/bIsLastMarker.
1009 // This is not done here, see comment 14 in task #1232379#
1010 // or http://www.w3.org/TR/SVG/painting.html#OrientAttribute
1011 basegfx::B2DVector aEntering(
1012 basegfx::utils::getTangentEnteringPoint(
1013 aSubPolygonPath,
1014 nPointIndex));
1015 basegfx::B2DVector aLeaving(
1016 basegfx::utils::getTangentLeavingPoint(
1017 aSubPolygonPath,
1018 nPointIndex));
1019 const bool bEntering(!aEntering.equalZero());
1020 const bool bLeaving(!aLeaving.equalZero());
1021
1022 if(bEntering || bLeaving)
1023 {
1024 basegfx::B2DVector aSum(0.0, 0.0);
1025
1026 if(bEntering)
1027 {
1028 aSum += aEntering.normalize();
1029 }
1030
1031 if(bLeaving)
1032 {
1033 aSum += aLeaving.normalize();
1034 }
1035
1036 if(!aSum.equalZero())
1037 {
1038 const double fAngle(atan2(aSum.getY(), aSum.getX()));
1039
1040 // apply rotation
1041 aCombinedTransform.rotate(fAngle);
1042 }
1043 }
1044 }
1045 else
1046 {
1047 // apply rotation
1048 aCombinedTransform.rotate(pPrepared->getAngle());
1049 }
1050
1051 // get and apply target position
1052 const basegfx::B2DPoint aPoint(aSubPolygonPath.getB2DPoint(b % nSubPolygonPointCount));
1053
1054 aCombinedTransform.translate(aPoint.getX(), aPoint.getY());
1055
1056 // prepare marker
1057 drawinglayer::primitive2d::Primitive2DReference xMarker(
1058 new drawinglayer::primitive2d::TransformPrimitive2D(
1059 aCombinedTransform,
1060 aPreparedMarkerPrimitives));
1061
1062 if(!aPreparedMarkerClipRange.isEmpty())
1063 {
1064 // marker needs to be clipped, it's bigger as the mapping
1065 basegfx::B2DPolyPolygon aClipPolygon(basegfx::utils::createPolygonFromRect(aPreparedMarkerClipRange));
1066
1067 aClipPolygon.transform(aCombinedTransform);
1068 xMarker = new drawinglayer::primitive2d::MaskPrimitive2D(
1069 aClipPolygon,
1070 drawinglayer::primitive2d::Primitive2DContainer { xMarker });
1071 }
1072
1073 // add marker
1074 rTarget.push_back(xMarker);
1075 }
1076 }
1077 }
1078 }
1079
1080 void SvgStyleAttributes::add_path(
1081 const basegfx::B2DPolyPolygon& rPath,
1082 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
1083 const basegfx::utils::PointIndexSet* pHelpPointIndices) const
1084 {
1085 if(!rPath.count())
1086 {
1087 // no geometry at all
1088 return;
1089 }
1090
1091 const basegfx::B2DRange aGeoRange(rPath.getB2DRange());
1092
1093 if(aGeoRange.isEmpty())
1094 {
1095 // no geometry range
1096 return;
1097 }
1098
1099 const double fOpacity(getOpacity().solve(mrOwner));
1100
1101 if(basegfx::fTools::equalZero(fOpacity))
1102 {
1103 // not visible
1104 return;
1105 }
1106
1107 // check if it's a line
1108 const bool bNoWidth(basegfx::fTools::equalZero(aGeoRange.getWidth()));
1109 const bool bNoHeight(basegfx::fTools::equalZero(aGeoRange.getHeight()));
1110 const bool bIsTwoPointLine(1 == rPath.count()
1111 && !rPath.areControlPointsUsed()
1112 && 2 == rPath.getB2DPolygon(0).count());
1113 const bool bIsLine(bIsTwoPointLine || bNoWidth || bNoHeight);
1114
1115 if(!bIsLine)
1116 {
1117 // create fill
1118 basegfx::B2DPolyPolygon aPath(rPath);
1119 const bool bNeedToCheckClipRule(SVGToken::Path == mrOwner.getType() || SVGToken::Polygon == mrOwner.getType());
1120 const bool bClipPathIsNonzero(bNeedToCheckClipRule && mbIsClipPathContent && FillRule::nonzero == maClipRule);
1121 const bool bFillRuleIsNonzero(bNeedToCheckClipRule && !mbIsClipPathContent && FillRule::nonzero == getFillRule());
1122
1123 if(bClipPathIsNonzero || bFillRuleIsNonzero)
1124 {
1125 if(getFill() || getSvgGradientNodeFill() || getSvgPatternNodeFill()) {
1126 // nonzero is wanted, solve geometrically (see description on basegfx)
1127 // basegfx::utils::createNonzeroConform() is expensive for huge paths
1128 // and is only needed if path will be filled later on
1129 aPath = basegfx::utils::createNonzeroConform(aPath);
1130 }
1131 }
1132
1133 add_fill(aPath, rTarget, aGeoRange);
1134 }
1135
1136 // create stroke
1137 add_stroke(rPath, rTarget, aGeoRange);
1138
1139 // Svg supports markers for path, polygon, polyline and line
1140 if(SVGToken::Path == mrOwner.getType() || // path
1141 SVGToken::Polygon == mrOwner.getType() || // polygon, polyline
1142 SVGToken::Line == mrOwner.getType()) // line
1143 {
1144 // try to add markers
1145 add_markers(rPath, rTarget, pHelpPointIndices);
1146 }
1147 }
1148
1149 void SvgStyleAttributes::add_postProcess(
1150 drawinglayer::primitive2d::Primitive2DContainer& rTarget,
1151 const drawinglayer::primitive2d::Primitive2DContainer& rSource,
1152 const basegfx::B2DHomMatrix* pTransform) const
1153 {
1154 if(rSource.empty())
1155 return;
1156
1157 const double fOpacity(getOpacity().solve(mrOwner));
1158
1159 if(basegfx::fTools::equalZero(fOpacity))
1160 {
1161 return;
1162 }
1163
1164 drawinglayer::primitive2d::Primitive2DContainer aSource(rSource);
1165
1166 if(basegfx::fTools::less(fOpacity, 1.0))
1167 {
1168 // embed in UnifiedTransparencePrimitive2D
1169 const drawinglayer::primitive2d::Primitive2DReference xRef(
1170 new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
1171 aSource,
1172 1.0 - fOpacity));
1173
1174 aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
1175 }
1176
1177 if(pTransform)
1178 {
1179 // create embedding group element with transformation. This applies the given
1180 // transformation to the graphical content, but *not* to mask and/or clip (as needed)
1181 const drawinglayer::primitive2d::Primitive2DReference xRef(
1182 new drawinglayer::primitive2d::TransformPrimitive2D(
1183 *pTransform,
1184 aSource));
1185
1186 aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
1187 }
1188
1189 const SvgClipPathNode* pClip = accessClipPathXLink();
1190 while(pClip)
1191 {
1192 // #i124852# transform may be needed when SvgUnits::userSpaceOnUse
1193 pClip->apply(aSource, pTransform);
1194 pClip = pClip->getSvgStyleAttributes()->accessClipPathXLink();
1195 }
1196
1197 if(!aSource.empty()) // test again, applied clipPath may have lead to empty geometry
1198 {
1199 const SvgMaskNode* pMask = accessMaskXLink();
1200 if(pMask)
1201 {
1202 // #i124852# transform may be needed when SvgUnits::userSpaceOnUse
1203 pMask->apply(aSource, pTransform);
1204 }
1205 }
1206
1207 // This is part of the SVG import of self-written SVGs from
1208 // Draw/Impress containing multiple Slides/Pages. To be able
1209 // to later 'break' these to multiple Pages if wanted, embed
1210 // each Page-Content in an identifiable Primitive Grouping
1211 // Object.
1212 // This is the case when the current Node is a GroupNode, has
1213 // class="Page" set, has a parent that also is a GroupNode
1214 // at which class="Slide" is set.
1215 // Multiple Slides/Pages are possible for Draw and Impress.
1216 if(SVGToken::G == mrOwner.getType() && mrOwner.getClass())
1217 {
1218 const OUString aOwnerClass(*mrOwner.getClass());
1219
1220 if("Page" == aOwnerClass)
1221 {
1222 const SvgNode* pParent(mrOwner.getParent());
1223
1224 if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
1225 {
1226 const OUString aParentClass(*pParent->getClass());
1227
1228 if("Slide" == aParentClass)
1229 {
1230 // embed to grouping primitive to identify the
1231 // Slide/Page information
1232 const drawinglayer::primitive2d::Primitive2DReference xRef(
1233 new drawinglayer::primitive2d::PageHierarchyPrimitive2D(
1234 aSource));
1235
1236 aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
1237 }
1238 }
1239 }
1240 }
1241
1242 if(!aSource.empty()) // test again, applied mask may have lead to empty geometry
1243 {
1244 // append to current target
1245 rTarget.append(aSource);
1246 }
1247 }
1248
1249 SvgStyleAttributes::SvgStyleAttributes(SvgNode& rOwner)
1250 : mrOwner(rOwner),
1251 mpCssStyleParent(nullptr),
1252 maFill(),
1253 maStroke(),
1254 maStopColor(basegfx::BColor(0.0, 0.0, 0.0), true),
1255 maStrokeWidth(),
1256 maStopOpacity(),
1257 maFillOpacity(),
1258 maStrokeDasharray(),
1259 maStrokeDashOffset(),
1260 maStrokeLinecap(StrokeLinecap::notset),
1261 maStrokeLinejoin(StrokeLinejoin::notset),
1262 maStrokeMiterLimit(),
1263 maStrokeOpacity(),
1264 maFontFamily(),
1265 maFontSize(),
1266 maFontSizeNumber(),
1267 maFontStretch(FontStretch::notset),
1268 maFontStyle(FontStyle::notset),
1269 maFontWeight(FontWeight::notset),
1270 maTextAlign(TextAlign::notset),
1271 maTextDecoration(TextDecoration::notset),
1272 maTextAnchor(TextAnchor::notset),
1273 maColor(),
1274 maOpacity(),
1275 maVisibility(Visibility::notset),
1276 maTitle(),
1277 maDesc(),
1278 maClipPathXLink(),
1279 mpClipPathXLink(nullptr),
1280 maMaskXLink(),
1281 mpMaskXLink(nullptr),
1282 maMarkerStartXLink(),
1283 mpMarkerStartXLink(nullptr),
1284 maMarkerMidXLink(),
1285 mpMarkerMidXLink(nullptr),
1286 maMarkerEndXLink(),
1287 mpMarkerEndXLink(nullptr),
1288 maFillRule(FillRule::notset),
1289 maClipRule(FillRule::nonzero),
1290 maBaselineShift(BaselineShift::Baseline),
1291 maBaselineShiftNumber(0),
1292 maResolvingParent(30, 0),
1293 mbIsClipPathContent(SVGToken::ClipPathNode == mrOwner.getType()),
1294 mbStrokeDasharraySet(false)
1295 {
1296 const SvgStyleAttributes* pParentStyle = getParentStyle();
1297 if(!mbIsClipPathContent)
1298 {
1299 if(pParentStyle)
1300 {
1301 mbIsClipPathContent = pParentStyle->mbIsClipPathContent;
1302 }
1303 }
1304 }
1305
1306 SvgStyleAttributes::~SvgStyleAttributes()
1307 {
1308 }
1309
1310 void SvgStyleAttributes::parseStyleAttribute(
1311 SVGToken aSVGToken,
1312 const OUString& aContent,
1313 bool bCaseIndependent)
1314 {
1315 switch(aSVGToken)
1316 {
1317 case SVGToken::Fill:
1318 {
1319 SvgPaint aSvgPaint;
1320 OUString aURL;
1321 SvgNumber aOpacity;
1322
1323 if(readSvgPaint(aContent, aSvgPaint, aURL, bCaseIndependent, aOpacity))
1324 {
1325 setFill(aSvgPaint);
1326 if(aOpacity.isSet())
1327 {
1328 setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
1329 }
1330 }
1331 else if(!aURL.isEmpty())
1332 {
1333 maNodeFillURL = aURL;
1334 }
1335 break;
1336 }
1337 case SVGToken::FillOpacity:
1338 {
1339 SvgNumber aNum;
1340
1341 if(readSingleNumber(aContent, aNum))
1342 {
1343 maFillOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
1344 }
1345 break;
1346 }
1347 case SVGToken::FillRule:
1348 {
1349 if(!aContent.isEmpty())
1350 {
1351 if(aContent.match(commonStrings::aStrNonzero))
1352 {
1353 maFillRule = FillRule::nonzero;
1354 }
1355 else if(aContent.match(commonStrings::aStrEvenOdd))
1356 {
1357 maFillRule = FillRule::evenodd;
1358 }
1359 }
1360 break;
1361 }
1362 case SVGToken::Stroke:
1363 {
1364 SvgPaint aSvgPaint;
1365 OUString aURL;
1366 SvgNumber aOpacity;
1367
1368 if(readSvgPaint(aContent, aSvgPaint, aURL, bCaseIndependent, aOpacity))
1369 {
1370 maStroke = aSvgPaint;
1371 if(aOpacity.isSet())
1372 {
1373 setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
1374 }
1375 }
1376 else if(!aURL.isEmpty())
1377 {
1378 maNodeStrokeURL = aURL;
1379 }
1380 break;
1381 }
1382 case SVGToken::StrokeDasharray:
1383 {
1384 if(!aContent.isEmpty())
1385 {
1386 SvgNumberVector aVector;
1387
1388 if(aContent.startsWith("none"))
1389 {
1390 // #121221# The special value 'none' needs to be handled
1391 // in the sense that *when* it is set, the parent shall not
1392 // be used. Before this was only dependent on the array being
1393 // empty
1394 mbStrokeDasharraySet = true;
1395 }
1396 else if(readSvgNumberVector(aContent, aVector))
1397 {
1398 maStrokeDasharray = aVector;
1399 }
1400 }
1401 break;
1402 }
1403 case SVGToken::StrokeDashoffset:
1404 {
1405 SvgNumber aNum;
1406
1407 if(readSingleNumber(aContent, aNum))
1408 {
1409 if(aNum.isPositive())
1410 {
1411 maStrokeDashOffset = aNum;
1412 }
1413 }
1414 break;
1415 }
1416 case SVGToken::StrokeLinecap:
1417 {
1418 if(!aContent.isEmpty())
1419 {
1420 if(aContent.startsWith("butt"))
1421 {
1422 setStrokeLinecap(StrokeLinecap::butt);
1423 }
1424 else if(aContent.startsWith("round"))
1425 {
1426 setStrokeLinecap(StrokeLinecap::round);
1427 }
1428 else if(aContent.startsWith("square"))
1429 {
1430 setStrokeLinecap(StrokeLinecap::square);
1431 }
1432 }
1433 break;
1434 }
1435 case SVGToken::StrokeLinejoin:
1436 {
1437 if(!aContent.isEmpty())
1438 {
1439 if(aContent.startsWith("miter"))
1440 {
1441 setStrokeLinejoin(StrokeLinejoin::miter);
1442 }
1443 else if(aContent.startsWith("round"))
1444 {
1445 setStrokeLinejoin(StrokeLinejoin::round);
1446 }
1447 else if(aContent.startsWith("bevel"))
1448 {
1449 setStrokeLinejoin(StrokeLinejoin::bevel);
1450 }
1451 }
1452 break;
1453 }
1454 case SVGToken::StrokeMiterlimit:
1455 {
1456 SvgNumber aNum;
1457
1458 if(readSingleNumber(aContent, aNum))
1459 {
1460 if(basegfx::fTools::moreOrEqual(aNum.getNumber(), 1.0))
1461 { //readSingleNumber sets SvgUnit::px as default, if unit is missing. Correct it here.
1462 maStrokeMiterLimit = SvgNumber(aNum.getNumber(), SvgUnit::none);
1463 }
1464 }
1465 break;
1466 }
1467 case SVGToken::StrokeOpacity:
1468 {
1469
1470 SvgNumber aNum;
1471
1472 if(readSingleNumber(aContent, aNum))
1473 {
1474 maStrokeOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
1475 }
1476 break;
1477 }
1478 case SVGToken::StrokeWidth:
1479 {
1480 SvgNumber aNum;
1481
1482 if(readSingleNumber(aContent, aNum))
1483 {
1484 if(aNum.isPositive())
1485 {
1486 maStrokeWidth = aNum;
1487 }
1488 }
1489 break;
1490 }
1491 case SVGToken::StopColor:
1492 {
1493 SvgPaint aSvgPaint;
1494 OUString aURL;
1495 SvgNumber aOpacity;
1496
1497 if(readSvgPaint(aContent, aSvgPaint, aURL, bCaseIndependent, aOpacity))
1498 {
1499 maStopColor = aSvgPaint;
1500 if(aOpacity.isSet())
1501 {
1502 setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
1503 }
1504 }
1505 break;
1506 }
1507 case SVGToken::StopOpacity:
1508 {
1509 SvgNumber aNum;
1510
1511 if(readSingleNumber(aContent, aNum))
1512 {
1513 if(aNum.isPositive())
1514 {
1515 maStopOpacity = aNum;
1516 }
1517 }
1518 break;
1519 }
1520 case SVGToken::Font:
1521 {
1522 break;
1523 }
1524 case SVGToken::FontFamily:
1525 {
1526 SvgStringVector aSvgStringVector;
1527
1528 if(readSvgStringVector(aContent, aSvgStringVector))
1529 {
1530 maFontFamily = aSvgStringVector;
1531 }
1532 break;
1533 }
1534 case SVGToken::FontSize:
1535 {
1536 if(!aContent.isEmpty())
1537 {
1538 if(aContent.startsWith("xx-small"))
1539 {
1540 setFontSize(FontSize::xx_small);
1541 }
1542 else if(aContent.startsWith("x-small"))
1543 {
1544 setFontSize(FontSize::x_small);
1545 }
1546 else if(aContent.startsWith("small"))
1547 {
1548 setFontSize(FontSize::small);
1549 }
1550 else if(aContent.startsWith("smaller"))
1551 {
1552 setFontSize(FontSize::smaller);
1553 }
1554 else if(aContent.startsWith("medium"))
1555 {
1556 setFontSize(FontSize::medium);
1557 }
1558 else if(aContent.startsWith("larger"))
1559 {
1560 setFontSize(FontSize::larger);
1561 }
1562 else if(aContent.startsWith("large"))
1563 {
1564 setFontSize(FontSize::large);
1565 }
1566 else if(aContent.startsWith("x-large"))
1567 {
1568 setFontSize(FontSize::x_large);
1569 }
1570 else if(aContent.startsWith("xx-large"))
1571 {
1572 setFontSize(FontSize::xx_large);
1573 }
1574 else if(aContent.startsWith("initial"))
1575 {
1576 setFontSize(FontSize::initial);
1577 }
1578 else
1579 {
1580 SvgNumber aNum;
1581
1582 if(readSingleNumber(aContent, aNum))
1583 {
1584 maFontSizeNumber = aNum;
1585 }
1586 }
1587 }
1588 break;
1589 }
1590 case SVGToken::FontSizeAdjust:
1591 {
1592 break;
1593 }
1594 case SVGToken::FontStretch:
1595 {
1596 if(!aContent.isEmpty())
1597 {
1598 if(aContent.startsWith("normal"))
1599 {
1600 setFontStretch(FontStretch::normal);
1601 }
1602 else if(aContent.startsWith("wider"))
1603 {
1604 setFontStretch(FontStretch::wider);
1605 }
1606 else if(aContent.startsWith("narrower"))
1607 {
1608 setFontStretch(FontStretch::narrower);
1609 }
1610 else if(aContent.startsWith("ultra-condensed"))
1611 {
1612 setFontStretch(FontStretch::ultra_condensed);
1613 }
1614 else if(aContent.startsWith("extra-condensed"))
1615 {
1616 setFontStretch(FontStretch::extra_condensed);
1617 }
1618 else if(aContent.startsWith("condensed"))
1619 {
1620 setFontStretch(FontStretch::condensed);
1621 }
1622 else if(aContent.startsWith("semi-condensed"))
1623 {
1624 setFontStretch(FontStretch::semi_condensed);
1625 }
1626 else if(aContent.startsWith("semi-expanded"))
1627 {
1628 setFontStretch(FontStretch::semi_expanded);
1629 }
1630 else if(aContent.startsWith("expanded"))
1631 {
1632 setFontStretch(FontStretch::expanded);
1633 }
1634 else if(aContent.startsWith("extra-expanded"))
1635 {
1636 setFontStretch(FontStretch::extra_expanded);
1637 }
1638 else if(aContent.startsWith("ultra-expanded"))
1639 {
1640 setFontStretch(FontStretch::ultra_expanded);
1641 }
1642 }
1643 break;
1644 }
1645 case SVGToken::FontStyle:
1646 {
1647 if(!aContent.isEmpty())
1648 {
1649 if(aContent.startsWith("normal"))
1650 {
1651 setFontStyle(FontStyle::normal);
1652 }
1653 else if(aContent.startsWith("italic"))
1654 {
1655 setFontStyle(FontStyle::italic);
1656 }
1657 else if(aContent.startsWith("oblique"))
1658 {
1659 setFontStyle(FontStyle::oblique);
1660 }
1661 }
1662 break;
1663 }
1664 case SVGToken::FontVariant:
1665 {
1666 break;
1667 }
1668 case SVGToken::FontWeight:
1669 {
1670 if(!aContent.isEmpty())
1671 {
1672 if(aContent.startsWith("100"))
1673 {
1674 setFontWeight(FontWeight::N100);
1675 }
1676 else if(aContent.startsWith("200"))
1677 {
1678 setFontWeight(FontWeight::N200);
1679 }
1680 else if(aContent.startsWith("300"))
1681 {
1682 setFontWeight(FontWeight::N300);
1683 }
1684 else if(aContent.startsWith("400") || aContent.startsWith("normal"))
1685 {
1686 setFontWeight(FontWeight::N400);
1687 }
1688 else if(aContent.startsWith("500"))
1689 {
1690 setFontWeight(FontWeight::N500);
1691 }
1692 else if(aContent.startsWith("600"))
1693 {
1694 setFontWeight(FontWeight::N600);
1695 }
1696 else if(aContent.startsWith("700") || aContent.startsWith("bold"))
1697 {
1698 setFontWeight(FontWeight::N700);
1699 }
1700 else if(aContent.startsWith("800"))
1701 {
1702 setFontWeight(FontWeight::N800);
1703 }
1704 else if(aContent.startsWith("900"))
1705 {
1706 setFontWeight(FontWeight::N900);
1707 }
1708 else if(aContent.startsWith("bolder"))
1709 {
1710 setFontWeight(FontWeight::bolder);
1711 }
1712 else if(aContent.startsWith("lighter"))
1713 {
1714 setFontWeight(FontWeight::lighter);
1715 }
1716 }
1717 break;
1718 }
1719 case SVGToken::Direction:
1720 {
1721 break;
1722 }
1723 case SVGToken::LetterSpacing:
1724 {
1725 break;
1726 }
1727 case SVGToken::TextDecoration:
1728 {
1729 if(!aContent.isEmpty())
1730 {
1731 if(aContent.startsWith("none"))
1732 {
1733 setTextDecoration(TextDecoration::none);
1734 }
1735 else if(aContent.startsWith("underline"))
1736 {
1737 setTextDecoration(TextDecoration::underline);
1738 }
1739 else if(aContent.startsWith("overline"))
1740 {
1741 setTextDecoration(TextDecoration::overline);
1742 }
1743 else if(aContent.startsWith("line-through"))
1744 {
1745 setTextDecoration(TextDecoration::line_through);
1746 }
1747 else if(aContent.startsWith("blink"))
1748 {
1749 setTextDecoration(TextDecoration::blink);
1750 }
1751 }
1752 break;
1753 }
1754 case SVGToken::UnicodeBidi:
1755 {
1756 break;
1757 }
1758 case SVGToken::WordSpacing:
1759 {
1760 break;
1761 }
1762 case SVGToken::TextAnchor:
1763 {
1764 if(!aContent.isEmpty())
1765 {
1766 if(aContent.startsWith("start"))
1767 {
1768 setTextAnchor(TextAnchor::start);
1769 }
1770 else if(aContent.startsWith("middle"))
1771 {
1772 setTextAnchor(TextAnchor::middle);
1773 }
1774 else if(aContent.startsWith("end"))
1775 {
1776 setTextAnchor(TextAnchor::end);
1777 }
1778 }
1779 break;
1780 }
1781 case SVGToken::TextAlign:
1782 {
1783 if(!aContent.isEmpty())
1784 {
1785 if(aContent.startsWith("left"))
1786 {
1787 setTextAlign(TextAlign::left);
1788 }
1789 else if(aContent.startsWith("right"))
1790 {
1791 setTextAlign(TextAlign::right);
1792 }
1793 else if(aContent.startsWith("center"))
1794 {
1795 setTextAlign(TextAlign::center);
1796 }
1797 else if(aContent.startsWith("justify"))
1798 {
1799 setTextAlign(TextAlign::justify);
1800 }
1801 }
1802 break;
1803 }
1804 case SVGToken::Color:
1805 {
1806 SvgPaint aSvgPaint;
1807 OUString aURL;
1808 SvgNumber aOpacity;
1809
1810 if(readSvgPaint(aContent, aSvgPaint, aURL, bCaseIndependent, aOpacity))
1811 {
1812 maColor = aSvgPaint;
1813 if(aOpacity.isSet())
1814 {
1815 setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
1816 }
1817 }
1818 break;
1819 }
1820 case SVGToken::Opacity:
1821 {
1822 SvgNumber aNum;
1823
1824 if(readSingleNumber(aContent, aNum))
1825 {
1826 setOpacity(SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet()));
1827 }
1828 break;
1829 }
1830 case SVGToken::Visibility:
1831 {
1832 if(!aContent.isEmpty())
1833 {
1834 if(aContent.startsWith("visible"))
1835 {
1836 setVisibility(Visibility::visible);
1837 }
1838 else if(aContent.startsWith("hidden"))
1839 {
1840 setVisibility(Visibility::hidden);
1841 }
1842 else if(aContent.startsWith("collapse"))
1843 {
1844 setVisibility(Visibility::collapse);
1845 }
1846 else if(aContent.startsWith("inherit"))
1847 {
1848 setVisibility(Visibility::inherit);
1849 }
1850 }
1851 break;
1852 }
1853 case SVGToken::Title:
1854 {
1855 maTitle = aContent;
1856 break;
1857 }
1858 case SVGToken::Desc:
1859 {
1860 maDesc = aContent;
1861 break;
1862 }
1863 case SVGToken::ClipPathProperty:
1864 {
1865 readLocalUrl(aContent, maClipPathXLink);
1866 break;
1867 }
1868 case SVGToken::Mask:
1869 {
1870 readLocalUrl(aContent, maMaskXLink);
1871 break;
1872 }
1873 case SVGToken::ClipRule:
1874 {
1875 if(!aContent.isEmpty())
1876 {
1877 if(aContent.match(commonStrings::aStrNonzero))
1878 {
1879 maClipRule = FillRule::nonzero;
1880 }
1881 else if(aContent.match(commonStrings::aStrEvenOdd))
1882 {
1883 maClipRule = FillRule::evenodd;
1884 }
1885 }
1886 break;
1887 }
1888 case SVGToken::Marker:
1889 {
1890 if(bCaseIndependent)
1891 {
1892 readLocalUrl(aContent, maMarkerEndXLink);
1893 maMarkerStartXLink = maMarkerMidXLink = maMarkerEndXLink;
1894 }
1895 break;
1896 }
1897 case SVGToken::MarkerStart:
1898 {
1899 readLocalUrl(aContent, maMarkerStartXLink);
1900 break;
1901 }
1902 case SVGToken::MarkerMid:
1903 {
1904 readLocalUrl(aContent, maMarkerMidXLink);
1905 break;
1906 }
1907 case SVGToken::MarkerEnd:
1908 {
1909 readLocalUrl(aContent, maMarkerEndXLink);
1910 break;
1911 }
1912 case SVGToken::Display:
1913 {
1914 // There may be display:none statements inside of style defines, e.g. the following line:
1915 // style="display:none"
1916 // taken from a svg example; this needs to be parsed and set at the owning node. Do not call
1917 // mrOwner.parseAttribute(...) here, this would lead to a recursion
1918 if(!aContent.isEmpty())
1919 {
1920 mrOwner.setDisplay(getDisplayFromContent(aContent));
1921 }
1922 break;
1923 }
1924 case SVGToken::BaselineShift:
1925 {
1926 if(!aContent.isEmpty())
1927 {
1928 SvgNumber aNum;
1929
1930 if(aContent.startsWith("sub"))
1931 {
1932 setBaselineShift(BaselineShift::Sub);
1933 }
1934 else if(aContent.startsWith("super"))
1935 {
1936 setBaselineShift(BaselineShift::Super);
1937 }
1938 else if(readSingleNumber(aContent, aNum))
1939 {
1940 maBaselineShiftNumber = aNum;
1941
1942 if(SvgUnit::percent == aNum.getUnit())
1943 {
1944 setBaselineShift(BaselineShift::Percentage);
1945 }
1946 else
1947 {
1948 setBaselineShift(BaselineShift::Length);
1949 }
1950 }
1951 else
1952 {
1953 // no BaselineShift or inherit (which is automatically)
1954 setBaselineShift(BaselineShift::Baseline);
1955 }
1956 }
1957 break;
1958 }
1959 default:
1960 {
1961 break;
1962 }
1963 }
1964 }
1965
1966 // #i125258# ask if fill is a direct hard attribute (no hierarchy)
1967 bool SvgStyleAttributes::isFillSet() const
1968 {
1969 if(mbIsClipPathContent)
1970 {
1971 return false;
1972 }
1973 else if(maFill.isSet())
1974 {
1975 return true;
1976 }
1977
1978 return false;
1979 }
1980
1981 const basegfx::BColor* SvgStyleAttributes::getCurrentColor() const
1982 {
1983 static basegfx::BColor aBlack(0.0, 0.0, 0.0);
1984 const basegfx::BColor *aColor = getColor();
1985 if( aColor )
1986 return aColor;
1987 else
1988 return &aBlack;
1989 }
1990
1991 const basegfx::BColor* SvgStyleAttributes::getFill() const
1992 {
1993 if(maFill.isSet())
1994 {
1995 if(maFill.isCurrent())
1996 {
1997 return getCurrentColor();
1998 }
1999 else if(maFill.isOn())
2000 {
2001 return &maFill.getBColor();
2002 }
2003 else if(mbIsClipPathContent)
2004 {
2005 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2006
2007 if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
2008 {
2009 ++maResolvingParent[0];
2010 const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
2011 --maResolvingParent[0];
2012
2013 return pFill;
2014 }
2015 }
2016 }
2017 else if (maNodeFillURL.isEmpty())
2018 {
2019 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2020
2021 if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
2022 {
2023 ++maResolvingParent[0];
2024 const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
2025 --maResolvingParent[0];
2026
2027 if(mbIsClipPathContent)
2028 {
2029 if (pFill)
2030 {
2031 return pFill;
2032 }
2033 else
2034 {
2035 static basegfx::BColor aBlack(0.0, 0.0, 0.0);
2036 return &aBlack;
2037 }
2038 }
2039 else
2040 {
2041 return pFill;
2042 }
2043 }
2044 }
2045
2046 return nullptr;
2047 }
2048
2049 const basegfx::BColor* SvgStyleAttributes::getStroke() const
2050 {
2051 if(maStroke.isSet())
2052 {
2053 if(maStroke.isCurrent())
2054 {
2055 return getCurrentColor();
2056 }
2057 else if(maStroke.isOn())
2058 {
2059 return &maStroke.getBColor();
2060 }
2061 }
2062 else if (maNodeStrokeURL.isEmpty())
2063 {
2064 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2065
2066 if (pSvgStyleAttributes && maResolvingParent[1] < nStyleDepthLimit)
2067 {
2068 ++maResolvingParent[1];
2069 auto ret = pSvgStyleAttributes->getStroke();
2070 --maResolvingParent[1];
2071 return ret;
2072 }
2073 }
2074
2075 return nullptr;
2076 }
2077
2078 const basegfx::BColor& SvgStyleAttributes::getStopColor() const
2079 {
2080 if(maStopColor.isCurrent())
2081 {
2082 return *getCurrentColor();
2083 }
2084 else
2085 {
2086 return maStopColor.getBColor();
2087 }
2088 }
2089
2090 const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeFill() const
2091 {
2092 if (!maFill.isSet())
2093 {
2094 if (!maNodeFillURL.isEmpty())
2095 {
2096 const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
2097
2098 if(pNode)
2099 {
2100 if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient == pNode->getType())
2101 {
2102 return static_cast< const SvgGradientNode* >(pNode);
2103 }
2104 }
2105 }
2106 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2107
2108 if (pSvgStyleAttributes && maResolvingParent[2] < nStyleDepthLimit)
2109 {
2110 ++maResolvingParent[2];
2111 auto ret = pSvgStyleAttributes->getSvgGradientNodeFill();
2112 --maResolvingParent[2];
2113 return ret;
2114 }
2115 }
2116
2117 return nullptr;
2118 }
2119
2120 const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeStroke() const
2121 {
2122 if (!maStroke.isSet())
2123 {
2124 if(!maNodeStrokeURL.isEmpty())
2125 {
2126 const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
2127
2128 if(pNode)
2129 {
2130 if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient == pNode->getType())
2131 {
2132 return static_cast< const SvgGradientNode* >(pNode);
2133 }
2134 }
2135 }
2136
2137 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2138
2139 if (pSvgStyleAttributes && maResolvingParent[3] < nStyleDepthLimit)
2140 {
2141 ++maResolvingParent[3];
2142 auto ret = pSvgStyleAttributes->getSvgGradientNodeStroke();
2143 --maResolvingParent[3];
2144 return ret;
2145 }
2146 }
2147
2148 return nullptr;
2149 }
2150
2151 const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeFill() const
2152 {
2153 if (!maFill.isSet())
2154 {
2155 if (!maNodeFillURL.isEmpty())
2156 {
2157 const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
2158
2159 if(pNode)
2160 {
2161 if(SVGToken::Pattern == pNode->getType())
2162 {
2163 return static_cast< const SvgPatternNode* >(pNode);
2164 }
2165 }
2166 }
2167
2168 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2169
2170 if (pSvgStyleAttributes && maResolvingParent[4] < nStyleDepthLimit)
2171 {
2172 ++maResolvingParent[4];
2173 auto ret = pSvgStyleAttributes->getSvgPatternNodeFill();
2174 --maResolvingParent[4];
2175 return ret;
2176 }
2177 }
2178
2179 return nullptr;
2180 }
2181
2182 const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeStroke() const
2183 {
2184 if (!maStroke.isSet())
2185 {
2186 if(!maNodeStrokeURL.isEmpty())
2187 {
2188 const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
2189
2190 if(pNode)
2191 {
2192 if(SVGToken::Pattern == pNode->getType())
2193 {
2194 return static_cast< const SvgPatternNode* >(pNode);
2195 }
2196 }
2197 }
2198
2199 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2200
2201 if (pSvgStyleAttributes && maResolvingParent[5] < nStyleDepthLimit)
2202 {
2203 ++maResolvingParent[5];
2204 auto ret = pSvgStyleAttributes->getSvgPatternNodeStroke();
2205 --maResolvingParent[5];
2206 return ret;
2207 }
2208 }
2209
2210 return nullptr;
2211 }
2212
2213 SvgNumber SvgStyleAttributes::getStrokeWidth() const
2214 {
2215 if(maStrokeWidth.isSet())
2216 {
2217 return maStrokeWidth;
2218 }
2219
2220 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2221
2222 if (pSvgStyleAttributes && maResolvingParent[6] < nStyleDepthLimit)
2223 {
2224 ++maResolvingParent[6];
2225 auto ret = pSvgStyleAttributes->getStrokeWidth();
2226 --maResolvingParent[6];
2227 return ret;
2228 }
2229
2230 if(mbIsClipPathContent)
2231 {
2232 return SvgNumber(0.0);
2233 }
2234
2235 // default is 1
2236 return SvgNumber(1.0);
2237 }
2238
2239 SvgNumber SvgStyleAttributes::getStopOpacity() const
2240 {
2241 if(maStopOpacity.isSet())
2242 {
2243 return maStopOpacity;
2244 }
2245
2246 // default is 1
2247 return SvgNumber(1.0);
2248 }
2249
2250 SvgNumber SvgStyleAttributes::getFillOpacity() const
2251 {
2252 if(maFillOpacity.isSet())
2253 {
2254 return maFillOpacity;
2255 }
2256
2257 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2258
2259 if (pSvgStyleAttributes && maResolvingParent[7] < nStyleDepthLimit)
2260 {
2261 ++maResolvingParent[7];
2262 auto ret = pSvgStyleAttributes->getFillOpacity();
2263 --maResolvingParent[7];
2264 return ret;
2265 }
2266
2267 // default is 1
2268 return SvgNumber(1.0);
2269 }
2270
2271 SvgNumber SvgStyleAttributes::getOpacity() const
2272 {
2273 if(maOpacity.isSet())
2274 {
2275 return maOpacity;
2276 }
2277
2278 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2279
2280 if (pSvgStyleAttributes && maResolvingParent[8] < nStyleDepthLimit)
2281 {
2282 ++maResolvingParent[8];
2283 auto ret = pSvgStyleAttributes->getOpacity();
2284 --maResolvingParent[8];
2285 return ret;
2286 }
2287
2288 // default is 1
2289 return SvgNumber(1.0);
2290 }
2291
2292 Visibility SvgStyleAttributes::getVisibility() const
2293 {
2294 if(Visibility::notset == maVisibility || Visibility::inherit == maVisibility)
2295 {
2296 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2297
2298 if (pSvgStyleAttributes && maResolvingParent[9] < nStyleDepthLimit)
2299 {
2300 ++maResolvingParent[9];
2301 auto ret = pSvgStyleAttributes->getVisibility();
2302 --maResolvingParent[9];
2303 return ret;
2304 }
2305 //default is Visible
2306 return Visibility::visible;
2307 }
2308
2309 // Visibility correction/exception for self-exported SVGs:
2310 // When Impress exports single or multi-page SVGs, it puts the
2311 // single slides into <g visibility="hidden">. Not sure why
2312 // this happens, but this leads (correctly) to empty imported
2313 // Graphics.
2314 // Thus, if Visibility::hidden is active and owner is a SVGToken::G
2315 // and it's parent is also a SVGToken::G and it has a Class 'SlideGroup'
2316 // set, check if we are an Impress export.
2317 // We are an Impress export if an SVG-Node titled 'ooo:meta_slides'
2318 // exists.
2319 // All together gives:
2320 if(Visibility::hidden == maVisibility
2321 && SVGToken::G == mrOwner.getType()
2322 && nullptr != mrOwner.getDocument().findSvgNodeById("ooo:meta_slides"))
2323 {
2324 const SvgNode* pParent(mrOwner.getParent());
2325
2326 if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
2327 {
2328 const OUString aClass(*pParent->getClass());
2329
2330 if("SlideGroup" == aClass)
2331 {
2332 // if we detect this exception,
2333 // override Visibility::hidden -> Visibility::visible
2334 return Visibility::visible;
2335 }
2336 }
2337 }
2338
2339 return maVisibility;
2340 }
2341
2342 FillRule SvgStyleAttributes::getFillRule() const
2343 {
2344 if(FillRule::notset != maFillRule)
2345 {
2346 return maFillRule;
2347 }
2348
2349 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2350
2351 if (pSvgStyleAttributes && maResolvingParent[10] < nStyleDepthLimit)
2352 {
2353 ++maResolvingParent[10];
2354 auto ret = pSvgStyleAttributes->getFillRule();
2355 --maResolvingParent[10];
2356 return ret;
2357 }
2358
2359 // default is NonZero
2360 return FillRule::nonzero;
2361 }
2362
2363 const SvgNumberVector& SvgStyleAttributes::getStrokeDasharray() const
2364 {
2365 if(!maStrokeDasharray.empty())
2366 {
2367 return maStrokeDasharray;
2368 }
2369 else if(mbStrokeDasharraySet)
2370 {
2371 // #121221# is set to empty *by purpose*, do not visit parent styles
2372 return maStrokeDasharray;
2373 }
2374
2375 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2376
2377 if (pSvgStyleAttributes && maResolvingParent[11] < nStyleDepthLimit)
2378 {
2379 ++maResolvingParent[11];
2380 const SvgNumberVector& ret = pSvgStyleAttributes->getStrokeDasharray();
2381 --maResolvingParent[11];
2382 return ret;
2383 }
2384
2385 // default empty
2386 return maStrokeDasharray;
2387 }
2388
2389 SvgNumber SvgStyleAttributes::getStrokeDashOffset() const
2390 {
2391 if(maStrokeDashOffset.isSet())
2392 {
2393 return maStrokeDashOffset;
2394 }
2395
2396 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2397
2398 if (pSvgStyleAttributes && maResolvingParent[12] < nStyleDepthLimit)
2399 {
2400 ++maResolvingParent[12];
2401 auto ret = pSvgStyleAttributes->getStrokeDashOffset();
2402 --maResolvingParent[12];
2403 return ret;
2404 }
2405
2406 // default is 0
2407 return SvgNumber(0.0);
2408 }
2409
2410 StrokeLinecap SvgStyleAttributes::getStrokeLinecap() const
2411 {
2412 if(maStrokeLinecap != StrokeLinecap::notset)
2413 {
2414 return maStrokeLinecap;
2415 }
2416
2417 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2418
2419 if (pSvgStyleAttributes && maResolvingParent[13] < nStyleDepthLimit)
2420 {
2421 ++maResolvingParent[13];
2422 auto ret = pSvgStyleAttributes->getStrokeLinecap();
2423 --maResolvingParent[13];
2424 return ret;
2425 }
2426
2427 // default is StrokeLinecap::butt
2428 return StrokeLinecap::butt;
2429 }
2430
2431 StrokeLinejoin SvgStyleAttributes::getStrokeLinejoin() const
2432 {
2433 if(maStrokeLinejoin != StrokeLinejoin::notset)
2434 {
2435 return maStrokeLinejoin;
2436 }
2437
2438 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2439
2440 if (pSvgStyleAttributes && maResolvingParent[14] < nStyleDepthLimit)
2441 {
2442 ++maResolvingParent[14];
2443 auto ret = pSvgStyleAttributes->getStrokeLinejoin();
2444 --maResolvingParent[14];
2445 return ret;
2446 }
2447
2448 // default is StrokeLinejoin::butt
2449 return StrokeLinejoin::miter;
2450 }
2451
2452 SvgNumber SvgStyleAttributes::getStrokeMiterLimit() const
2453 {
2454 if(maStrokeMiterLimit.isSet())
2455 {
2456 return maStrokeMiterLimit;
2457 }
2458
2459 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2460
2461 if (pSvgStyleAttributes && maResolvingParent[15] < nStyleDepthLimit)
2462 {
2463 ++maResolvingParent[15];
2464 auto ret = pSvgStyleAttributes->getStrokeMiterLimit();
2465 --maResolvingParent[15];
2466 return ret;
2467 }
2468
2469 // default is 4
2470 return SvgNumber(4.0, SvgUnit::none);
2471 }
2472
2473 SvgNumber SvgStyleAttributes::getStrokeOpacity() const
2474 {
2475 if(maStrokeOpacity.isSet())
2476 {
2477 return maStrokeOpacity;
2478 }
2479
2480 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2481
2482 if (pSvgStyleAttributes && maResolvingParent[16] < nStyleDepthLimit)
2483 {
2484 ++maResolvingParent[16];
2485 auto ret = pSvgStyleAttributes->getStrokeOpacity();
2486 --maResolvingParent[16];
2487 return ret;
2488 }
2489
2490 // default is 1
2491 return SvgNumber(1.0);
2492 }
2493
2494 const SvgStringVector& SvgStyleAttributes::getFontFamily() const
2495 {
2496 if(!maFontFamily.empty() && !maFontFamily[0].startsWith("inherit"))
2497 {
2498 return maFontFamily;
2499 }
2500
2501 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2502
2503 if (pSvgStyleAttributes && maResolvingParent[17] < nStyleDepthLimit)
2504 {
2505 ++maResolvingParent[17];
2506 const SvgStringVector& ret = pSvgStyleAttributes->getFontFamily();
2507 --maResolvingParent[17];
2508 return ret;
2509 }
2510
2511 // default is empty
2512 return maFontFamily;
2513 }
2514
2515 SvgNumber SvgStyleAttributes::getFontSizeNumber() const
2516 {
2517 // default size is 'medium' or 16px, which is equal to the default PPI used in svgio ( 96.0 )
2518 // converted to pixels
2519 const double aDefaultSize = F_SVG_PIXEL_PER_INCH / 6.0;
2520
2521 if(maFontSizeNumber.isSet())
2522 {
2523 if(!maFontSizeNumber.isPositive())
2524 return aDefaultSize;
2525
2526 // #122524# Handle SvgUnit::percent relative to parent FontSize (see SVG1.1
2527 // spec 10.10 Font selection properties \91font-size\92, lastline (click 'normative
2528 // definition of the property')
2529 if(SvgUnit::percent == maFontSizeNumber.getUnit())
2530 {
2531 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2532
2533 if(pSvgStyleAttributes)
2534 {
2535 const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
2536
2537 return SvgNumber(
2538 aParentNumber.getNumber() * maFontSizeNumber.getNumber() * 0.01,
2539 aParentNumber.getUnit(),
2540 true);
2541 }
2542 // if there's no parent style, set the font size based on the default size
2543 // 100% = 16px
2544 return SvgNumber(
2545 maFontSizeNumber.getNumber() * aDefaultSize / 100.0, SvgUnit::px, true);
2546 }
2547 else if((SvgUnit::em == maFontSizeNumber.getUnit()) || (SvgUnit::ex == maFontSizeNumber.getUnit()))
2548 {
2549 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2550
2551 if(pSvgStyleAttributes)
2552 {
2553 const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
2554
2555 return SvgNumber(
2556 aParentNumber.getNumber() * maFontSizeNumber.getNumber(),
2557 aParentNumber.getUnit(),
2558 true);
2559 }
2560 }
2561
2562 return maFontSizeNumber;
2563 }
2564
2565 //In CSS2, the suggested scaling factor between adjacent indexes is 1.2
2566 switch(maFontSize)
2567 {
2568 case FontSize::notset:
2569 break;
2570 case FontSize::xx_small:
2571 {
2572 return SvgNumber(aDefaultSize / 1.728);
2573 }
2574 case FontSize::x_small:
2575 {
2576 return SvgNumber(aDefaultSize / 1.44);
2577 }
2578 case FontSize::small:
2579 {
2580 return SvgNumber(aDefaultSize / 1.2);
2581 }
2582 case FontSize::smaller:
2583 {
2584 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2585 if(pSvgStyleAttributes)
2586 {
2587 const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
2588 return SvgNumber(aParentNumber.getNumber() / 1.2, aParentNumber.getUnit());
2589 }
2590 [[fallthrough]];
2591 }
2592 case FontSize::medium:
2593 case FontSize::initial:
2594 {
2595 return SvgNumber(aDefaultSize);
2596 }
2597 case FontSize::large:
2598 {
2599 return SvgNumber(aDefaultSize * 1.2);
2600 }
2601 case FontSize::larger:
2602 {
2603 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2604 if(pSvgStyleAttributes)
2605 {
2606 const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
2607 return SvgNumber(aParentNumber.getNumber() * 1.2, aParentNumber.getUnit());
2608 }
2609 [[fallthrough]];
2610 }
2611 case FontSize::x_large:
2612 {
2613 return SvgNumber(aDefaultSize * 1.44);
2614 }
2615 case FontSize::xx_large:
2616 {
2617 return SvgNumber(aDefaultSize * 1.728);
2618 }
2619 }
2620
2621 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2622
2623 if(pSvgStyleAttributes)
2624 {
2625 return pSvgStyleAttributes->getFontSizeNumber();
2626 }
2627
2628 return SvgNumber(aDefaultSize);
2629 }
2630
2631 FontStretch SvgStyleAttributes::getFontStretch() const
2632 {
2633 if(maFontStretch != FontStretch::notset)
2634 {
2635 if(FontStretch::wider != maFontStretch && FontStretch::narrower != maFontStretch)
2636 {
2637 return maFontStretch;
2638 }
2639 }
2640
2641 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2642
2643 if (pSvgStyleAttributes && maResolvingParent[18] < nStyleDepthLimit)
2644 {
2645 ++maResolvingParent[18];
2646 FontStretch aInherited = pSvgStyleAttributes->getFontStretch();
2647 --maResolvingParent[18];
2648
2649 if(FontStretch::wider == maFontStretch)
2650 {
2651 aInherited = getWider(aInherited);
2652 }
2653 else if(FontStretch::narrower == maFontStretch)
2654 {
2655 aInherited = getNarrower(aInherited);
2656 }
2657
2658 return aInherited;
2659 }
2660
2661 // default is FontStretch::normal
2662 return FontStretch::normal;
2663 }
2664
2665 FontStyle SvgStyleAttributes::getFontStyle() const
2666 {
2667 if(maFontStyle != FontStyle::notset)
2668 {
2669 return maFontStyle;
2670 }
2671
2672 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2673
2674 if (pSvgStyleAttributes && maResolvingParent[19] < nStyleDepthLimit)
2675 {
2676 ++maResolvingParent[19];
2677 auto ret = pSvgStyleAttributes->getFontStyle();
2678 --maResolvingParent[19];
2679 return ret;
2680 }
2681
2682 // default is FontStyle::normal
2683 return FontStyle::normal;
2684 }
2685
2686 FontWeight SvgStyleAttributes::getFontWeight() const
2687 {
2688 if(maFontWeight != FontWeight::notset)
2689 {
2690 if(FontWeight::bolder != maFontWeight && FontWeight::lighter != maFontWeight)
2691 {
2692 return maFontWeight;
2693 }
2694 }
2695
2696 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2697
2698 if (pSvgStyleAttributes && maResolvingParent[20] < nStyleDepthLimit)
2699 {
2700 ++maResolvingParent[20];
2701 FontWeight aInherited = pSvgStyleAttributes->getFontWeight();
2702 --maResolvingParent[20];
2703
2704 if(FontWeight::bolder == maFontWeight)
2705 {
2706 aInherited = getBolder(aInherited);
2707 }
2708 else if(FontWeight::lighter == maFontWeight)
2709 {
2710 aInherited = getLighter(aInherited);
2711 }
2712
2713 return aInherited;
2714 }
2715
2716 // default is FontWeight::N400 (FontWeight::normal)
2717 return FontWeight::N400;
2718 }
2719
2720 TextAlign SvgStyleAttributes::getTextAlign() const
2721 {
2722 if(maTextAlign != TextAlign::notset)
2723 {
2724 return maTextAlign;
2725 }
2726
2727 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2728
2729 if (pSvgStyleAttributes && maResolvingParent[21] < nStyleDepthLimit)
2730 {
2731 ++maResolvingParent[21];
2732 auto ret = pSvgStyleAttributes->getTextAlign();
2733 --maResolvingParent[21];
2734 return ret;
2735 }
2736
2737 // default is TextAlign::left
2738 return TextAlign::left;
2739 }
2740
2741 const SvgStyleAttributes* SvgStyleAttributes::getTextDecorationDefiningSvgStyleAttributes() const
2742 {
2743 if(maTextDecoration != TextDecoration::notset)
2744 {
2745 return this;
2746 }
2747
2748 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2749
2750 if (pSvgStyleAttributes && maResolvingParent[22] < nStyleDepthLimit)
2751 {
2752 ++maResolvingParent[22];
2753 auto ret = pSvgStyleAttributes->getTextDecorationDefiningSvgStyleAttributes();
2754 --maResolvingParent[22];
2755 return ret;
2756 }
2757
2758 // default is 0
2759 return nullptr;
2760 }
2761
2762 TextDecoration SvgStyleAttributes::getTextDecoration() const
2763 {
2764 const SvgStyleAttributes* pDefining = getTextDecorationDefiningSvgStyleAttributes();
2765
2766 if(pDefining)
2767 {
2768 return pDefining->maTextDecoration;
2769 }
2770 else
2771 {
2772 // default is TextDecoration::none
2773 return TextDecoration::none;
2774 }
2775 }
2776
2777 TextAnchor SvgStyleAttributes::getTextAnchor() const
2778 {
2779 if(maTextAnchor != TextAnchor::notset)
2780 {
2781 return maTextAnchor;
2782 }
2783
2784 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2785
2786 if (pSvgStyleAttributes && maResolvingParent[23] < nStyleDepthLimit)
2787 {
2788 ++maResolvingParent[23];
2789 auto ret = pSvgStyleAttributes->getTextAnchor();
2790 --maResolvingParent[23];
2791 return ret;
2792 }
2793
2794 // default is TextAnchor::start
2795 return TextAnchor::start;
2796 }
2797
2798 const basegfx::BColor* SvgStyleAttributes::getColor() const
2799 {
2800 if(maColor.isSet())
2801 {
2802 if(maColor.isCurrent())
2803 {
2804 OSL_ENSURE(false, "Svg error: current color uses current color (!)");
2805 return nullptr;
2806 }
2807 else if(maColor.isOn())
2808 {
2809 return &maColor.getBColor();
2810 }
2811 }
2812 else
2813 {
2814 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2815
2816 if (pSvgStyleAttributes && maResolvingParent[24] < nStyleDepthLimit)
2817 {
2818 ++maResolvingParent[24];
2819 auto ret = pSvgStyleAttributes->getColor();
2820 --maResolvingParent[24];
2821 return ret;
2822 }
2823 }
2824
2825 return nullptr;
2826 }
2827
2828 OUString const & SvgStyleAttributes::getClipPathXLink() const
2829 {
2830 return maClipPathXLink;
2831 }
2832
2833 const SvgClipPathNode* SvgStyleAttributes::accessClipPathXLink() const
2834 {
2835 if(!mpClipPathXLink)
2836 {
2837 const OUString aClipPath(getClipPathXLink());
2838
2839 if(!aClipPath.isEmpty())
2840 {
2841 const_cast< SvgStyleAttributes* >(this)->mpClipPathXLink = dynamic_cast< const SvgClipPathNode* >(mrOwner.getDocument().findSvgNodeById(aClipPath));
2842 }
2843 }
2844
2845 return mpClipPathXLink;
2846 }
2847
2848 OUString SvgStyleAttributes::getMaskXLink() const
2849 {
2850 if(!maMaskXLink.isEmpty())
2851 {
2852 return maMaskXLink;
2853 }
2854
2855 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2856
2857 if (pSvgStyleAttributes && !pSvgStyleAttributes->maMaskXLink.isEmpty() && maResolvingParent[25] < nStyleDepthLimit)
2858 {
2859 ++maResolvingParent[25];
2860 auto ret = pSvgStyleAttributes->getMaskXLink();
2861 --maResolvingParent[25];
2862 return ret;
2863 }
2864
2865 return OUString();
2866 }
2867
2868 const SvgMaskNode* SvgStyleAttributes::accessMaskXLink() const
2869 {
2870 if(!mpMaskXLink)
2871 {
2872 const OUString aMask(getMaskXLink());
2873
2874 if(!aMask.isEmpty())
2875 {
2876 const_cast< SvgStyleAttributes* >(this)->mpMaskXLink = dynamic_cast< const SvgMaskNode* >(mrOwner.getDocument().findSvgNodeById(aMask));
2877 }
2878 }
2879
2880 return mpMaskXLink;
2881 }
2882
2883 OUString SvgStyleAttributes::getMarkerStartXLink() const
2884 {
2885 if(!maMarkerStartXLink.isEmpty())
2886 {
2887 return maMarkerStartXLink;
2888 }
2889
2890 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2891
2892 if (pSvgStyleAttributes && maResolvingParent[26] < nStyleDepthLimit)
2893 {
2894 ++maResolvingParent[26];
2895 auto ret = pSvgStyleAttributes->getMarkerStartXLink();
2896 --maResolvingParent[26];
2897 return ret;
2898 }
2899
2900 return OUString();
2901 }
2902
2903 const SvgMarkerNode* SvgStyleAttributes::accessMarkerStartXLink() const
2904 {
2905 if(!mpMarkerStartXLink)
2906 {
2907 const OUString aMarker(getMarkerStartXLink());
2908
2909 if(!aMarker.isEmpty())
2910 {
2911 const_cast< SvgStyleAttributes* >(this)->mpMarkerStartXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerStartXLink()));
2912 }
2913 }
2914
2915 return mpMarkerStartXLink;
2916 }
2917
2918 OUString SvgStyleAttributes::getMarkerMidXLink() const
2919 {
2920 if(!maMarkerMidXLink.isEmpty())
2921 {
2922 return maMarkerMidXLink;
2923 }
2924
2925 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2926
2927 if (pSvgStyleAttributes && maResolvingParent[27] < nStyleDepthLimit)
2928 {
2929 ++maResolvingParent[27];
2930 auto ret = pSvgStyleAttributes->getMarkerMidXLink();
2931 --maResolvingParent[27];
2932 return ret;
2933 }
2934
2935 return OUString();
2936 }
2937
2938 const SvgMarkerNode* SvgStyleAttributes::accessMarkerMidXLink() const
2939 {
2940 if(!mpMarkerMidXLink)
2941 {
2942 const OUString aMarker(getMarkerMidXLink());
2943
2944 if(!aMarker.isEmpty())
2945 {
2946 const_cast< SvgStyleAttributes* >(this)->mpMarkerMidXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerMidXLink()));
2947 }
2948 }
2949
2950 return mpMarkerMidXLink;
2951 }
2952
2953 OUString SvgStyleAttributes::getMarkerEndXLink() const
2954 {
2955 if(!maMarkerEndXLink.isEmpty())
2956 {
2957 return maMarkerEndXLink;
2958 }
2959
2960 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2961
2962 if (pSvgStyleAttributes && maResolvingParent[28] < nStyleDepthLimit)
2963 {
2964 ++maResolvingParent[28];
2965 auto ret = pSvgStyleAttributes->getMarkerEndXLink();
2966 --maResolvingParent[28];
2967 return ret;
2968 }
2969
2970 return OUString();
2971 }
2972
2973 const SvgMarkerNode* SvgStyleAttributes::accessMarkerEndXLink() const
2974 {
2975 if(!mpMarkerEndXLink)
2976 {
2977 const OUString aMarker(getMarkerEndXLink());
2978
2979 if(!aMarker.isEmpty())
2980 {
2981 const_cast< SvgStyleAttributes* >(this)->mpMarkerEndXLink = dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerEndXLink()));
2982 }
2983 }
2984
2985 return mpMarkerEndXLink;
2986 }
2987
2988 SvgNumber SvgStyleAttributes::getBaselineShiftNumber() const
2989 {
2990 // #122524# Handle SvgUnit::percent relative to parent BaselineShift
2991 if(SvgUnit::percent == maBaselineShiftNumber.getUnit())
2992 {
2993 const SvgStyleAttributes* pSvgStyleAttributes = getParentStyle();
2994
2995 if (pSvgStyleAttributes && maResolvingParent[29] < nStyleDepthLimit)
2996 {
2997 ++maResolvingParent[29];
2998 const SvgNumber aParentNumber = pSvgStyleAttributes->getBaselineShiftNumber();
2999 --maResolvingParent[29];
3000
3001 return SvgNumber(
3002 aParentNumber.getNumber() * maBaselineShiftNumber.getNumber() * 0.01,
3003 aParentNumber.getUnit(),
3004 true);
3005 }
3006 }
3007
3008 return maBaselineShiftNumber;
3009 }
3010 } // end of namespace svgio
3011
3012 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
3013
FREE OFFICE SUITE