Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 464 insertions, 0 deletions

diff --git a/dom/svg/SVGPathDataParser.cpp b/dom/svg/SVGPathDataParser.cpp
new file mode 100644
index 0000000000..b08b98c98f
--- /dev/null
+++ b/dom/svg/SVGPathDataParser.cpp
@@ -0,0 +1,464 @@
+/* -*- 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/. */
+
+#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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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() || IsAlpha(*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
+  // http://www.w3.org/TR/SVG/implnote.html
+  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