void SVGTextPositioningElement::svgAttributeChanged(const QualifiedName& attrName)
{
bool updateRelativeLengths = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::dxAttr
|| attrName == SVGNames::dyAttr;
if (updateRelativeLengths)
updateRelativeLengthsInformation();
if (updateRelativeLengths || attrName == SVGNames::rotateAttr) {
SVGElement::InvalidationGuard invalidationGuard(this);
LayoutObject* layoutObject = this->layoutObject();
if (!layoutObject)
return;
if (LayoutSVGText* textLayoutObject = LayoutSVGText::locateLayoutSVGTextAncestor(layoutObject))
textLayoutObject->setNeedsPositioningValuesUpdate();
markForLayoutAndParentResourceInvalidation(layoutObject);
return;
}
SVGTextContentElement::svgAttributeChanged(attrName);
}
void SVGForeignObjectElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
if (attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange);
}
SVGElement::InvalidationGuard invalidationGuard(this);
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
if (RenderObject* renderer = this->renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
}
void SVGMarkerElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledElement::svgAttributeChanged(attrName);
bool invalidateClients = false;
if (attrName == SVGNames::refXAttr
|| attrName == SVGNames::refYAttr
|| attrName == SVGNames::markerWidthAttr
|| attrName == SVGNames::markerHeightAttr) {
invalidateClients = true;
updateRelativeLengthsInformation();
}
RenderObject* object = renderer();
if (!object)
return;
if (invalidateClients
|| attrName == SVGNames::markerUnitsAttr
|| attrName == SVGNames::orientAttr
|| SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName)
|| SVGFitToViewBox::isKnownAttribute(attrName)
|| SVGStyledElement::isKnownAttribute(attrName))
object->setNeedsLayout(true);
}
void SVGRectElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGeometryElement::svgAttributeChanged(attrName);
return;
}
SVGElement::InvalidationGuard invalidationGuard(this);
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr
|| attrName == SVGNames::rxAttr
|| attrName == SVGNames::ryAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
RenderSVGShape* renderer = toRenderSVGShape(this->renderer());
if (!renderer)
return;
if (isLengthAttribute) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
bool isLengthAttribute = attrName == SVGNames::x1Attr
|| attrName == SVGNames::y1Attr
|| attrName == SVGNames::x2Attr
|| attrName == SVGNames::y2Attr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
auto* renderer = downcast<RenderSVGShape>(this->renderer());
if (!renderer)
return;
if (isLengthAttribute) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGForeignObjectElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderObject* renderer = this->renderer();
if (!renderer)
return;
if (SVGStyledTransformableElement::isKnownAttribute(attrName)) {
renderer->setNeedsTransformUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
if (isLengthAttribute
|| SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName) {
if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr ||
attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr) {
SVGElement::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::xAttr || attrName == SVGNames::yAttr) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange,
StyleChangeReasonForTracing::fromAttribute(attrName));
}
updateRelativeLengthsInformation();
if (m_targetElementInstance) {
ASSERT(m_targetElementInstance->correspondingElement());
transferUseWidthAndHeightIfNeeded(
*this, *m_targetElementInstance,
*m_targetElementInstance->correspondingElement());
}
LayoutObject* object = this->layoutObject();
if (object)
markForLayoutAndParentResourceInvalidation(object);
return;
}
if (SVGURIReference::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
updateTargetReference();
invalidateShadowTree();
return;
}
SVGGraphicsElement::svgAttributeChanged(attrName);
}
void SVGTextPositioningElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGTextContentElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
bool updateRelativeLengths = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::dxAttr
|| attrName == SVGNames::dyAttr;
if (updateRelativeLengths)
updateRelativeLengthsInformation();
auto renderer = this->renderer();
if (!renderer)
return;
if (updateRelativeLengths || attrName == SVGNames::rotateAttr) {
if (auto* textAncestor = RenderSVGText::locateRenderSVGTextAncestor(*renderer))
textAncestor->setNeedsPositioningValuesUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
bool isLengthAttribute = attrName == SVGNames::x1Attr
|| attrName == SVGNames::y1Attr
|| attrName == SVGNames::x2Attr
|| attrName == SVGNames::y2Attr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderSVGPath* renderer = static_cast<RenderSVGPath*>(this->renderer());
if (!renderer)
return;
if (isLengthAttribute) {
renderer->setNeedsPathUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer);
}
Node::InsertionNotificationRequest SVGElement::insertedInto(ContainerNode* rootParent)
{
Element::insertedInto(rootParent);
updateRelativeLengthsInformation();
buildPendingResourcesIfNeeded();
return InsertionDone;
}
void SVGFilterElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledElement::svgAttributeChanged(attrName);
bool invalidateClients = false;
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr) {
invalidateClients = true;
updateRelativeLengthsInformation();
}
RenderObject* object = renderer();
if (!object)
return;
if (invalidateClients
|| attrName == SVGNames::filterUnitsAttr
|| attrName == SVGNames::primitiveUnitsAttr
|| attrName == SVGNames::filterResAttr
|| SVGStyledElement::isKnownAttribute(attrName)
|| SVGURIReference::isKnownAttribute(attrName)
|| SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
object->setNeedsLayout(true);
}
void SVGSVGElement::svgAttributeChanged(const QualifiedName& attrName)
{
bool updateRelativeLengths = false;
if (attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr
|| attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| SVGFitToViewBox::isKnownAttribute(attrName)) {
updateRelativeLengths = true;
updateRelativeLengthsInformation();
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (SVGTests::handleAttributeChange(this, attrName))
return;
if (updateRelativeLengths
|| SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName)
|| SVGZoomAndPan::isKnownAttribute(attrName)) {
if (renderer())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer());
return;
}
SVGStyledElement::svgAttributeChanged(attrName);
}
void SVGForeignObjectElement::svgAttributeChanged(
const QualifiedName& attrName) {
bool isWidthHeightAttribute =
attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
bool isXYAttribute =
attrName == SVGNames::xAttr || attrName == SVGNames::yAttr;
if (isXYAttribute || isWidthHeightAttribute) {
SVGElement::InvalidationGuard invalidationGuard(this);
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(
LocalStyleChange,
isWidthHeightAttribute
? StyleChangeReasonForTracing::create(
StyleChangeReason::SVGContainerSizeChange)
: StyleChangeReasonForTracing::fromAttribute(attrName));
updateRelativeLengthsInformation();
if (LayoutObject* layoutObject = this->layoutObject())
markForLayoutAndParentResourceInvalidation(layoutObject);
return;
}
SVGGraphicsElement::svgAttributeChanged(attrName);
}
void SVGMaskElement::svgAttributeChanged(const QualifiedName& attrName) {
bool isLengthAttr =
attrName == SVGNames::xAttr || attrName == SVGNames::yAttr ||
attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
if (isLengthAttr || attrName == SVGNames::maskUnitsAttr ||
attrName == SVGNames::maskContentUnitsAttr ||
SVGTests::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
if (isLengthAttr) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange,
StyleChangeReasonForTracing::fromAttribute(attrName));
updateRelativeLengthsInformation();
}
LayoutSVGResourceContainer* layoutObject =
toLayoutSVGResourceContainer(this->layoutObject());
if (layoutObject)
layoutObject->invalidateCacheAndMarkForLayout();
return;
}
SVGElement::svgAttributeChanged(attrName);
}
void SVGUseElement::buildShadowAndInstanceTree(SVGElement* target)
{
ASSERT(!m_targetElementInstance);
ASSERT(!m_needsShadowTreeRecreation);
// <use> creates a "user agent" shadow root. Do not build the shadow/instance tree for <use>
// elements living in a user agent shadow tree because they will get expanded in a second
// pass -- see expandUseElementsInShadowTree().
if (inUseShadowTree())
return;
// Do not allow self-referencing.
// 'target' may be null, if it's a non SVG namespaced element.
if (!target || target == this || isDisallowedElement(target))
return;
// Set up root SVG element in shadow tree.
RefPtrWillBeRawPtr<Element> newChild = target->cloneElementWithoutChildren();
m_targetElementInstance = toSVGElement(newChild.get());
ShadowRoot* shadowTreeRootElement = userAgentShadowRoot();
shadowTreeRootElement->appendChild(newChild.release());
// Clone the target subtree into the shadow tree, not handling <use> and <symbol> yet.
// SVG specification does not say a word about <use> & cycles. My view on this is: just ignore it!
// Non-appearing <use> content is easier to debug, then half-appearing content.
if (!buildShadowTree(target, m_targetElementInstance.get(), false)) {
clearShadowTree();
return;
}
if (instanceTreeIsLoading(m_targetElementInstance.get()))
return;
// Assure shadow tree building was successfull
ASSERT(m_targetElementInstance);
ASSERT(m_targetElementInstance->correspondingUseElement() == this);
ASSERT(m_targetElementInstance->correspondingElement() == target);
// Expand all <use> elements in the shadow tree.
// Expand means: replace the actual <use> element by what it references.
if (!expandUseElementsInShadowTree(m_targetElementInstance.get())) {
clearShadowTree();
return;
}
// Expand all <symbol> elements in the shadow tree.
// Expand means: replace the actual <symbol> element by the <svg> element.
expandSymbolElementsInShadowTree(toSVGElement(shadowTreeRootElement->firstChild()));
m_targetElementInstance = toSVGElement(shadowTreeRootElement->firstChild());
transferUseWidthAndHeightIfNeeded(*this, m_targetElementInstance.get(), *m_targetElementInstance->correspondingElement());
ASSERT(m_targetElementInstance->parentNode() == shadowTreeRootElement);
// Update relative length information.
updateRelativeLengthsInformation();
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
bool isXYAttribute = attrName == SVGNames::xAttr || attrName == SVGNames::yAttr;
bool isWidthHeightAttribute = attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
if (isXYAttribute || isWidthHeightAttribute)
updateRelativeLengthsInformation();
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderObject* object = renderer();
if (!object)
return;
if (SVGURIReference::isKnownAttribute(attrName)) {
if (hasPendingResources()) {
OwnPtr<SVGDocumentExtensions::SVGPendingElements> clients(document()->accessSVGExtensions()->removePendingResource(m_resourceId));
ASSERT(!clients->isEmpty());
const SVGDocumentExtensions::SVGPendingElements::const_iterator end = clients->end();
for (SVGDocumentExtensions::SVGPendingElements::const_iterator it = clients->begin(); it != end; ++it) {
ASSERT((*it)->hasPendingResources());
(*it)->setHasPendingResources(false);
}
m_resourceId = String();
setHasPendingResources(false);
}
invalidateShadowTree();
return;
}
if (isXYAttribute) {
updateContainerOffsets();
return;
}
if (isWidthHeightAttribute) {
updateContainerSizes();
return;
}
// Be very careful here, if svgAttributeChanged() has been called because a SVG CSS property changed, we do NOT want to reclone the tree!
if (SVGStyledElement::isKnownAttribute(attrName)) {
setNeedsStyleRecalc();
return;
}
if (SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
invalidateShadowTree();
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
bool isXYAttribute = attrName == SVGNames::xAttr || attrName == SVGNames::yAttr;
bool isWidthHeightAttribute = attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
if (isXYAttribute || isWidthHeightAttribute)
updateRelativeLengthsInformation();
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderObject* object = renderer();
if (!object)
return;
if (SVGURIReference::isKnownAttribute(attrName)) {
if (m_isPendingResource) {
document()->accessSVGExtensions()->removePendingResource(m_resourceId);
m_resourceId = String();
m_isPendingResource = false;
}
invalidateShadowTree();
return;
}
if (isXYAttribute) {
updateContainerOffsets();
return;
}
if (isWidthHeightAttribute) {
updateContainerSizes();
return;
}
// Be very careful here, if svgAttributeChanged() has been called because a SVG CSS property changed, we do NOT want to reclone the tree!
if (SVGStyledElement::isKnownAttribute(attrName)) {
setNeedsStyleRecalc();
return;
}
if (SVGStyledTransformableElement::isKnownAttribute(attrName)) {
object->setNeedsTransformUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
invalidateShadowTree();
}
void SVGTextPathElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGTextContentElement::svgAttributeChanged(attrName);
if (attrName == SVGNames::startOffsetAttr)
updateRelativeLengthsInformation();
if (!renderer())
return;
if (attrName == SVGNames::startOffsetAttr
|| SVGURIReference::isKnownAttribute(attrName))
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer());
}
void SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGradientElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
updateRelativeLengthsInformation();
if (RenderObject* object = renderer())
object->setNeedsLayout();
}
void SVGSVGElement::svgAttributeChanged(const QualifiedName& attrName)
{
bool updateRelativeLengthsOrViewBox = false;
bool widthChanged = attrName == SVGNames::widthAttr;
bool heightChanged = attrName == SVGNames::heightAttr;
if (widthChanged || heightChanged
|| attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr) {
updateRelativeLengthsOrViewBox = true;
updateRelativeLengthsInformation();
invalidateRelativeLengthClients();
// At the SVG/HTML boundary (aka LayoutSVGRoot), the width and
// height attributes can affect the replaced size so we need
// to mark it for updating.
//
// FIXME: For width/height animated as XML attributes on SVG
// roots, there is an attribute synchronization missing. See
// http://crbug.com/364807
if (widthChanged || heightChanged) {
LayoutObject* layoutObject = this->layoutObject();
if (layoutObject && layoutObject->isSVGRoot()) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::SVGContainerSizeChange));
}
} else {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange,
StyleChangeReasonForTracing::fromAttribute(attrName));
}
}
if (SVGFitToViewBox::isKnownAttribute(attrName)) {
updateRelativeLengthsOrViewBox = true;
invalidateRelativeLengthClients();
if (LayoutObject* object = layoutObject())
object->setNeedsTransformUpdate();
}
if (updateRelativeLengthsOrViewBox
|| SVGZoomAndPan::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
if (layoutObject())
markForLayoutAndParentResourceInvalidation(layoutObject());
return;
}
SVGGraphicsElement::svgAttributeChanged(attrName);
}
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 SVGRadialGradientElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGradientElement::svgAttributeChanged(attrName);
return;
}
SVGElement::InvalidationGuard invalidationGuard(this);
updateRelativeLengthsInformation();
RenderSVGResourceContainer* renderer = toRenderSVGResourceContainer(this->renderer());
if (renderer)
renderer->invalidateCacheAndMarkForLayout();
}
void SVGTextPositioningElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGTextContentElement::svgAttributeChanged(attrName);
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::dxAttr
|| attrName == SVGNames::dyAttr)
updateRelativeLengthsInformation();
if (!renderer())
return;
if (isKnownAttribute(attrName))
RenderSVGResource::markForLayoutAndParentResourceInvalidation(renderer());
}
void SVGImageElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
InstanceInvalidationGuard guard(*this);
if (attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr) {
invalidateSVGPresentationAttributeStyle();
return;
}
bool isLengthAttribute = attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr;
if (isLengthAttribute)
updateRelativeLengthsInformation();
if (SVGURIReference::isKnownAttribute(attrName)) {
m_imageLoader.updateFromElementIgnoringPreviousError();
return;
}
auto* renderer = this->renderer();
if (!renderer)
return;
if (isLengthAttribute) {
if (downcast<RenderSVGImage>(*renderer).updateImageViewport())
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
if (attrName == SVGNames::preserveAspectRatioAttr
|| SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr) {
SVGElement::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr) {
invalidateSVGPresentationAttributeStyle();
setNeedsStyleRecalc(LocalStyleChange,
StyleChangeReasonForTracing::fromAttribute(attrName));
}
updateRelativeLengthsInformation();
if (m_targetElementInstance) {
ASSERT(m_targetElementInstance->correspondingElement());
transferUseWidthAndHeightIfNeeded(*this, m_targetElementInstance.get(), *m_targetElementInstance->correspondingElement());
}
LayoutObject* object = this->layoutObject();
if (object)
markForLayoutAndParentResourceInvalidation(object);
return;
}
if (SVGURIReference::isKnownAttribute(attrName)) {
SVGElement::InvalidationGuard invalidationGuard(this);
if (isStructurallyExternal()) {
KURL url = document().completeURL(hrefString());
const KURL& existingURL = m_resource ? m_resource->url() : KURL();
if (url.hasFragmentIdentifier() && !equalIgnoringFragmentIdentifier(url, existingURL)) {
FetchRequest request(ResourceRequest(url), localName());
setDocumentResource(DocumentResource::fetchSVGDocument(request, document().fetcher()));
}
} else {
setDocumentResource(nullptr);
}
invalidateShadowTree();
return;
}
SVGGraphicsElement::svgAttributeChanged(attrName);
}
void SVGLinearGradientElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGGradientElement::svgAttributeChanged(attrName);
if (attrName == SVGNames::x1Attr
|| attrName == SVGNames::y1Attr
|| attrName == SVGNames::x2Attr
|| attrName == SVGNames::y2Attr) {
updateRelativeLengthsInformation();
RenderObject* object = renderer();
if (!object)
return;
object->setNeedsLayout(true);
}
}
void SVGFilterElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr)
updateRelativeLengthsInformation();
if (RenderObject* object = renderer())
object->setNeedsLayout();
}
void SVGMaskElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
SVGElement::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::xAttr
|| attrName == SVGNames::yAttr
|| attrName == SVGNames::widthAttr
|| attrName == SVGNames::heightAttr)
updateRelativeLengthsInformation();
RenderSVGResourceContainer* renderer = toRenderSVGResourceContainer(this->renderer());
if (renderer)
renderer->invalidateCacheAndMarkForLayout();
}
void SVGLineElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (attrName == SVGNames::x1Attr
|| attrName == SVGNames::y1Attr
|| attrName == SVGNames::x2Attr
|| attrName == SVGNames::y2Attr) {
updateRelativeLengthsInformation();
LayoutSVGShape* layoutObject = toLayoutSVGShape(this->layoutObject());
if (!layoutObject)
return;
SVGElement::InvalidationGuard invalidationGuard(this);
layoutObject->setNeedsShapeUpdate();
markForLayoutAndParentResourceInvalidation(layoutObject);
return;
}
SVGGeometryElement::svgAttributeChanged(attrName);
}
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);
}
