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