void SVGFEGaussianBlurElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
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) {
auto 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;
}
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
}
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 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 SVGFESpecularLightingElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::surfaceScaleAttr) {
setSurfaceScaleBaseValue(value.toFloat());
return;
}
if (name == SVGNames::specularConstantAttr) {
setSpecularConstantBaseValue(value.toFloat());
return;
}
if (name == SVGNames::specularExponentAttr) {
setSpecularExponentBaseValue(value.toFloat());
return;
}
if (name == SVGNames::kernelUnitLengthAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setKernelUnitLengthXBaseValue(x);
setKernelUnitLengthYBaseValue(y);
}
return;
}
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
}
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 SVGFETurbulenceElement::parseMappedAttribute(MappedAttribute* attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::typeAttr) {
if (value == "fractalNoise")
setTypeBaseValue(FETURBULENCE_TYPE_FRACTALNOISE);
else if (value == "turbulence")
setTypeBaseValue(FETURBULENCE_TYPE_TURBULENCE);
} else if (attr->name() == SVGNames::stitchTilesAttr) {
if (value == "stitch")
setStitchTilesBaseValue(SVG_STITCHTYPE_STITCH);
else if (value == "nostitch")
setStitchTilesBaseValue(SVG_STITCHTYPE_NOSTITCH);
} else if (attr->name() == SVGNames::baseFrequencyAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setBaseFrequencyXBaseValue(x);
setBaseFrequencyYBaseValue(y);
}
} else if (attr->name() == SVGNames::seedAttr)
setSeedBaseValue(value.toFloat());
else if (attr->name() == SVGNames::numOctavesAttr)
setNumOctavesBaseValue(value.toUIntStrict());
else
SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
}
void SVGFEConvolveMatrixElement::parseMappedAttribute(Attribute* attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::inAttr)
setIn1BaseValue(value);
else if (attr->name() == SVGNames::orderAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setOrderXBaseValue(x);
setOrderYBaseValue(y);
}
} else if (attr->name() == SVGNames::edgeModeAttr) {
if (value == "duplicate")
setEdgeModeBaseValue(EDGEMODE_DUPLICATE);
else if (value == "wrap")
setEdgeModeBaseValue(EDGEMODE_WRAP);
else if (value == "none")
setEdgeModeBaseValue(EDGEMODE_NONE);
} else if (attr->name() == SVGNames::kernelMatrixAttr) {
SVGNumberList newList;
newList.parse(value);
detachAnimatedKernelMatrixListWrappers(newList.size());
kernelMatrixBaseValue() = newList;
} else if (attr->name() == SVGNames::divisorAttr)
setDivisorBaseValue(value.toFloat());
else if (attr->name() == SVGNames::biasAttr)
setBiasBaseValue(value.toFloat());
else if (attr->name() == SVGNames::targetXAttr)
setTargetXBaseValue(value.toUIntStrict());
else if (attr->name() == SVGNames::targetYAttr)
setTargetYBaseValue(value.toUIntStrict());
else if (attr->name() == SVGNames::kernelUnitLengthAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setKernelUnitLengthXBaseValue(x);
setKernelUnitLengthYBaseValue(y);
}
} else if (attr->name() == SVGNames::preserveAlphaAttr) {
if (value == "true")
setPreserveAlphaBaseValue(true);
else if (value == "false")
setPreserveAlphaBaseValue(false);
} else
SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
}
PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGNumberOptionalNumber::cloneForAnimation(const String& value) const
{
float x, y;
if (!parseNumberOptionalNumber(value, x, y)) {
x = y = 0;
}
return SVGNumberOptionalNumber::create(SVGNumber::create(x), SVGNumber::create(y));
}
PassOwnPtr<SVGAnimatedType> SVGAnimatedNumberOptionalNumberAnimator::constructFromString(const String& string)
{
OwnPtr<SVGAnimatedType> animtedType = SVGAnimatedType::createNumberOptionalNumber(new pair<float, float>);
pair<float, float>& animatedNumber = animtedType->numberOptionalNumber();
if (!parseNumberOptionalNumber(string, animatedNumber.first, animatedNumber.second)) {
animatedNumber.first = 0;
animatedNumber.second = 0;
}
return animtedType.release();
}
void SVGIntegerOptionalInteger::setValueAsString(const String& value, ExceptionState& exceptionState)
{
float x, y;
if (!parseNumberOptionalNumber(value, x, y)) {
exceptionState.throwDOMException(SyntaxError, "The value provided ('" + value + "') is invalid.");
x = y = 0;
}
m_firstInteger->setValue(x);
m_secondInteger->setValue(y);
}
PassRefPtrWillBeRawPtr<SVGPropertyBase> SVGIntegerOptionalInteger::cloneForAnimation(const String& value) const
{
float floatX, floatY;
if (!parseNumberOptionalNumber(value, floatX, floatY)) {
return SVGIntegerOptionalInteger::create(SVGInteger::create(0), SVGInteger::create(0));
}
int x = static_cast<int>(roundf(floatX));
int y = static_cast<int>(roundf(floatY));
return SVGIntegerOptionalInteger::create(SVGInteger::create(x), SVGInteger::create(y));
}
SVGParsingError SVGNumberOptionalNumber::setValueAsString(const String& value)
{
float x, y;
SVGParsingError parseStatus;
if (!parseNumberOptionalNumber(value, x, y)) {
parseStatus = SVGParseStatus::ExpectedNumber;
x = y = 0;
}
m_firstNumber->setValue(x);
m_secondNumber->setValue(y);
return parseStatus;
}
void SVGFEGaussianBlurElement::parseMappedAttribute(MappedAttribute* attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::stdDeviationAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setStdDeviationXBaseValue(x);
setStdDeviationYBaseValue(y);
}
} else if (attr->name() == SVGNames::inAttr)
setIn1BaseValue(value);
else
SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
}
PassOwnPtr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString(const String& string)
{
OwnPtr<SVGAnimatedType> animtedType = SVGAnimatedType::createIntegerOptionalInteger(new pair<int, int>);
pair<int, int>& animatedInteger = animtedType->integerOptionalInteger();
float firstNumber = 0;
float secondNumber = 0;
if (!parseNumberOptionalNumber(string, firstNumber, secondNumber)) {
animatedInteger.first = 0;
animatedInteger.second = 0;
} else {
animatedInteger.first = static_cast<int>(roundf(firstNumber));
animatedInteger.second = static_cast<int>(roundf(secondNumber));
}
return animtedType.release();
}
std::unique_ptr<SVGAnimatedType> SVGAnimatedIntegerOptionalIntegerAnimator::constructFromString(const String& string)
{
auto animatedType = SVGAnimatedType::createIntegerOptionalInteger(std::make_unique<std::pair<int, int>>());
std::pair<int, int>& animatedInteger = animatedType->integerOptionalInteger();
float firstNumber = 0;
float secondNumber = 0;
if (!parseNumberOptionalNumber(string, firstNumber, secondNumber)) {
animatedInteger.first = 0;
animatedInteger.second = 0;
} else {
animatedInteger.first = static_cast<int>(roundf(firstNumber));
animatedInteger.second = static_cast<int>(roundf(secondNumber));
}
return animatedType;
}
void SVGFEDiffuseLightingElement::parseMappedAttribute(MappedAttribute *attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::inAttr)
setIn1BaseValue(value);
else if (attr->name() == SVGNames::surfaceScaleAttr)
setSurfaceScaleBaseValue(value.toFloat());
else if (attr->name() == SVGNames::diffuseConstantAttr)
setDiffuseConstantBaseValue(value.toInt());
else if (attr->name() == SVGNames::kernelUnitLengthAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setKernelUnitLengthXBaseValue(x);
setKernelUnitLengthYBaseValue(y);
}
} else
SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
}
void SVGFEMorphologyElement::parseMappedAttribute(Attribute* attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::operatorAttr) {
if (value == "erode")
set_operatorBaseValue(FEMORPHOLOGY_OPERATOR_ERODE);
else if (value == "dilate")
set_operatorBaseValue(FEMORPHOLOGY_OPERATOR_DILATE);
} else if (attr->name() == SVGNames::inAttr)
setIn1BaseValue(value);
else if (attr->name() == SVGNames::radiusAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setRadiusXBaseValue(x);
setRadiusYBaseValue(y);
}
} else
SVGFilterPrimitiveStandardAttributes::parseMappedAttribute(attr);
}
void SVGFETurbulenceElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::typeAttr) {
TurbulenceType propertyValue = SVGPropertyTraits<TurbulenceType>::fromString(value);
if (propertyValue > 0)
setTypeBaseValue(propertyValue);
return;
}
if (name == SVGNames::stitchTilesAttr) {
SVGStitchOptions propertyValue = SVGPropertyTraits<SVGStitchOptions>::fromString(value);
if (propertyValue > 0)
setStitchTilesBaseValue(propertyValue);
return;
}
if (name == SVGNames::baseFrequencyAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setBaseFrequencyXBaseValue(x);
setBaseFrequencyYBaseValue(y);
}
return;
}
if (name == SVGNames::seedAttr) {
setSeedBaseValue(value.toFloat());
return;
}
if (name == SVGNames::numOctavesAttr) {
setNumOctavesBaseValue(value.string().toUIntStrict());
return;
}
ASSERT_NOT_REACHED();
}
void SVGFilterElement::parseMappedAttribute(MappedAttribute* attr)
{
const String& value = attr->value();
if (attr->name() == SVGNames::filterUnitsAttr) {
if (value == "userSpaceOnUse")
setFilterUnitsBaseValue(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE);
else if (value == "objectBoundingBox")
setFilterUnitsBaseValue(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
} else if (attr->name() == SVGNames::primitiveUnitsAttr) {
if (value == "userSpaceOnUse")
setPrimitiveUnitsBaseValue(SVGUnitTypes::SVG_UNIT_TYPE_USERSPACEONUSE);
else if (value == "objectBoundingBox")
setPrimitiveUnitsBaseValue(SVGUnitTypes::SVG_UNIT_TYPE_OBJECTBOUNDINGBOX);
} else if (attr->name() == SVGNames::xAttr)
setXBaseValue(SVGLength(LengthModeWidth, value));
else if (attr->name() == SVGNames::yAttr)
setYBaseValue(SVGLength(LengthModeHeight, value));
else if (attr->name() == SVGNames::widthAttr)
setWidthBaseValue(SVGLength(LengthModeWidth, value));
else if (attr->name() == SVGNames::heightAttr)
setHeightBaseValue(SVGLength(LengthModeHeight, value));
else if (attr->name() == SVGNames::filterResAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y)) {
setFilterResXBaseValue(x);
setFilterResYBaseValue(y);
}
} else {
if (SVGURIReference::parseMappedAttribute(attr))
return;
if (SVGLangSpace::parseMappedAttribute(attr))
return;
if (SVGExternalResourcesRequired::parseMappedAttribute(attr))
return;
SVGStyledElement::parseMappedAttribute(attr);
}
}
bool SVGAnimatedType::setValueAsString(const QualifiedName& attrName, const String& value)
{
ExceptionCode ec = 0;
switch (m_type) {
case AnimatedAngle:
ASSERT(m_data.angle);
m_data.angle->setValueAsString(value, ec);
break;
case AnimatedBoolean:
ASSERT(m_data.boolean);
*m_data.boolean = value == "true" ? true : false;
break;
case AnimatedColor:
ASSERT(m_data.color);
*m_data.color = value.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(value);
break;
case AnimatedInteger: {
ASSERT(m_data.integer);
bool ok;
*m_data.integer = value.toIntStrict(&ok);
if (!ok)
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
break;
}
case AnimatedLength:
ASSERT(m_data.length);
m_data.length->setValueAsString(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName), ec);
break;
case AnimatedLengthList:
ASSERT(m_data.lengthList);
m_data.lengthList->parse(value, SVGLength::lengthModeForAnimatedLengthAttribute(attrName));
break;
case AnimatedNumber:
ASSERT(m_data.number);
parseNumberFromString(value, *m_data.number);
break;
case AnimatedNumberList:
ASSERT(m_data.numberList);
m_data.numberList->parse(value);
break;
case AnimatedNumberOptionalNumber:
ASSERT(m_data.numberOptionalNumber);
parseNumberOptionalNumber(value, m_data.numberOptionalNumber->first, m_data.numberOptionalNumber->second);
break;
case AnimatedPath: {
ASSERT(m_data.path);
OwnPtr<SVGPathByteStream> pathByteStream = adoptPtr(m_data.path);
if (!SVGPathParserFactory::self()->buildSVGPathByteStreamFromString(value, pathByteStream, UnalteredParsing))
ec = 1; // Arbitary value > 0, it doesn't matter as we don't report the exception code.
m_data.path = pathByteStream.leakPtr();
break;
}
case AnimatedPoints:
ASSERT(m_data.pointList);
m_data.pointList->clear();
pointsListFromSVGData(*m_data.pointList, value);
break;
case AnimatedPreserveAspectRatio:
ASSERT(m_data.preserveAspectRatio);
SVGPreserveAspectRatio::parsePreserveAspectRatio(this, value);
break;
case AnimatedRect:
ASSERT(m_data.rect);
parseRect(value, *m_data.rect);
break;
case AnimatedString:
ASSERT(m_data.string);
*m_data.string = value;
break;
default:
ASSERT_NOT_REACHED();
break;
}
return !ec;
}
void SVGFEConvolveMatrixElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);
return;
}
if (name == SVGNames::inAttr) {
setIn1BaseValue(value);
return;
}
if (name == SVGNames::orderAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y) && x >= 1 && y >= 1) {
setOrderXBaseValue(x);
setOrderYBaseValue(y);
} else
document().accessSVGExtensions()->reportWarning(
"feConvolveMatrix: problem parsing order=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
if (name == SVGNames::edgeModeAttr) {
EdgeModeType propertyValue = SVGPropertyTraits<EdgeModeType>::fromString(value);
if (propertyValue > 0)
setEdgeModeBaseValue(propertyValue);
else
document().accessSVGExtensions()->reportWarning(
"feConvolveMatrix: problem parsing edgeMode=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
if (name == SVGNames::kernelMatrixAttr) {
SVGNumberList newList;
newList.parse(value);
detachAnimatedKernelMatrixListWrappers(newList.size());
setKernelMatrixBaseValue(newList);
return;
}
if (name == SVGNames::divisorAttr) {
float divisor = value.toFloat();
if (divisor)
setDivisorBaseValue(divisor);
else
document().accessSVGExtensions()->reportWarning(
"feConvolveMatrix: problem parsing divisor=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
if (name == SVGNames::biasAttr) {
setBiasBaseValue(value.toFloat());
return;
}
if (name == SVGNames::targetXAttr) {
setTargetXBaseValue(value.string().toUIntStrict());
return;
}
if (name == SVGNames::targetYAttr) {
setTargetYBaseValue(value.string().toUIntStrict());
return;
}
if (name == SVGNames::kernelUnitLengthAttr) {
float x, y;
if (parseNumberOptionalNumber(value, x, y) && x > 0 && y > 0) {
setKernelUnitLengthXBaseValue(x);
setKernelUnitLengthYBaseValue(y);
} else
document().accessSVGExtensions()->reportWarning(
"feConvolveMatrix: problem parsing kernelUnitLength=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
if (name == SVGNames::preserveAlphaAttr) {
if (value == "true")
setPreserveAlphaBaseValue(true);
else if (value == "false")
setPreserveAlphaBaseValue(false);
else
document().accessSVGExtensions()->reportWarning(
"feConvolveMatrix: problem parsing preserveAlphaAttr=\"" + value
+ "\". Filtered element will not be displayed.");
return;
}
ASSERT_NOT_REACHED();
}