SVGPolyElement.cpp [plain text]
#include "config.h"
#if ENABLE(SVG)
#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"
namespace WebCore {
const SVGPropertyInfo* SVGPolyElement::pointsPropertyInfo()
{
static const SVGPropertyInfo* s_propertyInfo = 0;
if (!s_propertyInfo) {
s_propertyInfo = new SVGPropertyInfo(AnimatedPoints,
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(SVGStyledTransformableElement)
REGISTER_PARENT_ANIMATED_PROPERTIES(SVGTests)
END_REGISTER_ANIMATED_PROPERTIES
SVGPolyElement::SVGPolyElement(const QualifiedName& tagName, Document* document)
: SVGStyledTransformableElement(tagName, document)
{
registerAnimatedPropertiesForSVGPolyElement();
}
bool SVGPolyElement::isSupportedAttribute(const QualifiedName& attrName)
{
DEFINE_STATIC_LOCAL(HashSet<QualifiedName>, supportedAttributes, ());
if (supportedAttributes.isEmpty()) {
SVGTests::addSupportedAttributes(supportedAttributes);
SVGLangSpace::addSupportedAttributes(supportedAttributes);
SVGExternalResourcesRequired::addSupportedAttributes(supportedAttributes);
supportedAttributes.add(SVGNames::pointsAttr);
}
return supportedAttributes.contains<QualifiedName, SVGAttributeHashTranslator>(attrName);
}
void SVGPolyElement::parseAttribute(Attribute* attr)
{
if (!isSupportedAttribute(attr->name())) {
SVGStyledTransformableElement::parseAttribute(attr);
return;
}
const AtomicString& value = attr->value();
if (attr->name() == SVGNames::pointsAttr) {
SVGPointList newList;
if (!pointsListFromSVGData(newList, value))
document()->accessSVGExtensions()->reportError("Problem parsing points=\"" + value + "\"");
if (SVGAnimatedProperty* wrapper = SVGAnimatedProperty::lookupWrapper<SVGPolyElement, SVGAnimatedPointList, true>(this, pointsPropertyInfo()))
static_cast<SVGAnimatedPointList*>(wrapper)->detachListWrappers(newList.size());
m_points.value = newList;
return;
}
if (SVGTests::parseAttribute(attr))
return;
if (SVGLangSpace::parseAttribute(attr))
return;
if (SVGExternalResourcesRequired::parseAttribute(attr))
return;
ASSERT_NOT_REACHED();
}
void SVGPolyElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGStyledTransformableElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderSVGPath* renderer = static_cast<RenderSVGPath*>(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(void* contextElement)
{
ASSERT(contextElement);
SVGPolyElement* ownerType = static_cast<SVGPolyElement*>(contextElement);
if (!ownerType->m_points.shouldSynchronize)
return;
SVGAnimatedPropertySynchronizer<true>::synchronize(ownerType, pointsPropertyInfo()->attributeName, ownerType->m_points.value.valueAsString());
}
PassRefPtr<SVGAnimatedProperty> SVGPolyElement::lookupOrCreatePointsWrapper(void* contextElement)
{
ASSERT(contextElement);
SVGPolyElement* ownerType = static_cast<SVGPolyElement*>(contextElement);
return SVGAnimatedProperty::lookupOrCreateWrapper<SVGPolyElement, SVGAnimatedPointList, SVGPointList, true>
(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());
}
}
#endif // ENABLE(SVG)