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

#include "DrawTargetOffset.h"

#include "Logging.h"

#include "PathHelpers.h"

using namespace std;

namespace mozilla {

namespace gfx {

DrawTargetOffset::DrawTargetOffset()

{

}

bool

DrawTargetOffset::Init(DrawTarget *aDrawTarget, IntPoint aOrigin)

{

  mDrawTarget = aDrawTarget;

  mOrigin = aOrigin;

  mDrawTarget->SetTransform(Matrix::Translation(-mOrigin.x,

                                                -mOrigin.y));

  mFormat = mDrawTarget->GetFormat();

  SetPermitSubpixelAA(IsOpaque(mFormat));

  return true;

}

already_AddRefed<SourceSurface>

DrawTargetOffset::Snapshot()

{

  return mDrawTarget->Snapshot();

}

void

DrawTargetOffset::DetachAllSnapshots()

{}

// Skip the mClippedOut check since this is only used for Flush() which

// should happen even if we're clipped.

#define OFFSET_COMMAND(command) \

  void \

  DrawTargetOffset::command() \

  { \

    mDrawTarget->command(); \

  }

#define OFFSET_COMMAND1(command, type1) \

  void \

  DrawTargetOffset::command(type1 arg1) \

  { \

    mDrawTarget->command(arg1); \

  }

#define OFFSET_COMMAND3(command, type1, type2, type3) \

  void \

  DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3) \

  { \

    mDrawTarget->command(arg1, arg2, arg3); \

  }

#define OFFSET_COMMAND4(command, type1, type2, type3, type4) \

  void \

  DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3, type4 arg4) \

  { \

    mDrawTarget->command(arg1, arg2, arg3, arg4); \

  }

Unexecuted instantiation: mozilla::gfx::DrawTargetOffset::MaskSurface(mozilla::gfx::Pattern const&, mozilla::gfx::SourceSurface*, mozilla::gfx::PointTyped<mozilla::gfx::UnknownUnits, float>, mozilla::gfx::DrawOptions const&)

Unexecuted instantiation: mozilla::gfx::DrawTargetOffset::FillGlyphs(mozilla::gfx::ScaledFont*, mozilla::gfx::GlyphBuffer const&, mozilla::gfx::Pattern const&, mozilla::gfx::DrawOptions const&)

#define OFFSET_COMMAND5(command, type1, type2, type3, type4, type5) \

  void \

  DrawTargetOffset::command(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5) \

  { \

    mDrawTarget->command(arg1, arg2, arg3, arg4, arg5); \

  }

OFFSET_COMMAND(Flush)

OFFSET_COMMAND1(ClearRect, const Rect&)

OFFSET_COMMAND4(MaskSurface, const Pattern&, SourceSurface*, Point, const DrawOptions&)

OFFSET_COMMAND4(FillGlyphs, ScaledFont*, const GlyphBuffer&, const Pattern&, const DrawOptions&)

OFFSET_COMMAND3(Mask, const Pattern&, const Pattern&, const DrawOptions&)

void

DrawTargetOffset::DrawFilter(FilterNode* aNode, const Rect& aSourceRect, const Point& aDestPoint, const DrawOptions& aOptions)

{

  auto clone = mTransform;

  bool invertible = clone.Invert();

  auto src = aSourceRect;

  if (invertible) {

    // Try to reduce the source rect so that it's not much bigger

    // than the draw target. The result is not minimal. Examples

    // are left as an exercise for the reader.

    auto destRect = Rect(mOrigin.x,

                         mOrigin.y,

                         mDrawTarget->GetSize().width,

                         mDrawTarget->GetSize().height);

    auto dtBounds = clone.TransformBounds(destRect);

    src = aSourceRect.Intersect(dtBounds);

  }

  auto shift = src.TopLeft() - aSourceRect.TopLeft();

  mDrawTarget->DrawFilter(aNode, src, aDestPoint + shift, aOptions);

}

void

