void SVGFELightElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::azimuthAttr)
m_azimuth->setBaseValueAsString(value, parseError);
else if (name == SVGNames::elevationAttr)
m_elevation->setBaseValueAsString(value, parseError);
else if (name == SVGNames::xAttr)
m_x->setBaseValueAsString(value, parseError);
else if (name == SVGNames::yAttr)
m_y->setBaseValueAsString(value, parseError);
else if (name == SVGNames::zAttr)
m_z->setBaseValueAsString(value, parseError);
else if (name == SVGNames::pointsAtXAttr)
m_pointsAtX->setBaseValueAsString(value, parseError);
else if (name == SVGNames::pointsAtYAttr)
m_pointsAtY->setBaseValueAsString(value, parseError);
else if (name == SVGNames::pointsAtZAttr)
m_pointsAtZ->setBaseValueAsString(value, parseError);
else if (name == SVGNames::specularExponentAttr)
m_specularExponent->setBaseValueAsString(value, parseError);
else if (name == SVGNames::limitingConeAngleAttr)
m_limitingConeAngle->setBaseValueAsString(value, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGMarkerElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGElement::parseAttribute(name, value);
else if (name == SVGNames::markerUnitsAttr) {
SVGMarkerUnitsType propertyValue = SVGPropertyTraits<SVGMarkerUnitsType>::fromString(value);
if (propertyValue > 0)
setMarkerUnitsBaseValue(propertyValue);
} else if (name == SVGNames::refXAttr)
setRefXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::refYAttr)
setRefYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::markerWidthAttr)
setMarkerWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::markerHeightAttr)
setMarkerHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::orientAttr) {
SVGAngle angle;
SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(value, angle);
if (orientType > 0)
setOrientTypeBaseValue(orientType);
if (orientType == SVGMarkerOrientAngle)
setOrientAngleBaseValue(angle);
} else if (SVGLangSpace::parseAttribute(name, value)
|| SVGExternalResourcesRequired::parseAttribute(name, value)
|| SVGFitToViewBox::parseAttribute(this, name, value)) {
} else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGRectElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGGraphicsElement::parseAttribute(name, value);
else if (name == SVGNames::xAttr)
setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::yAttr)
setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::rxAttr)
setRxBaseValue(SVGLength::construct(LengthModeWidth, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::ryAttr)
setRyBaseValue(SVGLength::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::widthAttr)
setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::heightAttr)
setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
else if (SVGLangSpace::parseAttribute(name, value)
|| SVGExternalResourcesRequired::parseAttribute(name, value)) {
} else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGRectElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGeometryElement::svgAttributeChanged(attrName);
return;
}
SVGElement::InvalidationGuard invalidationGuard(this);
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr
|| attrName == SVGNames::rxAttr
|| attrName == SVGNames::ryAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
RenderSVGShape* renderer = toRenderSVGShape(this->renderer());
if (!renderer)
return;
if (isLengthAttribute) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGForeignObjectElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
if (attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange);
}
SVGElement::InvalidationGuard invalidationGuard(this);
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
if (RenderObject* renderer = this->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
}
void SVGFEGaussianBlurElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::stdDeviationAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setStdDeviationXBaseValue(x);
setStdDeviationYBaseValue(y);
}
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::edgeModeAttr) {
EdgeModeType propertyValue = SVGPropertyTraits<EdgeModeType>::fromString(value);
if (propertyValue > 0)
setEdgeModeBaseValue(propertyValue);
else
document().accessSVGExtensions()->reportWarning(
"feGaussianBlur: problem parsing edgeMode=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
ASSERT_NOT_REACHED();
}
void SVGFEMorphologyElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::operatorAttr) {
MorphologyOperatorType propertyValue = SVGPropertyTraits<MorphologyOperatorType>::fromString(value);
if (propertyValue > 0)
setSVGOperatorBaseValue(propertyValue);
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::radiusAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setRadiusXBaseValue(x);
setRadiusYBaseValue(y);
}
return;
}
ASSERT_NOT_REACHED();
}
void SVGMaskElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGElement::parseAttribute(name, value);
else if (name == SVGNames::maskUnitsAttr) {
SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setMaskUnitsBaseValue(propertyValue);
return;
} else if (name == SVGNames::maskContentUnitsAttr) {
SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setMaskContentUnitsBaseValue(propertyValue);
return;
} else if (name == SVGNames::xAttr)
setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::yAttr)
setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::widthAttr)
setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::heightAttr)
setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (SVGTests::parseAttribute(name, value)
|| SVGLangSpace::parseAttribute(name, value)
|| SVGExternalResourcesRequired::parseAttribute(name, value)) {
} else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGPathElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
RenderSVGPath* renderer = downcast<RenderSVGPath>(this->renderer());
if (attrName == SVGNames::dAttr) {
if (m_pathSegList.shouldSynchronize && !SVGAnimatedProperty::lookupWrapper<SVGPathElement, SVGAnimatedPathSegListPropertyTearOff>(this, dPropertyInfo())->isAnimating()) {
SVGPathSegList newList(PathSegUnalteredRole);
buildSVGPathSegListFromByteStream(m_pathByteStream, *this, newList, UnalteredParsing);
m_pathSegList.value = newList;
}
if (renderer)
renderer->setNeedsShapeUpdate();
invalidateMPathDependencies();
}
if (renderer)
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
}
void SVGEllipseElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::cxAttr
|| attrName == SVGNames::cyAttr
|| attrName == SVGNames::rxAttr
|| attrName == SVGNames::ryAttr) {
invalidateSVGPresentationAttributeStyle();
return;
}
RenderSVGShape* renderer = toRenderSVGShape(this->renderer());
if (!renderer)
return;
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGPolyElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGGeometryElement::parseAttribute(name, value);
return;
}
if (name == SVGNames::pointsAttr) {
SVGPointList newList;
if (!pointsListFromSVGData(newList, value))
document().accessSVGExtensions()->reportError("Problem parsing points=\"" + value + "\"");
if (SVGAnimatedProperty* wrapper = SVGAnimatedProperty::lookupWrapper<SVGPolyElement, SVGAnimatedPointList>(this, pointsPropertyInfo()))
static_cast<SVGAnimatedPointList*>(wrapper)->detachListWrappers(newList.size());
m_points.value = newList;
return;
}
if (SVGLangSpace::parseAttribute(name, value))
return;
if (SVGExternalResourcesRequired::parseAttribute(name, value))
return;
ASSERT_NOT_REACHED();
}
void SVGFEDropShadowElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::stdDeviationAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setStdDeviationXBaseValue(x);
setStdDeviationYBaseValue(y);
}
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::dxAttr) {
setDxBaseValue(value.toFloat());
return;
}
if (name == SVGNames::dyAttr) {
setDyBaseValue(value.toFloat());
return;
}
ASSERT_NOT_REACHED();
}
void SVGFEConvolveMatrixElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::edgeModeAttr
|| attrName == SVGNames::divisorAttr
|| attrName == SVGNames::biasAttr
|| attrName == SVGNames::targetXAttr
|| attrName == SVGNames::targetYAttr
|| attrName == SVGNames::kernelUnitLengthAttr
|| attrName == SVGNames::preserveAlphaAttr) {
primitiveAttributeChanged(attrName);
return;
}
if (attrName == SVGNames::inAttr
|| attrName == SVGNames::orderAttr
|| attrName == SVGNames::kernelMatrixAttr) {
invalidate();
return;
}
ASSERT_NOT_REACHED();
}
void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
bool isLengthAttribute = attrName == SVGNames::x1Attr
|| attrName == SVGNames::y1Attr
|| attrName == SVGNames::x2Attr
|| attrName == SVGNames::y2Attr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
auto* renderer = downcast<RenderSVGShape>(this->renderer());
if (!renderer)
return;
if (isLengthAttribute) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGPathElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGGraphicsElement::parseAttribute(name, value);
return;
}
if (name == SVGNames::dAttr) {
if (!buildSVGPathByteStreamFromString(value, m_pathByteStream.get(), UnalteredParsing))
document().accessSVGExtensions()->reportError("Problem parsing d=\"" + value + "\"");
return;
}
if (name == SVGNames::pathLengthAttr) {
setPathLengthBaseValue(value.toFloat());
if (pathLengthBaseValue() < 0)
document().accessSVGExtensions()->reportError("A negative value for path attribute <pathLength> is not allowed");
return;
}
if (SVGLangSpace::parseAttribute(name, value))
return;
if (SVGExternalResourcesRequired::parseAttribute(name, value))
return;
ASSERT_NOT_REACHED();
}
void SVGFECompositeElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::operatorAttr
|| attrName == SVGNames::k1Attr
|| attrName == SVGNames::k2Attr
|| attrName == SVGNames::k3Attr
|| attrName == SVGNames::k4Attr) {
primitiveAttributeChanged(attrName);
return;
}
if (attrName == SVGNames::inAttr || attrName == SVGNames::in2Attr) {
invalidate();
return;
}
ASSERT_NOT_REACHED();
}
void SVGTextPositioningElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGTextContentElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
bool updateRelativeLengths = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::dxAttr
|| attrName == SVGNames::dyAttr;
if (updateRelativeLengths)
updateRelativeLengthsInformation();
auto renderer = this->renderer();
if (!renderer)
return;
if (updateRelativeLengths || attrName == SVGNames::rotateAttr) {
if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*renderer))
textAncestor->setNeedsPositioningValuesUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGFEBlendElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::modeAttr) {
BlendMode mode = BlendModeNormal;
if (parseBlendMode(value, mode))
setModeBaseValue(mode);
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::in2Attr) {
setIn2BaseValue(value);
return;
}
ASSERT_NOT_REACHED();
}
void SVGAnimationElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGSMILElement::parseAttribute(name, value);
return;
}
if (name == SVGNames::valuesAttr) {
// Per the SMIL specification, leading and trailing white space,
// and white space before and after semicolon separators, is allowed and will be ignored.
// http://www.w3.org/TR/SVG11/animate.html#ValuesAttribute
value.string().split(';', m_values);
for (unsigned i = 0; i < m_values.size(); ++i)
m_values[i] = m_values[i].stripWhiteSpace();
updateAnimationMode();
return;
}
if (name == SVGNames::keyTimesAttr) {
parseKeyTimes(value, m_keyTimes, true);
return;
}
if (name == SVGNames::keyPointsAttr) {
if (hasTagName(SVGNames::animateMotionTag)) {
// This is specified to be an animateMotion attribute only but it is simpler to put it here
// where the other timing calculatations are.
parseKeyTimes(value, m_keyPoints, false);
}
return;
}
if (name == SVGNames::keySplinesAttr) {
parseKeySplines(value, m_keySplines);
return;
}
if (name == SVGNames::attributeTypeAttr) {
setAttributeType(value);
return;
}
if (name == SVGNames::calcModeAttr) {
setCalcMode(value);
return;
}
if (name == SVGNames::fromAttr || name == SVGNames::toAttr || name == SVGNames::byAttr) {
updateAnimationMode();
return;
}
if (SVGTests::parseAttribute(name, value))
return;
if (SVGExternalResourcesRequired::parseAttribute(name, value))
return;
ASSERT_NOT_REACHED();
}
void SVGFEColorMatrixElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::typeAttr) {
ColorMatrixType propertyValue = SVGPropertyTraits<ColorMatrixType>::fromString(value);
if (propertyValue > 0)
setTypeBaseValue(propertyValue);
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::valuesAttr) {
SVGNumberList newList;
newList.parse(value);
detachAnimatedValuesListWrappers(newList.size());
setValuesBaseValue(newList);
return;
}
ASSERT_NOT_REACHED();
}
void SVGPolyElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGeometryElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
RenderSVGShape* renderer = toRenderSVGShape(this->renderer());
if (!renderer)
return;
if (attrName == SVGNames::pointsAttr) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGPatternElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
} else if (name == SVGNames::patternUnitsAttr) {
m_patternUnits->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::patternContentUnitsAttr) {
m_patternContentUnits->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::patternTransformAttr) {
m_patternTransform->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::xAttr) {
m_x->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::yAttr) {
m_y->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::widthAttr) {
m_width->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::heightAttr) {
m_height->setBaseValueAsString(value, parseError);
} else if (SVGURIReference::parseAttribute(name, value, parseError)) {
} else if (SVGTests::parseAttribute(name, value)) {
} else if (SVGFitToViewBox::parseAttribute(name, value, document(), parseError)) {
} else {
ASSERT_NOT_REACHED();
}
reportAttributeParsingError(parseError, name, value);
}
void SVGFELightElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
return;
}
if (name == SVGNames::azimuthAttr) {
setAzimuthBaseValue(value.toFloat());
return;
}
if (name == SVGNames::elevationAttr) {
setElevationBaseValue(value.toFloat());
return;
}
if (name == SVGNames::xAttr) {
setXBaseValue(value.toFloat());
return;
}
if (name == SVGNames::yAttr) {
setYBaseValue(value.toFloat());
return;
}
if (name == SVGNames::zAttr) {
setZBaseValue(value.toFloat());
return;
}
if (name == SVGNames::pointsAtXAttr) {
setPointsAtXBaseValue(value.toFloat());
return;
}
if (name == SVGNames::pointsAtYAttr) {
setPointsAtYBaseValue(value.toFloat());
return;
}
if (name == SVGNames::pointsAtZAttr) {
setPointsAtZBaseValue(value.toFloat());
return;
}
if (name == SVGNames::specularExponentAttr) {
setSpecularExponentBaseValue(value.toFloat());
return;
}
if (name == SVGNames::limitingConeAngleAttr) {
setLimitingConeAngleBaseValue(value.toFloat());
return;
}
ASSERT_NOT_REACHED();
}
void SVGSymbolElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
invalidateInstances();
}
void SVGAnimationElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGSMILElement::svgAttributeChanged(attrName);
return;
}
animationAttributeChanged();
}
void SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
invalidate();
}
void SVGCursorElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
for (auto& client : m_clients)
client->setNeedsStyleRecalc();
}
void SVGGradientElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
if (RenderObject* object = renderer())
object->setNeedsLayout();
}
void SVGTextContentElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
{
if (!isSupportedAttribute(name))
SVGGraphicsElement::collectStyleForPresentationAttribute(name, value, style);
else if (name.matches(XMLNames::spaceAttr)) {
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, preserveString, ("preserve", AtomicString::ConstructFromLiteral));
if (value == preserveString)
addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePre);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValueNowrap);
}
void SVGTRefElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGTextPositioningElement::parseAttribute(name, value);
return;
}
if (SVGURIReference::parseAttribute(name, value))
return;
ASSERT_NOT_REACHED();
}
