Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#include "SVGPathDataParser.h"
#include "mozilla/gfx/Point.h"
#include "SVGDataParser.h"
#include "SVGContentUtils.h"
#include "SVGPathData.h"
#include "SVGPathSegUtils.h"
using namespace mozilla::dom::SVGPathSeg_Binding;
using namespace mozilla::gfx;
namespace mozilla {
static inline char16_t ToUpper(char16_t aCh) {
return aCh >= 'a' && aCh <= 'z' ? aCh - 'a' + 'A' : aCh;
}
bool SVGPathDataParser::Parse() {
mPathSegList->Clear();
return ParsePath();
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseCoordPair(float& aX, float& aY) {
return SVGContentUtils::ParseNumber(mIter, mEnd, aX) && SkipCommaWsp() &&
SVGContentUtils::ParseNumber(mIter, mEnd, aY);
}
bool SVGPathDataParser::ParseFlag(bool& aFlag) {
if (mIter == mEnd || (*mIter != '0' && *mIter != '1')) {
return false;
}
aFlag = (*mIter == '1');
++mIter;
return true;
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParsePath() {
while (SkipWsp()) {
if (!ParseSubPath()) {
return false;
}
}
return true;
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseSubPath() {
return ParseMoveto() && ParseSubPathElements();
}
bool SVGPathDataParser::ParseSubPathElements() {
while (SkipWsp() && !IsStartOfSubPath()) {
char16_t commandType = ToUpper(*mIter);
// Upper case commands have absolute co-ordinates,
// lower case commands have relative co-ordinates.
bool absCoords = commandType == *mIter;
++mIter;
SkipWsp();
if (!ParseSubPathElement(commandType, absCoords)) {
return false;
}
}
return true;
}
bool SVGPathDataParser::ParseSubPathElement(char16_t aCommandType,
bool aAbsCoords) {
switch (aCommandType) {
case 'Z':
return ParseClosePath();
case 'L':
return ParseLineto(aAbsCoords);
case 'H':
return ParseHorizontalLineto(aAbsCoords);
case 'V':
return ParseVerticalLineto(aAbsCoords);
case 'C':
return ParseCurveto(aAbsCoords);
case 'S':
return ParseSmoothCurveto(aAbsCoords);
case 'Q':
return ParseQuadBezierCurveto(aAbsCoords);
case 'T':
return ParseSmoothQuadBezierCurveto(aAbsCoords);
case 'A':
return ParseEllipticalArc(aAbsCoords);
}
return false;
}
bool SVGPathDataParser::IsStartOfSubPath() const {
return *mIter == 'm' || *mIter == 'M';
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseMoveto() {
if (!IsStartOfSubPath()) {
return false;
}
bool absCoords = (*mIter == 'M');
++mIter;
SkipWsp();
float x, y;
if (!ParseCoordPair(x, y)) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(
absCoords ? PATHSEG_MOVETO_ABS : PATHSEG_MOVETO_REL, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
// Per SVG 1.1 Section 8.3.2
// If a moveto is followed by multiple pairs of coordinates,
// the subsequent pairs are treated as implicit lineto commands
return ParseLineto(absCoords);
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseClosePath() {
return NS_SUCCEEDED(mPathSegList->AppendSeg(PATHSEG_CLOSEPATH));
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseLineto(bool aAbsCoords) {
while (true) {
float x, y;
if (!ParseCoordPair(x, y)) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(
aAbsCoords ? PATHSEG_LINETO_ABS : PATHSEG_LINETO_REL, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseHorizontalLineto(bool aAbsCoords) {
while (true) {
float x;
if (!SVGContentUtils::ParseNumber(mIter, mEnd, x)) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(aAbsCoords
? PATHSEG_LINETO_HORIZONTAL_ABS
: PATHSEG_LINETO_HORIZONTAL_REL,
x))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseVerticalLineto(bool aAbsCoords) {
while (true) {
float y;
if (!SVGContentUtils::ParseNumber(mIter, mEnd, y)) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(aAbsCoords
? PATHSEG_LINETO_VERTICAL_ABS
: PATHSEG_LINETO_VERTICAL_REL,
y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseCurveto(bool aAbsCoords) {
while (true) {
float x1, y1, x2, y2, x, y;
if (!(ParseCoordPair(x1, y1) && SkipCommaWsp() && ParseCoordPair(x2, y2) &&
SkipCommaWsp() && ParseCoordPair(x, y))) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(
aAbsCoords ? PATHSEG_CURVETO_CUBIC_ABS : PATHSEG_CURVETO_CUBIC_REL,
x1, y1, x2, y2, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseSmoothCurveto(bool aAbsCoords) {
while (true) {
float x2, y2, x, y;
if (!(ParseCoordPair(x2, y2) && SkipCommaWsp() && ParseCoordPair(x, y))) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(
aAbsCoords ? PATHSEG_CURVETO_CUBIC_SMOOTH_ABS
: PATHSEG_CURVETO_CUBIC_SMOOTH_REL,
x2, y2, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseQuadBezierCurveto(bool aAbsCoords) {
while (true) {
float x1, y1, x, y;
if (!(ParseCoordPair(x1, y1) && SkipCommaWsp() && ParseCoordPair(x, y))) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(aAbsCoords
? PATHSEG_CURVETO_QUADRATIC_ABS
: PATHSEG_CURVETO_QUADRATIC_REL,
x1, y1, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// Start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseSmoothQuadBezierCurveto(bool aAbsCoords) {
while (true) {
float x, y;
if (!ParseCoordPair(x, y)) {
return false;
}
if (NS_FAILED(mPathSegList->AppendSeg(
aAbsCoords ? PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS
: PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL,
x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//----------------------------------------------------------------------
bool SVGPathDataParser::ParseEllipticalArc(bool aAbsCoords) {
while (true) {
float r1, r2, angle, x, y;
bool largeArcFlag, sweepFlag;
if (!(SVGContentUtils::ParseNumber(mIter, mEnd, r1) && SkipCommaWsp() &&
SVGContentUtils::ParseNumber(mIter, mEnd, r2) && SkipCommaWsp() &&
SVGContentUtils::ParseNumber(mIter, mEnd, angle) && SkipCommaWsp() &&
ParseFlag(largeArcFlag) && SkipCommaWsp() && ParseFlag(sweepFlag) &&
SkipCommaWsp() && ParseCoordPair(x, y))) {
return false;
}
// We can only pass floats after 'type', and per the SVG spec for arc,
// non-zero args are treated at 'true'.
if (NS_FAILED(mPathSegList->AppendSeg(
aAbsCoords ? PATHSEG_ARC_ABS : PATHSEG_ARC_REL, r1, r2, angle,
largeArcFlag ? 1.0f : 0.0f, sweepFlag ? 1.0f : 0.0f, x, y))) {
return false;
}
if (!SkipWsp() || IsAsciiAlpha(*mIter)) {
// End of data, or start of a new command
return true;
}
SkipCommaWsp();
}
}
//-----------------------------------------------------------------------
static double CalcVectorAngle(double ux, double uy, double vx, double vy) {
double ta = atan2(uy, ux);
double tb = atan2(vy, vx);
if (tb >= ta) return tb - ta;
return 2 * M_PI - (ta - tb);
}
SVGArcConverter::SVGArcConverter(const Point& from, const Point& to,
const Point& radii, double angle,
bool largeArcFlag, bool sweepFlag) {
MOZ_ASSERT(radii.x != 0.0f && radii.y != 0.0f, "Bad radii");
const double radPerDeg = M_PI / 180.0;
mSegIndex = 0;
if (from == to) {
mNumSegs = 0;
return;
}
// Convert to center parameterization as shown in
mRx = fabs(radii.x);
mRy = fabs(radii.y);
mSinPhi = sin(angle * radPerDeg);
mCosPhi = cos(angle * radPerDeg);
double x1dash =
mCosPhi * (from.x - to.x) / 2.0 + mSinPhi * (from.y - to.y) / 2.0;
double y1dash =
-mSinPhi * (from.x - to.x) / 2.0 + mCosPhi * (from.y - to.y) / 2.0;
double root;
double numerator = mRx * mRx * mRy * mRy - mRx * mRx * y1dash * y1dash -
mRy * mRy * x1dash * x1dash;
if (numerator < 0.0) {
// If mRx , mRy and are such that there is no solution (basically,
// the ellipse is not big enough to reach from 'from' to 'to'
// then the ellipse is scaled up uniformly until there is
// exactly one solution (until the ellipse is just big enough).
// -> find factor s, such that numerator' with mRx'=s*mRx and
// mRy'=s*mRy becomes 0 :
double s = sqrt(1.0 - numerator / (mRx * mRx * mRy * mRy));
mRx *= s;
mRy *= s;
root = 0.0;
} else {
root = (largeArcFlag == sweepFlag ? -1.0 : 1.0) *
sqrt(numerator /
(mRx * mRx * y1dash * y1dash + mRy * mRy * x1dash * x1dash));
}
double cxdash = root * mRx * y1dash / mRy;
double cydash = -root * mRy * x1dash / mRx;
mC.x = mCosPhi * cxdash - mSinPhi * cydash + (from.x + to.x) / 2.0;
mC.y = mSinPhi * cxdash + mCosPhi * cydash + (from.y + to.y) / 2.0;
mTheta = CalcVectorAngle(1.0, 0.0, (x1dash - cxdash) / mRx,
(y1dash - cydash) / mRy);
double dtheta =
CalcVectorAngle((x1dash - cxdash) / mRx, (y1dash - cydash) / mRy,
(-x1dash - cxdash) / mRx, (-y1dash - cydash) / mRy);
if (!sweepFlag && dtheta > 0)
dtheta -= 2.0 * M_PI;
else if (sweepFlag && dtheta < 0)
dtheta += 2.0 * M_PI;
// Convert into cubic bezier segments <= 90deg
mNumSegs = static_cast<int>(ceil(fabs(dtheta / (M_PI / 2.0))));
mDelta = dtheta / mNumSegs;
mT = 8.0 / 3.0 * sin(mDelta / 4.0) * sin(mDelta / 4.0) / sin(mDelta / 2.0);
mFrom = from;
}
bool SVGArcConverter::GetNextSegment(Point* cp1, Point* cp2, Point* to) {
if (mSegIndex == mNumSegs) {
return false;
}
double cosTheta1 = cos(mTheta);
double sinTheta1 = sin(mTheta);
double theta2 = mTheta + mDelta;
double cosTheta2 = cos(theta2);
double sinTheta2 = sin(theta2);
// a) calculate endpoint of the segment:
to->x = mCosPhi * mRx * cosTheta2 - mSinPhi * mRy * sinTheta2 + mC.x;
to->y = mSinPhi * mRx * cosTheta2 + mCosPhi * mRy * sinTheta2 + mC.y;
// b) calculate gradients at start/end points of segment:
cp1->x =
mFrom.x + mT * (-mCosPhi * mRx * sinTheta1 - mSinPhi * mRy * cosTheta1);
cp1->y =
mFrom.y + mT * (-mSinPhi * mRx * sinTheta1 + mCosPhi * mRy * cosTheta1);
cp2->x = to->x + mT * (mCosPhi * mRx * sinTheta2 + mSinPhi * mRy * cosTheta2);
cp2->y = to->y + mT * (mSinPhi * mRx * sinTheta2 - mCosPhi * mRy * cosTheta2);
// do next segment
mTheta = theta2;
mFrom = *to;
++mSegIndex;
return true;
}
} // namespace mozilla