/* -*- 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 "SVGPathData.h" #include "gfx2DGlue.h" #include "gfxPlatform.h" #include "mozilla/gfx/2D.h" #include "mozilla/gfx/Types.h" #include "mozilla/gfx/Point.h" #include "mozilla/RefPtr.h" #include "nsError.h" #include "nsString.h" #include "nsSVGPathDataParser.h" #include "nsSVGPathGeometryElement.h" // for nsSVGMark #include <stdarg.h> #include "nsStyleConsts.h" #include "SVGContentUtils.h" #include "SVGPathSegUtils.h" #include <algorithm> using namespace mozilla; using namespace mozilla::gfx; static bool IsMoveto(uint16_t aSegType) { return aSegType == PATHSEG_MOVETO_ABS || aSegType == PATHSEG_MOVETO_REL; } nsresult SVGPathData::CopyFrom(const SVGPathData& rhs) { if (!mData.Assign(rhs.mData, fallible)) { return NS_ERROR_OUT_OF_MEMORY; } return NS_OK; } void SVGPathData::GetValueAsString(nsAString& aValue) const { // we need this function in DidChangePathSegList aValue.Truncate(); if (!Length()) { return; } uint32_t i = 0; for (;;) { nsAutoString segAsString; SVGPathSegUtils::GetValueAsString(&mData[i], segAsString); // We ignore OOM, since it's not useful for us to return an error. aValue.Append(segAsString); i += 1 + SVGPathSegUtils::ArgCountForType(mData[i]); if (i >= mData.Length()) { MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); return; } aValue.Append(' '); } } nsresult SVGPathData::SetValueFromString(const nsAString& aValue) { // We don't use a temp variable since the spec says to parse everything up to // the first error. We still return any error though so that callers know if // there's a problem. nsSVGPathDataParser pathParser(aValue, this); return pathParser.Parse() ? NS_OK : NS_ERROR_DOM_SYNTAX_ERR; } nsresult SVGPathData::AppendSeg(uint32_t aType, ...) { uint32_t oldLength = mData.Length(); uint32_t newLength = oldLength + 1 + SVGPathSegUtils::ArgCountForType(aType); if (!mData.SetLength(newLength, fallible)) { return NS_ERROR_OUT_OF_MEMORY; } mData[oldLength] = SVGPathSegUtils::EncodeType(aType); va_list args; va_start(args, aType); for (uint32_t i = oldLength + 1; i < newLength; ++i) { // NOTE! 'float' is promoted to 'double' when passed through '...'! mData[i] = float(va_arg(args, double)); } va_end(args); return NS_OK; } float SVGPathData::GetPathLength() const { SVGPathTraversalState state; uint32_t i = 0; while (i < mData.Length()) { SVGPathSegUtils::TraversePathSegment(&mData[i], state); i += 1 + SVGPathSegUtils::ArgCountForType(mData[i]); } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); return state.length; } #ifdef DEBUG uint32_t SVGPathData::CountItems() const { uint32_t i = 0, count = 0; while (i < mData.Length()) { i += 1 + SVGPathSegUtils::ArgCountForType(mData[i]); count++; } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); return count; } #endif bool SVGPathData::GetSegmentLengths(nsTArray<double> *aLengths) const { aLengths->Clear(); SVGPathTraversalState state; uint32_t i = 0; while (i < mData.Length()) { state.length = 0.0; SVGPathSegUtils::TraversePathSegment(&mData[i], state); if (!aLengths->AppendElement(state.length)) { aLengths->Clear(); return false; } i += 1 + SVGPathSegUtils::ArgCountForType(mData[i]); } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); return true; } bool SVGPathData::GetDistancesFromOriginToEndsOfVisibleSegments(FallibleTArray<double> *aOutput) const { SVGPathTraversalState state; aOutput->Clear(); uint32_t i = 0; while (i < mData.Length()) { uint32_t segType = SVGPathSegUtils::DecodeType(mData[i]); SVGPathSegUtils::TraversePathSegment(&mData[i], state); // We skip all moveto commands except an initial moveto. See the text 'A // "move to" command does not count as an additional point when dividing up // the duration...': // // http://www.w3.org/TR/SVG11/animate.html#AnimateMotionElement // // This is important in the non-default case of calcMode="linear". In // this case an equal amount of time is spent on each path segment, // except on moveto segments which are jumped over immediately. if (i == 0 || (segType != PATHSEG_MOVETO_ABS && segType != PATHSEG_MOVETO_REL)) { if (!aOutput->AppendElement(state.length, fallible)) { return false; } } i += 1 + SVGPathSegUtils::ArgCountForType(segType); } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt?"); return true; } uint32_t SVGPathData::GetPathSegAtLength(float aDistance) const { // TODO [SVGWG issue] get specified what happen if 'aDistance' < 0, or // 'aDistance' > the length of the path, or the seg list is empty. // Return -1? Throwing would better help authors avoid tricky bugs (DOM // could do that if we return -1). uint32_t i = 0, segIndex = 0; SVGPathTraversalState state; while (i < mData.Length()) { SVGPathSegUtils::TraversePathSegment(&mData[i], state); if (state.length >= aDistance) { return segIndex; } i += 1 + SVGPathSegUtils::ArgCountForType(mData[i]); segIndex++; } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); return std::max(0U, segIndex - 1); // -1 because while loop takes us 1 too far } /** * The SVG spec says we have to paint stroke caps for zero length subpaths: * * http://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes * * Cairo only does this for |stroke-linecap: round| and not for * |stroke-linecap: square| (since that's what Adobe Acrobat has always done). * Most likely the other backends that DrawTarget uses have the same behavior. * * To help us conform to the SVG spec we have this helper function to draw an * approximation of square caps for zero length subpaths. It does this by * inserting a subpath containing a single user space axis aligned straight * line that is as small as it can be while minimizing the risk of it being * thrown away by the DrawTarget's backend for being too small to affect * rendering. The idea is that we'll then get stroke caps drawn for this axis * aligned line, creating an axis aligned rectangle that approximates the * square that would ideally be drawn. * * Since we don't have any information about transforms from user space to * device space, we choose the length of the small line that we insert by * making it a small percentage of the stroke width of the path. This should * hopefully allow us to make the line as long as possible (to avoid rounding * issues in the backend resulting in the backend seeing it as having zero * length) while still avoiding the small rectangle being noticably different * from a square. * * Note that this function inserts a subpath into the current gfx path that * will be present during both fill and stroke operations. */ static void ApproximateZeroLengthSubpathSquareCaps(PathBuilder* aPB, const Point& aPoint, Float aStrokeWidth) { // Note that caps are proportional to stroke width, so if stroke width is // zero it's actually fine for |tinyLength| below to end up being zero. // However, it would be a waste to inserting a LineTo in that case, so better // not to. MOZ_ASSERT(aStrokeWidth > 0.0f, "Make the caller check for this, or check it here"); // The fraction of the stroke width that we choose for the length of the // line is rather arbitrary, other than being chosen to meet the requirements // described in the comment above. Float tinyLength = aStrokeWidth / SVG_ZERO_LENGTH_PATH_FIX_FACTOR; aPB->LineTo(aPoint + Point(tinyLength, 0)); aPB->MoveTo(aPoint); } #define MAYBE_APPROXIMATE_ZERO_LENGTH_SUBPATH_SQUARE_CAPS_TO_DT \ do { \ if (!subpathHasLength && hasLineCaps && aStrokeWidth > 0 && \ subpathContainsNonMoveTo && \ SVGPathSegUtils::IsValidType(prevSegType) && \ (!IsMoveto(prevSegType) || segType == PATHSEG_CLOSEPATH)) { \ ApproximateZeroLengthSubpathSquareCaps(builder, segStart, aStrokeWidth);\ } \ } while(0) already_AddRefed<Path> SVGPathData::BuildPath(PathBuilder* builder, uint8_t aStrokeLineCap, Float aStrokeWidth) const { if (mData.IsEmpty() || !IsMoveto(SVGPathSegUtils::DecodeType(mData[0]))) { return nullptr; // paths without an initial moveto are invalid } bool hasLineCaps = aStrokeLineCap != NS_STYLE_STROKE_LINECAP_BUTT; bool subpathHasLength = false; // visual length bool subpathContainsNonMoveTo = false; uint32_t segType = PATHSEG_UNKNOWN; uint32_t prevSegType = PATHSEG_UNKNOWN; Point pathStart(0.0, 0.0); // start point of [sub]path Point segStart(0.0, 0.0); Point segEnd; Point cp1, cp2; // previous bezier's control points Point tcp1, tcp2; // temporaries // Regarding cp1 and cp2: If the previous segment was a cubic bezier curve, // then cp2 is its second control point. If the previous segment was a // quadratic curve, then cp1 is its (only) control point. uint32_t i = 0; while (i < mData.Length()) { segType = SVGPathSegUtils::DecodeType(mData[i++]); uint32_t argCount = SVGPathSegUtils::ArgCountForType(segType); switch (segType) { case PATHSEG_CLOSEPATH: // set this early to allow drawing of square caps for "M{x},{y} Z": subpathContainsNonMoveTo = true; MAYBE_APPROXIMATE_ZERO_LENGTH_SUBPATH_SQUARE_CAPS_TO_DT; segEnd = pathStart; builder->Close(); break; case PATHSEG_MOVETO_ABS: MAYBE_APPROXIMATE_ZERO_LENGTH_SUBPATH_SQUARE_CAPS_TO_DT; pathStart = segEnd = Point(mData[i], mData[i+1]); builder->MoveTo(segEnd); subpathHasLength = false; break; case PATHSEG_MOVETO_REL: MAYBE_APPROXIMATE_ZERO_LENGTH_SUBPATH_SQUARE_CAPS_TO_DT; pathStart = segEnd = segStart + Point(mData[i], mData[i+1]); builder->MoveTo(segEnd); subpathHasLength = false; break; case PATHSEG_LINETO_ABS: segEnd = Point(mData[i], mData[i+1]); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_LINETO_REL: segEnd = segStart + Point(mData[i], mData[i+1]); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_CURVETO_CUBIC_ABS: cp1 = Point(mData[i], mData[i+1]); cp2 = Point(mData[i+2], mData[i+3]); segEnd = Point(mData[i+4], mData[i+5]); if (segEnd != segStart || segEnd != cp1 || segEnd != cp2) { subpathHasLength = true; builder->BezierTo(cp1, cp2, segEnd); } break; case PATHSEG_CURVETO_CUBIC_REL: cp1 = segStart + Point(mData[i], mData[i+1]); cp2 = segStart + Point(mData[i+2], mData[i+3]); segEnd = segStart + Point(mData[i+4], mData[i+5]); if (segEnd != segStart || segEnd != cp1 || segEnd != cp2) { subpathHasLength = true; builder->BezierTo(cp1, cp2, segEnd); } break; case PATHSEG_CURVETO_QUADRATIC_ABS: cp1 = Point(mData[i], mData[i+1]); // Convert quadratic curve to cubic curve: tcp1 = segStart + (cp1 - segStart) * 2 / 3; segEnd = Point(mData[i+2], mData[i+3]); // set before setting tcp2! tcp2 = cp1 + (segEnd - cp1) / 3; if (segEnd != segStart || segEnd != cp1) { subpathHasLength = true; builder->BezierTo(tcp1, tcp2, segEnd); } break; case PATHSEG_CURVETO_QUADRATIC_REL: cp1 = segStart + Point(mData[i], mData[i+1]); // Convert quadratic curve to cubic curve: tcp1 = segStart + (cp1 - segStart) * 2 / 3; segEnd = segStart + Point(mData[i+2], mData[i+3]); // set before setting tcp2! tcp2 = cp1 + (segEnd - cp1) / 3; if (segEnd != segStart || segEnd != cp1) { subpathHasLength = true; builder->BezierTo(tcp1, tcp2, segEnd); } break; case PATHSEG_ARC_ABS: case PATHSEG_ARC_REL: { Point radii(mData[i], mData[i+1]); segEnd = Point(mData[i+5], mData[i+6]); if (segType == PATHSEG_ARC_REL) { segEnd += segStart; } if (segEnd != segStart) { subpathHasLength = true; if (radii.x == 0.0f || radii.y == 0.0f) { builder->LineTo(segEnd); } else { nsSVGArcConverter converter(segStart, segEnd, radii, mData[i+2], mData[i+3] != 0, mData[i+4] != 0); while (converter.GetNextSegment(&cp1, &cp2, &segEnd)) { builder->BezierTo(cp1, cp2, segEnd); } } } break; } case PATHSEG_LINETO_HORIZONTAL_ABS: segEnd = Point(mData[i], segStart.y); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_LINETO_HORIZONTAL_REL: segEnd = segStart + Point(mData[i], 0.0f); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_LINETO_VERTICAL_ABS: segEnd = Point(segStart.x, mData[i]); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_LINETO_VERTICAL_REL: segEnd = segStart + Point(0.0f, mData[i]); if (segEnd != segStart) { subpathHasLength = true; builder->LineTo(segEnd); } break; case PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: cp1 = SVGPathSegUtils::IsCubicType(prevSegType) ? segStart * 2 - cp2 : segStart; cp2 = Point(mData[i], mData[i+1]); segEnd = Point(mData[i+2], mData[i+3]); if (segEnd != segStart || segEnd != cp1 || segEnd != cp2) { subpathHasLength = true; builder->BezierTo(cp1, cp2, segEnd); } break; case PATHSEG_CURVETO_CUBIC_SMOOTH_REL: cp1 = SVGPathSegUtils::IsCubicType(prevSegType) ? segStart * 2 - cp2 : segStart; cp2 = segStart + Point(mData[i], mData[i+1]); segEnd = segStart + Point(mData[i+2], mData[i+3]); if (segEnd != segStart || segEnd != cp1 || segEnd != cp2) { subpathHasLength = true; builder->BezierTo(cp1, cp2, segEnd); } break; case PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: cp1 = SVGPathSegUtils::IsQuadraticType(prevSegType) ? segStart * 2 - cp1 : segStart; // Convert quadratic curve to cubic curve: tcp1 = segStart + (cp1 - segStart) * 2 / 3; segEnd = Point(mData[i], mData[i+1]); // set before setting tcp2! tcp2 = cp1 + (segEnd - cp1) / 3; if (segEnd != segStart || segEnd != cp1) { subpathHasLength = true; builder->BezierTo(tcp1, tcp2, segEnd); } break; case PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: cp1 = SVGPathSegUtils::IsQuadraticType(prevSegType) ? segStart * 2 - cp1 : segStart; // Convert quadratic curve to cubic curve: tcp1 = segStart + (cp1 - segStart) * 2 / 3; segEnd = segStart + Point(mData[i], mData[i+1]); // changed before setting tcp2! tcp2 = cp1 + (segEnd - cp1) / 3; if (segEnd != segStart || segEnd != cp1) { subpathHasLength = true; builder->BezierTo(tcp1, tcp2, segEnd); } break; default: NS_NOTREACHED("Bad path segment type"); return nullptr; // according to spec we'd use everything up to the bad seg anyway } subpathContainsNonMoveTo = segType != PATHSEG_MOVETO_ABS && segType != PATHSEG_MOVETO_REL; i += argCount; prevSegType = segType; segStart = segEnd; } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); MOZ_ASSERT(prevSegType == segType, "prevSegType should be left at the final segType"); MAYBE_APPROXIMATE_ZERO_LENGTH_SUBPATH_SQUARE_CAPS_TO_DT; return builder->Finish(); } already_AddRefed<Path> SVGPathData::BuildPathForMeasuring() const { // Since the path that we return will not be used for painting it doesn't // matter what we pass to CreatePathBuilder as aFillRule. Hawever, we do want // to pass something other than NS_STYLE_STROKE_LINECAP_SQUARE as // aStrokeLineCap to avoid the insertion of extra little lines (by // ApproximateZeroLengthSubpathSquareCaps), in which case the value that we // pass as aStrokeWidth doesn't matter (since it's only used to determine the // length of those extra little lines). RefPtr<DrawTarget> drawTarget = gfxPlatform::GetPlatform()->ScreenReferenceDrawTarget(); RefPtr<PathBuilder> builder = drawTarget->CreatePathBuilder(FillRule::FILL_WINDING); return BuildPath(builder, NS_STYLE_STROKE_LINECAP_BUTT, 0); } static double AngleOfVector(const Point& aVector) { // C99 says about atan2 "A domain error may occur if both arguments are // zero" and "On a domain error, the function returns an implementation- // defined value". In the case of atan2 the implementation-defined value // seems to commonly be zero, but it could just as easily be a NaN value. // We specifically want zero in this case, hence the check: return (aVector != Point(0.0, 0.0)) ? atan2(aVector.y, aVector.x) : 0.0; } static float AngleOfVector(const Point& cp1, const Point& cp2) { return static_cast<float>(AngleOfVector(cp1 - cp2)); } void SVGPathData::GetMarkerPositioningData(nsTArray<nsSVGMark> *aMarks) const { // This code should assume that ANY type of segment can appear at ANY index. // It should also assume that segments such as M and Z can appear in weird // places, and repeat multiple times consecutively. // info on current [sub]path (reset every M command): Point pathStart(0.0, 0.0); float pathStartAngle = 0.0f; // info on previous segment: uint16_t prevSegType = PATHSEG_UNKNOWN; Point prevSegEnd(0.0, 0.0); float prevSegEndAngle = 0.0f; Point prevCP; // if prev seg was a bezier, this was its last control point uint32_t i = 0; while (i < mData.Length()) { // info on current segment: uint16_t segType = SVGPathSegUtils::DecodeType(mData[i++]); // advances i to args Point& segStart = prevSegEnd; Point segEnd; float segStartAngle, segEndAngle; switch (segType) // to find segStartAngle, segEnd and segEndAngle { case PATHSEG_CLOSEPATH: segEnd = pathStart; segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); break; case PATHSEG_MOVETO_ABS: case PATHSEG_MOVETO_REL: if (segType == PATHSEG_MOVETO_ABS) { segEnd = Point(mData[i], mData[i+1]); } else { segEnd = segStart + Point(mData[i], mData[i+1]); } pathStart = segEnd; // If authors are going to specify multiple consecutive moveto commands // with markers, me might as well make the angle do something useful: segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); i += 2; break; case PATHSEG_LINETO_ABS: case PATHSEG_LINETO_REL: if (segType == PATHSEG_LINETO_ABS) { segEnd = Point(mData[i], mData[i+1]); } else { segEnd = segStart + Point(mData[i], mData[i+1]); } segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); i += 2; break; case PATHSEG_CURVETO_CUBIC_ABS: case PATHSEG_CURVETO_CUBIC_REL: { Point cp1, cp2; // control points if (segType == PATHSEG_CURVETO_CUBIC_ABS) { cp1 = Point(mData[i], mData[i+1]); cp2 = Point(mData[i+2], mData[i+3]); segEnd = Point(mData[i+4], mData[i+5]); } else { cp1 = segStart + Point(mData[i], mData[i+1]); cp2 = segStart + Point(mData[i+2], mData[i+3]); segEnd = segStart + Point(mData[i+4], mData[i+5]); } prevCP = cp2; segStartAngle = AngleOfVector(cp1 == segStart ? (cp1 == cp2 ? segEnd : cp2) : cp1, segStart); segEndAngle = AngleOfVector(segEnd, cp2 == segEnd ? (cp1 == cp2 ? segStart : cp1) : cp2); i += 6; break; } case PATHSEG_CURVETO_QUADRATIC_ABS: case PATHSEG_CURVETO_QUADRATIC_REL: { Point cp1; // control point if (segType == PATHSEG_CURVETO_QUADRATIC_ABS) { cp1 = Point(mData[i], mData[i+1]); segEnd = Point(mData[i+2], mData[i+3]); } else { cp1 = segStart + Point(mData[i], mData[i+1]); segEnd = segStart + Point(mData[i+2], mData[i+3]); } prevCP = cp1; segStartAngle = AngleOfVector(cp1 == segStart ? segEnd : cp1, segStart); segEndAngle = AngleOfVector(segEnd, cp1 == segEnd ? segStart : cp1); i += 4; break; } case PATHSEG_ARC_ABS: case PATHSEG_ARC_REL: { double rx = mData[i]; double ry = mData[i+1]; double angle = mData[i+2]; bool largeArcFlag = mData[i+3] != 0.0f; bool sweepFlag = mData[i+4] != 0.0f; if (segType == PATHSEG_ARC_ABS) { segEnd = Point(mData[i+5], mData[i+6]); } else { segEnd = segStart + Point(mData[i+5], mData[i+6]); } // See section F.6 of SVG 1.1 for details on what we're doing here: // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes if (segStart == segEnd) { // F.6.2 says "If the endpoints (x1, y1) and (x2, y2) are identical, // then this is equivalent to omitting the elliptical arc segment // entirely." We take that very literally here, not adding a mark, and // not even setting any of the 'prev' variables so that it's as if this // arc had never existed; note the difference this will make e.g. if // the arc is proceeded by a bezier curve and followed by a "smooth" // bezier curve of the same degree! i += 7; continue; } // Below we have funny interleaving of F.6.6 (Correction of out-of-range // radii) and F.6.5 (Conversion from endpoint to center parameterization) // which is designed to avoid some unnecessary calculations. if (rx == 0.0 || ry == 0.0) { // F.6.6 step 1 - straight line or coincidental points segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); i += 7; break; } rx = fabs(rx); // F.6.6.1 ry = fabs(ry); // F.6.5.1: angle = angle * M_PI/180.0; double x1p = cos(angle) * (segStart.x - segEnd.x) / 2.0 + sin(angle) * (segStart.y - segEnd.y) / 2.0; double y1p = -sin(angle) * (segStart.x - segEnd.x) / 2.0 + cos(angle) * (segStart.y - segEnd.y) / 2.0; // This is the root in F.6.5.2 and the numerator under that root: double root; double numerator = rx*rx*ry*ry - rx*rx*y1p*y1p - ry*ry*x1p*x1p; if (numerator >= 0.0) { root = sqrt(numerator/(rx*rx*y1p*y1p + ry*ry*x1p*x1p)); if (largeArcFlag == sweepFlag) root = -root; } else { // F.6.6 step 3 - |numerator < 0.0|. This is equivalent to the result // of F.6.6.2 (lamedh) being greater than one. What we have here is // ellipse radii that are too small for the ellipse to reach between // segStart and segEnd. We scale the radii up uniformly so that the // ellipse is just big enough to fit (i.e. to the point where there is // exactly one solution). double lamedh = 1.0 - numerator/(rx*rx*ry*ry); // equiv to eqn F.6.6.2 double s = sqrt(lamedh); rx *= s; // F.6.6.3 ry *= s; root = 0.0; } double cxp = root * rx * y1p / ry; // F.6.5.2 double cyp = -root * ry * x1p / rx; double theta, delta; theta = AngleOfVector(Point((x1p-cxp)/rx, (y1p-cyp)/ry)); // F.6.5.5 delta = AngleOfVector(Point((-x1p-cxp)/rx, (-y1p-cyp)/ry)) - // F.6.5.6 theta; if (!sweepFlag && delta > 0) delta -= 2.0 * M_PI; else if (sweepFlag && delta < 0) delta += 2.0 * M_PI; double tx1, ty1, tx2, ty2; tx1 = -cos(angle)*rx*sin(theta) - sin(angle)*ry*cos(theta); ty1 = -sin(angle)*rx*sin(theta) + cos(angle)*ry*cos(theta); tx2 = -cos(angle)*rx*sin(theta+delta) - sin(angle)*ry*cos(theta+delta); ty2 = -sin(angle)*rx*sin(theta+delta) + cos(angle)*ry*cos(theta+delta); if (delta < 0.0f) { tx1 = -tx1; ty1 = -ty1; tx2 = -tx2; ty2 = -ty2; } segStartAngle = static_cast<float>(atan2(ty1, tx1)); segEndAngle = static_cast<float>(atan2(ty2, tx2)); i += 7; break; } case PATHSEG_LINETO_HORIZONTAL_ABS: case PATHSEG_LINETO_HORIZONTAL_REL: if (segType == PATHSEG_LINETO_HORIZONTAL_ABS) { segEnd = Point(mData[i++], segStart.y); } else { segEnd = segStart + Point(mData[i++], 0.0f); } segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); break; case PATHSEG_LINETO_VERTICAL_ABS: case PATHSEG_LINETO_VERTICAL_REL: if (segType == PATHSEG_LINETO_VERTICAL_ABS) { segEnd = Point(segStart.x, mData[i++]); } else { segEnd = segStart + Point(0.0f, mData[i++]); } segStartAngle = segEndAngle = AngleOfVector(segEnd, segStart); break; case PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: case PATHSEG_CURVETO_CUBIC_SMOOTH_REL: { Point cp1 = SVGPathSegUtils::IsCubicType(prevSegType) ? segStart * 2 - prevCP : segStart; Point cp2; if (segType == PATHSEG_CURVETO_CUBIC_SMOOTH_ABS) { cp2 = Point(mData[i], mData[i+1]); segEnd = Point(mData[i+2], mData[i+3]); } else { cp2 = segStart + Point(mData[i], mData[i+1]); segEnd = segStart + Point(mData[i+2], mData[i+3]); } prevCP = cp2; segStartAngle = AngleOfVector(cp1 == segStart ? (cp1 == cp2 ? segEnd : cp2) : cp1, segStart); segEndAngle = AngleOfVector(segEnd, cp2 == segEnd ? (cp1 == cp2 ? segStart : cp1) : cp2); i += 4; break; } case PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: case PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: { Point cp1 = SVGPathSegUtils::IsQuadraticType(prevSegType) ? segStart * 2 - prevCP : segStart; if (segType == PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS) { segEnd = Point(mData[i], mData[i+1]); } else { segEnd = segStart + Point(mData[i], mData[i+1]); } prevCP = cp1; segStartAngle = AngleOfVector(cp1 == segStart ? segEnd : cp1, segStart); segEndAngle = AngleOfVector(segEnd, cp1 == segEnd ? segStart : cp1); i += 2; break; } default: // Leave any existing marks in aMarks so we have a visual indication of // when things went wrong. MOZ_ASSERT(false, "Unknown segment type - path corruption?"); return; } // Set the angle of the mark at the start of this segment: if (aMarks->Length()) { nsSVGMark &mark = aMarks->LastElement(); if (!IsMoveto(segType) && IsMoveto(prevSegType)) { // start of new subpath pathStartAngle = mark.angle = segStartAngle; } else if (IsMoveto(segType) && !IsMoveto(prevSegType)) { // end of a subpath if (prevSegType != PATHSEG_CLOSEPATH) mark.angle = prevSegEndAngle; } else { if (!(segType == PATHSEG_CLOSEPATH && prevSegType == PATHSEG_CLOSEPATH)) mark.angle = SVGContentUtils::AngleBisect(prevSegEndAngle, segStartAngle); } } // Add the mark at the end of this segment, and set its position: if (!aMarks->AppendElement(nsSVGMark(static_cast<float>(segEnd.x), static_cast<float>(segEnd.y), 0.0f, nsSVGMark::eMid))) { aMarks->Clear(); // OOM, so try to free some return; } if (segType == PATHSEG_CLOSEPATH && prevSegType != PATHSEG_CLOSEPATH) { aMarks->LastElement().angle = //aMarks->ElementAt(pathStartIndex).angle = SVGContentUtils::AngleBisect(segEndAngle, pathStartAngle); } prevSegType = segType; prevSegEnd = segEnd; prevSegEndAngle = segEndAngle; } MOZ_ASSERT(i == mData.Length(), "Very, very bad - mData corrupt"); if (aMarks->Length()) { if (prevSegType != PATHSEG_CLOSEPATH) { aMarks->LastElement().angle = prevSegEndAngle; } aMarks->LastElement().type = nsSVGMark::eEnd; aMarks->ElementAt(0).type = nsSVGMark::eStart; } } size_t SVGPathData::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const { return mData.ShallowSizeOfExcludingThis(aMallocSizeOf); } size_t SVGPathData::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const { return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf); }