gecko-dev/dom/svg/nsSVGPathGeometryElement.h
Nathan Froyd 01583602a9 Bug 1207245 - part 6 - rename nsRefPtr<T> to RefPtr<T>; r=ehsan; a=Tomcat
The bulk of this commit was generated with a script, executed at the top
level of a typical source code checkout.  The only non-machine-generated
part was modifying MFBT's moz.build to reflect the new naming.

CLOSED TREE makes big refactorings like this a piece of cake.

 # The main substitution.
find . -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.mm' -o -name '*.idl'| \
    xargs perl -p -i -e '
 s/nsRefPtr\.h/RefPtr\.h/g; # handle includes
 s/nsRefPtr ?</RefPtr</g;   # handle declarations and variables
'

 # Handle a special friend declaration in gfx/layers/AtomicRefCountedWithFinalize.h.
perl -p -i -e 's/::nsRefPtr;/::RefPtr;/' gfx/layers/AtomicRefCountedWithFinalize.h

 # Handle nsRefPtr.h itself, a couple places that define constructors
 # from nsRefPtr, and code generators specially.  We do this here, rather
 # than indiscriminantly s/nsRefPtr/RefPtr/, because that would rename
 # things like nsRefPtrHashtable.
perl -p -i -e 's/nsRefPtr/RefPtr/g' \
     mfbt/nsRefPtr.h \
     xpcom/glue/nsCOMPtr.h \
     xpcom/base/OwningNonNull.h \
     ipc/ipdl/ipdl/lower.py \
     ipc/ipdl/ipdl/builtin.py \
     dom/bindings/Codegen.py \
     python/lldbutils/lldbutils/utils.py

 # In our indiscriminate substitution above, we renamed
 # nsRefPtrGetterAddRefs, the class behind getter_AddRefs.  Fix that up.
find . -name '*.cpp' -o -name '*.h' -o -name '*.idl' | \
    xargs perl -p -i -e 's/nsRefPtrGetterAddRefs/RefPtrGetterAddRefs/g'

if [ -d .git ]; then
    git mv mfbt/nsRefPtr.h mfbt/RefPtr.h
else
    hg mv mfbt/nsRefPtr.h mfbt/RefPtr.h
fi

--HG--
rename : mfbt/nsRefPtr.h => mfbt/RefPtr.h
2015-10-18 01:24:48 -04:00

199 lines
6.7 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 __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