SVGMarkerElement.cpp [plain text]
#include "config.h"
#include "SVGMarkerElement.h"
#include "Attribute.h"
#include "RenderSVGResourceMarker.h"
#include "SVGElementInstance.h"
#include "SVGFitToViewBox.h"
#include "SVGNames.h"
#include "SVGSVGElement.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
const SVGPropertyInfo* SVGMarkerElement::orientTypePropertyInfo()
{
static const SVGPropertyInfo* s_propertyInfo = 0;
if (!s_propertyInfo) {
s_propertyInfo = new SVGPropertyInfo(AnimatedEnumeration,
PropertyIsReadWrite,
SVGNames::orientAttr,
orientTypeIdentifier(),
&SVGMarkerElement::synchronizeOrientType,
&SVGMarkerElement::lookupOrCreateOrientTypeWrapper);
}
return s_propertyInfo;
}
DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refXAttr, RefX, refX)
DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::refYAttr, RefY, refY)
DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerWidthAttr, MarkerWidth, markerWidth)
DEFINE_ANIMATED_LENGTH(SVGMarkerElement, SVGNames::markerHeightAttr, MarkerHeight, markerHeight)
DEFINE_ANIMATED_ENUMERATION(SVGMarkerElement, SVGNames::markerUnitsAttr, MarkerUnits, markerUnits, SVGMarkerUnitsType)
DEFINE_ANIMATED_ANGLE_AND_ENUMERATION(SVGMarkerElement, SVGNames::orientAttr, orientAngleIdentifier(), OrientAngle, orientAngle)
DEFINE_ANIMATED_BOOLEAN(SVGMarkerElement, SVGNames::externalResourcesRequiredAttr, ExternalResourcesRequired, externalResourcesRequired)
DEFINE_ANIMATED_RECT(SVGMarkerElement, SVGNames::viewBoxAttr, ViewBox, viewBox)
DEFINE_ANIMATED_PRESERVEASPECTRATIO(SVGMarkerElement, SVGNames::preserveAspectRatioAttr, PreserveAspectRatio, preserveAspectRatio)
BEGIN_REGISTER_ANIMATED_PROPERTIES(SVGMarkerElement)
REGISTER_LOCAL_ANIMATED_PROPERTY(refX)
REGISTER_LOCAL_ANIMATED_PROPERTY(refY)
REGISTER_LOCAL_ANIMATED_PROPERTY(markerWidth)
REGISTER_LOCAL_ANIMATED_PROPERTY(markerHeight)
REGISTER_LOCAL_ANIMATED_PROPERTY(markerUnits)
REGISTER_LOCAL_ANIMATED_PROPERTY(orientAngle)
REGISTER_LOCAL_ANIMATED_PROPERTY(orientType)
REGISTER_LOCAL_ANIMATED_PROPERTY(externalResourcesRequired)
REGISTER_LOCAL_ANIMATED_PROPERTY(viewBox)
REGISTER_LOCAL_ANIMATED_PROPERTY(preserveAspectRatio)
REGISTER_PARENT_ANIMATED_PROPERTIES(SVGElement)
END_REGISTER_ANIMATED_PROPERTIES
inline SVGMarkerElement::SVGMarkerElement(const QualifiedName& tagName, Document& document)
: SVGElement(tagName, document)
, m_refX(LengthModeWidth)
, m_refY(LengthModeHeight)
, m_markerWidth(LengthModeWidth, "3")
, m_markerHeight(LengthModeHeight, "3")
, m_markerUnits(SVGMarkerUnitsStrokeWidth)
, m_orientType(SVGMarkerOrientAngle)
{
ASSERT(hasTagName(SVGNames::markerTag));
registerAnimatedPropertiesForSVGMarkerElement();
}
PassRefPtr<SVGMarkerElement> SVGMarkerElement::create(const QualifiedName& tagName, Document& document)
{
return adoptRef(new SVGMarkerElement(tagName, document));
}
const AtomicString& SVGMarkerElement::orientTypeIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGOrientType", AtomicString::ConstructFromLiteral));
return s_identifier;
}
const AtomicString& SVGMarkerElement::orientAngleIdentifier()
{
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, s_identifier, ("SVGOrientAngle", AtomicString::ConstructFromLiteral));
return s_identifier;
}
AffineTransform SVGMarkerElement::viewBoxToViewTransform(float viewWidth, float viewHeight) const
{
return SVGFitToViewBox::viewBoxToViewTransform(viewBox(), preserveAspectRatio(), viewWidth, viewHeight);
}
bool SVGMarkerElement::isSupportedAttribute(const QualifiedName& attrName)
{
static NeverDestroyed<HashSet<QualifiedName>> supportedAttributes;
if (supportedAttributes.get().isEmpty()) {
SVGLangSpace::addSupportedAttributes(supportedAttributes);
SVGExternalResourcesRequired::addSupportedAttributes(supportedAttributes);
SVGFitToViewBox::addSupportedAttributes(supportedAttributes);
supportedAttributes.get().add(SVGNames::markerUnitsAttr);
supportedAttributes.get().add(SVGNames::refXAttr);
supportedAttributes.get().add(SVGNames::refYAttr);
supportedAttributes.get().add(SVGNames::markerWidthAttr);
supportedAttributes.get().add(SVGNames::markerHeightAttr);
supportedAttributes.get().add(SVGNames::orientAttr);
}
return supportedAttributes.get().contains<SVGAttributeHashTranslator>(attrName);
}
void SVGMarkerElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
SVGParsingError parseError = NoError;
if (!isSupportedAttribute(name))
SVGElement::parseAttribute(name, value);
else if (name == SVGNames::markerUnitsAttr) {
SVGMarkerUnitsType propertyValue = SVGPropertyTraits<SVGMarkerUnitsType>::fromString(value);
if (propertyValue > 0)
setMarkerUnitsBaseValue(propertyValue);
} else if (name == SVGNames::refXAttr)
setRefXBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::refYAttr)
setRefYBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::markerWidthAttr)
setMarkerWidthBaseValue(SVGLength::construct(LengthModeWidth, value, parseError));
else if (name == SVGNames::markerHeightAttr)
setMarkerHeightBaseValue(SVGLength::construct(LengthModeHeight, value, parseError));
else if (name == SVGNames::orientAttr) {
SVGAngle angle;
SVGMarkerOrientType orientType = SVGPropertyTraits<SVGMarkerOrientType>::fromString(value, angle);
if (orientType > 0)
setOrientTypeBaseValue(orientType);
if (orientType == SVGMarkerOrientAngle)
setOrientAngleBaseValue(angle);
} else if (SVGLangSpace::parseAttribute(name, value)
|| SVGExternalResourcesRequired::parseAttribute(name, value)
|| SVGFitToViewBox::parseAttribute(this, name, value)) {
} else
ASSERT_NOT_REACHED();
reportAttributeParsingError(parseError, name, value);
}
void SVGMarkerElement::svgAttributeChanged(const QualifiedName& attrName)
{
if (!isSupportedAttribute(attrName)) {
SVGElement::svgAttributeChanged(attrName);
return;
}
SVGElementInstance::InvalidationGuard invalidationGuard(this);
if (attrName == SVGNames::refXAttr
|| attrName == SVGNames::refYAttr
|| attrName == SVGNames::markerWidthAttr
|| attrName == SVGNames::markerHeightAttr)
updateRelativeLengthsInformation();
if (RenderObject* object = renderer())
object->setNeedsLayout();
}
void SVGMarkerElement::childrenChanged(const ChildChange& change)
{
SVGElement::childrenChanged(change);
if (change.source == ChildChangeSourceParser)
return;
if (RenderObject* object = renderer())
object->setNeedsLayout();
}
void SVGMarkerElement::setOrientToAuto()
{
setOrientTypeBaseValue(SVGMarkerOrientAuto);
setOrientAngleBaseValue(SVGAngle());
m_orientAngle.shouldSynchronize = true;
m_orientType.shouldSynchronize = true;
invalidateSVGAttributes();
svgAttributeChanged(orientAnglePropertyInfo()->attributeName);
}
void SVGMarkerElement::setOrientToAngle(const SVGAngle& angle)
{
setOrientTypeBaseValue(SVGMarkerOrientAngle);
setOrientAngleBaseValue(angle);
m_orientAngle.shouldSynchronize = true;
m_orientType.shouldSynchronize = true;
invalidateSVGAttributes();
svgAttributeChanged(orientAnglePropertyInfo()->attributeName);
}
RenderPtr<RenderElement> SVGMarkerElement::createElementRenderer(PassRef<RenderStyle> style)
{
return createRenderer<RenderSVGResourceMarker>(*this, WTF::move(style));
}
bool SVGMarkerElement::selfHasRelativeLengths() const
{
return refX().isRelative()
|| refY().isRelative()
|| markerWidth().isRelative()
|| markerHeight().isRelative();
}
void SVGMarkerElement::synchronizeOrientType(SVGElement* contextElement)
{
ASSERT(contextElement);
SVGMarkerElement* ownerType = toSVGMarkerElement(contextElement);
if (!ownerType->m_orientType.shouldSynchronize)
return;
if (ownerType->m_orientType.value != SVGMarkerOrientAuto)
return;
DEPRECATED_DEFINE_STATIC_LOCAL(AtomicString, autoString, ("auto", AtomicString::ConstructFromLiteral));
ownerType->m_orientType.synchronize(ownerType, orientTypePropertyInfo()->attributeName, autoString);
}
PassRefPtr<SVGAnimatedProperty> SVGMarkerElement::lookupOrCreateOrientTypeWrapper(SVGElement* contextElement)
{
ASSERT(contextElement);
SVGMarkerElement* ownerType = toSVGMarkerElement(contextElement);
return SVGAnimatedProperty::lookupOrCreateWrapper<SVGMarkerElement, SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>, SVGMarkerOrientType>
(ownerType, orientTypePropertyInfo(), ownerType->m_orientType.value);
}
PassRefPtr<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>> SVGMarkerElement::orientTypeAnimated()
{
m_orientType.shouldSynchronize = true;
return static_pointer_cast<SVGAnimatedEnumerationPropertyTearOff<SVGMarkerOrientType>>(lookupOrCreateOrientTypeWrapper(this));
}
}