void SVGElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
{
if (SVGAnimatedPropertyBase* property = propertyFromAttribute(name)) {
SVGParsingError parseError = property->setBaseValueAsString(value);
reportAttributeParsingError(parseError, name, value);
return;
}
if (name == HTMLNames::classAttr) {
// SVG animation has currently requires special storage of values so we set
// the className here. svgAttributeChanged actually causes the resulting
// style updates (instead of Element::parseAttribute). We don't
// tell Element about the change to avoid parsing the class list twice
SVGParsingError parseError = m_className->setBaseValueAsString(value);
reportAttributeParsingError(parseError, name, value);
} else if (name == tabindexAttr) {
Element::parseAttribute(name, oldValue, value);
} else {
// standard events
const AtomicString& eventName = HTMLElement::eventNameForAttributeName(name);
if (!eventName.isNull())
setAttributeEventListener(eventName, createAttributeEventListener(this, name, value, eventParameterName()));
else
Element::parseAttribute(name, oldValue, value);
}
}
void SVGAnimationElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
{
if (name == SVGNames::valuesAttr) {
if (!parseValues(value, m_values)) {
reportAttributeParsingError(ParsingAttributeFailedError, name, value);
return;
}
updateAnimationMode();
return;
}
if (name == SVGNames::keyTimesAttr) {
if (!parseKeyTimes(value, m_keyTimes, true))
reportAttributeParsingError(ParsingAttributeFailedError, name, value);
return;
}
if (name == SVGNames::keyPointsAttr) {
if (isSVGAnimateMotionElement(*this)) {
// This is specified to be an animateMotion attribute only but it is simpler to put it here
// where the other timing calculatations are.
if (!parseKeyTimes(value, m_keyPoints, false))
reportAttributeParsingError(ParsingAttributeFailedError, name, value);
}
return;
}
if (name == SVGNames::keySplinesAttr) {
if (!parseKeySplines(value, m_keySplines))
reportAttributeParsingError(ParsingAttributeFailedError, name, value);
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;
}
SVGSMILElement::parseAttribute(name, oldValue, value);
}
void SVGMaskElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == SVGNames::maskUnitsAttr) {
auto propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setMaskUnitsBaseValue(propertyValue);
return;
}
if (name == SVGNames::maskContentUnitsAttr) {
auto propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setMaskContentUnitsBaseValue(propertyValue);
return;
}
SVGParsingError parseError = NoError;
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));
reportAttributeParsingError(parseError, name, value);
SVGElement::parseAttribute(name, value);
SVGTests::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(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 SVGFilterElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (name == SVGNames::filterUnitsAttr) {
SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setFilterUnitsBaseValue(propertyValue);
} else if (name == SVGNames::primitiveUnitsAttr) {
SVGUnitTypes::SVGUnitType propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setPrimitiveUnitsBaseValue(propertyValue);
} 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 (name == SVGNames::filterResAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setFilterResXBaseValue(x);
setFilterResYBaseValue(y);
}
}
reportAttributeParsingError(parseError, name, value);
SVGElement::parseAttribute(name, value);
SVGURIReference::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(name, value);
}
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 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 SVGImageElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == SVGNames::preserveAspectRatioAttr) {
SVGPreserveAspectRatio preserveAspectRatio;
preserveAspectRatio.parse(value);
setPreserveAspectRatioBaseValue(preserveAspectRatio);
return;
}
SVGParsingError parseError = NoError;
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, ForbidNegativeLengths));
else if (name == SVGNames::heightAttr)
setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
reportAttributeParsingError(parseError, name, value);
SVGGraphicsElement::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(name, value);
SVGURIReference::parseAttribute(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 SVGSVGElement::parseAttribute(const QualifiedName& name,
const AtomicString& oldValue,
const AtomicString& value) {
if (!nearestViewportElement()) {
bool setListener = true;
// Only handle events if we're the outermost <svg> element
if (name == HTMLNames::onunloadAttr) {
document().setWindowAttributeEventListener(
EventTypeNames::unload,
createAttributeEventListener(document().frame(), name, value,
eventParameterName()));
} else if (name == HTMLNames::onresizeAttr) {
document().setWindowAttributeEventListener(
EventTypeNames::resize,
createAttributeEventListener(document().frame(), name, value,
eventParameterName()));
} else if (name == HTMLNames::onscrollAttr) {
document().setWindowAttributeEventListener(
EventTypeNames::scroll,
createAttributeEventListener(document().frame(), name, value,
eventParameterName()));
} else {
setListener = false;
}
if (setListener)
return;
}
if (name == HTMLNames::onabortAttr) {
document().setWindowAttributeEventListener(
EventTypeNames::abort,
createAttributeEventListener(document().frame(), name, value,
eventParameterName()));
} else if (name == HTMLNames::onerrorAttr) {
document().setWindowAttributeEventListener(
EventTypeNames::error,
createAttributeEventListener(document().frame(), name, value,
eventParameterName()));
} else if (SVGZoomAndPan::parseAttribute(name, value)) {
} else if (name == SVGNames::widthAttr || name == SVGNames::heightAttr) {
SVGAnimatedLength* property =
name == SVGNames::widthAttr ? m_width : m_height;
SVGParsingError parseError;
if (!value.isNull())
parseError = property->setBaseValueAsString(value);
if (parseError != SVGParseStatus::NoError || value.isNull())
property->setDefaultValueAsString("100%");
reportAttributeParsingError(parseError, name, value);
} else {
SVGElement::parseAttribute(name, oldValue, value);
}
}
void SVGElement::parseAttributeNew(const QualifiedName& name, const AtomicString& value)
{
RefPtr<SVGAnimatedPropertyBase> property = propertyFromAttribute(name);
if (property) {
SVGParsingError parseError = NoError;
property->setBaseValueAsString(value, parseError);
reportAttributeParsingError(parseError, name, value);
return;
}
SVGElement::parseAttribute(name, value);
}
void SVGSymbolElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (SVGFitToViewBox::parseAttribute(name, value, document(), parseError)) {
} else {
ASSERT_NOT_REACHED();
}
reportAttributeParsingError(parseError, name, value);
}
void SVGClipPathElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGGraphicsElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::clipPathUnitsAttr)
m_clipPathUnits->setBaseValueAsString(value, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGFEMergeNodeElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::inAttr)
m_in1->setBaseValueAsString(value, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGCursorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (name == SVGNames::xAttr)
setXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::yAttr)
setYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
reportAttributeParsingError(parseError, name, value);
SVGElement::parseAttribute(name, value);
SVGTests::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(name, value);
SVGURIReference::parseAttribute(name, value);
}
void SVGSVGElement::parseMappedAttribute(Attribute* attr)
{
SVGParsingError parseError = NoError;
if (!nearestViewportElement()) {
bool setListener = true;
// Only handle events if we're the outermost <svg> element
if (attr->name() == HTMLNames::onunloadAttr)
document()->setWindowAttributeEventListener(eventNames().unloadEvent, createAttributeEventListener(document()->frame(), attr));
else if (attr->name() == HTMLNames::onresizeAttr)
document()->setWindowAttributeEventListener(eventNames().resizeEvent, createAttributeEventListener(document()->frame(), attr));
else if (attr->name() == HTMLNames::onscrollAttr)
document()->setWindowAttributeEventListener(eventNames().scrollEvent, createAttributeEventListener(document()->frame(), attr));
else if (attr->name() == SVGNames::onzoomAttr)
document()->setWindowAttributeEventListener(eventNames().zoomEvent, createAttributeEventListener(document()->frame(), attr));
else
setListener = false;
if (setListener)
return;
}
if (attr->name() == HTMLNames::onabortAttr)
document()->setWindowAttributeEventListener(eventNames().abortEvent, createAttributeEventListener(document()->frame(), attr));
else if (attr->name() == HTMLNames::onerrorAttr)
document()->setWindowAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(document()->frame(), attr));
else if (attr->name() == SVGNames::xAttr)
setXBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError));
else if (attr->name() == SVGNames::yAttr)
setYBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError));
else if (attr->name() == SVGNames::widthAttr) {
setWidthBaseValue(SVGLength::construct(LengthModeWidth, attr->value(), parseError, ForbidNegativeLengths));
addCSSProperty(attr, CSSPropertyWidth, attr->value());
} else if (attr->name() == SVGNames::heightAttr) {
setHeightBaseValue(SVGLength::construct(LengthModeHeight, attr->value(), parseError, ForbidNegativeLengths));
addCSSProperty(attr, CSSPropertyHeight, attr->value());
} else if (SVGTests::parseMappedAttribute(attr)
|| SVGLangSpace::parseMappedAttribute(attr)
|| SVGExternalResourcesRequired::parseMappedAttribute(attr)
|| SVGFitToViewBox::parseMappedAttribute(document(), attr)
|| SVGZoomAndPan::parseMappedAttribute(attr)) {
} else
SVGStyledLocatableElement::parseMappedAttribute(attr);
reportAttributeParsingError(parseError, attr);
}
void SVGCircleElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGGeometryElement::parseAttribute(name, value);
else if (name == SVGNames::cxAttr)
m_cx->setBaseValueAsString(value, parseError);
else if (name == SVGNames::cyAttr)
m_cy->setBaseValueAsString(value, parseError);
else if (name == SVGNames::rAttr)
m_r->setBaseValueAsString(value, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGLinearGradientElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (name == SVGNames::x1Attr)
setX1BaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::y1Attr)
setY1BaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::x2Attr)
setX2BaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::y2Attr)
setY2BaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
reportAttributeParsingError(parseError, name, value);
SVGGradientElement::parseAttribute(name, value);
}
void SVGSVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!nearestViewportElement()) {
bool setListener = true;
// Only handle events if we're the outermost <svg> element
if (name == HTMLNames::onunloadAttr)
document()->setWindowAttributeEventListener(eventNames().unloadEvent, createAttributeEventListener(document()->frame(), name, value));
else if (name == HTMLNames::onresizeAttr)
document()->setWindowAttributeEventListener(eventNames().resizeEvent, createAttributeEventListener(document()->frame(), name, value));
else if (name == HTMLNames::onscrollAttr)
document()->setWindowAttributeEventListener(eventNames().scrollEvent, createAttributeEventListener(document()->frame(), name, value));
else if (name == SVGNames::onzoomAttr)
document()->setWindowAttributeEventListener(eventNames().zoomEvent, createAttributeEventListener(document()->frame(), name, value));
else
setListener = false;
if (setListener)
return;
}
if (name == HTMLNames::onabortAttr)
document()->setWindowAttributeEventListener(eventNames().abortEvent, createAttributeEventListener(document()->frame(), name, value));
else if (name == HTMLNames::onerrorAttr)
document()->setWindowAttributeEventListener(eventNames().errorEvent, createAttributeEventListener(document()->frame(), 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::widthAttr)
setWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::heightAttr)
setHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
else if (SVGTests::parseAttribute(name, value)
|| SVGLangSpace::parseAttribute(name, value)
|| SVGExternalResourcesRequired::parseAttribute(name, value)
|| SVGFitToViewBox::parseAttribute(this, name, value)
|| SVGZoomAndPan::parseAttribute(this, name, value)) {
} else
SVGStyledTransformableElement::parseAttribute(name, value);
reportAttributeParsingError(parseError, name, value);
}
void SVGCursorElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
} else if (name == SVGNames::xAttr) {
m_x->setBaseValueAsString(value, parseError);
} else if (name == SVGNames::yAttr) {
m_y->setBaseValueAsString(value, parseError);
} else if (SVGURIReference::parseAttribute(name, value, parseError)) {
} else if (SVGTests::parseAttribute(name, value)) {
} else {
ASSERT_NOT_REACHED();
}
reportAttributeParsingError(parseError, name, value);
}
void SVGAElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGGraphicsElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::targetAttr) {
m_svgTarget->setBaseValueAsString(value, parseError);
} else if (SVGURIReference::parseAttribute(name, value, parseError)) {
} else {
ASSERT_NOT_REACHED();
}
reportAttributeParsingError(parseError, name, value);
}
void SVGForeignObjectElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
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));
reportAttributeParsingError(parseError, name, value);
SVGGraphicsElement::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(name, value);
}
void SVGLineElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGGeometryElement::parseAttribute(name, value);
else if (name == SVGNames::x1Attr)
m_x1->setBaseValueAsString(value, parseError);
else if (name == SVGNames::y1Attr)
m_y1->setBaseValueAsString(value, parseError);
else if (name == SVGNames::x2Attr)
m_x2->setBaseValueAsString(value, parseError);
else if (name == SVGNames::y2Attr)
m_y2->setBaseValueAsString(value, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGFilterPrimitiveStandardAttributes::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
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 (name == SVGNames::resultAttr)
setResultBaseValue(value);
reportAttributeParsingError(parseError, name, value);
SVGElement::parseAttribute(name, value);
}
void SVGEllipseElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGGeometryElement::parseAttribute(name, value);
else if (name == SVGNames::cxAttr)
m_cx->setBaseValueAsString(value, AllowNegativeLengths, parseError);
else if (name == SVGNames::cyAttr)
m_cy->setBaseValueAsString(value, AllowNegativeLengths, parseError);
else if (name == SVGNames::rxAttr)
m_rx->setBaseValueAsString(value, ForbidNegativeLengths, parseError);
else if (name == SVGNames::ryAttr)
m_ry->setBaseValueAsString(value, ForbidNegativeLengths, parseError);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGForeignObjectElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGGraphicsElement::parseAttribute(name, value);
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
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGScriptElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGElement::parseAttribute(name, value);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::typeAttr)
return;
if (name == HTMLNames::onerrorAttr) {
setAttributeEventListener(EventTypeNames::error, createAttributeEventListener(this, name, value));
} else if (SVGURIReference::parseAttribute(name, value, parseError)) {
} else {
ASSERT_NOT_REACHED();
}
reportAttributeParsingError(parseError, name, value);
}
void SVGPatternElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == SVGNames::patternUnitsAttr) {
auto propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setPatternUnitsBaseValue(propertyValue);
return;
}
if (name == SVGNames::patternContentUnitsAttr) {
auto propertyValue = SVGPropertyTraits<SVGUnitTypes::SVGUnitType>::fromString(value);
if (propertyValue > 0)
setPatternContentUnitsBaseValue(propertyValue);
return;
}
if (name == SVGNames::patternTransformAttr) {
SVGTransformListValues newList;
newList.parse(value);
detachAnimatedPatternTransformListWrappers(newList.size());
setPatternTransformBaseValue(newList);
return;
}
SVGParsingError parseError = NoError;
if (name == SVGNames::xAttr)
setXBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::yAttr)
setYBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::widthAttr)
setWidthBaseValue(SVGLengthValue::construct(LengthModeWidth, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::heightAttr)
setHeightBaseValue(SVGLengthValue::construct(LengthModeHeight, value, parseError, ForbidNegativeLengths));
reportAttributeParsingError(parseError, name, value);
SVGElement::parseAttribute(name, value);
SVGURIReference::parseAttribute(name, value);
SVGTests::parseAttribute(name, value);
SVGExternalResourcesRequired::parseAttribute(name, value);
SVGFitToViewBox::parseAttribute(this, name, value);
}
void SVGTextPathElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (name == SVGNames::startOffsetAttr)
setStartOffsetBaseValue(SVGLength::construct(LengthModeOther, value, parseError));
else if (name == SVGNames::methodAttr) {
SVGTextPathMethodType propertyValue = SVGPropertyTraits<SVGTextPathMethodType>::fromString(value);
if (propertyValue > 0)
setMethodBaseValue(propertyValue);
} else if (name == SVGNames::spacingAttr) {
SVGTextPathSpacingType propertyValue = SVGPropertyTraits<SVGTextPathSpacingType>::fromString(value);
if (propertyValue > 0)
setSpacingBaseValue(propertyValue);
}
reportAttributeParsingError(parseError, name, value);
SVGTextContentElement::parseAttribute(name, value);
SVGURIReference::parseAttribute(name, value);
}
void SVGRadialGradientElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (name == SVGNames::cxAttr)
setCxBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::cyAttr)
setCyBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::rAttr)
setRBaseValue(SVGLength::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
else if (name == SVGNames::fxAttr)
setFxBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::fyAttr)
setFyBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::frAttr)
setFrBaseValue(SVGLength::construct(LengthModeOther, value, parseError, ForbidNegativeLengths));
reportAttributeParsingError(parseError, name, value);
SVGGradientElement::parseAttribute(name, value);
}
