mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-23 04:41:11 +00:00
291 lines
10 KiB
C++
291 lines
10 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/. */
|
|
|
|
#include "PathHelpers.h"
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
UserDataKey sDisablePixelSnapping;
|
|
|
|
void AppendRectToPath(PathBuilder* aPathBuilder, const Rect& aRect,
|
|
bool aDrawClockwise) {
|
|
if (aDrawClockwise) {
|
|
aPathBuilder->MoveTo(aRect.TopLeft());
|
|
aPathBuilder->LineTo(aRect.TopRight());
|
|
aPathBuilder->LineTo(aRect.BottomRight());
|
|
aPathBuilder->LineTo(aRect.BottomLeft());
|
|
} else {
|
|
aPathBuilder->MoveTo(aRect.TopRight());
|
|
aPathBuilder->LineTo(aRect.TopLeft());
|
|
aPathBuilder->LineTo(aRect.BottomLeft());
|
|
aPathBuilder->LineTo(aRect.BottomRight());
|
|
}
|
|
aPathBuilder->Close();
|
|
}
|
|
|
|
void AppendRoundedRectToPath(PathBuilder* aPathBuilder, const Rect& aRect,
|
|
const RectCornerRadii& aRadii, bool aDrawClockwise,
|
|
const Maybe<Matrix>& aTransform) {
|
|
// For CW drawing, this looks like:
|
|
//
|
|
// ...******0** 1 C
|
|
// ****
|
|
// *** 2
|
|
// **
|
|
// *
|
|
// *
|
|
// 3
|
|
// *
|
|
// *
|
|
//
|
|
// Where 0, 1, 2, 3 are the control points of the Bezier curve for
|
|
// the corner, and C is the actual corner point.
|
|
//
|
|
// At the start of the loop, the current point is assumed to be
|
|
// the point adjacent to the top left corner on the top
|
|
// horizontal. Note that corner indices start at the top left and
|
|
// continue clockwise, whereas in our loop i = 0 refers to the top
|
|
// right corner.
|
|
//
|
|
// When going CCW, the control points are swapped, and the first
|
|
// corner that's drawn is the top left (along with the top segment).
|
|
//
|
|
// There is considerable latitude in how one chooses the four
|
|
// control points for a Bezier curve approximation to an ellipse.
|
|
// For the overall path to be continuous and show no corner at the
|
|
// endpoints of the arc, points 0 and 3 must be at the ends of the
|
|
// straight segments of the rectangle; points 0, 1, and C must be
|
|
// collinear; and points 3, 2, and C must also be collinear. This
|
|
// leaves only two free parameters: the ratio of the line segments
|
|
// 01 and 0C, and the ratio of the line segments 32 and 3C. See
|
|
// the following papers for extensive discussion of how to choose
|
|
// these ratios:
|
|
//
|
|
// Dokken, Tor, et al. "Good approximation of circles by
|
|
// curvature-continuous Bezier curves." Computer-Aided
|
|
// Geometric Design 7(1990) 33--41.
|
|
// Goldapp, Michael. "Approximation of circular arcs by cubic
|
|
// polynomials." Computer-Aided Geometric Design 8(1991) 227--238.
|
|
// Maisonobe, Luc. "Drawing an elliptical arc using polylines,
|
|
// quadratic, or cubic Bezier curves."
|
|
// http://www.spaceroots.org/documents/ellipse/elliptical-arc.pdf
|
|
//
|
|
// We follow the approach in section 2 of Goldapp (least-error,
|
|
// Hermite-type approximation) and make both ratios equal to
|
|
//
|
|
// 2 2 + n - sqrt(2n + 28)
|
|
// alpha = - * ---------------------
|
|
// 3 n - 4
|
|
//
|
|
// where n = 3( cbrt(sqrt(2)+1) - cbrt(sqrt(2)-1) ).
|
|
//
|
|
// This is the result of Goldapp's equation (10b) when the angle
|
|
// swept out by the arc is pi/2, and the parameter "a-bar" is the
|
|
// expression given immediately below equation (21).
|
|
//
|
|
// Using this value, the maximum radial error for a circle, as a
|
|
// fraction of the radius, is on the order of 0.2 x 10^-3.
|
|
// Neither Dokken nor Goldapp discusses error for a general
|
|
// ellipse; Maisonobe does, but his choice of control points
|
|
// follows different constraints, and Goldapp's expression for
|
|
// 'alpha' gives much smaller radial error, even for very flat
|
|
// ellipses, than Maisonobe's equivalent.
|
|
//
|
|
// For the various corners and for each axis, the sign of this
|
|
// constant changes, or it might be 0 -- it's multiplied by the
|
|
// appropriate multiplier from the list before using.
|
|
|
|
const Float alpha = Float(0.55191497064665766025);
|
|
|
|
typedef struct {
|
|
Float a, b;
|
|
} twoFloats;
|
|
|
|
twoFloats cwCornerMults[4] = {{-1, 0}, // cc == clockwise
|
|
{0, -1},
|
|
{+1, 0},
|
|
{0, +1}};
|
|
twoFloats ccwCornerMults[4] = {{+1, 0}, // ccw == counter-clockwise
|
|
{0, -1},
|
|
{-1, 0},
|
|
{0, +1}};
|
|
|
|
twoFloats* cornerMults = aDrawClockwise ? cwCornerMults : ccwCornerMults;
|
|
|
|
Point cornerCoords[] = {aRect.TopLeft(), aRect.TopRight(),
|
|
aRect.BottomRight(), aRect.BottomLeft()};
|
|
|
|
Point pc, p0, p1, p2, p3;
|
|
|
|
if (aDrawClockwise) {
|
|
Point pt(aRect.X() + aRadii[eCornerTopLeft].width, aRect.Y());
|
|
if (aTransform) {
|
|
pt = aTransform->TransformPoint(pt);
|
|
}
|
|
aPathBuilder->MoveTo(pt);
|
|
} else {
|
|
Point pt(aRect.X() + aRect.Width() - aRadii[eCornerTopRight].width,
|
|
aRect.Y());
|
|
if (aTransform) {
|
|
pt = aTransform->TransformPoint(pt);
|
|
}
|
|
aPathBuilder->MoveTo(pt);
|
|
}
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
// the corner index -- either 1 2 3 0 (cw) or 0 3 2 1 (ccw)
|
|
int c = aDrawClockwise ? ((i + 1) % 4) : ((4 - i) % 4);
|
|
|
|
// i+2 and i+3 respectively. These are used to index into the corner
|
|
// multiplier table, and were deduced by calculating out the long form
|
|
// of each corner and finding a pattern in the signs and values.
|
|
int i2 = (i + 2) % 4;
|
|
int i3 = (i + 3) % 4;
|
|
|
|
pc = cornerCoords[c];
|
|
|
|
if (aRadii[c].width > 0.0 && aRadii[c].height > 0.0) {
|
|
p0.x = pc.x + cornerMults[i].a * aRadii[c].width;
|
|
p0.y = pc.y + cornerMults[i].b * aRadii[c].height;
|
|
|
|
p3.x = pc.x + cornerMults[i3].a * aRadii[c].width;
|
|
p3.y = pc.y + cornerMults[i3].b * aRadii[c].height;
|
|
|
|
p1.x = p0.x + alpha * cornerMults[i2].a * aRadii[c].width;
|
|
p1.y = p0.y + alpha * cornerMults[i2].b * aRadii[c].height;
|
|
|
|
p2.x = p3.x - alpha * cornerMults[i3].a * aRadii[c].width;
|
|
p2.y = p3.y - alpha * cornerMults[i3].b * aRadii[c].height;
|
|
|
|
if (aTransform.isNothing()) {
|
|
aPathBuilder->LineTo(p0);
|
|
aPathBuilder->BezierTo(p1, p2, p3);
|
|
} else {
|
|
const Matrix& transform = *aTransform;
|
|
aPathBuilder->LineTo(transform.TransformPoint(p0));
|
|
aPathBuilder->BezierTo(transform.TransformPoint(p1),
|
|
transform.TransformPoint(p2),
|
|
transform.TransformPoint(p3));
|
|
}
|
|
} else {
|
|
if (aTransform.isNothing()) {
|
|
aPathBuilder->LineTo(pc);
|
|
} else {
|
|
aPathBuilder->LineTo(aTransform->TransformPoint(pc));
|
|
}
|
|
}
|
|
}
|
|
|
|
aPathBuilder->Close();
|
|
}
|
|
|
|
void AppendEllipseToPath(PathBuilder* aPathBuilder, const Point& aCenter,
|
|
const Size& aDimensions) {
|
|
Size halfDim = aDimensions / 2.f;
|
|
Rect rect(aCenter - Point(halfDim.width, halfDim.height), aDimensions);
|
|
RectCornerRadii radii(halfDim.width, halfDim.height);
|
|
|
|
AppendRoundedRectToPath(aPathBuilder, rect, radii);
|
|
}
|
|
|
|
bool SnapLineToDevicePixelsForStroking(Point& aP1, Point& aP2,
|
|
const DrawTarget& aDrawTarget,
|
|
Float aLineWidth) {
|
|
Matrix mat = aDrawTarget.GetTransform();
|
|
if (mat.HasNonTranslation()) {
|
|
return false;
|
|
}
|
|
if (aP1.x != aP2.x && aP1.y != aP2.y) {
|
|
return false; // not a horizontal or vertical line
|
|
}
|
|
Point p1 = aP1 + mat.GetTranslation(); // into device space
|
|
Point p2 = aP2 + mat.GetTranslation();
|
|
p1.Round();
|
|
p2.Round();
|
|
p1 -= mat.GetTranslation(); // back into user space
|
|
p2 -= mat.GetTranslation();
|
|
|
|
aP1 = p1;
|
|
aP2 = p2;
|
|
|
|
bool lineWidthIsOdd = (int(aLineWidth) % 2) == 1;
|
|
if (lineWidthIsOdd) {
|
|
if (aP1.x == aP2.x) {
|
|
// snap vertical line, adding 0.5 to align it to be mid-pixel:
|
|
aP1 += Point(0.5, 0);
|
|
aP2 += Point(0.5, 0);
|
|
} else {
|
|
// snap horizontal line, adding 0.5 to align it to be mid-pixel:
|
|
aP1 += Point(0, 0.5);
|
|
aP2 += Point(0, 0.5);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void StrokeSnappedEdgesOfRect(const Rect& aRect, DrawTarget& aDrawTarget,
|
|
const ColorPattern& aColor,
|
|
const StrokeOptions& aStrokeOptions) {
|
|
if (aRect.IsEmpty()) {
|
|
return;
|
|
}
|
|
|
|
Point p1 = aRect.TopLeft();
|
|
Point p2 = aRect.BottomLeft();
|
|
SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
|
|
aStrokeOptions.mLineWidth);
|
|
aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions);
|
|
|
|
p1 = aRect.BottomLeft();
|
|
p2 = aRect.BottomRight();
|
|
SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
|
|
aStrokeOptions.mLineWidth);
|
|
aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions);
|
|
|
|
p1 = aRect.TopLeft();
|
|
p2 = aRect.TopRight();
|
|
SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
|
|
aStrokeOptions.mLineWidth);
|
|
aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions);
|
|
|
|
p1 = aRect.TopRight();
|
|
p2 = aRect.BottomRight();
|
|
SnapLineToDevicePixelsForStroking(p1, p2, aDrawTarget,
|
|
aStrokeOptions.mLineWidth);
|
|
aDrawTarget.StrokeLine(p1, p2, aColor, aStrokeOptions);
|
|
}
|
|
|
|
// The logic for this comes from _cairo_stroke_style_max_distance_from_path
|
|
Margin MaxStrokeExtents(const StrokeOptions& aStrokeOptions,
|
|
const Matrix& aTransform) {
|
|
double styleExpansionFactor = 0.5f;
|
|
|
|
if (aStrokeOptions.mLineCap == CapStyle::SQUARE) {
|
|
styleExpansionFactor = M_SQRT1_2;
|
|
}
|
|
|
|
if (aStrokeOptions.mLineJoin == JoinStyle::MITER &&
|
|
styleExpansionFactor < M_SQRT2 * aStrokeOptions.mMiterLimit) {
|
|
styleExpansionFactor = M_SQRT2 * aStrokeOptions.mMiterLimit;
|
|
}
|
|
|
|
styleExpansionFactor *= aStrokeOptions.mLineWidth;
|
|
|
|
double dx = styleExpansionFactor * hypot(aTransform._11, aTransform._21);
|
|
double dy = styleExpansionFactor * hypot(aTransform._22, aTransform._12);
|
|
|
|
// Even if the stroke only partially covers a pixel, it must still render to
|
|
// full pixels. Round up to compensate for this.
|
|
dx = ceil(dx);
|
|
dy = ceil(dy);
|
|
|
|
return Margin(dy, dx, dy, dx);
|
|
}
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|