DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (b6d82b1a6b02)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
/* -*- 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 MOZILLA_GFX_PATHHELPERS_H_
#define MOZILLA_GFX_PATHHELPERS_H_

#include "2D.h"
#include "UserData.h"

#include <cmath>

namespace mozilla {
namespace gfx {

struct PathOp {
  PathOp() {}
  ~PathOp() {}

  enum OpType {
    OP_MOVETO = 0,
    OP_LINETO,
    OP_BEZIERTO,
    OP_QUADRATICBEZIERTO,
    OP_ARC,
    OP_CLOSE
  };

  OpType mType;
  Point mP1;
#if (!defined(__GNUC__) || __GNUC__ >= 7) && defined(__clang__)
  union {
    struct {
      Point mP2;
      Point mP3;
    };
    struct {
      float mRadius;
      float mStartAngle;
      float mEndAngle;
      bool mAntiClockwise;
    };
  };
#else
  Point mP2;
  Point mP3;
  float mRadius;
  float mStartAngle;
  float mEndAngle;
  bool mAntiClockwise;
#endif
};

const int32_t sPointCount[] = {1, 1, 3, 2, 0, 0};

// 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, const Matrix& aTransform = Matrix()) {
  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);
  transform *= aTransform;
  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) {
  RefPtr<PathBuilder> builder = aDrawTarget.CreatePathBuilder();
  AppendRectToPath(builder, aRect, aDrawClockwise);
  return builder->Finish();
}

/**
 * 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) {
  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) {
  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_ */