gfx/2d/DrawTargetDual.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef MOZILLA_GFX_DRAWTARGETDUAL_H_
   8 #define MOZILLA_GFX_DRAWTARGETDUAL_H_
   9
  10 #include <vector>
  11 #include <sstream>
  12
  13 #include "SourceSurfaceDual.h"
  14
  15 #include "2D.h"
  16 #include "Filters.h"
  17
  18 namespace mozilla {
  19 namespace gfx {
  20
  21 #define FORWARD_FUNCTION(funcName)   \
  22   virtual void funcName() override { \
  23     mA->funcName();                  \
  24     mB->funcName();                  \
  25   }
  26 #define FORWARD_FUNCTION1(funcName, var1Type, var1Name) \
  27   virtual void funcName(var1Type var1Name) override {   \
  28     mA->funcName(var1Name);                             \
  29     mB->funcName(var1Name);                             \
  30   }
  31
  32 /* This is a special type of DrawTarget. It duplicates all drawing calls
  33  * accross two drawtargets. An exception to this is when a snapshot of another
  34  * dual DrawTarget is used as the source for any surface data. In this case
  35  * the snapshot of the first source DrawTarget is used as a source for the call
  36  * to the first destination DrawTarget (mA) and the snapshot of the second
  37  * source DrawTarget is used at the source for the second destination
  38  * DrawTarget (mB). This class facilitates black-background/white-background
  39  * drawing for per-component alpha extraction for backends which do not support
  40  * native component alpha.
  41  */
  42 class DrawTargetDual : public DrawTarget {
  43  public:
  44   virtual bool IsValid() const override {
  45     return mA->IsValid() && mB->IsValid();
  46   };
  47
  48   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetDual, override)
  49   DrawTargetDual(DrawTarget* aA, DrawTarget* aB) : mA(aA), mB(aB) {
  50     mFormat = aA->GetFormat();
  51   }
  52
  53   virtual DrawTargetType GetType() const override { return mA->GetType(); }
  54   virtual BackendType GetBackendType() const override {
  55     return mA->GetBackendType();
  56   }
  57   virtual already_AddRefed<SourceSurface> Snapshot() override {
  58     return MakeAndAddRef<SourceSurfaceDual>(mA, mB);
  59   }
  60   virtual IntSize GetSize() const override { return mA->GetSize(); }
  61
  62   virtual void DetachAllSnapshots() override;
  63
  64   FORWARD_FUNCTION(Flush)
  65   FORWARD_FUNCTION1(PushClip, const Path*, aPath)
  66   FORWARD_FUNCTION1(PushClipRect, const Rect&, aRect)
  67   FORWARD_FUNCTION(PopClip)
  68   FORWARD_FUNCTION(PopLayer)
  69
  70   virtual void SetTransform(const Matrix& aTransform) override {
  71     mTransform = aTransform;
  72     mA->SetTransform(aTransform);
  73     mB->SetTransform(aTransform);
  74   }
  75
  76   virtual bool SupportsRegionClipping() const override {
  77     return mA->SupportsRegionClipping() && mB->SupportsRegionClipping();
  78   }
  79
  80   virtual void DrawSurface(SourceSurface* aSurface, const Rect& aDest,
  81                            const Rect& aSource,
  82                            const DrawSurfaceOptions& aSurfOptions,
  83                            const DrawOptions& aOptions) override;
  84
  85   virtual void DrawFilter(
  86       FilterNode* aNode, const Rect& aSourceRect, const Point& aDestPoint,
  87       const DrawOptions& aOptions = DrawOptions()) override {
  88     mA->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
  89     mB->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
  90   }
  91
  92   virtual void MaskSurface(
  93       const Pattern& aSource, SourceSurface* aMask, Point aOffset,
  94       const DrawOptions& aOptions = DrawOptions()) override;
  95
  96   virtual void DrawSurfaceWithShadow(SourceSurface* aSurface,
  97                                      const Point& aDest,
  98                                      const DeviceColor& aColor,
  99                                      const Point& aOffset, Float aSigma,
 100                                      CompositionOp aOp) override;
 101
 102   virtual void ClearRect(const Rect& aRect) override;
 103
 104   virtual void CopySurface(SourceSurface* aSurface, const IntRect& aSourceRect,
 105                            const IntPoint& aDestination) override;
 106
 107   virtual void FillRect(const Rect& aRect, const Pattern& aPattern,
 108                         const DrawOptions& aOptions) override;
 109
 110   virtual void StrokeRect(const Rect& aRect, const Pattern& aPattern,
 111                           const StrokeOptions& aStrokeOptions,
 112                           const DrawOptions& aOptions) override;
 113
 114   virtual void StrokeLine(const Point& aStart, const Point& aEnd,
 115                           const Pattern& aPattern,
 116                           const StrokeOptions& aStrokeOptions,
 117                           const DrawOptions& aOptions) override;
 118
 119   virtual void Stroke(const Path* aPath, const Pattern& aPattern,
 120                       const StrokeOptions& aStrokeOptions,
 121                       const DrawOptions& aOptions) override;
 122
 123   virtual void Fill(const Path* aPath, const Pattern& aPattern,
 124                     const DrawOptions& aOptions) override;
 125
 126   virtual void FillGlyphs(ScaledFont* aScaledFont, const GlyphBuffer& aBuffer,
 127                           const Pattern& aPattern,
 128                           const DrawOptions& aOptions) override;
 129
 130   virtual void Mask(const Pattern& aSource, const Pattern& aMask,
 131                     const DrawOptions& aOptions) override;
 132
 133   virtual void PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask,
 134                          const Matrix& aMaskTransform,
 135                          const IntRect& aBounds = IntRect(),
 136                          bool aCopyBackground = false) override;
 137
 138   virtual bool Unrotate(IntPoint aRotation) override {
 139     return mA->Unrotate(aRotation) && mB->Unrotate(aRotation);
 140   }
 141
 142   virtual already_AddRefed<SourceSurface> CreateSourceSurfaceFromData(
 143       unsigned char* aData, const IntSize& aSize, int32_t aStride,
 144       SurfaceFormat aFormat) const override {
 145     return mA->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat);
 146   }
 147
 148   virtual already_AddRefed<SourceSurface> OptimizeSourceSurface(
 149       SourceSurface* aSurface) const override {
 150     return mA->OptimizeSourceSurface(aSurface);
 151   }
 152
 153   virtual already_AddRefed<SourceSurface> CreateSourceSurfaceFromNativeSurface(
 154       const NativeSurface& aSurface) const override {
 155     return mA->CreateSourceSurfaceFromNativeSurface(aSurface);
 156   }
 157
 158   virtual already_AddRefed<DrawTarget> CreateSimilarDrawTarget(
 159       const IntSize& aSize, SurfaceFormat aFormat) const override;
 160   virtual bool CanCreateSimilarDrawTarget(const IntSize& aSize,
 161                                           SurfaceFormat aFormat) const override;
 162   virtual RefPtr<DrawTarget> CreateClippedDrawTarget(
 163       const Rect& aBounds, SurfaceFormat aFormat) override;
 164
 165   virtual already_AddRefed<PathBuilder> CreatePathBuilder(
 166       FillRule aFillRule = FillRule::FILL_WINDING) const override {
 167     return mA->CreatePathBuilder(aFillRule);
 168   }
 169
 170   virtual already_AddRefed<GradientStops> CreateGradientStops(
 171       GradientStop* aStops, uint32_t aNumStops,
 172       ExtendMode aExtendMode = ExtendMode::CLAMP) const override {
 173     return mA->CreateGradientStops(aStops, aNumStops, aExtendMode);
 174   }
 175
 176   virtual already_AddRefed<FilterNode> CreateFilter(FilterType aType) override {
 177     return mA->CreateFilter(aType);
 178   }
 179
 180   virtual void* GetNativeSurface(NativeSurfaceType aType) override {
 181     return nullptr;
 182   }
 183
 184   virtual bool IsDualDrawTarget() const override { return true; }
 185
 186   virtual bool IsCurrentGroupOpaque() override {
 187     return mA->IsCurrentGroupOpaque();
 188   }
 189
 190  private:
 191   RefPtr<DrawTarget> mA;
 192   RefPtr<DrawTarget> mB;
 193 };
 194
 195 }  // namespace gfx
 196 }  // namespace mozilla
 197
 198 #endif /* MOZILLA_GFX_DRAWTARGETDUAL_H_ */