/* -*- 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_DRAWTARGETOFFSET_H_

#define MOZILLA_GFX_DRAWTARGETOFFSET_H_

#include "2D.h"

#include "mozilla/Vector.h"

#include "Filters.h"

#include "Logging.h"

#include <vector>

namespace mozilla {

namespace gfx {

class DrawTargetOffset : public DrawTarget

{

public:

  DrawTargetOffset();

  bool Init(DrawTarget *aDrawTarget, IntPoint aOrigin);

  // We'll pestimistically return true here

  virtual bool IsTiledDrawTarget() const override { return true; }

  virtual bool IsCaptureDT() const override { return mDrawTarget->IsCaptureDT(); }

  virtual DrawTargetType GetType() const override { return mDrawTarget->GetType(); }

  virtual BackendType GetBackendType() const override { return mDrawTarget->GetBackendType(); }

  virtual already_AddRefed<SourceSurface> Snapshot() override;

  virtual void DetachAllSnapshots() override;

  virtual IntSize GetSize() const override {

    return mDrawTarget->GetSize();

  }

  virtual IntRect GetRect() const override {

    return mDrawTarget->GetRect();

  }

  virtual void Flush() override;

  virtual void DrawSurface(SourceSurface *aSurface,

                           const Rect &aDest,

                           const Rect &aSource,

                           const DrawSurfaceOptions &aSurfOptions,

                           const DrawOptions &aOptions) override;

  virtual void DrawFilter(FilterNode *aNode,

                          const Rect &aSourceRect,

                          const Point &aDestPoint,

                          const DrawOptions &aOptions = DrawOptions()) override;

  virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,

                                     const Point &aDest,

                                     const Color &aColor,

                                     const Point &aOffset,

                                     Float aSigma,

                                     CompositionOp aOperator) override { /* Not implemented */ MOZ_CRASH("GFX: DrawSurfaceWithShadow"); }

  virtual void ClearRect(const Rect &aRect) override;

  virtual void MaskSurface(const Pattern &aSource,

                           SourceSurface *aMask,

                           Point aOffset,

                           const DrawOptions &aOptions = DrawOptions()) override;

  virtual void CopySurface(SourceSurface *aSurface,

                           const IntRect &aSourceRect,

                           const IntPoint &aDestination) override;

  virtual void FillRect(const Rect &aRect,

                        const Pattern &aPattern,

                        const DrawOptions &aOptions = DrawOptions()) override;

  virtual void StrokeRect(const Rect &aRect,

                          const Pattern &aPattern,

                          const StrokeOptions &aStrokeOptions = StrokeOptions(),

                          const DrawOptions &aOptions = DrawOptions()) override;

  virtual void StrokeLine(const Point &aStart,

                          const Point &aEnd,

                          const Pattern &aPattern,

                          const StrokeOptions &aStrokeOptions = StrokeOptions(),

                          const DrawOptions &aOptions = DrawOptions()) override;

  virtual void Stroke(const Path *aPath,

                      const Pattern &aPattern,

                      const StrokeOptions &aStrokeOptions = StrokeOptions(),

                      const DrawOptions &aOptions = DrawOptions()) override;

  virtual void Fill(const Path *aPath,

                    const Pattern &aPattern,

                    const DrawOptions &aOptions = DrawOptions()) override;

  virtual void FillGlyphs(ScaledFont *aFont,

                          const GlyphBuffer &aBuffer,

                          const Pattern &aPattern,

                          const DrawOptions &aOptions = DrawOptions()) override;

  virtual void Mask(const Pattern &aSource,

                    const Pattern &aMask,

                    const DrawOptions &aOptions = DrawOptions()) override;

  virtual void PushClip(const Path *aPath) override;

  virtual void PushClipRect(const Rect &aRect) override;

  virtual void PopClip() override;

  virtual void PushLayer(bool aOpaque, Float aOpacity,

                         SourceSurface* aMask,

                         const Matrix& aMaskTransform,

                         const IntRect& aBounds = IntRect(),

                         bool aCopyBackground = false) override;

  virtual void PushLayerWithBlend(bool aOpaque, Float aOpacity,

                         SourceSurface* aMask,

                         const Matrix& aMaskTransform,

                         const IntRect& aBounds = IntRect(),

                         bool aCopyBackground = false,

                         CompositionOp = CompositionOp::OP_OVER) override;

  virtual void PopLayer() override;

  virtual void SetTransform(const Matrix &aTransform) override;

  virtual void SetPermitSubpixelAA(bool aPermitSubpixelAA) override;

  virtual already_AddRefed<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,

                                                                  const IntSize &aSize,

                                                                  int32_t aStride,

                                                                  SurfaceFormat aFormat) const override

  {

    return mDrawTarget->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat);

  }

  virtual already_AddRefed<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const override

  {

    return mDrawTarget->OptimizeSourceSurface(aSurface);

  }

  virtual already_AddRefed<SourceSurface>

    CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const override

  {

    return mDrawTarget->CreateSourceSurfaceFromNativeSurface(aSurface);

  }

  virtual already_AddRefed<DrawTarget>

    CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const override

  {

    return mDrawTarget->CreateSimilarDrawTarget(aSize, aFormat);

  }

  virtual already_AddRefed<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const override

  {

    return mDrawTarget->CreatePathBuilder(aFillRule);

  }

  virtual already_AddRefed<GradientStops>

    CreateGradientStops(GradientStop *aStops,

                        uint32_t aNumStops,

                        ExtendMode aExtendMode = ExtendMode::CLAMP) const override

  {

    return mDrawTarget->CreateGradientStops(aStops, aNumStops, aExtendMode);

  }

  virtual already_AddRefed<FilterNode> CreateFilter(FilterType aType) override

  {

    return mDrawTarget->CreateFilter(aType);

  }

private:

  RefPtr<DrawTarget> mDrawTarget;

  IntPoint mOrigin;

};

} // namespace gfx

} // namespace mozilla

#endif