gecko-dev/gfx/2d/PathHelpers.h

437 строки
16 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
2012-05-21 15:12:37 +04:00
* 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 MOZILLA_GFX_PATHHELPERS_H_
#define MOZILLA_GFX_PATHHELPERS_H_
#include "2D.h"
#include "UserData.h"
#include <cmath>
namespace mozilla {
namespace gfx {
// Kappa constant for 90-degree angle
const Float kKappaFactor = 0.55191497064665766025f;
// Calculate kappa constant for partial curve. The sign of angle in the
// tangent will actually ensure this is negative for a counter clockwise
// sweep, so changing signs later isn't needed.
inline Float ComputeKappaFactor(Float aAngle)
{
return (4.0f / 3.0f) * tanf(aAngle / 4.0f);
}
/**
* Draws a partial arc <= 90 degrees given exact start and end points.
* Assumes that it is continuing from an already specified start point.
*/
template <typename T>
inline void PartialArcToBezier(T* aSink,
const Point& aStartOffset, const Point& aEndOffset,
const Matrix& aTransform,
Float aKappaFactor = kKappaFactor)
{
Point cp1 =
aStartOffset + Point(-aStartOffset.y, aStartOffset.x) * aKappaFactor;
Point cp2 =
aEndOffset + Point(aEndOffset.y, -aEndOffset.x) * aKappaFactor;
aSink->BezierTo(aTransform.TransformPoint(cp1),
aTransform.TransformPoint(cp2),
aTransform.TransformPoint(aEndOffset));
}
/**
* Draws an acute arc (<= 90 degrees) given exact start and end points.
* Specialized version avoiding kappa calculation.
*/
template <typename T>
inline void AcuteArcToBezier(T* aSink,
const Point& aOrigin, const Size& aRadius,
const Point& aStartPoint, const Point& aEndPoint,
Float aKappaFactor = kKappaFactor)
{
aSink->LineTo(aStartPoint);
if (!aRadius.IsEmpty()) {
Float kappaX = aKappaFactor * aRadius.width / aRadius.height;
Float kappaY = aKappaFactor * aRadius.height / aRadius.width;
Point startOffset = aStartPoint - aOrigin;
Point endOffset = aEndPoint - aOrigin;
aSink->BezierTo(aStartPoint + Point(-startOffset.y * kappaX, startOffset.x * kappaY),
aEndPoint + Point(endOffset.y * kappaX, -endOffset.x * kappaY),
aEndPoint);
} else if (aEndPoint != aStartPoint) {
aSink->LineTo(aEndPoint);
}
}
/**
* Draws an acute arc (<= 90 degrees) given exact start and end points.
*/
template <typename T>
inline void AcuteArcToBezier(T* aSink,
const Point& aOrigin, const Size& aRadius,
const Point& aStartPoint, const Point& aEndPoint,
Float aStartAngle, Float aEndAngle)
{
AcuteArcToBezier(aSink, aOrigin, aRadius, aStartPoint, aEndPoint,
ComputeKappaFactor(aEndAngle - aStartAngle));
}
template <typename T>
void ArcToBezier(T* aSink, const Point &aOrigin, const Size &aRadius,
float aStartAngle, float aEndAngle, bool aAntiClockwise,
float aRotation = 0.0f)
{
Float sweepDirection = aAntiClockwise ? -1.0f : 1.0f;
// Calculate the total arc we're going to sweep.
Float arcSweepLeft = (aEndAngle - aStartAngle) * sweepDirection;
// Clockwise we always sweep from the smaller to the larger angle, ccw
// it's vice versa.
if (arcSweepLeft < 0) {
// Rerverse sweep is modulo'd into range rather than clamped.
arcSweepLeft = Float(2.0f * M_PI) + fmodf(arcSweepLeft, Float(2.0f * M_PI));
// Recalculate the start angle to land closer to end angle.
aStartAngle = aEndAngle - arcSweepLeft * sweepDirection;
} else if (arcSweepLeft > Float(2.0f * M_PI)) {
// Sweeping more than 2 * pi is a full circle.
arcSweepLeft = Float(2.0f * M_PI);
}
Float currentStartAngle = aStartAngle;
Point currentStartOffset(cosf(aStartAngle), sinf(aStartAngle));
Matrix transform = Matrix::Scaling(aRadius.width, aRadius.height);
if (aRotation != 0.0f) {
transform *= Matrix::Rotation(aRotation);
}
transform.PostTranslate(aOrigin);
aSink->LineTo(transform.TransformPoint(currentStartOffset));
while (arcSweepLeft > 0) {
Float currentEndAngle =
currentStartAngle + std::min(arcSweepLeft, Float(M_PI / 2.0f)) * sweepDirection;
Point currentEndOffset(cosf(currentEndAngle), sinf(currentEndAngle));
PartialArcToBezier(aSink, currentStartOffset, currentEndOffset, transform,
ComputeKappaFactor(currentEndAngle - currentStartAngle));
// We guarantee here the current point is the start point of the next
// curve segment.
arcSweepLeft -= Float(M_PI / 2.0f);
currentStartAngle = currentEndAngle;
currentStartOffset = currentEndOffset;
}
}
/* This is basically the ArcToBezier with the parameters for drawing a circle
* inlined which vastly simplifies it and avoids a bunch of transcedental function
* calls which should make it faster. */
template <typename T>
void EllipseToBezier(T* aSink, const Point &aOrigin, const Size &aRadius)
{
Matrix transform(aRadius.width, 0, 0, aRadius.height, aOrigin.x, aOrigin.y);
Point currentStartOffset(1, 0);
aSink->LineTo(transform.TransformPoint(currentStartOffset));
for (int i = 0; i < 4; i++) {
// cos(x+pi/2) == -sin(x)
// sin(x+pi/2) == cos(x)
Point currentEndOffset(-currentStartOffset.y, currentStartOffset.x);
PartialArcToBezier(aSink, currentStartOffset, currentEndOffset, transform);
// We guarantee here the current point is the start point of the next
// curve segment.
currentStartOffset = currentEndOffset;
}
}
/**
* Appends a path represending a rectangle to the path being built by
* aPathBuilder.
*
* aRect The rectangle to append.
* aDrawClockwise If set to true, the path will start at the left of the top
* left edge and draw clockwise. If set to false the path will
* start at the right of the top left edge and draw counter-
* clockwise.
*/
GFX2D_API void AppendRectToPath(PathBuilder* aPathBuilder,
const Rect& aRect,
bool aDrawClockwise = true);
inline already_AddRefed<Path> MakePathForRect(const DrawTarget& aDrawTarget,
const Rect& aRect,
bool aDrawClockwise = true)
{
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 08:24:48 +03:00
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
AppendRectToPath(builder, aRect, aDrawClockwise);
return builder->Finish();
}
struct RectCornerRadii {
Size radii[eCornerCount];
RectCornerRadii() {}
explicit RectCornerRadii(Float radius) {
NS_FOR_CSS_FULL_CORNERS(i) {
radii[i].SizeTo(radius, radius);
}
}
explicit RectCornerRadii(Float radiusX, Float radiusY) {
NS_FOR_CSS_FULL_CORNERS(i) {
radii[i].SizeTo(radiusX, radiusY);
}
}
RectCornerRadii(Float tl, Float tr, Float br, Float bl) {
radii[eCornerTopLeft].SizeTo(tl, tl);
radii[eCornerTopRight].SizeTo(tr, tr);
radii[eCornerBottomRight].SizeTo(br, br);
radii[eCornerBottomLeft].SizeTo(bl, bl);
}
RectCornerRadii(const Size& tl, const Size& tr,
const Size& br, const Size& bl) {
radii[eCornerTopLeft] = tl;
radii[eCornerTopRight] = tr;
radii[eCornerBottomRight] = br;
radii[eCornerBottomLeft] = bl;
}
const Size& operator[](size_t aCorner) const {
return radii[aCorner];
}
Size& operator[](size_t aCorner) {
return radii[aCorner];
}
bool operator==(const RectCornerRadii& aOther) const {
return TopLeft() == aOther.TopLeft() &&
TopRight() == aOther.TopRight() &&
BottomRight() == aOther.BottomRight() &&
BottomLeft() == aOther.BottomLeft();
}
bool AreRadiiSame() const {
return TopLeft() == TopRight() &&
TopLeft() == BottomRight() &&
TopLeft() == BottomLeft();
}
void Scale(Float aXScale, Float aYScale) {
NS_FOR_CSS_FULL_CORNERS(i) {
radii[i].Scale(aXScale, aYScale);
}
}
const Size TopLeft() const { return radii[eCornerTopLeft]; }
Size& TopLeft() { return radii[eCornerTopLeft]; }
const Size TopRight() const { return radii[eCornerTopRight]; }
Size& TopRight() { return radii[eCornerTopRight]; }
const Size BottomRight() const { return radii[eCornerBottomRight]; }
Size& BottomRight() { return radii[eCornerBottomRight]; }
const Size BottomLeft() const { return radii[eCornerBottomLeft]; }
Size& BottomLeft() { return radii[eCornerBottomLeft]; }
bool IsEmpty() const {
return TopLeft().IsEmpty() && TopRight().IsEmpty() &&
BottomRight().IsEmpty() && BottomLeft().IsEmpty();
}
};
/**
* Appends a path represending a rounded rectangle to the path being built by
* aPathBuilder.
*
* aRect The rectangle to append.
* aCornerRadii Contains the radii of the top-left, top-right, bottom-right
* and bottom-left corners, in that order.
* aDrawClockwise If set to true, the path will start at the left of the top
* left edge and draw clockwise. If set to false the path will
* start at the right of the top left edge and draw counter-
* clockwise.
*/
GFX2D_API void AppendRoundedRectToPath(PathBuilder* aPathBuilder,
const Rect& aRect,
const RectCornerRadii& aRadii,
bool aDrawClockwise = true);
inline already_AddRefed<Path> MakePathForRoundedRect(const DrawTarget& aDrawTarget,
const Rect& aRect,
const RectCornerRadii& aRadii,
bool aDrawClockwise = true)
{
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 08:24:48 +03:00
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
AppendRoundedRectToPath(builder, aRect, aRadii, aDrawClockwise);
return builder->Finish();
}
/**
* Appends a path represending an ellipse to the path being built by
* aPathBuilder.
*
* The ellipse extends aDimensions.width / 2.0 in the horizontal direction
* from aCenter, and aDimensions.height / 2.0 in the vertical direction.
*/
GFX2D_API void AppendEllipseToPath(PathBuilder* aPathBuilder,
const Point& aCenter,
const Size& aDimensions);
inline already_AddRefed<Path> MakePathForEllipse(const DrawTarget& aDrawTarget,
const Point& aCenter,
const Size& aDimensions)
{
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 08:24:48 +03:00
RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
AppendEllipseToPath(builder, aCenter, aDimensions);
return builder->Finish();
}
/**
* If aDrawTarget's transform only contains a translation, and if this line is
* a horizontal or vertical line, this function will snap the line's vertices
* to align with the device pixel grid so that stroking the line with a one
* pixel wide stroke will result in a crisp line that is not antialiased over
* two pixels across its width.
*
* @return Returns true if this function snaps aRect's vertices, else returns
* false.
*/
GFX2D_API bool SnapLineToDevicePixelsForStroking(Point& aP1, Point& aP2,
const DrawTarget& aDrawTarget,
Float aLineWidth);
/**
* This function paints each edge of aRect separately, snapping the edges using
* SnapLineToDevicePixelsForStroking. Stroking the edges as separate paths
* helps ensure not only that the stroke spans a single row of device pixels if
* possible, but also that the ends of stroke dashes start and end on device
* pixels too.
*/
GFX2D_API void StrokeSnappedEdgesOfRect(const Rect& aRect,
DrawTarget& aDrawTarget,
const ColorPattern& aColor,
const StrokeOptions& aStrokeOptions);
/**
* Return the margin, in device space, by which a stroke can extend beyond the
* rendered shape.
* @param aStrokeOptions The stroke options that the stroke is drawn with.
* @param aTransform The user space to device space transform.
* @return The stroke margin.
*/
GFX2D_API Margin MaxStrokeExtents(const StrokeOptions& aStrokeOptions,
const Matrix& aTransform);
extern UserDataKey sDisablePixelSnapping;
/**
* If aDrawTarget's transform only contains a translation or, if
* aAllowScaleOr90DegreeRotate is true, and/or a scale/90 degree rotation, this
* function will convert aRect to device space and snap it to device pixels.
* This function returns true if aRect is modified, otherwise it returns false.
*
* Note that the snapping is such that filling the rect using a DrawTarget
* which has the identity matrix as its transform will result in crisp edges.
* (That is, aRect will have integer values, aligning its edges between pixel
* boundaries.) If on the other hand you stroking the rect with an odd valued
* stroke width then the edges of the stroke will be antialiased (assuming an
* AntialiasMode that does antialiasing).
*
* Empty snaps are those which result in a rectangle of 0 area. If they are
* disallowed, an axis is left unsnapped if the rounding process results in a
* length of 0.
*/
inline bool UserToDevicePixelSnapped(Rect& aRect, const DrawTarget& aDrawTarget,
bool aAllowScaleOr90DegreeRotate = false,
bool aAllowEmptySnaps = true)
{
if (aDrawTarget.GetUserData(&sDisablePixelSnapping)) {
return false;
}
Matrix mat = aDrawTarget.GetTransform();
const Float epsilon = 0.0000001f;
#define WITHIN_E(a,b) (fabs((a)-(b)) < epsilon)
if (!aAllowScaleOr90DegreeRotate &&
(!WITHIN_E(mat._11, 1.f) || !WITHIN_E(mat._22, 1.f) ||
!WITHIN_E(mat._12, 0.f) || !WITHIN_E(mat._21, 0.f))) {
// We have non-translation, but only translation is allowed.
return false;
}
#undef WITHIN_E
Point p1 = mat.TransformPoint(aRect.TopLeft());
Point p2 = mat.TransformPoint(aRect.TopRight());
Point p3 = mat.TransformPoint(aRect.BottomRight());
// Check that the rectangle is axis-aligned. For an axis-aligned rectangle,
// two opposite corners define the entire rectangle. So check if
// the axis-aligned rectangle with opposite corners p1 and p3
// define an axis-aligned rectangle whose other corners are p2 and p4.
// We actually only need to check one of p2 and p4, since an affine
// transform maps parallelograms to parallelograms.
if (p2 == Point(p1.x, p3.y) || p2 == Point(p3.x, p1.y)) {
Point p1r = p1;
Point p3r = p3;
p1r.Round();
p3r.Round();
if (aAllowEmptySnaps || p1r.x != p3r.x) {
p1.x = p1r.x;
p3.x = p3r.x;
}
if (aAllowEmptySnaps || p1r.y != p3r.y) {
p1.y = p1r.y;
p3.y = p3r.y;
}
aRect.MoveTo(Point(std::min(p1.x, p3.x), std::min(p1.y, p3.y)));
aRect.SizeTo(Size(std::max(p1.x, p3.x) - aRect.X(),
std::max(p1.y, p3.y) - aRect.Y()));
return true;
}
return false;
}
/**
* This function has the same behavior as UserToDevicePixelSnapped except that
* aRect is not transformed to device space.
*/
inline bool MaybeSnapToDevicePixels(Rect& aRect, const DrawTarget& aDrawTarget,
bool aAllowScaleOr90DegreeRotate = false,
bool aAllowEmptySnaps = true)
{
if (UserToDevicePixelSnapped(aRect, aDrawTarget,
aAllowScaleOr90DegreeRotate, aAllowEmptySnaps)) {
// Since UserToDevicePixelSnapped returned true we know there is no
// rotation/skew in 'mat', so we can just use TransformBounds() here.
Matrix mat = aDrawTarget.GetTransform();
mat.Invert();
aRect = mat.TransformBounds(aRect);
return true;
}
return false;
}
} // namespace gfx
} // namespace mozilla
#endif /* MOZILLA_GFX_PATHHELPERS_H_ */