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();
}
Node::InsertionNotificationRequest SVGSMILElement::insertedInto(ContainerNode* rootParent)
{
SVGElement::insertedInto(rootParent);
if (!rootParent->inDocument())
return InsertionDone;
Deprecation::countDeprecation(document(), UseCounter::SVGSMILElementInDocument);
setAttributeName(constructQualifiedName(this, fastGetAttribute(SVGNames::attributeNameAttr)));
SVGSVGElement* owner = ownerSVGElement();
if (!owner)
return InsertionDone;
m_timeContainer = owner->timeContainer();
ASSERT(m_timeContainer);
m_timeContainer->setDocumentOrderIndexesDirty();
// "If no attribute is present, the default begin value (an offset-value of 0) must be evaluated."
if (!fastHasAttribute(SVGNames::beginAttr))
m_beginTimes.append(SMILTimeWithOrigin());
if (m_isWaitingForFirstInterval)
resolveFirstInterval();
if (m_timeContainer)
m_timeContainer->notifyIntervalsChanged();
buildPendingResource();
return InsertionDone;
}
Node::InsertionNotificationRequest SVGMPathElement::insertedInto(
ContainerNode* rootParent) {
SVGElement::insertedInto(rootParent);
if (rootParent->isConnected())
buildPendingResource();
return InsertionDone;
}
Node::InsertionNotificationRequest SVGTRefElement::insertedInto(ContainerNode& rootParent)
{
SVGElement::insertedInto(rootParent);
if (rootParent.inDocument())
buildPendingResource();
return InsertionDone;
}
void SVGUseElement::finishParsingChildren()
{
SVGGraphicsElement::finishParsingChildren();
SVGExternalResourcesRequired::finishParsingChildren();
if (m_wasInsertedByParser) {
buildPendingResource();
m_wasInsertedByParser = false;
}
}
void SVGMPathElement::svgAttributeChanged(const QualifiedName& attrName) {
if (SVGURIReference::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
buildPendingResource();
return;
}
SVGElement::svgAttributeChanged(attrName);
}
void SVGTRefElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (SVGURIReference::isKnownAttribute(attrName)) {
InstanceInvalidationGuard guard(*this);
buildPendingResource();
if (auto renderer = this->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
SVGTextPositioningElement::svgAttributeChanged(attrName);
}
void SVGUseElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
{
SVGElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
if (!attached())
return;
buildPendingResource();
if (m_shadowTreeRootElement)
m_shadowTreeRootElement->setChanged();
}
Node::InsertionNotificationRequest SVGUseElement::insertedInto(ContainerNode& rootParent)
{
// This functions exists to assure assumptions made in the code regarding SVGElementInstance creation/destruction are satisfied.
SVGGraphicsElement::insertedInto(rootParent);
if (!rootParent.inDocument())
return InsertionDone;
ASSERT(!m_targetElementInstance || !isWellFormedDocument(document()));
ASSERT(!hasPendingResources() || !isWellFormedDocument(document()));
if (!m_wasInsertedByParser)
buildPendingResource();
SVGExternalResourcesRequired::insertedIntoDocument(this);
return InsertionDone;
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
auto renderer = this->renderer();
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr) {
updateRelativeLengthsInformation();
if (renderer)
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
if (SVGExternalResourcesRequired::handleAttributeChange(this, attrName))
return;
if (SVGURIReference::isKnownAttribute(attrName)) {
bool isExternalReference = isExternalURIReference(href(), document());
if (isExternalReference) {
URL url = document().completeURL(href());
if (url.hasFragmentIdentifier()) {
CachedResourceRequest request(ResourceRequest(url.string()));
request.setInitiator(this);
setCachedDocument(document().cachedResourceLoader()->requestSVGDocument(request));
}
} else
setCachedDocument(0);
if (!m_wasInsertedByParser)
buildPendingResource();
return;
}
if (SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
invalidateShadowTree();
return;
}
ASSERT_NOT_REACHED();
}
void SVGFEImageElement::svgAttributeChanged(const QualifiedName& attrName) {
if (attrName == SVGNames::preserveAspectRatioAttr) {
SVGElement::InvalidationGuard invalidationGuard(this);
invalidate();
return;
}
if (SVGURIReference::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
buildPendingResource();
return;
}
SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
}
void SVGTRefElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGTextPositioningElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (SVGURIReference::isKnownAttribute(attrName)) {
buildPendingResource();
if (auto renderer = this->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGMPathElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (SVGURIReference::isKnownAttribute(attrName)) {
buildPendingResource();
return;
}
if (SVGExternalResourcesRequired::isKnownAttribute(attrName))
return;
ASSERT_NOT_REACHED();
}
void SVGTextPathElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGTextContentElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
if (SVGURIReference::isKnownAttribute(attrName)) {
buildPendingResource();
return;
}
if (attrName == SVGNames::startOffsetAttr)
updateRelativeLengthsInformation();
if (auto renderer = this->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
if (!attached())
return;
if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr ||
attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr ||
SVGTests::isKnownAttribute(attrName) ||
SVGLangSpace::isKnownAttribute(attrName) ||
SVGExternalResourcesRequired::isKnownAttribute(attrName) ||
SVGURIReference::isKnownAttribute(attrName) ||
SVGStyledTransformableElement::isKnownAttribute(attrName)) {
// TODO: Now that we're aware of the attribute name, we can finally optimize
// updating <use> attributes - to not reclone every time.
buildPendingResource();
if (m_shadowTreeRootElement)
m_shadowTreeRootElement->setChanged();
}
}
void SVGFEImageElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::preserveAspectRatioAttr) {
invalidate();
return;
}
if (SVGURIReference::isKnownAttribute(attrName)) {
buildPendingResource();
return;
}
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName))
return;
ASSERT_NOT_REACHED();
}
Node::InsertionNotificationRequest SVGFEImageElement::insertedInto(ContainerNode* rootParent)
{
SVGFilterPrimitiveStandardAttributes::insertedInto(rootParent);
buildPendingResource();
return InsertionDone;
}
void SVGUseElement::willAttachRenderers()
{
if (m_needsShadowTreeRecreation)
buildPendingResource();
}
void SVGTextPathElement::finishedInsertingSubtree()
{
buildPendingResource();
}
void SVGFEImageElement::finishedInsertingSubtree()
{
buildPendingResource();
}
void SVGFEImageElement::didNotifySubtreeInsertions(ContainerNode*)
{
buildPendingResource();
}
