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 (9c006434448d)

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
/* -*- 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_PATHRECORDING_H_
#define MOZILLA_GFX_PATHRECORDING_H_

#include "2D.h"
#include <vector>
#include <ostream>

#include "PathHelpers.h"

namespace mozilla {
namespace gfx {

class PathRecording;
class DrawEventRecorderPrivate;

class PathBuilderRecording : public PathBuilder {
 public:
  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathBuilderRecording, override)

  PathBuilderRecording(PathBuilder* aBuilder, FillRule aFillRule)
      : mPathBuilder(aBuilder), mFillRule(aFillRule) {}

  /* Move the current point in the path, any figure currently being drawn will
   * be considered closed during fill operations, however when stroking the
   * closing line segment will not be drawn.
   */
  virtual void MoveTo(const Point& aPoint) override;
  /* Add a linesegment to the current figure */
  virtual void LineTo(const Point& aPoint) override;
  /* Add a cubic bezier curve to the current figure */
  virtual void BezierTo(const Point& aCP1, const Point& aCP2,
                        const Point& aCP3) override;
  /* Add a quadratic bezier curve to the current figure */
  virtual void QuadraticBezierTo(const Point& aCP1, const Point& aCP2) override;
  /* Close the current figure, this will essentially generate a line segment
   * from the current point to the starting point for the current figure
   */
  virtual void Close() override;

  /* Add an arc to the current figure */
  virtual void Arc(const Point& aOrigin, float aRadius, float aStartAngle,
                   float aEndAngle, bool aAntiClockwise) override {
    ArcToBezier(this, aOrigin, Size(aRadius, aRadius), aStartAngle, aEndAngle,
                aAntiClockwise);
  }

  /* Point the current subpath is at - or where the next subpath will start
   * if there is no active subpath.
   */
  virtual Point CurrentPoint() const override;

  virtual already_AddRefed<Path> Finish() override;

  virtual BackendType GetBackendType() const override {
    return BackendType::RECORDING;
  }

 private:
  friend class PathRecording;

  RefPtr<PathBuilder> mPathBuilder;
  FillRule mFillRule;
  std::vector<PathOp> mPathOps;
};

class PathRecording : public Path {
 public:
  MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathRecording, override)

  PathRecording(Path* aPath, const std::vector<PathOp> aOps, FillRule aFillRule)
      : mPath(aPath), mPathOps(aOps), mFillRule(aFillRule) {}

  ~PathRecording();

  virtual BackendType GetBackendType() const override {
    return BackendType::RECORDING;
  }
  virtual already_AddRefed<PathBuilder> CopyToBuilder(
      FillRule aFillRule) const override;
  virtual already_AddRefed<PathBuilder> TransformedCopyToBuilder(
      const Matrix& aTransform, FillRule aFillRule) const override;
  virtual bool ContainsPoint(const Point& aPoint,
                             const Matrix& aTransform) const override {
    return mPath->ContainsPoint(aPoint, aTransform);
  }
  virtual bool StrokeContainsPoint(const StrokeOptions& aStrokeOptions,
                                   const Point& aPoint,
                                   const Matrix& aTransform) const override {
    return mPath->StrokeContainsPoint(aStrokeOptions, aPoint, aTransform);
  }

  virtual Rect GetBounds(const Matrix& aTransform = Matrix()) const override {
    return mPath->GetBounds(aTransform);
  }

  virtual Rect GetStrokedBounds(
      const StrokeOptions& aStrokeOptions,
      const Matrix& aTransform = Matrix()) const override {
    return mPath->GetStrokedBounds(aStrokeOptions, aTransform);
  }

  virtual void StreamToSink(PathSink* aSink) const override {
    mPath->StreamToSink(aSink);
  }

  virtual FillRule GetFillRule() const override { return mFillRule; }

  void StorePath(std::ostream& aStream) const;
  static void ReadPathToBuilder(std::istream& aStream, PathBuilder* aBuilder);

 private:
  friend class DrawTargetWrapAndRecord;
  friend class DrawTargetRecording;
  friend class RecordedPathCreation;

  RefPtr<Path> mPath;
  std::vector<PathOp> mPathOps;
  FillRule mFillRule;

  // Event recorders that have this path in their event stream.
  std::vector<RefPtr<DrawEventRecorderPrivate>> mStoredRecorders;
};

}  // namespace gfx
}  // namespace mozilla

#endif /* MOZILLA_GFX_PATHRECORDING_H_ */