summaryrefslogtreecommitdiffstats
path: root/dom/svg/nsSVGElement.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/svg/nsSVGElement.h')
-rw-r--r--dom/svg/nsSVGElement.h724
1 files changed, 724 insertions, 0 deletions
diff --git a/dom/svg/nsSVGElement.h b/dom/svg/nsSVGElement.h
new file mode 100644
index 000000000..42bc05746
--- /dev/null
+++ b/dom/svg/nsSVGElement.h
@@ -0,0 +1,724 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef __NS_SVGELEMENT_H__
+#define __NS_SVGELEMENT_H__
+
+/*
+ nsSVGElement is the base class for all SVG content elements.
+ It implements all the common DOM interfaces and handles attributes.
+*/
+
+#include "mozilla/Attributes.h"
+#include "mozilla/css/StyleRule.h"
+#include "nsAutoPtr.h"
+#include "nsChangeHint.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsError.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/ElementInlines.h"
+#include "nsISupportsImpl.h"
+#include "nsStyledElement.h"
+#include "nsSVGClass.h"
+#include "nsIDOMSVGElement.h"
+#include "SVGContentUtils.h"
+
+class nsSVGAngle;
+class nsSVGBoolean;
+class nsSVGEnum;
+class nsSVGInteger;
+class nsSVGIntegerPair;
+class nsSVGLength2;
+class nsSVGNumber2;
+class nsSVGNumberPair;
+class nsSVGString;
+class nsSVGViewBox;
+
+namespace mozilla {
+namespace dom {
+class SVGSVGElement;
+
+static const unsigned short SVG_UNIT_TYPE_UNKNOWN = 0;
+static const unsigned short SVG_UNIT_TYPE_USERSPACEONUSE = 1;
+static const unsigned short SVG_UNIT_TYPE_OBJECTBOUNDINGBOX = 2;
+
+} // namespace dom
+
+class SVGAnimatedNumberList;
+class SVGNumberList;
+class SVGAnimatedLengthList;
+class SVGUserUnitList;
+class SVGAnimatedPointList;
+class SVGAnimatedPathSegList;
+class SVGAnimatedPreserveAspectRatio;
+class nsSVGAnimatedTransformList;
+class SVGStringList;
+class DOMSVGStringList;
+
+namespace gfx {
+class Matrix;
+} // namespace gfx
+
+} // namespace mozilla
+
+class gfxMatrix;
+struct nsSVGEnumMapping;
+
+typedef nsStyledElement nsSVGElementBase;
+
+class nsSVGElement : public nsSVGElementBase // nsIContent
+ , public nsIDOMSVGElement
+{
+protected:
+ explicit nsSVGElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo);
+ friend nsresult NS_NewSVGElement(mozilla::dom::Element **aResult,
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo);
+ nsresult Init();
+ virtual ~nsSVGElement(){}
+
+public:
+
+ virtual nsresult Clone(mozilla::dom::NodeInfo *aNodeInfo, nsINode **aResult) const MOZ_MUST_OVERRIDE override;
+
+ typedef mozilla::SVGNumberList SVGNumberList;
+ typedef mozilla::SVGAnimatedNumberList SVGAnimatedNumberList;
+ typedef mozilla::SVGUserUnitList SVGUserUnitList;
+ typedef mozilla::SVGAnimatedLengthList SVGAnimatedLengthList;
+ typedef mozilla::SVGAnimatedPointList SVGAnimatedPointList;
+ typedef mozilla::SVGAnimatedPathSegList SVGAnimatedPathSegList;
+ typedef mozilla::SVGAnimatedPreserveAspectRatio SVGAnimatedPreserveAspectRatio;
+ typedef mozilla::nsSVGAnimatedTransformList nsSVGAnimatedTransformList;
+ typedef mozilla::SVGStringList SVGStringList;
+
+ // nsISupports
+ NS_DECL_ISUPPORTS_INHERITED
+
+ void DidAnimateClass();
+
+ // nsIContent interface methods
+
+ virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
+ nsIContent* aBindingParent,
+ bool aCompileEventHandlers) override;
+
+ virtual nsresult UnsetAttr(int32_t aNameSpaceID, nsIAtom* aAttribute,
+ bool aNotify) override;
+
+ virtual nsChangeHint GetAttributeChangeHint(const nsIAtom* aAttribute,
+ int32_t aModType) const override;
+
+ virtual bool IsNodeOfType(uint32_t aFlags) const override;
+
+ NS_IMETHOD WalkContentStyleRules(nsRuleWalker* aRuleWalker) override;
+ void WalkAnimatedContentStyleRules(nsRuleWalker* aRuleWalker);
+
+ NS_IMETHOD_(bool) IsAttributeMapped(const nsIAtom* aAttribute) const override;
+
+ static const MappedAttributeEntry sFillStrokeMap[];
+ static const MappedAttributeEntry sGraphicsMap[];
+ static const MappedAttributeEntry sTextContentElementsMap[];
+ static const MappedAttributeEntry sFontSpecificationMap[];
+ static const MappedAttributeEntry sGradientStopMap[];
+ static const MappedAttributeEntry sViewportsMap[];
+ static const MappedAttributeEntry sMarkersMap[];
+ static const MappedAttributeEntry sColorMap[];
+ static const MappedAttributeEntry sFiltersMap[];
+ static const MappedAttributeEntry sFEFloodMap[];
+ static const MappedAttributeEntry sLightingEffectsMap[];
+ static const MappedAttributeEntry sMaskMap[];
+
+ NS_FORWARD_NSIDOMNODE_TO_NSINODE
+ NS_FORWARD_NSIDOMELEMENT_TO_GENERIC
+ NS_DECL_NSIDOMSVGELEMENT
+
+ // Gets the element that establishes the rectangular viewport against which
+ // we should resolve percentage lengths (our "coordinate context"). Returns
+ // nullptr for outer <svg> or SVG without an <svg> parent (invalid SVG).
+ mozilla::dom::SVGSVGElement* GetCtx() const;
+
+ /**
+ * Returns aMatrix pre-multiplied by (explicit or implicit) transforms that
+ * are introduced by attributes on this element.
+ *
+ * If aWhich is eAllTransforms, then all the transforms from the coordinate
+ * space established by this element for its children to the coordinate
+ * space established by this element's parent element for this element, are
+ * included.
+ *
+ * If aWhich is eUserSpaceToParent, then only the transforms from this
+ * element's userspace to the coordinate space established by its parent is
+ * included. This includes any transforms introduced by the 'transform'
+ * attribute, transform animations and animateMotion, but not any offsets
+ * due to e.g. 'x'/'y' attributes, or any transform due to a 'viewBox'
+ * attribute. (SVG userspace is defined to be the coordinate space in which
+ * coordinates on an element apply.)
+ *
+ * If aWhich is eChildToUserSpace, then only the transforms from the
+ * coordinate space established by this element for its childre to this
+ * elements userspace are included. This includes any offsets due to e.g.
+ * 'x'/'y' attributes, and any transform due to a 'viewBox' attribute, but
+ * does not include any transforms due to the 'transform' attribute.
+ */
+ virtual gfxMatrix PrependLocalTransformsTo(
+ const gfxMatrix &aMatrix, SVGTransformTypes aWhich = eAllTransforms) const;
+
+ // Setter for to set the current <animateMotion> transformation
+ // Only visible for nsSVGGraphicElement, so it's a no-op here, and that
+ // subclass has the useful implementation.
+ virtual void SetAnimateMotionTransform(const mozilla::gfx::Matrix* aMatrix) {/*no-op*/}
+ virtual const mozilla::gfx::Matrix* GetAnimateMotionTransform() const { return nullptr; }
+
+ bool IsStringAnimatable(uint8_t aAttrEnum) {
+ return GetStringInfo().mStringInfo[aAttrEnum].mIsAnimatable;
+ }
+ bool NumberAttrAllowsPercentage(uint8_t aAttrEnum) {
+ return GetNumberInfo().mNumberInfo[aAttrEnum].mPercentagesAllowed;
+ }
+ virtual bool HasValidDimensions() const {
+ return true;
+ }
+ void SetLength(nsIAtom* aName, const nsSVGLength2 &aLength);
+
+ nsAttrValue WillChangeLength(uint8_t aAttrEnum);
+ nsAttrValue WillChangeNumberPair(uint8_t aAttrEnum);
+ nsAttrValue WillChangeIntegerPair(uint8_t aAttrEnum);
+ nsAttrValue WillChangeAngle(uint8_t aAttrEnum);
+ nsAttrValue WillChangeViewBox();
+ nsAttrValue WillChangePreserveAspectRatio();
+ nsAttrValue WillChangeNumberList(uint8_t aAttrEnum);
+ nsAttrValue WillChangeLengthList(uint8_t aAttrEnum);
+ nsAttrValue WillChangePointList();
+ nsAttrValue WillChangePathSegList();
+ nsAttrValue WillChangeTransformList();
+ nsAttrValue WillChangeStringList(bool aIsConditionalProcessingAttribute,
+ uint8_t aAttrEnum);
+
+ void DidChangeLength(uint8_t aAttrEnum, const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeNumber(uint8_t aAttrEnum);
+ void DidChangeNumberPair(uint8_t aAttrEnum,
+ const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeInteger(uint8_t aAttrEnum);
+ void DidChangeIntegerPair(uint8_t aAttrEnum,
+ const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeAngle(uint8_t aAttrEnum, const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeBoolean(uint8_t aAttrEnum);
+ void DidChangeEnum(uint8_t aAttrEnum);
+ void DidChangeViewBox(const nsAttrValue& aEmptyOrOldValue);
+ void DidChangePreserveAspectRatio(const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeNumberList(uint8_t aAttrEnum,
+ const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeLengthList(uint8_t aAttrEnum,
+ const nsAttrValue& aEmptyOrOldValue);
+ void DidChangePointList(const nsAttrValue& aEmptyOrOldValue);
+ void DidChangePathSegList(const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeTransformList(const nsAttrValue& aEmptyOrOldValue);
+ void DidChangeString(uint8_t aAttrEnum) {}
+ void DidChangeStringList(bool aIsConditionalProcessingAttribute,
+ uint8_t aAttrEnum,
+ const nsAttrValue& aEmptyOrOldValue);
+
+ void DidAnimateLength(uint8_t aAttrEnum);
+ void DidAnimateNumber(uint8_t aAttrEnum);
+ void DidAnimateNumberPair(uint8_t aAttrEnum);
+ void DidAnimateInteger(uint8_t aAttrEnum);
+ void DidAnimateIntegerPair(uint8_t aAttrEnum);
+ void DidAnimateAngle(uint8_t aAttrEnum);
+ void DidAnimateBoolean(uint8_t aAttrEnum);
+ void DidAnimateEnum(uint8_t aAttrEnum);
+ void DidAnimateViewBox();
+ void DidAnimatePreserveAspectRatio();
+ void DidAnimateNumberList(uint8_t aAttrEnum);
+ void DidAnimateLengthList(uint8_t aAttrEnum);
+ void DidAnimatePointList();
+ void DidAnimatePathSegList();
+ void DidAnimateTransformList(int32_t aModType);
+ void DidAnimateString(uint8_t aAttrEnum);
+
+ enum {
+ /**
+ * Flag to indicate to GetAnimatedXxx() methods that the object being
+ * requested should be allocated if it hasn't already been allocated, and
+ * that the method should not return null. Only applicable to methods that
+ * need to allocate the object that they return.
+ */
+ DO_ALLOCATE = 0x1
+ };
+
+ nsSVGLength2* GetAnimatedLength(const nsIAtom *aAttrName);
+ void GetAnimatedLengthValues(float *aFirst, ...);
+ void GetAnimatedNumberValues(float *aFirst, ...);
+ void GetAnimatedIntegerValues(int32_t *aFirst, ...);
+ SVGAnimatedNumberList* GetAnimatedNumberList(uint8_t aAttrEnum);
+ SVGAnimatedNumberList* GetAnimatedNumberList(nsIAtom *aAttrName);
+ void GetAnimatedLengthListValues(SVGUserUnitList *aFirst, ...);
+ SVGAnimatedLengthList* GetAnimatedLengthList(uint8_t aAttrEnum);
+ virtual SVGAnimatedPointList* GetAnimatedPointList() {
+ return nullptr;
+ }
+ virtual SVGAnimatedPathSegList* GetAnimPathSegList() {
+ // DOM interface 'SVGAnimatedPathData' (*inherited* by nsSVGPathElement)
+ // has a member called 'animatedPathSegList' member, so we have a shorter
+ // name so we don't get hidden by the GetAnimatedPathSegList declared by
+ // NS_DECL_NSIDOMSVGANIMATEDPATHDATA.
+ return nullptr;
+ }
+ /**
+ * Get the nsSVGAnimatedTransformList for this element.
+ *
+ * Despite the fact that animated transform lists are used for a variety of
+ * attributes, no SVG element uses more than one.
+ *
+ * It's relatively uncommon for elements to have their transform attribute
+ * set, so to save memory the nsSVGAnimatedTransformList is not allocated until
+ * the attribute is set/animated or its DOM wrapper is created. Callers that
+ * require the nsSVGAnimatedTransformList to be allocated and for this method
+ * to return non-null must pass the DO_ALLOCATE flag.
+ */
+ virtual nsSVGAnimatedTransformList* GetAnimatedTransformList(
+ uint32_t aFlags = 0) {
+ return nullptr;
+ }
+
+ virtual nsISMILAttr* GetAnimatedAttr(int32_t aNamespaceID, nsIAtom* aName) override;
+ void AnimationNeedsResample();
+ void FlushAnimations();
+
+ virtual void RecompileScriptEventListeners() override;
+
+ void GetStringBaseValue(uint8_t aAttrEnum, nsAString& aResult) const;
+ void SetStringBaseValue(uint8_t aAttrEnum, const nsAString& aValue);
+
+ virtual nsIAtom* GetPointListAttrName() const {
+ return nullptr;
+ }
+ virtual nsIAtom* GetPathDataAttrName() const {
+ return nullptr;
+ }
+ virtual nsIAtom* GetTransformListAttrName() const {
+ return nullptr;
+ }
+ const nsAttrValue* GetAnimatedClassName() const
+ {
+ if (!mClassAttribute.IsAnimated()) {
+ return nullptr;
+ }
+ return mClassAnimAttr;
+ }
+
+ virtual void ClearAnyCachedPath() {}
+ virtual nsIDOMNode* AsDOMNode() final override { return this; }
+ virtual bool IsTransformable() { return false; }
+
+ // WebIDL
+ mozilla::dom::SVGSVGElement* GetOwnerSVGElement();
+ nsSVGElement* GetViewportElement();
+ already_AddRefed<mozilla::dom::SVGAnimatedString> ClassName();
+ virtual bool IsFocusableInternal(int32_t* aTabIndex, bool aWithMouse) override;
+
+protected:
+ virtual JSObject* WrapNode(JSContext *cx, JS::Handle<JSObject*> aGivenProto) override;
+
+#ifdef DEBUG
+ // We define BeforeSetAttr here and mark it final to ensure it is NOT used
+ // by SVG elements.
+ // This is because we're not currently passing the correct value for aValue to
+ // BeforeSetAttr since it would involve allocating extra SVG value types.
+ // See the comment in nsSVGElement::WillChangeValue.
+ virtual nsresult BeforeSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+ nsAttrValueOrString* aValue,
+ bool aNotify) override final
+ {
+ return nsSVGElementBase::BeforeSetAttr(aNamespaceID, aName, aValue, aNotify);
+ }
+#endif // DEBUG
+ virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName,
+ const nsAttrValue* aValue, bool aNotify) override;
+ virtual bool ParseAttribute(int32_t aNamespaceID, nsIAtom* aAttribute,
+ const nsAString& aValue, nsAttrValue& aResult) override;
+ static nsresult ReportAttributeParseFailure(nsIDocument* aDocument,
+ nsIAtom* aAttribute,
+ const nsAString& aValue);
+
+ void UpdateContentStyleRule();
+ void UpdateAnimatedContentStyleRule();
+ mozilla::css::StyleRule* GetAnimatedContentStyleRule();
+
+ nsAttrValue WillChangeValue(nsIAtom* aName);
+ // aNewValue is set to the old value. This value may be invalid if
+ // !StoresOwnData.
+ void DidChangeValue(nsIAtom* aName, const nsAttrValue& aEmptyOrOldValue,
+ nsAttrValue& aNewValue);
+ void MaybeSerializeAttrBeforeRemoval(nsIAtom* aName, bool aNotify);
+
+ static nsIAtom* GetEventNameForAttr(nsIAtom* aAttr);
+
+ struct LengthInfo {
+ nsIAtom** mName;
+ float mDefaultValue;
+ uint8_t mDefaultUnitType;
+ uint8_t mCtxType;
+ };
+
+ struct LengthAttributesInfo {
+ nsSVGLength2* mLengths;
+ LengthInfo* mLengthInfo;
+ uint32_t mLengthCount;
+
+ LengthAttributesInfo(nsSVGLength2 *aLengths,
+ LengthInfo *aLengthInfo,
+ uint32_t aLengthCount) :
+ mLengths(aLengths), mLengthInfo(aLengthInfo), mLengthCount(aLengthCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct NumberInfo {
+ nsIAtom** mName;
+ float mDefaultValue;
+ bool mPercentagesAllowed;
+ };
+
+ struct NumberAttributesInfo {
+ nsSVGNumber2* mNumbers;
+ NumberInfo* mNumberInfo;
+ uint32_t mNumberCount;
+
+ NumberAttributesInfo(nsSVGNumber2 *aNumbers,
+ NumberInfo *aNumberInfo,
+ uint32_t aNumberCount) :
+ mNumbers(aNumbers), mNumberInfo(aNumberInfo), mNumberCount(aNumberCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct NumberPairInfo {
+ nsIAtom** mName;
+ float mDefaultValue1;
+ float mDefaultValue2;
+ };
+
+ struct NumberPairAttributesInfo {
+ nsSVGNumberPair* mNumberPairs;
+ NumberPairInfo* mNumberPairInfo;
+ uint32_t mNumberPairCount;
+
+ NumberPairAttributesInfo(nsSVGNumberPair *aNumberPairs,
+ NumberPairInfo *aNumberPairInfo,
+ uint32_t aNumberPairCount) :
+ mNumberPairs(aNumberPairs), mNumberPairInfo(aNumberPairInfo),
+ mNumberPairCount(aNumberPairCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct IntegerInfo {
+ nsIAtom** mName;
+ int32_t mDefaultValue;
+ };
+
+ struct IntegerAttributesInfo {
+ nsSVGInteger* mIntegers;
+ IntegerInfo* mIntegerInfo;
+ uint32_t mIntegerCount;
+
+ IntegerAttributesInfo(nsSVGInteger *aIntegers,
+ IntegerInfo *aIntegerInfo,
+ uint32_t aIntegerCount) :
+ mIntegers(aIntegers), mIntegerInfo(aIntegerInfo), mIntegerCount(aIntegerCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct IntegerPairInfo {
+ nsIAtom** mName;
+ int32_t mDefaultValue1;
+ int32_t mDefaultValue2;
+ };
+
+ struct IntegerPairAttributesInfo {
+ nsSVGIntegerPair* mIntegerPairs;
+ IntegerPairInfo* mIntegerPairInfo;
+ uint32_t mIntegerPairCount;
+
+ IntegerPairAttributesInfo(nsSVGIntegerPair *aIntegerPairs,
+ IntegerPairInfo *aIntegerPairInfo,
+ uint32_t aIntegerPairCount) :
+ mIntegerPairs(aIntegerPairs), mIntegerPairInfo(aIntegerPairInfo),
+ mIntegerPairCount(aIntegerPairCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct AngleInfo {
+ nsIAtom** mName;
+ float mDefaultValue;
+ uint8_t mDefaultUnitType;
+ };
+
+ struct AngleAttributesInfo {
+ nsSVGAngle* mAngles;
+ AngleInfo* mAngleInfo;
+ uint32_t mAngleCount;
+
+ AngleAttributesInfo(nsSVGAngle *aAngles,
+ AngleInfo *aAngleInfo,
+ uint32_t aAngleCount) :
+ mAngles(aAngles), mAngleInfo(aAngleInfo), mAngleCount(aAngleCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct BooleanInfo {
+ nsIAtom** mName;
+ bool mDefaultValue;
+ };
+
+ struct BooleanAttributesInfo {
+ nsSVGBoolean* mBooleans;
+ BooleanInfo* mBooleanInfo;
+ uint32_t mBooleanCount;
+
+ BooleanAttributesInfo(nsSVGBoolean *aBooleans,
+ BooleanInfo *aBooleanInfo,
+ uint32_t aBooleanCount) :
+ mBooleans(aBooleans), mBooleanInfo(aBooleanInfo), mBooleanCount(aBooleanCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ friend class nsSVGEnum;
+
+ struct EnumInfo {
+ nsIAtom** mName;
+ nsSVGEnumMapping* mMapping;
+ uint16_t mDefaultValue;
+ };
+
+ struct EnumAttributesInfo {
+ nsSVGEnum* mEnums;
+ EnumInfo* mEnumInfo;
+ uint32_t mEnumCount;
+
+ EnumAttributesInfo(nsSVGEnum *aEnums,
+ EnumInfo *aEnumInfo,
+ uint32_t aEnumCount) :
+ mEnums(aEnums), mEnumInfo(aEnumInfo), mEnumCount(aEnumCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct NumberListInfo {
+ nsIAtom** mName;
+ };
+
+ struct NumberListAttributesInfo {
+ SVGAnimatedNumberList* mNumberLists;
+ NumberListInfo* mNumberListInfo;
+ uint32_t mNumberListCount;
+
+ NumberListAttributesInfo(SVGAnimatedNumberList *aNumberLists,
+ NumberListInfo *aNumberListInfo,
+ uint32_t aNumberListCount)
+ : mNumberLists(aNumberLists)
+ , mNumberListInfo(aNumberListInfo)
+ , mNumberListCount(aNumberListCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct LengthListInfo {
+ nsIAtom** mName;
+ uint8_t mAxis;
+ /**
+ * Flag to indicate whether appending zeros to the end of the list would
+ * change the rendering of the SVG for the attribute in question. For x and
+ * y on the <text> element this is true, but for dx and dy on <text> this
+ * is false. This flag is fed down to SVGLengthListSMILType so it can
+ * determine if it can sensibly animate from-to lists of different lengths,
+ * which is desirable in the case of dx and dy.
+ */
+ bool mCouldZeroPadList;
+ };
+
+ struct LengthListAttributesInfo {
+ SVGAnimatedLengthList* mLengthLists;
+ LengthListInfo* mLengthListInfo;
+ uint32_t mLengthListCount;
+
+ LengthListAttributesInfo(SVGAnimatedLengthList *aLengthLists,
+ LengthListInfo *aLengthListInfo,
+ uint32_t aLengthListCount)
+ : mLengthLists(aLengthLists)
+ , mLengthListInfo(aLengthListInfo)
+ , mLengthListCount(aLengthListCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ struct StringInfo {
+ nsIAtom** mName;
+ int32_t mNamespaceID;
+ bool mIsAnimatable;
+ };
+
+ struct StringAttributesInfo {
+ nsSVGString* mStrings;
+ StringInfo* mStringInfo;
+ uint32_t mStringCount;
+
+ StringAttributesInfo(nsSVGString *aStrings,
+ StringInfo *aStringInfo,
+ uint32_t aStringCount) :
+ mStrings(aStrings), mStringInfo(aStringInfo), mStringCount(aStringCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ friend class mozilla::DOMSVGStringList;
+
+ struct StringListInfo {
+ nsIAtom** mName;
+ };
+
+ struct StringListAttributesInfo {
+ SVGStringList* mStringLists;
+ StringListInfo* mStringListInfo;
+ uint32_t mStringListCount;
+
+ StringListAttributesInfo(SVGStringList *aStringLists,
+ StringListInfo *aStringListInfo,
+ uint32_t aStringListCount) :
+ mStringLists(aStringLists), mStringListInfo(aStringListInfo),
+ mStringListCount(aStringListCount)
+ {}
+
+ void Reset(uint8_t aAttrEnum);
+ };
+
+ virtual LengthAttributesInfo GetLengthInfo();
+ virtual NumberAttributesInfo GetNumberInfo();
+ virtual NumberPairAttributesInfo GetNumberPairInfo();
+ virtual IntegerAttributesInfo GetIntegerInfo();
+ virtual IntegerPairAttributesInfo GetIntegerPairInfo();
+ virtual AngleAttributesInfo GetAngleInfo();
+ virtual BooleanAttributesInfo GetBooleanInfo();
+ virtual EnumAttributesInfo GetEnumInfo();
+ // We assume all viewboxes and preserveAspectRatios are alike
+ // so we don't need to wrap the class
+ virtual nsSVGViewBox *GetViewBox();
+ virtual SVGAnimatedPreserveAspectRatio *GetPreserveAspectRatio();
+ virtual NumberListAttributesInfo GetNumberListInfo();
+ virtual LengthListAttributesInfo GetLengthListInfo();
+ virtual StringAttributesInfo GetStringInfo();
+ virtual StringListAttributesInfo GetStringListInfo();
+
+ static nsSVGEnumMapping sSVGUnitTypesMap[];
+
+private:
+ void UnsetAttrInternal(int32_t aNameSpaceID, nsIAtom* aAttribute,
+ bool aNotify);
+
+ nsSVGClass mClassAttribute;
+ nsAutoPtr<nsAttrValue> mClassAnimAttr;
+ RefPtr<mozilla::css::StyleRule> mContentStyleRule;
+};
+
+/**
+ * A macro to implement the NS_NewSVGXXXElement() functions.
+ */
+#define NS_IMPL_NS_NEW_SVG_ELEMENT(_elementName) \
+nsresult \
+NS_NewSVG##_elementName##Element(nsIContent **aResult, \
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) \
+{ \
+ RefPtr<nsSVG##_elementName##Element> it = \
+ new nsSVG##_elementName##Element(aNodeInfo); \
+ \
+ nsresult rv = it->Init(); \
+ \
+ if (NS_FAILED(rv)) { \
+ return rv; \
+ } \
+ \
+ it.forget(aResult); \
+ \
+ return rv; \
+}
+
+#define NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT(_elementName) \
+nsresult \
+NS_NewSVG##_elementName##Element(nsIContent **aResult, \
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo) \
+{ \
+ RefPtr<mozilla::dom::SVG##_elementName##Element> it = \
+ new mozilla::dom::SVG##_elementName##Element(aNodeInfo); \
+ \
+ nsresult rv = it->Init(); \
+ \
+ if (NS_FAILED(rv)) { \
+ return rv; \
+ } \
+ \
+ it.forget(aResult); \
+ \
+ return rv; \
+}
+
+#define NS_IMPL_NS_NEW_NAMESPACED_SVG_ELEMENT_CHECK_PARSER(_elementName) \
+nsresult \
+NS_NewSVG##_elementName##Element(nsIContent **aResult, \
+ already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo, \
+ mozilla::dom::FromParser aFromParser) \
+{ \
+ RefPtr<mozilla::dom::SVG##_elementName##Element> it = \
+ new mozilla::dom::SVG##_elementName##Element(aNodeInfo, aFromParser); \
+ \
+ nsresult rv = it->Init(); \
+ \
+ if (NS_FAILED(rv)) { \
+ return rv; \
+ } \
+ \
+ it.forget(aResult); \
+ \
+ return rv; \
+}
+
+// No unlinking, we'd need to null out the value pointer (the object it
+// points to is held by the element) and null-check it everywhere.
+#define NS_SVG_VAL_IMPL_CYCLE_COLLECTION(_val, _element) \
+NS_IMPL_CYCLE_COLLECTION_CLASS(_val) \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_val) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(_element) \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_0(_val)
+
+#define NS_SVG_VAL_IMPL_CYCLE_COLLECTION_WRAPPERCACHED(_val, _element) \
+NS_IMPL_CYCLE_COLLECTION_CLASS(_val) \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(_val) \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER \
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(_val) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(_element) \
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS \
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END \
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(_val) \
+NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER \
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+#endif // __NS_SVGELEMENT_H__