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