SVGFilterPrimitiveStandardAttributes.cpp [plain text]
#include "config.h"
#if ENABLE(FILTERS)
#include "SVGFilterPrimitiveStandardAttributes.h"
#include "Attribute.h"
#include "FilterEffect.h"
#include "RenderSVGResourceFilterPrimitive.h"
#include "SVGElement.h"
#include "SVGElementInstance.h"
#include "SVGFilterBuilder.h"
#include "SVGLength.h"
#include "SVGNames.h"
#include "SVGUnitTypes.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
DEFINE_ANIMATED_LENGTH(SVGFilterPrimitiveStandardAttributes, SVGNames::xAttr, X, x)
DEFINE_ANIMATED_LENGTH(SVGFilterPrimitiveStandardAttributes, SVGNames::yAttr, Y, y)
DEFINE_ANIMATED_LENGTH(SVGFilterPrimitiveStandardAttributes, SVGNames::widthAttr, Width, width)
DEFINE_ANIMATED_LENGTH(SVGFilterPrimitiveStandardAttributes, SVGNames::heightAttr, Height, height)
DEFINE_ANIMATED_STRING(SVGFilterPrimitiveStandardAttributes, SVGNames::resultAttr, Result, result)
BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGFilterPrimitiveStandardAttributes)
REGISTER_LOCAL_ANIMATED_PROPERTY(x)
REGISTER_LOCAL_ANIMATED_PROPERTY(y)
REGISTER_LOCAL_ANIMATED_PROPERTY(width)
REGISTER_LOCAL_ANIMATED_PROPERTY(height)
REGISTER_LOCAL_ANIMATED_PROPERTY(result)
REGISTER_PARENT_ANIMATED_PROPERTIES(SVGElement)
END_REGISTER_ANIMATED_PROPERTIES
SVGFilterPrimitiveStandardAttributes::SVGFilterPrimitiveStandardAttributes(const QualifiedName& tagName, Document& document)
: SVGElement(tagName, document)
, m_x(LengthModeWidth, "0%")
, m_y(LengthModeHeight, "0%")
, m_width(LengthModeWidth, "100%")
, m_height(LengthModeHeight, "100%")
{
registerAnimatedPropertiesForSVGFilterPrimitiveStandardAttributes();
}
bool SVGFilterPrimitiveStandardAttributes::isSupportedAttribute(const QualifiedName& attrName)
{
static NeverDestroyed<HashSet<QualifiedName>> supportedAttributes;
if (supportedAttributes.get().isEmpty()) {
supportedAttributes.get().add(SVGNames::xAttr);
supportedAttributes.get().add(SVGNames::yAttr);
supportedAttributes.get().add(SVGNames::widthAttr);
supportedAttributes.get().add(SVGNames::heightAttr);
supportedAttributes.get().add(SVGNames::resultAttr);
}
return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
}
void SVGFilterPrimitiveStandardAttributes::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGElement::parseAttribute(name, value);
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::resultAttr)
setResultBaseValue(value);
else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
bool SVGFilterPrimitiveStandardAttributes::setFilterEffectAttribute(FilterEffect*, const QualifiedName&)
{
ASSERT_NOT_REACHED();
return false;
}
void SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
invalidate();
}
void SVGFilterPrimitiveStandardAttributes::childrenChanged(const ChildChange& change)
{
SVGElement::childrenChanged(change);
if (change.source == ChildChangeSourceParser)
return;
invalidate();
}
void SVGFilterPrimitiveStandardAttributes::setStandardAttributes(FilterEffect* filterEffect) const
{
ASSERT(filterEffect);
if (!filterEffect)
return;
if (hasAttribute(SVGNames::xAttr))
filterEffect->setHasX(true);
if (hasAttribute(SVGNames::yAttr))
filterEffect->setHasY(true);
if (hasAttribute(SVGNames::widthAttr))
filterEffect->setHasWidth(true);
if (hasAttribute(SVGNames::heightAttr))
filterEffect->setHasHeight(true);
}
RenderPtr<RenderElement> SVGFilterPrimitiveStandardAttributes::createElementRenderer(PassRef<RenderStyle> style)
{
return createRenderer<RenderSVGResourceFilterPrimitive>(*this, WTF::move(style));
}
bool SVGFilterPrimitiveStandardAttributes::rendererIsNeeded(const RenderStyle& style)
{
if (parentNode() && (parentNode()->hasTagName(SVGNames::filterTag)))
return SVGElement::rendererIsNeeded(style);
return false;
}
void invalidateFilterPrimitiveParent(SVGElement* element)
{
if (!element)
return;
ContainerNode* parent = element->parentNode();
if (!parent)
return;
RenderElement* renderer = parent->renderer();
if (!renderer || !renderer->isSVGResourceFilterPrimitive())
return;
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer, false);
}
}
#endif