void SVGSMILElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (attrName == SVGNames::durAttr) {
m_cachedDur = invalidCachedTime;
} else if (attrName == SVGNames::repeatDurAttr) {
m_cachedRepeatDur = invalidCachedTime;
} else if (attrName == SVGNames::repeatCountAttr) {
m_cachedRepeatCount = invalidCachedTime;
} else if (attrName == SVGNames::minAttr) {
m_cachedMin = invalidCachedTime;
} else if (attrName == SVGNames::maxAttr) {
m_cachedMax = invalidCachedTime;
} else if (attrName == SVGNames::attributeNameAttr) {
setAttributeName(constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr)));
} else if (attrName.matches(SVGNames::hrefAttr) || attrName.matches(XLinkNames::hrefAttr)) {
// TODO(fs): Could be smarter here when 'href' is specified and 'xlink:href' is changed.
SVGElement::InvalidationGuard invalidationGuard(this);
buildPendingResource();
if (m_targetElement)
clearAnimatedType();
} else if (attrName == SVGNames::beginAttr || attrName == SVGNames::endAttr) {
if (inDocument()) {
connectEventBaseConditions();
if (attrName == SVGNames::beginAttr)
beginListChanged(elapsed());
else if (attrName == SVGNames::endAttr)
endListChanged(elapsed());
}
} else {
SVGElement::svgAttributeChanged(attrName);
return;
}
animationAttributeChanged();
}
void SVGLangSpace::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name.matches(XMLNames::langAttr))
setXmllang(value);
if (name.matches(XMLNames::spaceAttr))
setXmlspace(value);
}
bool SVGTextPositioningElement::isKnownAttribute(const QualifiedName& attrName)
{
return (attrName.matches(SVGNames::xAttr) ||
attrName.matches(SVGNames::yAttr) ||
attrName.matches(SVGNames::dxAttr) ||
attrName.matches(SVGNames::dyAttr) ||
attrName.matches(SVGNames::rotateAttr) ||
SVGTextContentElement::isKnownAttribute(attrName));
}
bool SVGTextContentElement::isKnownAttribute(const QualifiedName& attrName)
{
return (attrName.matches(SVGNames::lengthAdjustAttr) ||
attrName.matches(SVGNames::textLengthAttr) ||
SVGTests::isKnownAttribute(attrName) ||
SVGLangSpace::isKnownAttribute(attrName) ||
SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
SVGStyledElement::isKnownAttribute(attrName));
}
bool SVGLangSpace::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name.matches(XMLNames::langAttr)) {
setXmllang(value);
return true;
}
if (name.matches(XMLNames::spaceAttr)) {
setXmlspace(value);
return true;
}
return false;
}
void SVGStyledElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGElement::svgAttributeChanged(attrName);
if (attrName.matches(HTMLNames::classAttr))
classAttributeChanged(className());
RenderObject* object = renderer();
if (attrName == idAttributeName()) {
// Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
if (object && object->isSVGResourceContainer())
object->toRenderSVGResourceContainer()->idChanged();
}
if (!document()->parsing() && object) {
// If we're the child of a resource element, tell the resource (and eventually its resources) that we've changed.
invalidateResourcesInAncestorChain();
// If we're referencing resources, tell them we've changed.
deregisterFromResources(object);
}
// Invalidate all SVGElementInstances associated with us
SVGElementInstance::invalidateAllInstancesOfElement(this);
}
void SVGStyledElement::synchronizeProperty(const QualifiedName& attrName)
{
SVGElement::synchronizeProperty(attrName);
if (attrName == anyQName() || attrName.matches(HTMLNames::classAttr))
synchronizeClassName();
}
bool SVGURIReference::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name.matches(XLinkNames::hrefAttr)) {
setHrefBaseValue(value);
return true;
}
return false;
}
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 HTMLElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
{
if (name == alignAttr) {
if (equalIgnoringCase(value, "middle"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, CSSValueCenter);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, value);
} else if (name == contenteditableAttr) {
if (value.isEmpty() || equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWrite);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
UseCounter::count(document(), UseCounter::ContentEditableTrue);
if (hasTagName(htmlTag))
UseCounter::count(document(), UseCounter::ContentEditableTrueOnHTML);
} else if (equalIgnoringCase(value, "plaintext-only")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
UseCounter::count(document(), UseCounter::ContentEditablePlainTextOnly);
} else if (equalIgnoringCase(value, "false")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadOnly);
}
} else if (name == hiddenAttr) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyDisplay, CSSValueNone);
} else if (name == draggableAttr) {
if (equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueElement);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserSelect, CSSValueNone);
} else if (equalIgnoringCase(value, "false")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueNone);
}
} else if (name == dirAttr) {
if (equalIgnoringCase(value, "auto")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, unicodeBidiAttributeForDirAuto(this));
} else {
if (isValidDirAttribute(value))
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, value);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, "ltr");
if (!hasTagName(bdiTag) && !hasTagName(bdoTag) && !hasTagName(outputTag))
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, CSSValueIsolate);
}
} else if (name.matches(XMLNames::langAttr)) {
mapLanguageAttributeToLocale(value, style);
} else if (name == langAttr) {
// xml:lang has a higher priority than lang.
if (!fastHasAttribute(XMLNames::langAttr))
mapLanguageAttributeToLocale(value, style);
} else {
Element::collectStyleForPresentationAttribute(name, value, style);
}
}
void SVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
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 = NoError;
m_className->setBaseValueAsString(value, parseError);
reportAttributeParsingError(parseError, name, value);
} else if (name.matches(XMLNames::langAttr) || name.matches(XMLNames::spaceAttr)) {
} else if (name == tabindexAttr) {
Element::parseAttribute(name, value);
} else {
// standard events
const AtomicString& eventName = HTMLElement::eventNameForAttributeName(name);
if (!eventName.isNull())
setAttributeEventListener(eventName, createAttributeEventListener(this, name, value, eventParameterName()));
else
Element::parseAttribute(name, value);
}
}
void SVGStyledElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGElement::svgAttributeChanged(attrName);
if (attrName.matches(HTMLNames::classAttr))
classAttributeChanged(className());
RenderObject* object = renderer();
if (isIdAttributeName(attrName)) {
// Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
if (object && object->isSVGResourceContainer())
object->toRenderSVGResourceContainer()->idChanged();
}
// Invalidate all SVGElementInstances associated with us
SVGElementInstance::invalidateAllInstancesOfElement(this);
}
bool SVGURIReference::isKnownAttribute(const QualifiedName& attrName)
{
return attrName.matches(XLinkNames::hrefAttr);
}
bool SVGAnimatedHref::isKnownAttribute(const QualifiedName& attrName) {
return attrName.matches(SVGNames::hrefAttr) ||
attrName.matches(XLinkNames::hrefAttr);
}
bool SVGTextContentElement::isPresentationAttribute(const QualifiedName& name) const
{
if (name.matches(XMLNames::spaceAttr))
return true;
return SVGGraphicsElement::isPresentationAttribute(name);
}
bool HTMLElement::isPresentationAttribute(const QualifiedName& name) const
{
if (name == alignAttr || name == contenteditableAttr || name == hiddenAttr || name == langAttr || name.matches(XMLNames::langAttr) || name == draggableAttr || name == dirAttr)
return true;
return Element::isPresentationAttribute(name);
}
bool SVGLangSpace::isKnownAttribute(const QualifiedName& attrName)
{
return attrName.matches(XMLNames::langAttr) || attrName.matches(XMLNames::spaceAttr);
}
PassRefPtr<HTMLSelectElement> HTMLSelectElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
{
ASSERT(tagName.matches(selectTag));
return adoptRef(new HTMLSelectElement(tagName, document, form));
}
void SVGURIReference::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name.matches(XLinkNames::hrefAttr))
setHrefBaseValue(value);
}