gfx/2d/DrawTargetRecording.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_DRAWTARGETRECORDING_H_
   7 #define MOZILLA_GFX_DRAWTARGETRECORDING_H_
   8
   9 #include "2D.h"
  10 #include "DrawEventRecorder.h"
  11
  12 namespace mozilla {
  13 namespace gfx {
  14
  15 class DrawTargetRecording : public DrawTarget
  16 {
  17 public:
  18   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetRecording)
  19   DrawTargetRecording(DrawEventRecorder *aRecorder, DrawTarget *aDT, bool aHasData = false);
  20   ~DrawTargetRecording();
  21
  22   virtual DrawTargetType GetType() const MOZ_OVERRIDE { return mFinalDT->GetType(); }
  23   virtual BackendType GetBackendType() const { return mFinalDT->GetBackendType(); }
  24
  25   virtual TemporaryRef<SourceSurface> Snapshot();
  26
  27   virtual IntSize GetSize() { return mFinalDT->GetSize(); }
  28
  29   /* Ensure that the DrawTarget backend has flushed all drawing operations to
  30    * this draw target. This must be called before using the backing surface of
  31    * this draw target outside of GFX 2D code.
  32    */
  33   virtual void Flush() { mFinalDT->Flush(); }
  34
  35   /*
  36    * Draw a surface to the draw target. Possibly doing partial drawing or
  37    * applying scaling. No sampling happens outside the source.
  38    *
  39    * aSurface Source surface to draw
  40    * aDest Destination rectangle that this drawing operation should draw to
  41    * aSource Source rectangle in aSurface coordinates, this area of aSurface
  42    *         will be stretched to the size of aDest.
  43    * aOptions General draw options that are applied to the operation
  44    * aSurfOptions DrawSurface options that are applied
  45    */
  46   virtual void DrawSurface(SourceSurface *aSurface,
  47                            const Rect &aDest,
  48                            const Rect &aSource,
  49                            const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
  50                            const DrawOptions &aOptions = DrawOptions());
  51
  52   virtual void DrawFilter(FilterNode *aNode,
  53                           const Rect &aSourceRect,
  54                           const Point &aDestPoint,
  55                           const DrawOptions &aOptions = DrawOptions());
  56
  57   /*
  58    * Blend a surface to the draw target with a shadow. The shadow is drawn as a
  59    * gaussian blur using a specified sigma. The shadow is clipped to the size
  60    * of the input surface, so the input surface should contain a transparent
  61    * border the size of the approximate coverage of the blur (3 * aSigma).
  62    * NOTE: This function works in device space!
  63    *
  64    * aSurface Source surface to draw.
  65    * aDest Destination point that this drawing operation should draw to.
  66    * aColor Color of the drawn shadow
  67    * aOffset Offset of the shadow
  68    * aSigma Sigma used for the guassian filter kernel
  69    * aOperator Composition operator used
  70    */
  71   virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,
  72                                      const Point &aDest,
  73                                      const Color &aColor,
  74                                      const Point &aOffset,
  75                                      Float aSigma,
  76                                      CompositionOp aOperator);
  77
  78   /*
  79    * Clear a rectangle on the draw target to transparent black. This will
  80    * respect the clipping region and transform.
  81    *
  82    * aRect Rectangle to clear
  83    */
  84   virtual void ClearRect(const Rect &aRect);
  85
  86   /*
  87    * This is essentially a 'memcpy' between two surfaces. It moves a pixel
  88    * aligned area from the source surface unscaled directly onto the
  89    * drawtarget. This ignores both transform and clip.
  90    *
  91    * aSurface Surface to copy from
  92    * aSourceRect Source rectangle to be copied
  93    * aDest Destination point to copy the surface to
  94    */
  95   virtual void CopySurface(SourceSurface *aSurface,
  96                            const IntRect &aSourceRect,
  97                            const IntPoint &aDestination);
  98
  99   /*
 100    * Fill a rectangle on the DrawTarget with a certain source pattern.
 101    *
 102    * aRect Rectangle that forms the mask of this filling operation
 103    * aPattern Pattern that forms the source of this filling operation
 104    * aOptions Options that are applied to this operation
 105    */
 106   virtual void FillRect(const Rect &aRect,
 107                         const Pattern &aPattern,
 108                         const DrawOptions &aOptions = DrawOptions());
 109
 110   /*
 111    * Stroke a rectangle on the DrawTarget with a certain source pattern.
 112    *
 113    * aRect Rectangle that forms the mask of this stroking operation
 114    * aPattern Pattern that forms the source of this stroking operation
 115    * aOptions Options that are applied to this operation
 116    */
 117   virtual void StrokeRect(const Rect &aRect,
 118                           const Pattern &aPattern,
 119                           const StrokeOptions &aStrokeOptions = StrokeOptions(),
 120                           const DrawOptions &aOptions = DrawOptions());
 121
 122   /*
 123    * Stroke a line on the DrawTarget with a certain source pattern.
 124    *
 125    * aStart Starting point of the line
 126    * aEnd End point of the line
 127    * aPattern Pattern that forms the source of this stroking operation
 128    * aOptions Options that are applied to this operation
 129    */
 130   virtual void StrokeLine(const Point &aStart,
 131                           const Point &aEnd,
 132                           const Pattern &aPattern,
 133                           const StrokeOptions &aStrokeOptions = StrokeOptions(),
 134                           const DrawOptions &aOptions = DrawOptions());
 135
 136   /*
 137    * Stroke a path on the draw target with a certain source pattern.
 138    *
 139    * aPath Path that is to be stroked
 140    * aPattern Pattern that should be used for the stroke
 141    * aStrokeOptions Stroke options used for this operation
 142    * aOptions Draw options used for this operation
 143    */
 144   virtual void Stroke(const Path *aPath,
 145                       const Pattern &aPattern,
 146                       const StrokeOptions &aStrokeOptions = StrokeOptions(),
 147                       const DrawOptions &aOptions = DrawOptions());
 148
 149   /*
 150    * Fill a path on the draw target with a certain source pattern.
 151    *
 152    * aPath Path that is to be filled
 153    * aPattern Pattern that should be used for the fill
 154    * aOptions Draw options used for this operation
 155    */
 156   virtual void Fill(const Path *aPath,
 157                     const Pattern &aPattern,
 158                     const DrawOptions &aOptions = DrawOptions());
 159
 160   /*
 161    * Fill a series of clyphs on the draw target with a certain source pattern.
 162    */
 163   virtual void FillGlyphs(ScaledFont *aFont,
 164                           const GlyphBuffer &aBuffer,
 165                           const Pattern &aPattern,
 166                           const DrawOptions &aOptions = DrawOptions(),
 167                           const GlyphRenderingOptions *aRenderingOptions = nullptr);
 168
 169   /*
 170    * This takes a source pattern and a mask, and composites the source pattern
 171    * onto the destination surface using the alpha channel of the mask pattern
 172    * as a mask for the operation.
 173    *
 174    * aSource Source pattern
 175    * aMask Mask pattern
 176    * aOptions Drawing options
 177    */
 178   virtual void Mask(const Pattern &aSource,
 179                     const Pattern &aMask,
 180                     const DrawOptions &aOptions = DrawOptions());
 181
 182   virtual void MaskSurface(const Pattern &aSource,
 183                            SourceSurface *aMask,
 184                            Point aOffset,
 185                            const DrawOptions &aOptions = DrawOptions());
 186
 187   /*
 188    * Push a clip to the DrawTarget.
 189    *
 190    * aPath The path to clip to
 191    */
 192   virtual void PushClip(const Path *aPath);
 193
 194   /*
 195    * Push an axis-aligned rectangular clip to the DrawTarget. This rectangle
 196    * is specified in user space.
 197    *
 198    * aRect The rect to clip to
 199    */
 200   virtual void PushClipRect(const Rect &aRect);
 201
 202   /* Pop a clip from the DrawTarget. A pop without a corresponding push will
 203    * be ignored.
 204    */
 205   virtual void PopClip();
 206
 207   /*
 208    * Create a SourceSurface optimized for use with this DrawTarget from
 209    * existing bitmap data in memory.
 210    *
 211    * The SourceSurface does not take ownership of aData, and may be freed at any time.
 212    */
 213   virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
 214                                                                   const IntSize &aSize,
 215                                                                   int32_t aStride,
 216                                                                   SurfaceFormat aFormat) const;
 217
 218   /*
 219    * Create a SourceSurface optimized for use with this DrawTarget from
 220    * an arbitrary other SourceSurface. This may return aSourceSurface or some
 221    * other existing surface.
 222    */
 223   virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const;
 224
 225   /*
 226    * Create a SourceSurface for a type of NativeSurface. This may fail if the
 227    * draw target does not know how to deal with the type of NativeSurface passed
 228    * in.
 229    */
 230   virtual TemporaryRef<SourceSurface>
 231     CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const;
 232
 233   /*
 234    * Create a DrawTarget whose snapshot is optimized for use with this DrawTarget.
 235    */
 236   virtual TemporaryRef<DrawTarget>
 237     CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const;
 238
 239   /*
 240    * Create a path builder with the specified fillmode.
 241    *
 242    * We need the fill mode up front because of Direct2D.
 243    * ID2D1SimplifiedGeometrySink requires the fill mode
 244    * to be set before calling BeginFigure().
 245    */
 246   virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const;
 247
 248   /*
 249    * Create a GradientStops object that holds information about a set of
 250    * gradient stops, this object is required for linear or radial gradient
 251    * patterns to represent the color stops in the gradient.
 252    *
 253    * aStops An array of gradient stops
 254    * aNumStops Number of stops in the array aStops
 255    * aExtendNone This describes how to extend the stop color outside of the
 256    *             gradient area.
 257    */
 258   virtual TemporaryRef<GradientStops>
 259     CreateGradientStops(GradientStop *aStops,
 260                         uint32_t aNumStops,
 261                         ExtendMode aExtendMode = ExtendMode::CLAMP) const;
 262
 263   virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType);
 264
 265   /*
 266    * Set a transform on the surface, this transform is applied at drawing time
 267    * to both the mask and source of the operation.
 268    */
 269   virtual void SetTransform(const Matrix &aTransform);
 270
 271   /* Tries to get a native surface for a DrawTarget, this may fail if the
 272    * draw target cannot convert to this surface type.
 273    */
 274   virtual void *GetNativeSurface(NativeSurfaceType aType) { return mFinalDT->GetNativeSurface(aType); }
 275
 276 private:
 277   Path *GetPathForPathRecording(const Path *aPath) const;
 278   void EnsureStored(const Path *aPath);
 279
 280   RefPtr<DrawEventRecorderPrivate> mRecorder;
 281   RefPtr<DrawTarget> mFinalDT;
 282 };
 283
 284 }
 285 }
 286
 287 #endif /* MOZILLA_GFX_DRAWTARGETRECORDING_H_ */