horok/libreoffice
1
0
Fork 0
Code Activity
libreoffice/svgio/source/svgreader/svgstyleattributes.cxx
Daniel Baumann 8e63e14cf6
Adding upstream version 4:25.2.3. 
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
2025-06-22 16:20:04 +02:00

3286 lines
126 KiB
C++
Raw Permalink Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/config.h>
#include <algorithm>
#include <svgstyleattributes.hxx>
#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
#include <drawinglayer/primitive2d/PolyPolygonStrokePrimitive2D.hxx>
#include <svgnode.hxx>
#include <svgdocument.hxx>
#include <drawinglayer/primitive2d/svggradientprimitive2d.hxx>
#include <svggradientnode.hxx>
#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
#include <drawinglayer/primitive2d/PolyPolygonRGBAPrimitive2D.hxx>
#include <basegfx/vector/b2enums.hxx>
#include <drawinglayer/processor2d/linegeometryextractor2d.hxx>
#include <drawinglayer/processor2d/textaspolygonextractor2d.hxx>
#include <basegfx/polygon/b2dpolypolygoncutter.hxx>
#include <svgclippathnode.hxx>
#include <svgfilternode.hxx>
#include <svgmasknode.hxx>
#include <basegfx/polygon/b2dpolypolygontools.hxx>
#include <svgmarkernode.hxx>
#include <svgpatternnode.hxx>
#include <drawinglayer/primitive2d/patternfillprimitive2d.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <drawinglayer/primitive2d/maskprimitive2d.hxx>
#include <drawinglayer/primitive2d/pagehierarchyprimitive2d.hxx>
#include <o3tl/string_view.hxx>
#include <o3tl/unit_conversion.hxx>
const int nStyleDepthLimit = 1024;
namespace svgio::svgreader
{
static basegfx::B2DLineJoin StrokeLinejoinToB2DLineJoin(StrokeLinejoin aStrokeLinejoin)
{
if(StrokeLinejoin::round == aStrokeLinejoin)
{
return basegfx::B2DLineJoin::Round;
}
else if(StrokeLinejoin::bevel == aStrokeLinejoin)
{
return basegfx::B2DLineJoin::Bevel;
}
return basegfx::B2DLineJoin::Miter;
}
static css::drawing::LineCap StrokeLinecapToDrawingLineCap(StrokeLinecap aStrokeLinecap)
{
switch(aStrokeLinecap)
{
default: /* StrokeLinecap::notset, StrokeLinecap::butt */
{
return css::drawing::LineCap_BUTT;
}
case StrokeLinecap::round:
{
return css::drawing::LineCap_ROUND;
}
case StrokeLinecap::square:
{
return css::drawing::LineCap_SQUARE;
}
}
}
FontStretch getWider(FontStretch aSource)
{
switch(aSource)
{
case FontStretch::ultra_condensed: aSource = FontStretch::extra_condensed; break;
case FontStretch::extra_condensed: aSource = FontStretch::condensed; break;
case FontStretch::condensed: aSource = FontStretch::semi_condensed; break;
case FontStretch::semi_condensed: aSource = FontStretch::normal; break;
case FontStretch::normal: aSource = FontStretch::semi_expanded; break;
case FontStretch::semi_expanded: aSource = FontStretch::expanded; break;
case FontStretch::expanded: aSource = FontStretch::extra_expanded; break;
case FontStretch::extra_expanded: aSource = FontStretch::ultra_expanded; break;
default: break;
}
return aSource;
}
FontStretch getNarrower(FontStretch aSource)
{
switch(aSource)
{
case FontStretch::extra_condensed: aSource = FontStretch::ultra_condensed; break;
case FontStretch::condensed: aSource = FontStretch::extra_condensed; break;
case FontStretch::semi_condensed: aSource = FontStretch::condensed; break;
case FontStretch::normal: aSource = FontStretch::semi_condensed; break;
case FontStretch::semi_expanded: aSource = FontStretch::normal; break;
case FontStretch::expanded: aSource = FontStretch::semi_expanded; break;
case FontStretch::extra_expanded: aSource = FontStretch::expanded; break;
case FontStretch::ultra_expanded: aSource = FontStretch::extra_expanded; break;
default: break;
}
return aSource;
}
FontWeight getBolder(FontWeight aSource)
{
switch(aSource)
{
case FontWeight::N100: aSource = FontWeight::N200; break;
case FontWeight::N200: aSource = FontWeight::N300; break;
case FontWeight::N300: aSource = FontWeight::N400; break;
case FontWeight::N400: aSource = FontWeight::N500; break;
case FontWeight::N500: aSource = FontWeight::N600; break;
case FontWeight::N600: aSource = FontWeight::N700; break;
case FontWeight::N700: aSource = FontWeight::N800; break;
case FontWeight::N800: aSource = FontWeight::N900; break;
default: break;
}
return aSource;
}
FontWeight getLighter(FontWeight aSource)
{
switch(aSource)
{
case FontWeight::N200: aSource = FontWeight::N100; break;
case FontWeight::N300: aSource = FontWeight::N200; break;
case FontWeight::N400: aSource = FontWeight::N300; break;
case FontWeight::N500: aSource = FontWeight::N400; break;
case FontWeight::N600: aSource = FontWeight::N500; break;
case FontWeight::N700: aSource = FontWeight::N600; break;
case FontWeight::N800: aSource = FontWeight::N700; break;
case FontWeight::N900: aSource = FontWeight::N800; break;
default: break;
}
return aSource;
}
::FontWeight getVclFontWeight(FontWeight aSource)
{
::FontWeight nRetval(WEIGHT_NORMAL);
switch(aSource)
{
case FontWeight::N100: nRetval = WEIGHT_ULTRALIGHT; break;
case FontWeight::N200: nRetval = WEIGHT_LIGHT; break;
case FontWeight::N300: nRetval = WEIGHT_SEMILIGHT; break;
case FontWeight::N400: nRetval = WEIGHT_NORMAL; break;
case FontWeight::N500: nRetval = WEIGHT_MEDIUM; break;
case FontWeight::N600: nRetval = WEIGHT_SEMIBOLD; break;
case FontWeight::N700: nRetval = WEIGHT_BOLD; break;
case FontWeight::N800: nRetval = WEIGHT_ULTRABOLD; break;
case FontWeight::N900: nRetval = WEIGHT_BLACK; break;
default: break;
}
return nRetval;
}
void SvgStyleAttributes::readCssStyle(std::u16string_view rCandidate)
{
const sal_Int32 nLen(rCandidate.size());
sal_Int32 nPos(0);
while(nPos < nLen)
{
// get TokenName
OUStringBuffer aTokenName;
skip_char(rCandidate, u' ', nPos, nLen);
copyString(rCandidate, nPos, aTokenName, nLen);
if (aTokenName.isEmpty())
{
// if no TokenName advance one by force to avoid death loop, continue
OSL_ENSURE(false, "Could not interpret on current position, advancing one byte (!)");
nPos++;
continue;
}
// get TokenValue
OUStringBuffer aTokenValue;
skip_char(rCandidate, u' ', u':', nPos, nLen);
copyToLimiter(rCandidate, u';', nPos, aTokenValue, nLen);
skip_char(rCandidate, u' ', u';', nPos, nLen);
if (aTokenValue.isEmpty())
{
// no value - continue
continue;
}
// generate OUStrings
const OUString aOUTokenName(aTokenName.makeStringAndClear());
OUString aOUTokenValue(aTokenValue.makeStringAndClear());
// check for '!important' CssStyle mark, currently not supported
// but needs to be extracted for correct parsing
OUString aTokenImportant(u"!important"_ustr);
const sal_Int32 nIndexTokenImportant(aOUTokenValue.indexOf(aTokenImportant));
if(-1 != nIndexTokenImportant)
{
// if there currently just remove it and remove spaces to have the value only
OUString aNewOUTokenValue;
if(nIndexTokenImportant > 0)
{
// copy content before token
aNewOUTokenValue += aOUTokenValue.subView(0, nIndexTokenImportant);
}
if(aOUTokenValue.getLength() > nIndexTokenImportant + aTokenImportant.getLength())
{
// copy content after token
aNewOUTokenValue += aOUTokenValue.subView(nIndexTokenImportant + aTokenImportant.getLength());
}
// remove spaces
aOUTokenValue = aNewOUTokenValue.trim();
}
// valid token-value pair, parse it
parseStyleAttribute(StrToSVGToken(aOUTokenName, true), aOUTokenValue);
}
}
const SvgStyleAttributes* SvgStyleAttributes::getCssStyleOrParentStyle() const
{
if(const SvgStyleAttributes* pCssStyleParent = getCssStyle())
{
return pCssStyleParent;
}
if(mrOwner.supportsParentStyle() && mrOwner.getParent())
{
return mrOwner.getParent()->getSvgStyleAttributes();
}
return nullptr;
}
const SvgMarkerNode* SvgStyleAttributes::getMarkerParentNode() const
{
if (SVGToken::Marker == mrOwner.getType())
return static_cast<const SvgMarkerNode *>(&mrOwner);
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[32] < nStyleDepthLimit)
{
++maResolvingParent[32];
const SvgMarkerNode* ret = pSvgStyleAttributes->getMarkerParentNode();
--maResolvingParent[32];
return ret;
}
return nullptr;
}
void SvgStyleAttributes::add_text(
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
drawinglayer::primitive2d::Primitive2DContainer&& rSource) const
{
if(rSource.empty())
return;
// at this point the primitives in rSource are of type TextSimplePortionPrimitive2D
// or TextDecoratedPortionPrimitive2D and have the Fill Color (pAttributes->getFill())
// set. When another fill is used and also evtl. stroke is set it gets necessary to
// dismantle to geometry and add needed primitives
const basegfx::BColor* pFill = getFill();
const SvgGradientNode* pFillGradient = getSvgGradientNodeFill();
const SvgPatternNode* pFillPattern = getSvgPatternNodeFill();
const basegfx::BColor* pStroke = getStroke();
const SvgGradientNode* pStrokeGradient = getSvgGradientNodeStroke();
const SvgPatternNode* pStrokePattern = getSvgPatternNodeStroke();
basegfx::B2DPolyPolygon aMergedArea;
if(pFillGradient || pFillPattern || pStroke || pStrokeGradient || pStrokePattern)
{
// text geometry is needed, create
// use neutral ViewInformation and create LineGeometryExtractor2D
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
drawinglayer::processor2d::TextAsPolygonExtractor2D aExtractor(aViewInformation2D);
// process
aExtractor.process(rSource);
// get results
const drawinglayer::processor2d::TextAsPolygonDataNodeVector& rResult = aExtractor.getTarget();
const sal_uInt32 nResultCount(rResult.size());
basegfx::B2DPolyPolygonVector aTextFillVector;
aTextFillVector.reserve(nResultCount);
for(sal_uInt32 a(0); a < nResultCount; a++)
{
const drawinglayer::processor2d::TextAsPolygonDataNode& rCandidate = rResult[a];
if(rCandidate.getIsFilled())
{
aTextFillVector.push_back(rCandidate.getB2DPolyPolygon());
}
}
if(!aTextFillVector.empty())
{
aMergedArea = basegfx::utils::mergeToSinglePolyPolygon(aTextFillVector);
}
}
const bool bStrokeUsed(pStroke || pStrokeGradient || pStrokePattern);
// add fill. Use geometry even for simple color fill when stroke
// is used, else text rendering and the geometry-based stroke will
// normally not really match optically due to diverse system text
// renderers
if(aMergedArea.count() && (pFillGradient || pFillPattern || bStrokeUsed))
{
// create text fill content based on geometry
add_fill(aMergedArea, rTarget, aMergedArea.getB2DRange());
}
else if(pFill)
{
// add the already prepared primitives for single color fill
rTarget.append(std::move(rSource));
}
// add stroke
if(aMergedArea.count() && bStrokeUsed)
{
// create text stroke content
add_stroke(aMergedArea, rTarget, aMergedArea.getB2DRange());
}
}
void SvgStyleAttributes::add_fillGradient(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const SvgGradientNode& rFillGradient,
const basegfx::B2DRange& rGeoRange) const
{
// create fill content
drawinglayer::primitive2d::SvgGradientEntryVector aSvgGradientEntryVector;
// get the color stops
rFillGradient.collectGradientEntries(aSvgGradientEntryVector);
if(aSvgGradientEntryVector.empty())
return;
basegfx::B2DHomMatrix aGeoToUnit;
basegfx::B2DHomMatrix aGradientTransform;
if(rFillGradient.getGradientTransform())
{
aGradientTransform = *rFillGradient.getGradientTransform();
}
if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
{
aGeoToUnit.translate(-rGeoRange.getMinX(), -rGeoRange.getMinY());
aGeoToUnit.scale(1.0 / rGeoRange.getWidth(), 1.0 / rGeoRange.getHeight());
}
if(SVGToken::LinearGradient == rFillGradient.getType())
{
basegfx::B2DPoint aStart(0.0, 0.0);
basegfx::B2DPoint aEnd(1.0, 0.0);
if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
{
// all possible units
aStart.setX(rFillGradient.getX1().solve(mrOwner, NumberType::xcoordinate));
aStart.setY(rFillGradient.getY1().solve(mrOwner, NumberType::ycoordinate));
aEnd.setX(rFillGradient.getX2().solve(mrOwner, NumberType::xcoordinate));
aEnd.setY(rFillGradient.getY2().solve(mrOwner, NumberType::ycoordinate));
}
else
{
// fractions or percent relative to object bounds
const SvgNumber X1(rFillGradient.getX1());
const SvgNumber Y1(rFillGradient.getY1());
const SvgNumber X2(rFillGradient.getX2());
const SvgNumber Y2(rFillGradient.getY2());
aStart.setX(SvgUnit::percent == X1.getUnit() ? X1.getNumber() * 0.01 : X1.getNumber());
aStart.setY(SvgUnit::percent == Y1.getUnit() ? Y1.getNumber() * 0.01 : Y1.getNumber());
aEnd.setX(SvgUnit::percent == X2.getUnit() ? X2.getNumber() * 0.01 : X2.getNumber());
aEnd.setY(SvgUnit::percent == Y2.getUnit() ? Y2.getNumber() * 0.01 : Y2.getNumber());
}
if(!aGeoToUnit.isIdentity())
{
aStart *= aGeoToUnit;
aEnd *= aGeoToUnit;
}
rTarget.push_back(
new drawinglayer::primitive2d::SvgLinearGradientPrimitive2D(
aGradientTransform,
rPath,
std::move(aSvgGradientEntryVector),
aStart,
aEnd,
SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
rFillGradient.getSpreadMethod()));
}
else
{
basegfx::B2DPoint aStart(0.5, 0.5);
basegfx::B2DPoint aFocal;
double fRadius(0.5);
const SvgNumber* pFx = rFillGradient.getFx();
const SvgNumber* pFy = rFillGradient.getFy();
const bool bFocal(pFx || pFy);
if (SvgUnits::userSpaceOnUse == rFillGradient.getGradientUnits())
{
// all possible units
aStart.setX(rFillGradient.getCx().solve(mrOwner, NumberType::xcoordinate));
aStart.setY(rFillGradient.getCy().solve(mrOwner, NumberType::ycoordinate));
fRadius = rFillGradient.getR().solve(mrOwner);
if(bFocal)
{
aFocal.setX(pFx ? pFx->solve(mrOwner, NumberType::xcoordinate) : aStart.getX());
aFocal.setY(pFy ? pFy->solve(mrOwner, NumberType::ycoordinate) : aStart.getY());
}
}
else
{
// fractions or percent relative to object bounds
const SvgNumber Cx(rFillGradient.getCx());
const SvgNumber Cy(rFillGradient.getCy());
const SvgNumber R(rFillGradient.getR());
aStart.setX(SvgUnit::percent == Cx.getUnit() ? Cx.getNumber() * 0.01 : Cx.getNumber());
aStart.setY(SvgUnit::percent == Cy.getUnit() ? Cy.getNumber() * 0.01 : Cy.getNumber());
fRadius = (SvgUnit::percent == R.getUnit()) ? R.getNumber() * 0.01 : R.getNumber();
if(bFocal)
{
aFocal.setX(pFx ? (SvgUnit::percent == pFx->getUnit() ? pFx->getNumber() * 0.01 : pFx->getNumber()) : aStart.getX());
aFocal.setY(pFy ? (SvgUnit::percent == pFy->getUnit() ? pFy->getNumber() * 0.01 : pFy->getNumber()) : aStart.getY());
}
}
if(!aGeoToUnit.isIdentity())
{
aStart *= aGeoToUnit;
fRadius = (aGeoToUnit * basegfx::B2DVector(fRadius, 0.0)).getLength();
if(bFocal)
{
aFocal *= aGeoToUnit;
}
}
rTarget.push_back(
new drawinglayer::primitive2d::SvgRadialGradientPrimitive2D(
aGradientTransform,
rPath,
std::move(aSvgGradientEntryVector),
aStart,
fRadius,
SvgUnits::userSpaceOnUse != rFillGradient.getGradientUnits(),
rFillGradient.getSpreadMethod(),
bFocal ? &aFocal : nullptr));
}
}
void SvgStyleAttributes::add_fillPatternTransform(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const SvgPatternNode& rFillPattern,
const basegfx::B2DRange& rGeoRange) const
{
// prepare fill polyPolygon with given pattern, check for patternTransform
if(rFillPattern.getPatternTransform() && !rFillPattern.getPatternTransform()->isIdentity())
{
// PatternTransform is active; Handle by filling the inverse transformed
// path and back-transforming the result
basegfx::B2DPolyPolygon aPath(rPath);
basegfx::B2DHomMatrix aInv(*rFillPattern.getPatternTransform());
drawinglayer::primitive2d::Primitive2DContainer aNewTarget;
aInv.invert();
aPath.transform(aInv);
add_fillPattern(aPath, aNewTarget, rFillPattern, aPath.getB2DRange());
if(!aNewTarget.empty())
{
rTarget.push_back(
new drawinglayer::primitive2d::TransformPrimitive2D(
*rFillPattern.getPatternTransform(),
std::move(aNewTarget)));
}
}
else
{
// no patternTransform, create fillPattern directly
add_fillPattern(rPath, rTarget, rFillPattern, rGeoRange);
}
}
void SvgStyleAttributes::add_fillPattern(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const SvgPatternNode& rFillPattern,
const basegfx::B2DRange& rGeoRange) const
{
// fill polyPolygon with given pattern
const drawinglayer::primitive2d::Primitive2DContainer& rPrimitives = rFillPattern.getPatternPrimitives();
if(rPrimitives.empty())
return;
double fTargetWidth(rGeoRange.getWidth());
double fTargetHeight(rGeoRange.getHeight());
if(fTargetWidth <= 0.0 || fTargetHeight <= 0.0)
return;
// get relative values from pattern
double fX(0.0);
double fY(0.0);
double fW(0.0);
double fH(0.0);
rFillPattern.getValuesRelative(fX, fY, fW, fH, rGeoRange, mrOwner);
if(fW <= 0.0 || fH <= 0.0)
return;
// build the reference range relative to the rGeoRange
const basegfx::B2DRange aReferenceRange(fX, fY, fX + fW, fY + fH);
// find out how the content is mapped to the reference range
basegfx::B2DHomMatrix aMapPrimitivesToUnitRange;
const basegfx::B2DRange* pViewBox = rFillPattern.getViewBox();
if(pViewBox)
{
// use viewBox/preserveAspectRatio
const SvgAspectRatio& rRatio = rFillPattern.getSvgAspectRatio();
const basegfx::B2DRange aUnitRange(0.0, 0.0, 1.0, 1.0);
if(rRatio.isSet())
{
// let mapping be created from SvgAspectRatio
aMapPrimitivesToUnitRange = rRatio.createMapping(aUnitRange, *pViewBox);
}
else
{
// choose default mapping
aMapPrimitivesToUnitRange = SvgAspectRatio::createLinearMapping(aUnitRange, *pViewBox);
}
}
else
{
// use patternContentUnits
const SvgUnits aPatternContentUnits(rFillPattern.getPatternContentUnits() ? *rFillPattern.getPatternContentUnits() : SvgUnits::userSpaceOnUse);
if (SvgUnits::userSpaceOnUse == aPatternContentUnits)
{
// create relative mapping to unit coordinates
aMapPrimitivesToUnitRange.scale(1.0 / (fW * fTargetWidth), 1.0 / (fH * fTargetHeight));
}
else
{
aMapPrimitivesToUnitRange.scale(1.0 / fW, 1.0 / fH);
}
}
// apply aMapPrimitivesToUnitRange to content when used
drawinglayer::primitive2d::Primitive2DContainer aPrimitives(rPrimitives);
if(!aMapPrimitivesToUnitRange.isIdentity())
{
const drawinglayer::primitive2d::Primitive2DReference xRef(
new drawinglayer::primitive2d::TransformPrimitive2D(
aMapPrimitivesToUnitRange,
std::move(aPrimitives)));
aPrimitives = drawinglayer::primitive2d::Primitive2DContainer { xRef };
}
// embed in PatternFillPrimitive2D
rTarget.push_back(
new drawinglayer::primitive2d::PatternFillPrimitive2D(
rPath,
std::move(aPrimitives),
aReferenceRange));
}
void SvgStyleAttributes::add_fill(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const basegfx::B2DRange& rGeoRange) const
{
const basegfx::BColor* pFill = nullptr;
const SvgGradientNode* pFillGradient = nullptr;
const SvgPatternNode* pFillPattern = nullptr;
if (mbUseFillFromContextFill)
{
if (const SvgMarkerNode* pMarker = getMarkerParentNode())
{
const SvgStyleAttributes* pStyle = pMarker->getContextStyleAttributes();
pFill = pStyle->getFill();
pFillGradient = pStyle->getSvgGradientNodeFill();
pFillPattern = pStyle->getSvgPatternNodeFill();
}
}
else if (mbUseFillFromContextStroke)
{
if (const SvgMarkerNode* pMarker = getMarkerParentNode())
{
const SvgStyleAttributes* pStyle = pMarker->getContextStyleAttributes();
pFill = pStyle->getStroke();
pFillGradient = pStyle->getSvgGradientNodeStroke();
pFillPattern = pStyle->getSvgPatternNodeStroke();
}
}
else
{
pFill = getFill();
pFillGradient = getSvgGradientNodeFill();
pFillPattern = getSvgPatternNodeFill();
}
if(!(pFill || pFillGradient || pFillPattern))
return;
double fFillOpacity(getFillOpacity().solve(mrOwner));
if (fFillOpacity <= 0.0 || basegfx::fTools::equalZero(fFillOpacity))
return;
drawinglayer::primitive2d::Primitive2DContainer aNewFill;
if(pFillGradient)
{
// create fill content with SVG gradient primitive
add_fillGradient(rPath, aNewFill, *pFillGradient, rGeoRange);
}
else if(pFillPattern)
{
// create fill content with SVG pattern primitive
add_fillPatternTransform(rPath, aNewFill, *pFillPattern, rGeoRange);
}
else // if(pFill)
{
// create fill content
if(basegfx::fTools::moreOrEqual(fFillOpacity, 1.0))
{
// no transparence
aNewFill.push_back(
new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
rPath, *pFill));
}
else
{
// transparence
aNewFill.push_back(
new drawinglayer::primitive2d::PolyPolygonRGBAPrimitive2D(
rPath, *pFill, 1.0 - fFillOpacity));
// do not embed again below
fFillOpacity = 1.0;
}
}
if(aNewFill.empty())
return;
if(basegfx::fTools::less(fFillOpacity, 1.0))
{
// embed in UnifiedTransparencePrimitive2D
rTarget.push_back(
new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
std::move(aNewFill),
1.0 - fFillOpacity));
}
else
{
// append
rTarget.append(aNewFill);
}
}
void SvgStyleAttributes::add_stroke(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const basegfx::B2DRange& rGeoRange) const
{
const basegfx::BColor* pStroke = nullptr;
const SvgGradientNode* pStrokeGradient = nullptr;
const SvgPatternNode* pStrokePattern = nullptr;
if(mbUseStrokeFromContextFill)
{
if (const SvgMarkerNode* pMarker = getMarkerParentNode())
{
const SvgStyleAttributes* pStyle = pMarker->getContextStyleAttributes();
pStroke = pStyle->getFill();
pStrokeGradient = pStyle->getSvgGradientNodeFill();
pStrokePattern = pStyle->getSvgPatternNodeFill();
}
}
else if(mbUseStrokeFromContextStroke)
{
if (const SvgMarkerNode* pMarker = getMarkerParentNode())
{
const SvgStyleAttributes* pStyle = pMarker->getContextStyleAttributes();
pStroke = pStyle->getStroke();
pStrokeGradient = pStyle->getSvgGradientNodeStroke();
pStrokePattern = pStyle->getSvgPatternNodeStroke();
}
}
else
{
pStroke = getStroke();
pStrokeGradient = getSvgGradientNodeStroke();
pStrokePattern = getSvgPatternNodeStroke();
}
if(!(pStroke || pStrokeGradient || pStrokePattern))
return;
drawinglayer::primitive2d::Primitive2DContainer aNewStroke;
const double fStrokeOpacity(getStrokeOpacity().solve(mrOwner));
if (fStrokeOpacity <= 0.0 || basegfx::fTools::equalZero(fStrokeOpacity))
return;
// get stroke width; SVG does not use 0.0 == hairline, so 0.0 is no line at all
const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
if (fStrokeWidth <= 0.0 || basegfx::fTools::equalZero(fStrokeWidth))
return;
if (fStrokeWidth > std::numeric_limits<sal_Int32>::max())
{
SAL_WARN("svgio", "ignoring ludicrous stroke width: " << fStrokeWidth);
return;
}
drawinglayer::primitive2d::Primitive2DReference aNewLinePrimitive;
// if we have a line with two identical points it is not really a line,
// but used by SVG sometimes to paint a single dot.In that case, create
// the geometry for a single dot
if(1 == rPath.count())
{
const basegfx::B2DPolygon& aSingle(rPath.getB2DPolygon(0));
if(2 == aSingle.count() && aSingle.getB2DPoint(0).equal(aSingle.getB2DPoint(1)))
{
aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(
basegfx::B2DPolyPolygon(
basegfx::utils::createPolygonFromCircle(
aSingle.getB2DPoint(0),
fStrokeWidth * (1.44 * 0.5))),
pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0));
}
}
if(!aNewLinePrimitive.is())
{
// get LineJoin, LineCap and stroke array
const basegfx::B2DLineJoin aB2DLineJoin(StrokeLinejoinToB2DLineJoin(getStrokeLinejoin()));
const css::drawing::LineCap aLineCap(StrokeLinecapToDrawingLineCap(getStrokeLinecap()));
::std::vector< double > aDashArray;
if(!getStrokeDasharray().empty())
{
aDashArray = solveSvgNumberVector(getStrokeDasharray(), mrOwner);
}
// convert svg:stroke-miterlimit to LineAttrute:mfMiterMinimumAngle
// The default needs to be set explicitly, because svg default <> Draw default
double fMiterMinimumAngle;
if (getStrokeMiterLimit().isSet())
{
fMiterMinimumAngle = 2.0 * asin(1.0/getStrokeMiterLimit().getNumber());
}
else
{
fMiterMinimumAngle = 2.0 * asin(0.25); // 1.0/default 4.0
}
// todo: Handle getStrokeDashOffset()
// prepare line attribute
const drawinglayer::attribute::LineAttribute aLineAttribute(
pStroke ? *pStroke : basegfx::BColor(0.0, 0.0, 0.0),
fStrokeWidth,
aB2DLineJoin,
aLineCap,
fMiterMinimumAngle);
if(aDashArray.empty())
{
aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
rPath,
aLineAttribute);
}
else
{
drawinglayer::attribute::StrokeAttribute aStrokeAttribute(std::move(aDashArray));
aNewLinePrimitive = new drawinglayer::primitive2d::PolyPolygonStrokePrimitive2D(
rPath,
aLineAttribute,
std::move(aStrokeAttribute));
}
}
if(pStrokeGradient || pStrokePattern)
{
// put primitive into Primitive2DReference and Primitive2DSequence
const drawinglayer::primitive2d::Primitive2DContainer aSeq { aNewLinePrimitive };
// use neutral ViewInformation and create LineGeometryExtractor2D
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
// process
aExtractor.process(aSeq);
// check for fill rsults
const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
if(!rLineFillVector.empty())
{
const basegfx::B2DPolyPolygon aMergedArea(
basegfx::utils::mergeToSinglePolyPolygon(
rLineFillVector));
if(aMergedArea.count())
{
if(pStrokeGradient)
{
// create fill content with SVG gradient primitive. Use original GeoRange,
// e.g. from circle without LineWidth
add_fillGradient(aMergedArea, aNewStroke, *pStrokeGradient, rGeoRange);
}
else // if(pStrokePattern)
{
// create fill content with SVG pattern primitive. Use GeoRange
// from the expanded data, e.g. circle with extended geo by half linewidth
add_fillPatternTransform(aMergedArea, aNewStroke, *pStrokePattern, aMergedArea.getB2DRange());
}
}
}
}
else // if(pStroke)
{
aNewStroke.push_back(aNewLinePrimitive);
}
if(aNewStroke.empty())
return;
if(basegfx::fTools::less(fStrokeOpacity, 1.0))
{
// embed in UnifiedTransparencePrimitive2D
rTarget.push_back(
new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
std::move(aNewStroke),
1.0 - fStrokeOpacity));
}
else
{
// append
rTarget.append(aNewStroke);
}
}
bool SvgStyleAttributes::prepare_singleMarker(
drawinglayer::primitive2d::Primitive2DContainer& rMarkerPrimitives,
basegfx::B2DHomMatrix& rMarkerTransform,
basegfx::B2DRange& rClipRange,
const SvgMarkerNode& rMarker) const
{
// reset return values
rMarkerTransform.identity();
rClipRange.reset();
// Set the current style attributes to the marker before calling getMarkerPrimitives,
// which calls decomposeSvgNode to decompose the children of the marker.
// If any children uses 'context-fill' or 'context-stroke',
// then these style attributes will be used in add_fill or add_stroke
const_cast<SvgMarkerNode&>(rMarker).setContextStyleAttributes(this);
// get marker primitive representation
rMarkerPrimitives = rMarker.getMarkerPrimitives();
if(!rMarkerPrimitives.empty())
{
basegfx::B2DRange aPrimitiveRange(0.0, 0.0, 1.0, 1.0);
const basegfx::B2DRange* pViewBox = rMarker.getViewBox();
if(pViewBox)
{
aPrimitiveRange = *pViewBox;
}
if(aPrimitiveRange.getWidth() > 0.0 && aPrimitiveRange.getHeight() > 0.0)
{
double fTargetWidth(rMarker.getMarkerWidth().isSet() ? rMarker.getMarkerWidth().solve(mrOwner, NumberType::xcoordinate) : 3.0);
double fTargetHeight(rMarker.getMarkerHeight().isSet() ? rMarker.getMarkerHeight().solve(mrOwner, NumberType::xcoordinate) : 3.0);
const bool bStrokeWidth(SvgMarkerNode::MarkerUnits::strokeWidth == rMarker.getMarkerUnits());
const double fStrokeWidth(getStrokeWidth().isSet() ? getStrokeWidth().solve(mrOwner) : 1.0);
if(bStrokeWidth)
{
// relative to strokeWidth
fTargetWidth *= fStrokeWidth;
fTargetHeight *= fStrokeWidth;
}
if(fTargetWidth > 0.0 && fTargetHeight > 0.0)
{
// create mapping
const basegfx::B2DRange aTargetRange(0.0, 0.0, fTargetWidth, fTargetHeight);
const SvgAspectRatio& rRatio = rMarker.getSvgAspectRatio();
if(rRatio.isSet() && Overflow::visible != rMarker.getSvgStyleAttributes()->getOverflow())
{
// let mapping be created from SvgAspectRatio
rMarkerTransform = rRatio.createMapping(aTargetRange, aPrimitiveRange);
if(rRatio.isMeetOrSlice())
{
// need to clip
rClipRange = aPrimitiveRange;
}
}
else
{
if(!pViewBox)
{
if(bStrokeWidth)
{
// adapt to strokewidth if needed
rMarkerTransform.scale(fStrokeWidth, fStrokeWidth);
}
}
else
{
// choose default mapping
rMarkerTransform = SvgAspectRatio::createLinearMapping(aTargetRange, aPrimitiveRange);
}
}
// get and apply reference point. Initially it's in marker local coordinate system
basegfx::B2DPoint aRefPoint(
rMarker.getRefX().isSet() ? rMarker.getRefX().solve(mrOwner, NumberType::xcoordinate) : 0.0,
rMarker.getRefY().isSet() ? rMarker.getRefY().solve(mrOwner, NumberType::ycoordinate) : 0.0);
// apply MarkerTransform to have it in mapped coordinates
aRefPoint *= rMarkerTransform;
// apply by moving RepPoint to (0.0)
rMarkerTransform.translate(-aRefPoint.getX(), -aRefPoint.getY());
return true;
}
}
}
return false;
}
void SvgStyleAttributes::add_markers(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const basegfx::utils::PointIndexSet* pHelpPointIndices) const
{
// try to access linked markers
const SvgMarkerNode* pStart = accessMarkerStartXLink();
const SvgMarkerNode* pMid = accessMarkerMidXLink();
const SvgMarkerNode* pEnd = accessMarkerEndXLink();
if(!(pStart || pMid || pEnd))
return;
const sal_uInt32 nSubPathCount(rPath.count());
if(!nSubPathCount)
return;
// remember prepared marker; pStart, pMid and pEnd may all be equal when
// only 'marker' was used instead of 'marker-start', 'marker-mid' or 'marker-end',
// see 'case SVGToken::Marker' in this file; thus in this case only one common
// marker in primitive form will be prepared
const SvgMarkerNode* pPrepared = nullptr;
// values for the prepared marker, results of prepare_singleMarker
drawinglayer::primitive2d::Primitive2DContainer aPreparedMarkerPrimitives;
basegfx::B2DHomMatrix aPreparedMarkerTransform;
basegfx::B2DRange aPreparedMarkerClipRange;
for (sal_uInt32 a(0); a < nSubPathCount; a++)
{
// iterate over sub-paths
const basegfx::B2DPolygon& aSubPolygonPath(rPath.getB2DPolygon(a));
const sal_uInt32 nSubPolygonPointCount(aSubPolygonPath.count());
const bool bSubPolygonPathIsClosed(aSubPolygonPath.isClosed());
if(nSubPolygonPointCount)
{
// for each sub-path, create one marker per point (when closed, two markers
// need to pe created for the 1st point)
const sal_uInt32 nTargetMarkerCount(bSubPolygonPathIsClosed ? nSubPolygonPointCount + 1 : nSubPolygonPointCount);
for (sal_uInt32 b(0); b < nTargetMarkerCount; b++)
{
const bool bIsFirstMarker(!a && !b);
const bool bIsLastMarker(nSubPathCount - 1 == a && nTargetMarkerCount - 1 == b);
const SvgMarkerNode* pNeeded = nullptr;
if(bIsFirstMarker)
{
// 1st point in 1st sub-polygon, use pStart
pNeeded = pStart;
}
else if(bIsLastMarker)
{
// last point in last sub-polygon, use pEnd
pNeeded = pEnd;
}
else
{
// anything in-between, use pMid
pNeeded = pMid;
}
if(pHelpPointIndices && !pHelpPointIndices->empty())
{
const basegfx::utils::PointIndexSet::const_iterator aFound(
pHelpPointIndices->find(basegfx::utils::PointIndex(a, b)));
if(aFound != pHelpPointIndices->end())
{
// this point is a pure helper point; do not create a marker for it
continue;
}
}
if(!pNeeded)
{
// no marker needs to be created for this point
continue;
}
if(pPrepared != pNeeded)
{
// if needed marker is not yet prepared, do it now
if(prepare_singleMarker(aPreparedMarkerPrimitives, aPreparedMarkerTransform, aPreparedMarkerClipRange, *pNeeded))
{
pPrepared = pNeeded;
}
else
{
// error: could not prepare given marker
OSL_ENSURE(false, "OOps, could not prepare given marker as primitives (!)");
pPrepared = nullptr;
continue;
}
}
// prepare complete transform
basegfx::B2DHomMatrix aCombinedTransform(aPreparedMarkerTransform);
// get rotation
if(pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start ||
pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
{
const sal_uInt32 nPointIndex(b % nSubPolygonPointCount);
// get entering and leaving tangents; this will search backward/forward
// in the polygon to find tangents unequal to zero, skipping empty edges
// see basegfx descriptions)
// Hint: Mozilla, Inkscape and others use only leaving tangent for start marker
// and entering tangent for end marker. To achieve this (if wanted) it is possible
// to make the fetch of aEntering/aLeaving dependent on bIsFirstMarker/bIsLastMarker.
// This is not done here, see comment 14 in task #1232379#
// or http://www.w3.org/TR/SVG/painting.html#OrientAttribute
basegfx::B2DVector aEntering(
basegfx::utils::getTangentEnteringPoint(
aSubPolygonPath,
nPointIndex));
basegfx::B2DVector aLeaving(
basegfx::utils::getTangentLeavingPoint(
aSubPolygonPath,
nPointIndex));
const bool bEntering(!aEntering.equalZero());
const bool bLeaving(!aLeaving.equalZero());
if(bEntering || bLeaving)
{
basegfx::B2DVector aSum(0.0, 0.0);
if(bEntering)
{
if(bIsFirstMarker && pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
aSum -= aEntering.normalize();
else
aSum += aEntering.normalize();
}
if(bLeaving)
{
if(bIsFirstMarker && pPrepared->getMarkerOrient() == SvgMarkerNode::MarkerOrient::auto_start_reverse)
aSum -= aLeaving.normalize();
else
aSum += aLeaving.normalize();
}
if(!aSum.equalZero())
{
const double fAngle(atan2(aSum.getY(), aSum.getX()));
// apply rotation
aCombinedTransform.rotate(fAngle);
}
}
}
else
{
// apply rotation
aCombinedTransform.rotate(pPrepared->getAngle());
}
// get and apply target position
const basegfx::B2DPoint aPoint(aSubPolygonPath.getB2DPoint(b % nSubPolygonPointCount));
aCombinedTransform.translate(aPoint.getX(), aPoint.getY());
// prepare marker
drawinglayer::primitive2d::Primitive2DReference xMarker(
new drawinglayer::primitive2d::TransformPrimitive2D(
aCombinedTransform,
drawinglayer::primitive2d::Primitive2DContainer(aPreparedMarkerPrimitives)));
if(!aPreparedMarkerClipRange.isEmpty())
{
// marker needs to be clipped, it's bigger as the mapping
basegfx::B2DPolyPolygon aClipPolygon(basegfx::utils::createPolygonFromRect(aPreparedMarkerClipRange));
aClipPolygon.transform(aCombinedTransform);
xMarker = new drawinglayer::primitive2d::MaskPrimitive2D(
std::move(aClipPolygon),
drawinglayer::primitive2d::Primitive2DContainer { xMarker });
}
// add marker
rTarget.push_back(xMarker);
}
}
}
}
void SvgStyleAttributes::add_path(
const basegfx::B2DPolyPolygon& rPath,
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
const basegfx::utils::PointIndexSet* pHelpPointIndices) const
{
if(!rPath.count())
{
// no geometry at all
return;
}
const basegfx::B2DRange aGeoRange(rPath.getB2DRange());
if(aGeoRange.isEmpty())
{
// no geometry range
return;
}
const double fOpacity(getOpacity().solve(mrOwner));
if(basegfx::fTools::equalZero(fOpacity))
{
// not visible
return;
}
// check if it's a line
const bool bNoWidth(basegfx::fTools::equalZero(aGeoRange.getWidth()));
const bool bNoHeight(basegfx::fTools::equalZero(aGeoRange.getHeight()));
const bool bIsTwoPointLine(1 == rPath.count()
&& !rPath.areControlPointsUsed()
&& 2 == rPath.getB2DPolygon(0).count());
const bool bIsLine(bIsTwoPointLine || bNoWidth || bNoHeight);
if(!bIsLine)
{
// create fill
basegfx::B2DPolyPolygon aPath(rPath);
if(SVGToken::Path == mrOwner.getType() || SVGToken::Polygon == mrOwner.getType())
{
if(FillRule::evenodd != getClipRule() && FillRule::evenodd != getFillRule())
{
if(getFill() || getSvgGradientNodeFill() || getSvgPatternNodeFill())
{
// nonzero is wanted, solve geometrically (see description on basegfx)
// basegfx::utils::createNonzeroConform() is expensive for huge paths
// and is only needed if path will be filled later on
aPath = basegfx::utils::createNonzeroConform(aPath);
}
}
}
add_fill(aPath, rTarget, aGeoRange);
}
// create stroke
add_stroke(rPath, rTarget, aGeoRange);
// Svg supports markers for path, polygon, polyline and line
if(SVGToken::Path == mrOwner.getType() || // path
SVGToken::Polygon == mrOwner.getType() || // polygon
SVGToken::Polyline == mrOwner.getType() || // polyline
SVGToken::Line == mrOwner.getType() || // line
SVGToken::Style == mrOwner.getType()) // tdf#150323
{
// try to add markers
add_markers(rPath, rTarget, pHelpPointIndices);
}
}
void SvgStyleAttributes::add_postProcess(
drawinglayer::primitive2d::Primitive2DContainer& rTarget,
drawinglayer::primitive2d::Primitive2DContainer&& rSource,
const std::optional<basegfx::B2DHomMatrix>& pTransform) const
{
// default is 1
double fOpacity(1.0);
if(maOpacity.isSet())
{
fOpacity = maOpacity.solve(mrOwner);
}
else
{
// if opacity is not set, check the css style
if (const SvgStyleAttributes* pSvgStyleAttributes = getCssStyle())
{
if (pSvgStyleAttributes->maOpacity.isSet())
{
fOpacity = pSvgStyleAttributes->maOpacity.solve(mrOwner);
}
}
}
if(basegfx::fTools::equalZero(fOpacity))
{
return;
}
drawinglayer::primitive2d::Primitive2DContainer aSource(std::move(rSource));
if(basegfx::fTools::less(fOpacity, 1.0))
{
// embed in UnifiedTransparencePrimitive2D
const drawinglayer::primitive2d::Primitive2DReference xRef(
new drawinglayer::primitive2d::UnifiedTransparencePrimitive2D(
std::move(aSource),
1.0 - fOpacity));
aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
}
if(pTransform)
{
// create embedding group element with transformation. This applies the given
// transformation to the graphical content, but *not* to mask and/or clip (as needed)
const drawinglayer::primitive2d::Primitive2DReference xRef(
new drawinglayer::primitive2d::TransformPrimitive2D(
*pTransform,
std::move(aSource)));
aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
}
const SvgClipPathNode* pClip = accessClipPathXLink();
while(pClip)
{
// #i124852# transform may be needed when SvgUnits::userSpaceOnUse
pClip->apply(aSource, pTransform);
pClip = pClip->getSvgStyleAttributes()->accessClipPathXLink();
}
if(!aSource.empty()) // test again, applied clipPath may have lead to empty geometry
{
const SvgFilterNode* pFilter = accessFilterXLink();
if(pFilter)
{
pFilter->apply(aSource, nullptr);
}
}
if(!aSource.empty()) // test again, applied filter may have lead to empty geometry
{
const SvgMaskNode* pMask = accessMaskXLink();
if(pMask)
{
// #i124852# transform may be needed when SvgUnits::userSpaceOnUse
pMask->apply(aSource, pTransform);
}
}
// This is part of the SVG import of self-written SVGs from
// Draw/Impress containing multiple Slides/Pages. To be able
// to later 'break' these to multiple Pages if wanted, embed
// each Page-Content in an identifiable Primitive Grouping
// Object.
// This is the case when the current Node is a GroupNode, has
// class="Page" set, has a parent that also is a GroupNode
// at which class="Slide" is set.
// Multiple Slides/Pages are possible for Draw and Impress.
if(SVGToken::G == mrOwner.getType() && mrOwner.getClass())
{
const OUString aOwnerClass(*mrOwner.getClass());
if("Page" == aOwnerClass)
{
const SvgNode* pParent(mrOwner.getParent());
if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
{
const OUString aParentClass(*pParent->getClass());
if("Slide" == aParentClass)
{
// embed to grouping primitive to identify the
// Slide/Page information
const drawinglayer::primitive2d::Primitive2DReference xRef(
new drawinglayer::primitive2d::PageHierarchyPrimitive2D(
std::move(aSource)));
aSource = drawinglayer::primitive2d::Primitive2DContainer { xRef };
}
}
}
}
if(!aSource.empty()) // test again, applied mask may have lead to empty geometry
{
// append to current target
rTarget.append(aSource);
}
}
SvgStyleAttributes::SvgStyleAttributes(SvgNode& rOwner)
: mrOwner(rOwner),
mpCssStyle(nullptr),
maStopColor(basegfx::BColor(0.0, 0.0, 0.0), true),
maStrokeLinecap(StrokeLinecap::notset),
maStrokeLinejoin(StrokeLinejoin::notset),
maFontSize(),
maFontStretch(FontStretch::notset),
maFontStyle(FontStyle::notset),
maFontWeight(FontWeight::notset),
maTextAlign(TextAlign::notset),
maTextDecoration(TextDecoration::notset),
maTextAnchor(TextAnchor::notset),
maOverflow(Overflow::notset),
maVisibility(Visibility::notset),
maFillRule(FillRule::notset),
maClipRule(FillRule::notset),
maBaselineShift(BaselineShift::Baseline),
maBaselineShiftNumber(0),
maDominantBaseline(DominantBaseline::Auto),
maResolvingParent(34, 0),
mbStrokeDasharraySet(false),
mbUseFillFromContextFill(false),
mbUseFillFromContextStroke(false),
mbUseStrokeFromContextFill(false),
mbUseStrokeFromContextStroke(false)
{
}
SvgStyleAttributes::~SvgStyleAttributes()
{
}
void SvgStyleAttributes::parseStyleAttribute(
SVGToken aSVGToken,
const OUString& aContent)
{
switch(aSVGToken)
{
case SVGToken::Fill:
{
SvgPaint aSvgPaint;
OUString aURL;
SvgNumber aOpacity;
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"context-fill"))
{
mbUseFillFromContextFill = true;
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"context-stroke"))
{
mbUseFillFromContextStroke = true;
}
else if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
{
setFill(aSvgPaint);
if(aOpacity.isSet())
{
setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
}
}
else if(!aURL.isEmpty())
{
maNodeFillURL = aURL;
}
break;
}
case SVGToken::FillOpacity:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
maFillOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
}
break;
}
case SVGToken::FillRule:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrNonzero))
{
maFillRule = FillRule::nonzero;
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrEvenOdd))
{
maFillRule = FillRule::evenodd;
}
}
break;
}
case SVGToken::Stroke:
{
SvgPaint aSvgPaint;
OUString aURL;
SvgNumber aOpacity;
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"context-stroke"))
{
mbUseStrokeFromContextStroke = true;
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"context-fill"))
{
mbUseStrokeFromContextFill = true;
}
else if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
{
maStroke = aSvgPaint;
if(aOpacity.isSet())
{
setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
}
}
else if(!aURL.isEmpty())
{
maNodeStrokeURL = aURL;
}
break;
}
case SVGToken::StrokeDasharray:
{
if(!aContent.isEmpty())
{
SvgNumberVector aVector;
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
{
// #121221# The special value 'none' needs to be handled
// in the sense that *when* it is set, the parent shall not
// be used. Before this was only dependent on the array being
// empty
mbStrokeDasharraySet = true;
}
else if(readSvgNumberVector(aContent, aVector))
{
maStrokeDasharray = std::move(aVector);
}
}
break;
}
case SVGToken::StrokeDashoffset:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
if(aNum.isPositive())
{
maStrokeDashOffset = aNum;
}
}
break;
}
case SVGToken::StrokeLinecap:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"butt"))
{
setStrokeLinecap(StrokeLinecap::butt);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"round"))
{
setStrokeLinecap(StrokeLinecap::round);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"square"))
{
setStrokeLinecap(StrokeLinecap::square);
}
}
break;
}
case SVGToken::StrokeLinejoin:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"miter"))
{
setStrokeLinejoin(StrokeLinejoin::miter);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"round"))
{
setStrokeLinejoin(StrokeLinejoin::round);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bevel"))
{
setStrokeLinejoin(StrokeLinejoin::bevel);
}
}
break;
}
case SVGToken::StrokeMiterlimit:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
if(basegfx::fTools::moreOrEqual(aNum.getNumber(), 1.0))
{ //readSingleNumber sets SvgUnit::px as default, if unit is missing. Correct it here.
maStrokeMiterLimit = SvgNumber(aNum.getNumber(), SvgUnit::none);
}
}
break;
}
case SVGToken::StrokeOpacity:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
maStrokeOpacity = SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet());
}
break;
}
case SVGToken::StrokeWidth:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
if(aNum.isPositive())
{
maStrokeWidth = aNum;
}
}
break;
}
case SVGToken::StopColor:
{
SvgPaint aSvgPaint;
OUString aURL;
SvgNumber aOpacity;
if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
{
maStopColor = aSvgPaint;
if(aOpacity.isSet())
{
setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
}
}
break;
}
case SVGToken::StopOpacity:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
if(aNum.isPositive())
{
maStopOpacity = aNum;
}
}
break;
}
case SVGToken::Font:
{
break;
}
case SVGToken::FontFamily:
{
SvgStringVector aSvgStringVector;
if(readSvgStringVector(aContent, aSvgStringVector, ','))
{
maFontFamily = std::move(aSvgStringVector);
}
break;
}
case SVGToken::FontSize:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"xx-small"))
{
setFontSize(FontSize::xx_small);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"x-small"))
{
setFontSize(FontSize::x_small);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"small"))
{
setFontSize(FontSize::small);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"smaller"))
{
setFontSize(FontSize::smaller);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"medium"))
{
setFontSize(FontSize::medium);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"larger"))
{
setFontSize(FontSize::larger);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"large"))
{
setFontSize(FontSize::large);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"x-large"))
{
setFontSize(FontSize::x_large);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"xx-large"))
{
setFontSize(FontSize::xx_large);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"initial"))
{
setFontSize(FontSize::initial);
}
else
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
maFontSizeNumber = aNum;
}
}
}
break;
}
case SVGToken::FontSizeAdjust:
{
break;
}
case SVGToken::FontStretch:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
{
setFontStretch(FontStretch::normal);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"wider"))
{
setFontStretch(FontStretch::wider);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"narrower"))
{
setFontStretch(FontStretch::narrower);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"ultra-condensed"))
{
setFontStretch(FontStretch::ultra_condensed);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"extra-condensed"))
{
setFontStretch(FontStretch::extra_condensed);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"condensed"))
{
setFontStretch(FontStretch::condensed);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"semi-condensed"))
{
setFontStretch(FontStretch::semi_condensed);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"semi-expanded"))
{
setFontStretch(FontStretch::semi_expanded);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"expanded"))
{
setFontStretch(FontStretch::expanded);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"extra-expanded"))
{
setFontStretch(FontStretch::extra_expanded);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"ultra-expanded"))
{
setFontStretch(FontStretch::ultra_expanded);
}
}
break;
}
case SVGToken::FontStyle:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
{
setFontStyle(FontStyle::normal);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"italic"))
{
setFontStyle(FontStyle::italic);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"oblique"))
{
setFontStyle(FontStyle::oblique);
}
}
break;
}
case SVGToken::FontVariant:
{
break;
}
case SVGToken::FontWeight:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"100"))
{
setFontWeight(FontWeight::N100);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"200"))
{
setFontWeight(FontWeight::N200);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"300"))
{
setFontWeight(FontWeight::N300);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"400") || o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"normal"))
{
setFontWeight(FontWeight::N400);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"500"))
{
setFontWeight(FontWeight::N500);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"600"))
{
setFontWeight(FontWeight::N600);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"700") || o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bold"))
{
setFontWeight(FontWeight::N700);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"800"))
{
setFontWeight(FontWeight::N800);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"900"))
{
setFontWeight(FontWeight::N900);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"bolder"))
{
setFontWeight(FontWeight::bolder);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"lighter"))
{
setFontWeight(FontWeight::lighter);
}
}
break;
}
case SVGToken::Direction:
{
break;
}
case SVGToken::LetterSpacing:
{
break;
}
case SVGToken::TextDecoration:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"none"))
{
setTextDecoration(TextDecoration::none);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"underline"))
{
setTextDecoration(TextDecoration::underline);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"overline"))
{
setTextDecoration(TextDecoration::overline);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"line-through"))
{
setTextDecoration(TextDecoration::line_through);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"blink"))
{
setTextDecoration(TextDecoration::blink);
}
}
break;
}
case SVGToken::UnicodeBidi:
{
break;
}
case SVGToken::WordSpacing:
{
break;
}
case SVGToken::TextAnchor:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"start"))
{
setTextAnchor(TextAnchor::start);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"middle"))
{
setTextAnchor(TextAnchor::middle);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"end"))
{
setTextAnchor(TextAnchor::end);
}
}
break;
}
case SVGToken::TextAlign:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"left"))
{
setTextAlign(TextAlign::left);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"right"))
{
setTextAlign(TextAlign::right);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"center"))
{
setTextAlign(TextAlign::center);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"justify"))
{
setTextAlign(TextAlign::justify);
}
}
break;
}
case SVGToken::Color:
{
SvgPaint aSvgPaint;
OUString aURL;
SvgNumber aOpacity;
if(readSvgPaint(aContent, aSvgPaint, aURL, aOpacity))
{
maColor = aSvgPaint;
if(aOpacity.isSet())
{
setOpacity(SvgNumber(std::clamp(aOpacity.getNumber(), 0.0, 1.0)));
}
}
break;
}
case SVGToken::Opacity:
{
SvgNumber aNum;
if(readSingleNumber(aContent, aNum))
{
setOpacity(SvgNumber(std::clamp(aNum.getNumber(), 0.0, 1.0), aNum.getUnit(), aNum.isSet()));
}
break;
}
case SVGToken::Overflow:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"visible"))
{
setOverflow(Overflow::visible);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hidden"))
{
setOverflow(Overflow::hidden);
}
}
break;
}
case SVGToken::Visibility:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"visible"))
{
setVisibility(Visibility::visible);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hidden"))
{
setVisibility(Visibility::hidden);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"collapse"))
{
setVisibility(Visibility::collapse);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"inherit"))
{
setVisibility(Visibility::inherit);
}
}
break;
}
case SVGToken::Title:
{
maTitle = aContent;
break;
}
case SVGToken::Desc:
{
maDesc = aContent;
break;
}
case SVGToken::ClipPathProperty:
{
readLocalUrl(aContent, maClipPathXLink);
break;
}
case SVGToken::Filter:
{
readLocalUrl(aContent, maFilterXLink);
break;
}
case SVGToken::Mask:
{
readLocalUrl(aContent, maMaskXLink);
break;
}
case SVGToken::ClipRule:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrNonzero))
{
maClipRule = FillRule::nonzero;
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), commonStrings::aStrEvenOdd))
{
maClipRule = FillRule::evenodd;
}
}
break;
}
case SVGToken::Marker:
{
// tdf#155819: Using the marker property from a style sheet is equivalent to using all three (start, mid, end).
if(mrOwner.getType() == SVGToken::Style)
{
readLocalUrl(aContent, maMarkerEndXLink);
maMarkerStartXLink = maMarkerMidXLink = maMarkerEndXLink;
}
break;
}
case SVGToken::MarkerStart:
{
readLocalUrl(aContent, maMarkerStartXLink);
break;
}
case SVGToken::MarkerMid:
{
readLocalUrl(aContent, maMarkerMidXLink);
break;
}
case SVGToken::MarkerEnd:
{
readLocalUrl(aContent, maMarkerEndXLink);
break;
}
case SVGToken::Display:
{
// There may be display:none statements inside of style defines, e.g. the following line:
// style="display:none"
// taken from a svg example; this needs to be parsed and set at the owning node. Do not call
// mrOwner.parseAttribute(...) here, this would lead to a recursion
if(!aContent.isEmpty())
{
mrOwner.setDisplay(getDisplayFromContent(aContent));
}
break;
}
case SVGToken::BaselineShift:
{
if(!aContent.isEmpty())
{
SvgNumber aNum;
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"sub"))
{
setBaselineShift(BaselineShift::Sub);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"super"))
{
setBaselineShift(BaselineShift::Super);
}
else if(readSingleNumber(aContent, aNum))
{
maBaselineShiftNumber = aNum;
if(SvgUnit::percent == aNum.getUnit())
{
setBaselineShift(BaselineShift::Percentage);
}
else
{
setBaselineShift(BaselineShift::Length);
}
}
else
{
// no BaselineShift or inherit (which is automatically)
setBaselineShift(BaselineShift::Baseline);
}
}
break;
}
case SVGToken::DominantBaseline:
{
if(!aContent.isEmpty())
{
if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"middle"))
{
setDominantBaseline(DominantBaseline::Middle);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"hanging"))
{
setDominantBaseline(DominantBaseline::Hanging);
}
else if(o3tl::equalsIgnoreAsciiCase(o3tl::trim(aContent), u"central"))
{
setDominantBaseline(DominantBaseline::Central);
}
else
{
// no DominantBaseline
setDominantBaseline(DominantBaseline::Auto);
}
}
break;
}
default:
{
break;
}
}
}
bool SvgStyleAttributes::isClipPathContent() const
{
if (SVGToken::ClipPathNode == mrOwner.getType())
return true;
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[31] < nStyleDepthLimit)
{
++maResolvingParent[31];
bool ret = pSvgStyleAttributes->isClipPathContent();
--maResolvingParent[31];
return ret;
}
return false;
}
// #i125258# ask if fill is a direct hard attribute (no hierarchy)
bool SvgStyleAttributes::isFillSet() const
{
if(isClipPathContent())
{
return false;
}
else if(maFill.isSet())
{
return true;
}
return false;
}
const basegfx::BColor* SvgStyleAttributes::getCurrentColor() const
{
static basegfx::BColor aBlack(0.0, 0.0, 0.0);
const basegfx::BColor *aColor = getColor();
if( aColor )
return aColor;
else
return &aBlack;
}
const basegfx::BColor* SvgStyleAttributes::getFill() const
{
if(maFill.isSet())
{
if(maFill.isCurrent())
{
return getCurrentColor();
}
else if(maFill.isOn())
{
return &maFill.getBColor();
}
else if(isClipPathContent())
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
{
++maResolvingParent[0];
const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
--maResolvingParent[0];
return pFill;
}
}
}
else if (maNodeFillURL.isEmpty())
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[0] < nStyleDepthLimit)
{
++maResolvingParent[0];
const basegfx::BColor* pFill = pSvgStyleAttributes->getFill();
--maResolvingParent[0];
if(isClipPathContent())
{
if (pFill)
{
return pFill;
}
else
{
static basegfx::BColor aBlack(0.0, 0.0, 0.0);
return &aBlack;
}
}
else
{
return pFill;
}
}
}
return nullptr;
}
const basegfx::BColor* SvgStyleAttributes::getStroke() const
{
if(maStroke.isSet())
{
if(maStroke.isCurrent())
{
return getCurrentColor();
}
else if(maStroke.isOn())
{
return &maStroke.getBColor();
}
}
else if (maNodeStrokeURL.isEmpty())
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[1] < nStyleDepthLimit)
{
++maResolvingParent[1];
auto ret = pSvgStyleAttributes->getStroke();
--maResolvingParent[1];
return ret;
}
}
return nullptr;
}
const basegfx::BColor& SvgStyleAttributes::getStopColor() const
{
if(maStopColor.isCurrent())
{
return *getCurrentColor();
}
else
{
return maStopColor.getBColor();
}
}
const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeFill() const
{
if (!maFill.isSet())
{
if (!maNodeFillURL.isEmpty())
{
const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
if(pNode)
{
if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient == pNode->getType())
{
return static_cast< const SvgGradientNode* >(pNode);
}
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[2] < nStyleDepthLimit)
{
++maResolvingParent[2];
auto ret = pSvgStyleAttributes->getSvgGradientNodeFill();
--maResolvingParent[2];
return ret;
}
}
return nullptr;
}
const SvgGradientNode* SvgStyleAttributes::getSvgGradientNodeStroke() const
{
if (!maStroke.isSet())
{
if(!maNodeStrokeURL.isEmpty())
{
const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
if(pNode)
{
if(SVGToken::LinearGradient == pNode->getType() || SVGToken::RadialGradient == pNode->getType())
{
return static_cast< const SvgGradientNode* >(pNode);
}
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[3] < nStyleDepthLimit)
{
++maResolvingParent[3];
auto ret = pSvgStyleAttributes->getSvgGradientNodeStroke();
--maResolvingParent[3];
return ret;
}
}
return nullptr;
}
const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeFill() const
{
if (!maFill.isSet())
{
if (!maNodeFillURL.isEmpty())
{
const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeFillURL);
if(pNode)
{
if(SVGToken::Pattern == pNode->getType())
{
return static_cast< const SvgPatternNode* >(pNode);
}
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[4] < nStyleDepthLimit)
{
++maResolvingParent[4];
auto ret = pSvgStyleAttributes->getSvgPatternNodeFill();
--maResolvingParent[4];
return ret;
}
}
return nullptr;
}
const SvgPatternNode* SvgStyleAttributes::getSvgPatternNodeStroke() const
{
if (!maStroke.isSet())
{
if(!maNodeStrokeURL.isEmpty())
{
const SvgNode* pNode = mrOwner.getDocument().findSvgNodeById(maNodeStrokeURL);
if(pNode)
{
if(SVGToken::Pattern == pNode->getType())
{
return static_cast< const SvgPatternNode* >(pNode);
}
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[5] < nStyleDepthLimit)
{
++maResolvingParent[5];
auto ret = pSvgStyleAttributes->getSvgPatternNodeStroke();
--maResolvingParent[5];
return ret;
}
}
return nullptr;
}
SvgNumber SvgStyleAttributes::getStrokeWidth() const
{
if(maStrokeWidth.isSet())
{
return maStrokeWidth;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[6] < nStyleDepthLimit)
{
++maResolvingParent[6];
auto ret = pSvgStyleAttributes->getStrokeWidth();
--maResolvingParent[6];
return ret;
}
if(isClipPathContent())
{
return SvgNumber(0.0);
}
// default is 1
return SvgNumber(1.0);
}
SvgNumber SvgStyleAttributes::getStopOpacity() const
{
if(maStopOpacity.isSet())
{
return maStopOpacity;
}
// default is 1
return SvgNumber(1.0);
}
SvgNumber SvgStyleAttributes::getFillOpacity() const
{
if(maFillOpacity.isSet())
{
return maFillOpacity;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[7] < nStyleDepthLimit)
{
++maResolvingParent[7];
auto ret = pSvgStyleAttributes->getFillOpacity();
--maResolvingParent[7];
return ret;
}
// default is 1
return SvgNumber(1.0);
}
SvgNumber SvgStyleAttributes::getOpacity() const
{
if(maOpacity.isSet())
{
return maOpacity;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[33] < nStyleDepthLimit)
{
++maResolvingParent[33];
auto ret = pSvgStyleAttributes->getOpacity();
--maResolvingParent[33];
return ret;
}
// default is 1
return SvgNumber(1.0);
}
Overflow SvgStyleAttributes::getOverflow() const
{
if(Overflow::notset != maOverflow)
{
return maOverflow;
}
if (const SvgStyleAttributes* pSvgStyleAttributes = getCssStyle())
{
return pSvgStyleAttributes->getOverflow();
}
return Overflow::hidden;
}
Visibility SvgStyleAttributes::getVisibility() const
{
if(Visibility::notset == maVisibility || Visibility::inherit == maVisibility)
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[9] < nStyleDepthLimit)
{
++maResolvingParent[9];
auto ret = pSvgStyleAttributes->getVisibility();
--maResolvingParent[9];
return ret;
}
//default is Visible
return Visibility::visible;
}
// Visibility correction/exception for self-exported SVGs:
// When Impress exports single or multi-page SVGs, it puts the
// single slides into <g visibility="hidden">. Not sure why
// this happens, but this leads (correctly) to empty imported
// Graphics.
// Thus, if Visibility::hidden is active and owner is a SVGToken::G
// and it's parent is also a SVGToken::G and it has a Class 'SlideGroup'
// set, check if we are an Impress export.
// We are an Impress export if an SVG-Node titled 'ooo:meta_slides'
// exists.
// All together gives:
if(Visibility::hidden == maVisibility
&& SVGToken::G == mrOwner.getType()
&& nullptr != mrOwner.getDocument().findSvgNodeById(u"ooo:meta_slides"_ustr))
{
const SvgNode* pParent(mrOwner.getParent());
if(nullptr != pParent && SVGToken::G == pParent->getType() && pParent->getClass())
{
const OUString aClass(*pParent->getClass());
if("SlideGroup" == aClass)
{
// if we detect this exception,
// override Visibility::hidden -> Visibility::visible
return Visibility::visible;
}
}
}
return maVisibility;
}
FillRule SvgStyleAttributes::getFillRule() const
{
if(FillRule::notset != maFillRule)
{
return maFillRule;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[10] < nStyleDepthLimit)
{
++maResolvingParent[10];
auto ret = pSvgStyleAttributes->getFillRule();
--maResolvingParent[10];
return ret;
}
// default is NonZero
return FillRule::nonzero;
}
FillRule SvgStyleAttributes::getClipRule() const
{
if(FillRule::notset != maClipRule)
{
return maClipRule;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[25] < nStyleDepthLimit)
{
++maResolvingParent[25];
auto ret = pSvgStyleAttributes->getClipRule();
--maResolvingParent[25];
return ret;
}
// default is NonZero
return FillRule::nonzero;
}
const SvgNumberVector& SvgStyleAttributes::getStrokeDasharray() const
{
if(!maStrokeDasharray.empty())
{
return maStrokeDasharray;
}
else if(mbStrokeDasharraySet)
{
// #121221# is set to empty *by purpose*, do not visit parent styles
return maStrokeDasharray;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[11] < nStyleDepthLimit)
{
++maResolvingParent[11];
const SvgNumberVector& ret = pSvgStyleAttributes->getStrokeDasharray();
--maResolvingParent[11];
return ret;
}
// default empty
return maStrokeDasharray;
}
SvgNumber SvgStyleAttributes::getStrokeDashOffset() const
{
if(maStrokeDashOffset.isSet())
{
return maStrokeDashOffset;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[12] < nStyleDepthLimit)
{
++maResolvingParent[12];
auto ret = pSvgStyleAttributes->getStrokeDashOffset();
--maResolvingParent[12];
return ret;
}
// default is 0
return SvgNumber(0.0);
}
StrokeLinecap SvgStyleAttributes::getStrokeLinecap() const
{
if(maStrokeLinecap != StrokeLinecap::notset)
{
return maStrokeLinecap;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[13] < nStyleDepthLimit)
{
++maResolvingParent[13];
auto ret = pSvgStyleAttributes->getStrokeLinecap();
--maResolvingParent[13];
return ret;
}
// default is StrokeLinecap::butt
return StrokeLinecap::butt;
}
StrokeLinejoin SvgStyleAttributes::getStrokeLinejoin() const
{
if(maStrokeLinejoin != StrokeLinejoin::notset)
{
return maStrokeLinejoin;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[14] < nStyleDepthLimit)
{
++maResolvingParent[14];
auto ret = pSvgStyleAttributes->getStrokeLinejoin();
--maResolvingParent[14];
return ret;
}
// default is StrokeLinejoin::butt
return StrokeLinejoin::miter;
}
SvgNumber SvgStyleAttributes::getStrokeMiterLimit() const
{
if(maStrokeMiterLimit.isSet())
{
return maStrokeMiterLimit;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[15] < nStyleDepthLimit)
{
++maResolvingParent[15];
auto ret = pSvgStyleAttributes->getStrokeMiterLimit();
--maResolvingParent[15];
return ret;
}
// default is 4
return SvgNumber(4.0, SvgUnit::none);
}
SvgNumber SvgStyleAttributes::getStrokeOpacity() const
{
if(maStrokeOpacity.isSet())
{
return maStrokeOpacity;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[16] < nStyleDepthLimit)
{
++maResolvingParent[16];
auto ret = pSvgStyleAttributes->getStrokeOpacity();
--maResolvingParent[16];
return ret;
}
// default is 1
return SvgNumber(1.0);
}
const SvgStringVector& SvgStyleAttributes::getFontFamily() const
{
if(!maFontFamily.empty() && !o3tl::equalsIgnoreAsciiCase(o3tl::trim(maFontFamily[0]), u"inherit"))
{
return maFontFamily;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[17] < nStyleDepthLimit)
{
++maResolvingParent[17];
const SvgStringVector& ret = pSvgStyleAttributes->getFontFamily();
--maResolvingParent[17];
return ret;
}
// default is empty
return maFontFamily;
}
SvgNumber SvgStyleAttributes::getFontSizeNumber() const
{
// default size is 'medium', i.e. 12 pt, or 16px
constexpr double aDefaultSize = o3tl::convert(12.0, o3tl::Length::pt, o3tl::Length::px);
if(maFontSizeNumber.isSet())
{
if(!maFontSizeNumber.isPositive())
return aDefaultSize;
// #122524# Handle SvgUnit::percent relative to parent FontSize (see SVG1.1
// spec 10.10 Font selection properties \91font-size\92, lastline (click 'normative
// definition of the property')
if(SvgUnit::percent == maFontSizeNumber.getUnit())
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if(pSvgStyleAttributes)
{
const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
return SvgNumber(
aParentNumber.getNumber() * maFontSizeNumber.getNumber() * 0.01,
aParentNumber.getUnit(),
true);
}
// if there's no parent style, set the font size based on the default size
// 100% = 16px
return SvgNumber(
maFontSizeNumber.getNumber() * aDefaultSize / 100.0, SvgUnit::px, true);
}
else if((SvgUnit::em == maFontSizeNumber.getUnit()) || (SvgUnit::ex == maFontSizeNumber.getUnit()))
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if(pSvgStyleAttributes)
{
const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
double n = aParentNumber.getNumber() * maFontSizeNumber.getNumber();
if (SvgUnit::ex == maFontSizeNumber.getUnit())
n *= 0.5; // FIXME: use "x-height of the first available font"
return SvgNumber(n, aParentNumber.getUnit());
}
}
return maFontSizeNumber;
}
//In CSS2, the suggested scaling factor between adjacent indexes is 1.2
switch(maFontSize)
{
case FontSize::notset:
break;
case FontSize::xx_small:
{
return SvgNumber(aDefaultSize / 1.728);
}
case FontSize::x_small:
{
return SvgNumber(aDefaultSize / 1.44);
}
case FontSize::small:
{
return SvgNumber(aDefaultSize / 1.2);
}
case FontSize::smaller:
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if(pSvgStyleAttributes)
{
const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
return SvgNumber(aParentNumber.getNumber() / 1.2, aParentNumber.getUnit());
}
[[fallthrough]];
}
case FontSize::medium:
case FontSize::initial:
{
return SvgNumber(aDefaultSize);
}
case FontSize::large:
{
return SvgNumber(aDefaultSize * 1.2);
}
case FontSize::larger:
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if(pSvgStyleAttributes)
{
const SvgNumber aParentNumber = pSvgStyleAttributes->getFontSizeNumber();
return SvgNumber(aParentNumber.getNumber() * 1.2, aParentNumber.getUnit());
}
[[fallthrough]];
}
case FontSize::x_large:
{
return SvgNumber(aDefaultSize * 1.44);
}
case FontSize::xx_large:
{
return SvgNumber(aDefaultSize * 1.728);
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if(pSvgStyleAttributes)
{
return pSvgStyleAttributes->getFontSizeNumber();
}
return SvgNumber(aDefaultSize);
}
FontStretch SvgStyleAttributes::getFontStretch() const
{
if(maFontStretch != FontStretch::notset)
{
if(FontStretch::wider != maFontStretch && FontStretch::narrower != maFontStretch)
{
return maFontStretch;
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[18] < nStyleDepthLimit)
{
++maResolvingParent[18];
FontStretch aInherited = pSvgStyleAttributes->getFontStretch();
--maResolvingParent[18];
if(FontStretch::wider == maFontStretch)
{
aInherited = getWider(aInherited);
}
else if(FontStretch::narrower == maFontStretch)
{
aInherited = getNarrower(aInherited);
}
return aInherited;
}
// default is FontStretch::normal
return FontStretch::normal;
}
FontStyle SvgStyleAttributes::getFontStyle() const
{
if(maFontStyle != FontStyle::notset)
{
return maFontStyle;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[19] < nStyleDepthLimit)
{
++maResolvingParent[19];
auto ret = pSvgStyleAttributes->getFontStyle();
--maResolvingParent[19];
return ret;
}
// default is FontStyle::normal
return FontStyle::normal;
}
FontWeight SvgStyleAttributes::getFontWeight() const
{
if(maFontWeight != FontWeight::notset)
{
if(FontWeight::bolder != maFontWeight && FontWeight::lighter != maFontWeight)
{
return maFontWeight;
}
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[20] < nStyleDepthLimit)
{
++maResolvingParent[20];
FontWeight aInherited = pSvgStyleAttributes->getFontWeight();
--maResolvingParent[20];
if(FontWeight::bolder == maFontWeight)
{
aInherited = getBolder(aInherited);
}
else if(FontWeight::lighter == maFontWeight)
{
aInherited = getLighter(aInherited);
}
return aInherited;
}
// default is FontWeight::N400 (FontWeight::normal)
return FontWeight::N400;
}
TextAlign SvgStyleAttributes::getTextAlign() const
{
if(maTextAlign != TextAlign::notset)
{
return maTextAlign;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[21] < nStyleDepthLimit)
{
++maResolvingParent[21];
auto ret = pSvgStyleAttributes->getTextAlign();
--maResolvingParent[21];
return ret;
}
// default is TextAlign::left
return TextAlign::left;
}
const SvgStyleAttributes* SvgStyleAttributes::getTextDecorationDefiningSvgStyleAttributes() const
{
if(maTextDecoration != TextDecoration::notset)
{
return this;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[22] < nStyleDepthLimit)
{
++maResolvingParent[22];
auto ret = pSvgStyleAttributes->getTextDecorationDefiningSvgStyleAttributes();
--maResolvingParent[22];
return ret;
}
// default is 0
return nullptr;
}
TextDecoration SvgStyleAttributes::getTextDecoration() const
{
const SvgStyleAttributes* pDefining = getTextDecorationDefiningSvgStyleAttributes();
if(pDefining)
{
return pDefining->maTextDecoration;
}
else
{
// default is TextDecoration::none
return TextDecoration::none;
}
}
TextAnchor SvgStyleAttributes::getTextAnchor() const
{
if(maTextAnchor != TextAnchor::notset)
{
return maTextAnchor;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[23] < nStyleDepthLimit)
{
++maResolvingParent[23];
auto ret = pSvgStyleAttributes->getTextAnchor();
--maResolvingParent[23];
return ret;
}
// default is TextAnchor::start
return TextAnchor::start;
}
const basegfx::BColor* SvgStyleAttributes::getColor() const
{
if(maColor.isSet())
{
if(maColor.isCurrent())
{
OSL_ENSURE(false, "Svg error: current color uses current color (!)");
return nullptr;
}
else if(maColor.isOn())
{
return &maColor.getBColor();
}
}
else
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[24] < nStyleDepthLimit)
{
++maResolvingParent[24];
auto ret = pSvgStyleAttributes->getColor();
--maResolvingParent[24];
return ret;
}
}
return nullptr;
}
OUString SvgStyleAttributes::getClipPathXLink() const
{
if(!maClipPathXLink.isEmpty())
{
return maClipPathXLink;
}
// This is called from add_postProcess so only check if it has a css style
if (const SvgStyleAttributes* pSvgStyleAttributes = getCssStyle())
{
return pSvgStyleAttributes->maClipPathXLink;
}
return OUString();
}
const SvgClipPathNode* SvgStyleAttributes::accessClipPathXLink() const
{
const OUString aClipPath(getClipPathXLink());
if(!aClipPath.isEmpty())
{
return dynamic_cast< const SvgClipPathNode* >(mrOwner.getDocument().findSvgNodeById(aClipPath));
}
return nullptr;
}
OUString SvgStyleAttributes::getFilterXLink() const
{
if(!maFilterXLink.isEmpty())
{
return maFilterXLink;
}
// This is called from add_postProcess so only check if it has a css style
if (const SvgStyleAttributes* pSvgStyleAttributes = getCssStyle())
{
return pSvgStyleAttributes->maFilterXLink;
}
return OUString();
}
const SvgFilterNode* SvgStyleAttributes::accessFilterXLink() const
{
const OUString aFilter(getFilterXLink());
if(!aFilter.isEmpty())
{
return dynamic_cast< const SvgFilterNode* >(mrOwner.getDocument().findSvgNodeById(aFilter));
}
return nullptr;
}
OUString SvgStyleAttributes::getMaskXLink() const
{
if(!maMaskXLink.isEmpty())
{
return maMaskXLink;
}
// This is called from add_postProcess so only check if it has a css style
if (const SvgStyleAttributes* pSvgStyleAttributes = getCssStyle())
{
return pSvgStyleAttributes->maMaskXLink;
}
return OUString();
}
const SvgMaskNode* SvgStyleAttributes::accessMaskXLink() const
{
const OUString aMask(getMaskXLink());
if(!aMask.isEmpty())
{
return dynamic_cast< const SvgMaskNode* >(mrOwner.getDocument().findSvgNodeById(aMask));
}
return nullptr;
}
OUString SvgStyleAttributes::getMarkerStartXLink() const
{
if(!maMarkerStartXLink.isEmpty())
{
return maMarkerStartXLink;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[26] < nStyleDepthLimit)
{
++maResolvingParent[26];
auto ret = pSvgStyleAttributes->getMarkerStartXLink();
--maResolvingParent[26];
return ret;
}
return OUString();
}
const SvgMarkerNode* SvgStyleAttributes::accessMarkerStartXLink() const
{
const OUString aMarker(getMarkerStartXLink());
if(!aMarker.isEmpty())
{
return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerStartXLink()));
}
return nullptr;
}
OUString SvgStyleAttributes::getMarkerMidXLink() const
{
if(!maMarkerMidXLink.isEmpty())
{
return maMarkerMidXLink;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[27] < nStyleDepthLimit)
{
++maResolvingParent[27];
auto ret = pSvgStyleAttributes->getMarkerMidXLink();
--maResolvingParent[27];
return ret;
}
return OUString();
}
const SvgMarkerNode* SvgStyleAttributes::accessMarkerMidXLink() const
{
const OUString aMarker(getMarkerMidXLink());
if(!aMarker.isEmpty())
{
return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerMidXLink()));
}
return nullptr;
}
OUString SvgStyleAttributes::getMarkerEndXLink() const
{
if(!maMarkerEndXLink.isEmpty())
{
return maMarkerEndXLink;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[28] < nStyleDepthLimit)
{
++maResolvingParent[28];
auto ret = pSvgStyleAttributes->getMarkerEndXLink();
--maResolvingParent[28];
return ret;
}
return OUString();
}
const SvgMarkerNode* SvgStyleAttributes::accessMarkerEndXLink() const
{
const OUString aMarker(getMarkerEndXLink());
if(!aMarker.isEmpty())
{
return dynamic_cast< const SvgMarkerNode* >(mrOwner.getDocument().findSvgNodeById(getMarkerEndXLink()));
}
return nullptr;
}
SvgNumber SvgStyleAttributes::getBaselineShiftNumber() const
{
// #122524# Handle SvgUnit::percent relative to parent BaselineShift
if(SvgUnit::percent == maBaselineShiftNumber.getUnit())
{
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[8] < nStyleDepthLimit)
{
++maResolvingParent[8];
const SvgNumber aParentNumber = pSvgStyleAttributes->getBaselineShiftNumber();
--maResolvingParent[8];
return SvgNumber(
aParentNumber.getNumber() * maBaselineShiftNumber.getNumber() * 0.01,
aParentNumber.getUnit(),
true);
}
}
return maBaselineShiftNumber;
}
BaselineShift SvgStyleAttributes::getBaselineShift() const
{
if(maBaselineShift != BaselineShift::Baseline)
{
return maBaselineShift;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[29] < nStyleDepthLimit)
{
++maResolvingParent[29];
auto ret = pSvgStyleAttributes->getBaselineShift();
--maResolvingParent[29];
return ret;
}
return BaselineShift::Baseline;
}
DominantBaseline SvgStyleAttributes::getDominantBaseline() const
{
if(maDominantBaseline != DominantBaseline::Auto)
{
return maDominantBaseline;
}
const SvgStyleAttributes* pSvgStyleAttributes = getCssStyleOrParentStyle();
if (pSvgStyleAttributes && maResolvingParent[30] < nStyleDepthLimit)
{
++maResolvingParent[30];
auto ret = pSvgStyleAttributes->getDominantBaseline();
--maResolvingParent[30];
return ret;
}
return DominantBaseline::Auto;
}
} // end of namespace svgio
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
View git blame Copy permalink