зеркало из https://github.com/mozilla/gecko-dev.git
724 строки
19 KiB
C++
724 строки
19 KiB
C++
/* -*- 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__
|