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(); }