gfx/2d/PathRecording.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef MOZILLA_GFX_PATHRECORDING_H_
   7 #define MOZILLA_GFX_PATHRECORDING_H_
   8
   9 #include "2D.h"
  10 #include <vector>
  11 #include <ostream>
  12
  13 namespace mozilla {
  14 namespace gfx {
  15
  16 struct PathOp
  17 {
  18   enum OpType {
  19     OP_MOVETO = 0,
  20     OP_LINETO,
  21     OP_BEZIERTO,
  22     OP_QUADRATICBEZIERTO,
  23     OP_CLOSE
  24   };
  25
  26   OpType mType;
  27   Point mP1;
  28   Point mP2;
  29   Point mP3;
  30 };
  31
  32 const int32_t sPointCount[] = { 1, 1, 3, 2, 0, 0 };
  33
  34 class PathRecording;
  35 class DrawEventRecorderPrivate;
  36
  37 class PathBuilderRecording : public PathBuilder
  38 {
  39 public:
  40   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathBuilderRecording)
  41   PathBuilderRecording(PathBuilder *aBuilder, FillRule aFillRule)
  42     : mPathBuilder(aBuilder), mFillRule(aFillRule)
  43   {
  44   }
  45
  46   /* Move the current point in the path, any figure currently being drawn will
  47    * be considered closed during fill operations, however when stroking the
  48    * closing line segment will not be drawn.
  49    */
  50   virtual void MoveTo(const Point &aPoint);
  51   /* Add a linesegment to the current figure */
  52   virtual void LineTo(const Point &aPoint);
  53   /* Add a cubic bezier curve to the current figure */
  54   virtual void BezierTo(const Point &aCP1,
  55                         const Point &aCP2,
  56                         const Point &aCP3);
  57   /* Add a quadratic bezier curve to the current figure */
  58   virtual void QuadraticBezierTo(const Point &aCP1,
  59                                  const Point &aCP2);
  60   /* Close the current figure, this will essentially generate a line segment
  61    * from the current point to the starting point for the current figure
  62    */
  63   virtual void Close();
  64
  65   /* Add an arc to the current figure */
  66   virtual void Arc(const Point &, float, float, float, bool) { }
  67
  68   /* Point the current subpath is at - or where the next subpath will start
  69    * if there is no active subpath.
  70    */
  71   virtual Point CurrentPoint() const;
  72
  73   virtual TemporaryRef<Path> Finish();
  74
  75 private:
  76   friend class PathRecording;
  77
  78   RefPtr<PathBuilder> mPathBuilder;
  79   FillRule mFillRule;
  80   std::vector<PathOp> mPathOps;
  81 };
  82
  83 class PathRecording : public Path
  84 {
  85 public:
  86   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(PathRecording)
  87   PathRecording(Path *aPath, const std::vector<PathOp> aOps, FillRule aFillRule)
  88     : mPath(aPath), mPathOps(aOps), mFillRule(aFillRule)
  89   {
  90   }
  91
  92   ~PathRecording();
  93
  94   virtual BackendType GetBackendType() const { return BackendType::RECORDING; }
  95   virtual TemporaryRef<PathBuilder> CopyToBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const;
  96   virtual TemporaryRef<PathBuilder> TransformedCopyToBuilder(const Matrix &aTransform,
  97                                                              FillRule aFillRule = FillRule::FILL_WINDING) const;
  98   virtual bool ContainsPoint(const Point &aPoint, const Matrix &aTransform) const
  99   { return mPath->ContainsPoint(aPoint, aTransform); }
 100   virtual bool StrokeContainsPoint(const StrokeOptions &aStrokeOptions,
 101                                    const Point &aPoint,
 102                                    const Matrix &aTransform) const
 103   { return mPath->StrokeContainsPoint(aStrokeOptions, aPoint, aTransform); }
 104
 105   virtual Rect GetBounds(const Matrix &aTransform = Matrix()) const
 106   { return mPath->GetBounds(aTransform); }
 107
 108   virtual Rect GetStrokedBounds(const StrokeOptions &aStrokeOptions,
 109                                 const Matrix &aTransform = Matrix()) const
 110   { return mPath->GetStrokedBounds(aStrokeOptions, aTransform); }
 111
 112   virtual void StreamToSink(PathSink *aSink) const { mPath->StreamToSink(aSink); }
 113
 114   virtual FillRule GetFillRule() const { return mFillRule; }
 115
 116   void StorePath(std::ostream &aStream) const;
 117   static void ReadPathToBuilder(std::istream &aStream, PathBuilder *aBuilder);
 118
 119 private:
 120   friend class DrawTargetRecording;
 121   friend class RecordedPathCreation;
 122
 123   RefPtr<Path> mPath;
 124   std::vector<PathOp> mPathOps;
 125   FillRule mFillRule;
 126
 127   // Event recorders that have this path in their event stream.
 128   std::vector<DrawEventRecorderPrivate*> mStoredRecorders;
 129 };
 130
 131 }
 132 }
 133
 134 #endif /* MOZILLA_GFX_PATHRECORDING_H_ */