diff options
Diffstat (limited to 'dom/svg/DOMSVGPathSeg.h')
| -rw-r--r-- | dom/svg/DOMSVGPathSeg.h | 723 |
1 files changed, 723 insertions, 0 deletions
diff --git a/dom/svg/DOMSVGPathSeg.h b/dom/svg/DOMSVGPathSeg.h new file mode 100644 index 000000000..33efe719b --- /dev/null +++ b/dom/svg/DOMSVGPathSeg.h @@ -0,0 +1,723 @@ +/* -*- 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 MOZILLA_DOMSVGPATHSEG_H__ +#define MOZILLA_DOMSVGPATHSEG_H__ + +#include "DOMSVGPathSegList.h" +#include "nsCycleCollectionParticipant.h" +#include "nsWrapperCache.h" +#include "SVGPathSegUtils.h" +#include "mozilla/dom/SVGPathSegBinding.h" + +class nsSVGElement; + +#define MOZ_SVG_LIST_INDEX_BIT_COUNT 31 + +namespace mozilla { + +#define CHECK_ARG_COUNT_IN_SYNC(segType) \ + MOZ_ASSERT(ArrayLength(mArgs) == \ + SVGPathSegUtils::ArgCountForType(uint32_t(segType)) || \ + uint32_t(segType) == PATHSEG_CLOSEPATH, \ + "Arg count/array size out of sync") + +#define IMPL_SVGPATHSEG_SUBCLASS_COMMON(segName, segType) \ + explicit DOMSVGPathSeg##segName(const float *aArgs) \ + : DOMSVGPathSeg() \ + { \ + CHECK_ARG_COUNT_IN_SYNC(segType); \ + memcpy(mArgs, aArgs, \ + SVGPathSegUtils::ArgCountForType(uint32_t(segType)) * sizeof(float)); \ + } \ + DOMSVGPathSeg##segName(DOMSVGPathSegList *aList, \ + uint32_t aListIndex, \ + bool aIsAnimValItem) \ + : DOMSVGPathSeg(aList, aListIndex, aIsAnimValItem) \ + { \ + CHECK_ARG_COUNT_IN_SYNC(segType); \ + } \ + /* From DOMSVGPathSeg: */ \ + virtual uint32_t \ + Type() const override \ + { \ + return segType; \ + } \ + virtual DOMSVGPathSeg* \ + Clone() override \ + { \ + /* InternalItem() + 1, because we're skipping the encoded seg type */ \ + float *args = IsInList() ? InternalItem() + 1 : mArgs; \ + return new DOMSVGPathSeg##segName(args); \ + } \ + virtual float* \ + PtrToMemberArgs() override \ + { \ + return mArgs; \ + } \ + \ + virtual JSObject* \ + WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override \ + { \ + return dom::SVGPathSeg##segName##Binding::Wrap(aCx, this, aGivenProto); \ + } + + +/** + * Class DOMSVGPathSeg + * + * This class is the base class of the classes that create the DOM objects that + * wrap the internal path segments that are encoded in an SVGPathData. Its + * sub-classes are also used to create the objects returned by + * SVGPathElement.createSVGPathSegXxx(). + * + * See the architecture comment in DOMSVGPathSegList.h for an overview of the + * important points regarding these DOM wrapper structures. + * + * See the architecture comment in DOMSVGLength.h (yes, LENGTH) for an overview + * of the important points regarding how this specific class works. + * + * The main differences between this class and DOMSVGLength is that we have + * sub-classes (it does not), and the "internal counterpart" that we provide a + * DOM wrapper for is a list of floats, not an instance of an internal class. + */ +class DOMSVGPathSeg : public nsWrapperCache +{ + friend class AutoChangePathSegNotifier; + +public: + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(DOMSVGPathSeg) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(DOMSVGPathSeg) + + /** + * Unlike the other list classes, we hide our ctor (because no one should be + * creating instances of this class directly). This factory method in exposed + * instead to take care of creating instances of the correct sub-class. + */ + static DOMSVGPathSeg *CreateFor(DOMSVGPathSegList *aList, + uint32_t aListIndex, + bool aIsAnimValItem); + + /** + * Create an unowned copy of this object. The caller is responsible for the + * first AddRef()! + */ + virtual DOMSVGPathSeg* Clone() = 0; + + bool IsInList() const { + return !!mList; + } + + /** + * In future, if this class is used for non-list segments, this will be + * different to IsInList(). + */ + bool HasOwner() const { + return !!mList; + } + + /** + * This method is called to notify this DOM object that it is being inserted + * into a list, and give it the information it needs as a result. + * + * This object MUST NOT already belong to a list when this method is called. + * That's not to say that script can't move these DOM objects between + * lists - it can - it's just that the logic to handle that (and send out + * the necessary notifications) is located elsewhere (in DOMSVGPathSegList).) + */ + void InsertingIntoList(DOMSVGPathSegList *aList, + uint32_t aListIndex, + bool aIsAnimValItem); + + static uint32_t MaxListIndex() { + return (1U << MOZ_SVG_LIST_INDEX_BIT_COUNT) - 1; + } + + /// This method is called to notify this object that its list index changed. + void UpdateListIndex(uint32_t aListIndex) { + mListIndex = aListIndex; + } + + /** + * This method is called to notify this DOM object that it is about to be + * removed from its current DOM list so that it can first make a copy of its + * internal counterpart's values. (If it didn't do this, then it would + * "lose" its value on being removed.) + */ + void RemovingFromList(); + + /** + * This method converts the segment to a string of floats as found in + * SVGPathData (i.e. the first float contains the type of the segment, + * encoded into a float, followed by its arguments in the same order as they + * are given in the <path> element's 'd' attribute). + */ + void ToSVGPathSegEncodedData(float *aData); + + /** + * The type of this path segment. + */ + virtual uint32_t Type() const = 0; + + // WebIDL + DOMSVGPathSegList* GetParentObject() { return mList; } + uint16_t PathSegType() const { return Type(); } + void GetPathSegTypeAsLetter(nsAString &aPathSegTypeAsLetter) + { aPathSegTypeAsLetter = SVGPathSegUtils::GetPathSegTypeAsLetter(Type()); } + virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override = 0; + +protected: + + /** + * Generic ctor for DOMSVGPathSeg objects that are created for an attribute. + */ + DOMSVGPathSeg(DOMSVGPathSegList *aList, + uint32_t aListIndex, + bool aIsAnimValItem); + + /** + * Ctor for creating the objects returned by + * SVGPathElement.createSVGPathSegXxx(), which do not initially belong to an + * attribute. + */ + DOMSVGPathSeg(); + + virtual ~DOMSVGPathSeg() { + // Our mList's weak ref to us must be nulled out when we die. If GC has + // unlinked us using the cycle collector code, then that has already + // happened, and mList is null. + if (mList) { + mList->ItemAt(mListIndex) = nullptr; + } + } + + nsSVGElement* Element() { + return mList->Element(); + } + + /** + * Get a reference to the internal SVGPathSeg list item that this DOM wrapper + * object currently wraps. + * + * To simplify the code we just have this one method for obtaining both + * baseVal and animVal internal items. This means that animVal items don't + * get const protection, but then our setter methods guard against changing + * animVal items. + */ + float* InternalItem(); + + virtual float* PtrToMemberArgs() = 0; + +#ifdef DEBUG + bool IndexIsValid(); +#endif + + RefPtr<DOMSVGPathSegList> mList; + + // Bounds for the following are checked in the ctor, so be sure to update + // that if you change the capacity of any of the following. + + uint32_t mListIndex:MOZ_SVG_LIST_INDEX_BIT_COUNT; + uint32_t mIsAnimValItem:1; // uint32_t because MSVC won't pack otherwise +}; + +class DOMSVGPathSegClosePath + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegClosePath() + : DOMSVGPathSeg() + { + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(ClosePath, PATHSEG_CLOSEPATH) + +protected: + // To allow IMPL_SVGPATHSEG_SUBCLASS_COMMON above to compile we need an + // mArgs, but since C++ doesn't allow zero-sized arrays we need to give it + // one (unused) element. + float mArgs[1]; +}; + +class DOMSVGPathSegMovetoAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegMovetoAbs(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(MovetoAbs, PATHSEG_MOVETO_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +class DOMSVGPathSegMovetoRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegMovetoRel(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(MovetoRel, PATHSEG_MOVETO_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +class DOMSVGPathSegLinetoAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegLinetoAbs(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoAbs, PATHSEG_LINETO_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +class DOMSVGPathSegLinetoRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegLinetoRel(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoRel, PATHSEG_LINETO_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +class DOMSVGPathSegCurvetoCubicAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoCubicAbs(float x1, float y1, + float x2, float y2, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x1; + mArgs[1] = y1; + mArgs[2] = x2; + mArgs[3] = y2; + mArgs[4] = x; + mArgs[5] = y; + } + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X1(); + void SetX1(float aX1, ErrorResult& rv); + float Y1(); + void SetY1(float aY1, ErrorResult& rv); + float X2(); + void SetX2(float aX2, ErrorResult& rv); + float Y2(); + void SetY2(float aY2, ErrorResult& rv); + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoCubicAbs, PATHSEG_CURVETO_CUBIC_ABS) + +protected: + float mArgs[6]; +}; + +class DOMSVGPathSegCurvetoCubicRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoCubicRel(float x1, float y1, + float x2, float y2, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x1; + mArgs[1] = y1; + mArgs[2] = x2; + mArgs[3] = y2; + mArgs[4] = x; + mArgs[5] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoCubicRel, PATHSEG_CURVETO_CUBIC_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X1(); + void SetX1(float aX1, ErrorResult& rv); + float Y1(); + void SetY1(float aY1, ErrorResult& rv); + float X2(); + void SetX2(float aX2, ErrorResult& rv); + float Y2(); + void SetY2(float aY2, ErrorResult& rv); + +protected: + float mArgs[6]; +}; + +class DOMSVGPathSegCurvetoQuadraticAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoQuadraticAbs(float x1, float y1, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x1; + mArgs[1] = y1; + mArgs[2] = x; + mArgs[3] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoQuadraticAbs, PATHSEG_CURVETO_QUADRATIC_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X1(); + void SetX1(float aX1, ErrorResult& rv); + float Y1(); + void SetY1(float aY1, ErrorResult& rv); + +protected: + float mArgs[4]; +}; + +class DOMSVGPathSegCurvetoQuadraticRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoQuadraticRel(float x1, float y1, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x1; + mArgs[1] = y1; + mArgs[2] = x; + mArgs[3] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoQuadraticRel, PATHSEG_CURVETO_QUADRATIC_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X1(); + void SetX1(float aX1, ErrorResult& rv); + float Y1(); + void SetY1(float aY1, ErrorResult& rv); + +protected: + float mArgs[4]; +}; + +class DOMSVGPathSegArcAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegArcAbs(float r1, float r2, float angle, + bool largeArcFlag, bool sweepFlag, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = r1; + mArgs[1] = r2; + mArgs[2] = angle; + mArgs[3] = largeArcFlag; + mArgs[4] = sweepFlag; + mArgs[5] = x; + mArgs[6] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(ArcAbs, PATHSEG_ARC_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float R1(); + void SetR1(float aR1, ErrorResult& rv); + float R2(); + void SetR2(float aR2, ErrorResult& rv); + float Angle(); + void SetAngle(float aAngle, ErrorResult& rv); + bool LargeArcFlag(); + void SetLargeArcFlag(bool aFlag, ErrorResult& rv); + bool SweepFlag(); + void SetSweepFlag(bool aFlag, ErrorResult& rv); + +protected: + float mArgs[7]; +}; + +class DOMSVGPathSegArcRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegArcRel(float r1, float r2, float angle, + bool largeArcFlag, bool sweepFlag, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = r1; + mArgs[1] = r2; + mArgs[2] = angle; + mArgs[3] = largeArcFlag; + mArgs[4] = sweepFlag; + mArgs[5] = x; + mArgs[6] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(ArcRel, PATHSEG_ARC_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float R1(); + void SetR1(float aR1, ErrorResult& rv); + float R2(); + void SetR2(float aR2, ErrorResult& rv); + float Angle(); + void SetAngle(float aAngle, ErrorResult& rv); + bool LargeArcFlag(); + void SetLargeArcFlag(bool aFlag, ErrorResult& rv); + bool SweepFlag(); + void SetSweepFlag(bool aFlag, ErrorResult& rv); + +protected: + float mArgs[7]; +}; + +class DOMSVGPathSegLinetoHorizontalAbs + : public DOMSVGPathSeg +{ +public: + explicit DOMSVGPathSegLinetoHorizontalAbs(float x) + : DOMSVGPathSeg() + { + mArgs[0] = x; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoHorizontalAbs, PATHSEG_LINETO_HORIZONTAL_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + +protected: + float mArgs[1]; +}; + +class DOMSVGPathSegLinetoHorizontalRel + : public DOMSVGPathSeg +{ +public: + explicit DOMSVGPathSegLinetoHorizontalRel(float x) + : DOMSVGPathSeg() + { + mArgs[0] = x; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoHorizontalRel, PATHSEG_LINETO_HORIZONTAL_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + +protected: + float mArgs[1]; +}; + +class DOMSVGPathSegLinetoVerticalAbs + : public DOMSVGPathSeg +{ +public: + explicit DOMSVGPathSegLinetoVerticalAbs(float y) + : DOMSVGPathSeg() + { + mArgs[0] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoVerticalAbs, PATHSEG_LINETO_VERTICAL_ABS) + + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[1]; +}; + +class DOMSVGPathSegLinetoVerticalRel + : public DOMSVGPathSeg +{ +public: + explicit DOMSVGPathSegLinetoVerticalRel(float y) + : DOMSVGPathSeg() + { + mArgs[0] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(LinetoVerticalRel, PATHSEG_LINETO_VERTICAL_REL) + + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[1]; +}; + +class DOMSVGPathSegCurvetoCubicSmoothAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoCubicSmoothAbs(float x2, float y2, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x2; + mArgs[1] = y2; + mArgs[2] = x; + mArgs[3] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoCubicSmoothAbs, PATHSEG_CURVETO_CUBIC_SMOOTH_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X2(); + void SetX2(float aX2, ErrorResult& rv); + float Y2(); + void SetY2(float aY2, ErrorResult& rv); + +protected: + float mArgs[4]; +}; + +class DOMSVGPathSegCurvetoCubicSmoothRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoCubicSmoothRel(float x2, float y2, + float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x2; + mArgs[1] = y2; + mArgs[2] = x; + mArgs[3] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoCubicSmoothRel, PATHSEG_CURVETO_CUBIC_SMOOTH_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + float X2(); + void SetX2(float aX2, ErrorResult& rv); + float Y2(); + void SetY2(float aY2, ErrorResult& rv); + +protected: + float mArgs[4]; +}; + +class DOMSVGPathSegCurvetoQuadraticSmoothAbs + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoQuadraticSmoothAbs(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoQuadraticSmoothAbs, PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +class DOMSVGPathSegCurvetoQuadraticSmoothRel + : public DOMSVGPathSeg +{ +public: + DOMSVGPathSegCurvetoQuadraticSmoothRel(float x, float y) + : DOMSVGPathSeg() + { + mArgs[0] = x; + mArgs[1] = y; + } + + IMPL_SVGPATHSEG_SUBCLASS_COMMON(CurvetoQuadraticSmoothRel, PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL) + + float X(); + void SetX(float aX, ErrorResult& rv); + float Y(); + void SetY(float aY, ErrorResult& rv); + +protected: + float mArgs[2]; +}; + +} // namespace mozilla + +#undef MOZ_SVG_LIST_INDEX_BIT_COUNT + +#endif // MOZILLA_DOMSVGPATHSEG_H__ |