/* -*- 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 "BasicLayersImpl.h"

#include <new>                          // for operator new

#include "Layers.h"                     // for Layer, etc

#include "basic/BasicImplData.h"        // for BasicImplData

#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc

#include "mozilla/DebugOnly.h"          // for DebugOnly

#include "mozilla/layers/CompositorTypes.h"

#include "mozilla/layers/ISurfaceAllocator.h"

#include "AutoMaskData.h"

namespace mozilla {

namespace layers {

using namespace mozilla::gfx;

bool

GetMaskData(Layer* aMaskLayer,

            const Point& aDeviceOffset,

            AutoMoz2DMaskData* aMaskData)

{

  if (aMaskLayer) {

    RefPtr<SourceSurface> surface =

      static_cast<BasicImplData*>(aMaskLayer->ImplData())->GetAsSourceSurface();

    if (surface) {

      Matrix transform;

      Matrix4x4 effectiveTransform = aMaskLayer->GetEffectiveTransform();

      DebugOnly<bool> maskIs2D = effectiveTransform.CanDraw2D(&transform);

      NS_ASSERTION(maskIs2D, "How did we end up with a 3D transform here?!");

      transform.PostTranslate(-aDeviceOffset.x, -aDeviceOffset.y);

      aMaskData->Construct(transform, surface);

      return true;

    }

  }

  return false;

}

already_AddRefed<SourceSurface>

GetMaskForLayer(Layer* aLayer, Matrix* aMaskTransform)

{

  if (!aLayer->GetMaskLayer()) {

    return nullptr;

  }

  MOZ_ASSERT(aMaskTransform);

  AutoMoz2DMaskData mask;

  if (GetMaskData(aLayer->GetMaskLayer(), Point(), &mask)) {

    *aMaskTransform = mask.GetTransform();

    RefPtr<SourceSurface> surf = mask.GetSurface();

    return surf.forget();

  }

  return nullptr;

}

void

PaintWithMask(gfxContext* aContext, float aOpacity, Layer* aMaskLayer)

{

  AutoMoz2DMaskData mask;

  if (GetMaskData(aMaskLayer, Point(), &mask)) {

    aContext->SetMatrix(mask.GetTransform());

    aContext->Mask(mask.GetSurface(), aOpacity);

    return;

  }

  // if there is no mask, just paint normally

  aContext->Paint(aOpacity);

}

void

FillRectWithMask(DrawTarget* aDT,

                 const Rect& aRect,

                 const Color& aColor,

                 const DrawOptions& aOptions,

                 SourceSurface* aMaskSource,

                 const Matrix* aMaskTransform)

{

  if (aMaskSource && aMaskTransform) {

    aDT->PushClipRect(aRect);

    Matrix oldTransform = aDT->GetTransform();

    aDT->SetTransform(*aMaskTransform);

    aDT->MaskSurface(ColorPattern(aColor), aMaskSource, Point(), aOptions);

    aDT->SetTransform(oldTransform);

    aDT->PopClip();

    return;

  }

  aDT->FillRect(aRect, ColorPattern(aColor), aOptions);

}

void

FillRectWithMask(DrawTarget* aDT,

                 const gfx::Point& aDeviceOffset,

                 const Rect& aRect,

                 const Color& aColor,

                 const DrawOptions& aOptions,

                 Layer* aMaskLayer)

{

  AutoMoz2DMaskData mask;

  if (GetMaskData(aMaskLayer, aDeviceOffset, &mask)) {

    const Matrix& maskTransform = mask.GetTransform();

    FillRectWithMask(aDT, aRect, aColor, aOptions, mask.GetSurface(), &maskTransform);

    return;

  }

  FillRectWithMask(aDT, aRect, aColor, aOptions);

}

void

FillRectWithMask(DrawTarget* aDT,

                 const Rect& aRect,

                 SourceSurface* aSurface,

                 SamplingFilter aSamplingFilter,

                 const DrawOptions& aOptions,

                 ExtendMode aExtendMode,

                 SourceSurface* aMaskSource,

                 const Matrix* aMaskTransform,

                 const Matrix* aSurfaceTransform)

{

  if (aMaskSource && aMaskTransform) {

    aDT->PushClipRect(aRect);

    Matrix oldTransform = aDT->GetTransform();

    Matrix inverseMask = *aMaskTransform;

    inverseMask.Invert();

    Matrix transform = oldTransform * inverseMask;

    if (aSurfaceTransform) {

      transform = (*aSurfaceTransform) * transform;

    }

    SurfacePattern source(aSurface, aExtendMode, transform, aSamplingFilter);

    aDT->SetTransform(*aMaskTransform);

    aDT->MaskSurface(source, aMaskSource, Point(0, 0), aOptions);

    aDT->SetTransform(oldTransform);

    aDT->PopClip();

    return;

  }

  aDT->FillRect(aRect,

                SurfacePattern(aSurface, aExtendMode,

                               aSurfaceTransform ? (*aSurfaceTransform) : Matrix(),

                               aSamplingFilter), aOptions);

}

void

FillRectWithMask(DrawTarget* aDT,

                 const gfx::Point& aDeviceOffset,

                 const Rect& aRect,

                 SourceSurface* aSurface,

                 SamplingFilter aSamplingFilter,

                 const DrawOptions& aOptions,

                 Layer* aMaskLayer)

{

  AutoMoz2DMaskData mask;

  if (GetMaskData(aMaskLayer, aDeviceOffset, &mask)) {

    const Matrix& maskTransform = mask.GetTransform();

    FillRectWithMask(aDT, aRect, aSurface, aSamplingFilter, aOptions,

                     ExtendMode::CLAMP,

                     mask.GetSurface(), &maskTransform);

    return;

  }

  FillRectWithMask(aDT, aRect, aSurface, aSamplingFilter, aOptions,

                   ExtendMode::CLAMP);

}

void

FillPathWithMask(DrawTarget* aDT,

                 const Path* aPath,

                 const Rect& aClipRect,

                 const Color& aColor,

                 const DrawOptions& aOptions,

                 SourceSurface* aMaskSource,

                 const Matrix* aMaskTransform)

{

  if (aMaskSource && aMaskTransform) {

    aDT->PushClipRect(aClipRect);

    Matrix oldTransform = aDT->GetTransform();

    aDT->SetTransform(*aMaskTransform);

    aDT->MaskSurface(ColorPattern(aColor), aMaskSource, Point(), aOptions);

    aDT->SetTransform(oldTransform);

    aDT->PopClip();

    return;

  }

  aDT->Fill(aPath, ColorPattern(aColor), aOptions);

}

void

FillPathWithMask(DrawTarget* aDT,

                 const Path* aPath,

                 const Rect& aClipRect,

                 SourceSurface* aSurface,

                 SamplingFilter aSamplingFilter,

                 const DrawOptions& aOptions,

                 ExtendMode aExtendMode,

                 SourceSurface* aMaskSource,

                 const Matrix* aMaskTransform,

                 const Matrix* aSurfaceTransform)

{

  if (aMaskSource && aMaskTransform) {

    aDT->PushClipRect(aClipRect);

    Matrix oldTransform = aDT->GetTransform();

    Matrix inverseMask = *aMaskTransform;

    inverseMask.Invert();

    Matrix transform = oldTransform * inverseMask;

    if (aSurfaceTransform) {

      transform = (*aSurfaceTransform) * transform;

    }

    SurfacePattern source(aSurface, aExtendMode, transform, aSamplingFilter);

    aDT->SetTransform(*aMaskTransform);

    aDT->MaskSurface(source, aMaskSource, Point(0, 0), aOptions);

    aDT->SetTransform(oldTransform);

    aDT->PopClip();

    return;

  }

  aDT->Fill(aPath,

            SurfacePattern(aSurface, aExtendMode,

                           aSurfaceTransform ? (*aSurfaceTransform) : Matrix(),

                           aSamplingFilter), aOptions);

}

BasicImplData*

ToData(Layer* aLayer)

{

  return static_cast<BasicImplData*>(aLayer->ImplData());

}

gfx::CompositionOp

GetEffectiveOperator(Layer* aLayer)

{

  CompositionOp op = aLayer->GetEffectiveMixBlendMode();

  if (op != CompositionOp::OP_OVER) {

    return op;

  }

  return ToData(aLayer)->GetOperator();

}

ShadowableLayer*

ToShadowable(Layer* aLayer)

{

  return aLayer->AsShadowableLayer();

}

bool

ShouldShadow(Layer* aLayer)

{

  if (!ToShadowable(aLayer)) {

    MOZ_ASSERT(aLayer->GetType() == Layer::TYPE_READBACK,

               "Only expect not to shadow ReadbackLayers");

    return false;

  }

  return true;

}

} // namespace layers

} // namespace mozilla