diff options
Diffstat (limited to 'dom/svg/nsSVGPathGeometryElement.h')
| -rw-r--r-- | dom/svg/nsSVGPathGeometryElement.h | 198 |
1 files changed, 198 insertions, 0 deletions
diff --git a/dom/svg/nsSVGPathGeometryElement.h b/dom/svg/nsSVGPathGeometryElement.h new file mode 100644 index 000000000..1091fa0dc --- /dev/null +++ b/dom/svg/nsSVGPathGeometryElement.h @@ -0,0 +1,198 @@ +/* -*- 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 __NS_SVGPATHGEOMETRYELEMENT_H__ +#define __NS_SVGPATHGEOMETRYELEMENT_H__ + +#include "mozilla/gfx/2D.h" +#include "SVGGraphicsElement.h" + +struct nsSVGMark { + enum Type { + eStart, + eMid, + eEnd, + + eTypeCount + }; + + float x, y, angle; + Type type; + nsSVGMark(float aX, float aY, float aAngle, Type aType) : + x(aX), y(aY), angle(aAngle), type(aType) {} +}; + +typedef mozilla::dom::SVGGraphicsElement nsSVGPathGeometryElementBase; + +class nsSVGPathGeometryElement : public nsSVGPathGeometryElementBase +{ +protected: + typedef mozilla::gfx::CapStyle CapStyle; + typedef mozilla::gfx::DrawTarget DrawTarget; + typedef mozilla::gfx::FillRule FillRule; + typedef mozilla::gfx::Float Float; + typedef mozilla::gfx::Matrix Matrix; + typedef mozilla::gfx::Path Path; + typedef mozilla::gfx::Point Point; + typedef mozilla::gfx::PathBuilder PathBuilder; + typedef mozilla::gfx::Rect Rect; + typedef mozilla::gfx::StrokeOptions StrokeOptions; + +public: + explicit nsSVGPathGeometryElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo); + + virtual nsresult AfterSetAttr(int32_t aNamespaceID, nsIAtom* aName, + const nsAttrValue* aValue, bool aNotify) override; + + /** + * Causes this element to discard any Path object that GetOrBuildPath may + * have cached. + */ + virtual void ClearAnyCachedPath() override final { + mCachedPath = nullptr; + } + + virtual bool AttributeDefinesGeometry(const nsIAtom *aName); + + /** + * Returns true if this element's geometry depends on the width or height of its + * coordinate context (typically the viewport established by its nearest <svg> + * ancestor). In other words, returns true if one of the attributes for which + * AttributeDefinesGeometry returns true has a percentage value. + * + * This could be moved up to a more general class so it can be used for non-leaf + * elements, but that would require care and for now there's no need. + */ + bool GeometryDependsOnCoordCtx(); + + virtual bool IsMarkable(); + virtual void GetMarkPoints(nsTArray<nsSVGMark> *aMarks); + + /** + * A method that can be faster than using a Moz2D Path and calling GetBounds/ + * GetStrokedBounds on it. It also helps us avoid rounding error for simple + * shapes and simple transforms where the Moz2D Path backends can fail to + * produce the clean integer bounds that content authors expect in some cases. + * + * If |aToNonScalingStrokeSpace| is non-null then |aBounds|, which is computed + * in bounds space, has the property that it's the smallest (axis-aligned) + * rectangular bound containing the image of this shape as stroked in + * non-scaling-stroke space. (When all transforms involved are rectilinear + * the bounds of the image of |aBounds| in non-scaling-stroke space will be + * tight, but if there are non-rectilinear transforms involved then that may + * be impossible and this method will return false). + * + * If |aToNonScalingStrokeSpace| is non-null then |*aToNonScalingStrokeSpace| + * must be non-singular. + */ + virtual bool GetGeometryBounds(Rect* aBounds, const StrokeOptions& aStrokeOptions, + const Matrix& aToBoundsSpace, + const Matrix* aToNonScalingStrokeSpace = nullptr) { + return false; + } + + /** + * For use with GetAsSimplePath. + */ + class SimplePath + { + public: + SimplePath() + : mType(NONE) + {} + bool IsPath() const { + return mType != NONE; + } + void SetRect(Float x, Float y, Float width, Float height) { + mX = x; mY = y, mWidthOrX2 = width, mHeightOrY2 = height; + mType = RECT; + } + Rect AsRect() const { + MOZ_ASSERT(mType == RECT); + return Rect(mX, mY, mWidthOrX2, mHeightOrY2); + } + bool IsRect() const { + return mType == RECT; + } + void SetLine(Float x1, Float y1, Float x2, Float y2) { + mX = x1, mY = y1, mWidthOrX2 = x2, mHeightOrY2 = y2; + mType = LINE; + } + Point Point1() const { + MOZ_ASSERT(mType == LINE); + return Point(mX, mY); + } + Point Point2() const { + MOZ_ASSERT(mType == LINE); + return Point(mWidthOrX2, mHeightOrY2); + } + bool IsLine() const { + return mType == LINE; + } + void Reset() { + mType = NONE; + } + private: + enum Type { + NONE, RECT, LINE + }; + Float mX, mY, mWidthOrX2, mHeightOrY2; + Type mType; + }; + + /** + * For some platforms there is significant overhead to creating and painting + * a Moz2D Path object. For Rects and lines it is better to get the path data + * using this method and then use the optimized DrawTarget methods for + * filling/stroking rects and lines. + */ + virtual void GetAsSimplePath(SimplePath* aSimplePath) { + aSimplePath->Reset(); + } + + /** + * Returns a Path that can be used to paint, hit-test or calculate bounds for + * this element. May return nullptr if there is no [valid] path. The path + * that is created may be cached and returned on subsequent calls. + */ + virtual already_AddRefed<Path> GetOrBuildPath(const DrawTarget& aDrawTarget, + FillRule fillRule); + + /** + * The same as GetOrBuildPath, but bypasses the cache (neither returns any + * previously cached Path, nor caches the Path that in does return). + * this element. May return nullptr if there is no [valid] path. + */ + virtual already_AddRefed<Path> BuildPath(PathBuilder* aBuilder) = 0; + + /** + * Returns a Path that can be used to measure the length of this elements + * path, or to find the position at a given distance along it. + * + * This is currently equivalent to calling GetOrBuildPath, but it may not be + * in the future. The reason for this function to be separate from + * GetOrBuildPath is because SVGPathData::BuildPath inserts small lines into + * the path if zero length subpaths are encountered, in order to implement + * the SVG specifications requirements that zero length subpaths should + * render circles/squares if stroke-linecap is round/square, respectively. + * In principle these inserted lines could interfere with path measurement, + * so we keep callers that are looking to do measurement separate in case we + * run into problems with the inserted lines negatively affecting measuring + * for content. + */ + virtual already_AddRefed<Path> GetOrBuildPathForMeasuring(); + + /** + * Returns the current computed value of the CSS property 'fill-rule' for + * this element. + */ + FillRule GetFillRule(); + +protected: + mutable RefPtr<Path> mCachedPath; +}; + +#endif |