DrawTargetOffset::PushClip(const Path* aPath)

{

  mDrawTarget->PushClip(aPath);

}

void

DrawTargetOffset::PushClipRect(const Rect& aRect)

{

  mDrawTarget->PushClipRect(aRect);

}

void

DrawTargetOffset::PopClip()

{

  mDrawTarget->PopClip();

}

void

DrawTargetOffset::CopySurface(SourceSurface *aSurface,

                             const IntRect &aSourceRect,

                             const IntPoint &aDestination)

{

  IntPoint tileOrigin = mOrigin;

  // CopySurface ignores the transform, account for that here.

  mDrawTarget->CopySurface(aSurface, aSourceRect, aDestination - tileOrigin);

}

void

DrawTargetOffset::SetTransform(const Matrix& aTransform)

{

  Matrix mat = aTransform;

  mat.PostTranslate(Float(-mOrigin.x), Float(-mOrigin.y));

  mDrawTarget->SetTransform(mat);

  DrawTarget::SetTransform(aTransform);

}

void

DrawTargetOffset::SetPermitSubpixelAA(bool aPermitSubpixelAA)

{

  mDrawTarget->SetPermitSubpixelAA(aPermitSubpixelAA);

}

void

DrawTargetOffset::DrawSurface(SourceSurface* aSurface, const Rect& aDest, const Rect& aSource, const DrawSurfaceOptions& aSurfaceOptions, const DrawOptions& aDrawOptions)

{

  mDrawTarget->DrawSurface(aSurface, aDest, aSource, aSurfaceOptions, aDrawOptions);

}

void

DrawTargetOffset::FillRect(const Rect& aRect, const Pattern& aPattern, const DrawOptions& aDrawOptions)

{

  mDrawTarget->FillRect(aRect, aPattern, aDrawOptions);

}

void

DrawTargetOffset::Stroke(const Path* aPath, const Pattern& aPattern, const StrokeOptions& aStrokeOptions, const DrawOptions& aDrawOptions)

{

  mDrawTarget->Stroke(aPath, aPattern, aStrokeOptions, aDrawOptions);

}

void

DrawTargetOffset::StrokeRect(const Rect& aRect, const Pattern& aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions& aDrawOptions)

{

  mDrawTarget->StrokeRect(aRect, aPattern, aStrokeOptions, aDrawOptions);

}

void

DrawTargetOffset::StrokeLine(const Point& aStart, const Point& aEnd, const Pattern& aPattern, const StrokeOptions &aStrokeOptions, const DrawOptions& aDrawOptions)

{

  mDrawTarget->StrokeLine(aStart, aEnd, aPattern, aStrokeOptions, aDrawOptions);

}

void

DrawTargetOffset::Fill(const Path* aPath, const Pattern& aPattern, const DrawOptions& aDrawOptions)

{

  mDrawTarget->Fill(aPath, aPattern, aDrawOptions);

}

void

DrawTargetOffset::PushLayer(bool aOpaque, Float aOpacity, SourceSurface* aMask,

                           const Matrix& aMaskTransform, const IntRect& aBounds,

                           bool aCopyBackground)

{

  IntRect bounds = aBounds;

  bounds.MoveBy(mOrigin);

  mDrawTarget->PushLayer(aOpaque, aOpacity, aMask, aMaskTransform, bounds, aCopyBackground);

}

void

DrawTargetOffset::PushLayerWithBlend(bool aOpaque, Float aOpacity,

                                    SourceSurface* aMask,

                                    const Matrix& aMaskTransform,

                                    const IntRect& aBounds,

                                    bool aCopyBackground,

                                    CompositionOp aOp)

{

  IntRect bounds = aBounds;

  bounds.MoveBy(mOrigin);

  mDrawTarget->PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, bounds, aCopyBackground, aOp);

}

void

DrawTargetOffset::PopLayer()

{

  mDrawTarget->PopLayer();

}

} // namespace gfx

} // namespace mozilla