SVGPolyElement.cpp [plain text]
#include "config.h"
#include "SVGPolyElement.h"
#include "Attribute.h"
#include "Document.h"
#include "FloatPoint.h"
#include "RenderSVGPath.h"
#include "RenderSVGResource.h"
#include "SVGAnimatedPointList.h"
#include "SVGElementInstance.h"
#include "SVGNames.h"
#include "SVGParserUtilities.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
const SVGPropertyInfo* SVGPolyElement::pointsPropertyInfo()
{
static const SVGPropertyInfo* s_propertyInfo = 0;
if (!s_propertyInfo) {
s_propertyInfo = new SVGPropertyInfo(AnimatedPoints,
PropertyIsReadWrite,
SVGNames::pointsAttr,
SVGNames::pointsAttr.localName(),
&SVGPolyElement::synchronizePoints,
&SVGPolyElement::lookupOrCreatePointsWrapper);
}
return s_propertyInfo;
}
DEFINE_ANIMATED_BOOLEAN(SVGPolyElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGPolyElement)
REGISTER_LOCAL_ANIMATED_PROPERTY(points)
REGISTER_LOCAL_ANIMATED_PROPERTY(externalResourcesRequired)
REGISTER_PARENT_ANIMATED_PROPERTIES(SVGGraphicsElement)
END_REGISTER_ANIMATED_PROPERTIES
SVGPolyElement::SVGPolyElement(const QualifiedName& tagName, Document& document)
: SVGGraphicsElement(tagName, document)
{
registerAnimatedPropertiesForSVGPolyElement();
}
bool SVGPolyElement::isSupportedAttribute(const QualifiedName& attrName)
{
static NeverDestroyed<HashSet<QualifiedName>> supportedAttributes;
if (supportedAttributes.get().isEmpty()) {
SVGLangSpace::addSupportedAttributes(supportedAttributes);
SVGExternalResourcesRequired::addSupportedAttributes(supportedAttributes);
supportedAttributes.get().add(SVGNames::pointsAttr);
}
return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
}
void SVGPolyElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (!isSupportedAttribute(name)) {
SVGGraphicsElement::parseAttribute(name, value);
return;
}
if (name == SVGNames::pointsAttr) {
SVGPointList newList;
if (!pointsListFromSVGData(newList, value))
document().accessSVGExtensions()->reportError("Problem parsing points=\"" + value + "\"");
if (SVGAnimatedProperty* wrapper = SVGAnimatedProperty::lookupWrapper<SVGPolyElement, SVGAnimatedPointList>(this, pointsPropertyInfo()))
static_cast<SVGAnimatedPointList*>(wrapper)->detachListWrappers(newList.size());
m_points.value = newList;
return;
}
if (SVGLangSpace::parseAttribute(name, value))
return;
if (SVGExternalResourcesRequired::parseAttribute(name, value))
return;
ASSERT_NOT_REACHED();
}
void SVGPolyElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGGraphicsElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
RenderSVGShape* renderer = toRenderSVGShape(this->renderer());
if (!renderer)
return;
if (attrName == SVGNames::pointsAttr) {
renderer->setNeedsShapeUpdate();
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
if (SVGLangSpace::isKnownAttribute(attrName) || SVGExternalResourcesRequired::isKnownAttribute(attrName)) {
RenderSVGResource::markForLayoutAndParentResourceInvalidation(*renderer);
return;
}
ASSERT_NOT_REACHED();
}
void SVGPolyElement::synchronizePoints(SVGElement* contextElement)
{
ASSERT(contextElement);
SVGPolyElement* ownerType = toSVGPolyElement(contextElement);
if (!ownerType->m_points.shouldSynchronize)
return;
ownerType->m_points.synchronize(ownerType, pointsPropertyInfo()->attributeName, ownerType->m_points.value.valueAsString());
}
PassRefPtr<SVGAnimatedProperty> SVGPolyElement::lookupOrCreatePointsWrapper(SVGElement* contextElement)
{
ASSERT(contextElement);
SVGPolyElement* ownerType = toSVGPolyElement(contextElement);
return SVGAnimatedProperty::lookupOrCreateWrapper<SVGPolyElement, SVGAnimatedPointList, SVGPointList>
(ownerType, pointsPropertyInfo(), ownerType->m_points.value);
}
SVGListPropertyTearOff<SVGPointList>* SVGPolyElement::points()
{
m_points.shouldSynchronize = true;
return static_cast<SVGListPropertyTearOff<SVGPointList>*>(static_pointer_cast<SVGAnimatedPointList>(lookupOrCreatePointsWrapper(this))->baseVal());
}
SVGListPropertyTearOff<SVGPointList>* SVGPolyElement::animatedPoints()
{
m_points.shouldSynchronize = true;
return static_cast<SVGListPropertyTearOff<SVGPointList>*>(static_pointer_cast<SVGAnimatedPointList>(lookupOrCreatePointsWrapper(this))->animVal());
}
bool isSVGPolyElement(const Node& node)
{
return node.hasTagName(SVGNames::polygonTag) || node.hasTagName(SVGNames::polylineTag);
}
}