Source code

Revision control

Other Tools

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* 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 "gfxDrawable.h"
#include "gfxASurface.h"
#include "gfxContext.h"
#include "gfxPlatform.h"
#include "gfx2DGlue.h"
#ifdef MOZ_X11
# include "cairo.h"
# include "gfxXlibSurface.h"
#endif
#include "mozilla/gfx/Logging.h"
using namespace mozilla;
using namespace mozilla::gfx;
gfxSurfaceDrawable::gfxSurfaceDrawable(SourceSurface* aSurface,
const IntSize aSize,
const gfxMatrix aTransform)
: gfxDrawable(aSize), mSourceSurface(aSurface), mTransform(aTransform) {
if (!mSourceSurface) {
gfxWarning() << "Creating gfxSurfaceDrawable with null SourceSurface";
}
}
bool gfxSurfaceDrawable::DrawWithSamplingRect(
DrawTarget* aDrawTarget, CompositionOp aOp, AntialiasMode aAntialiasMode,
const gfxRect& aFillRect, const gfxRect& aSamplingRect,
ExtendMode aExtendMode, const SamplingFilter aSamplingFilter,
gfxFloat aOpacity) {
if (!mSourceSurface) {
return true;
}
// When drawing with CLAMP we can expand the sampling rect to the nearest
// pixel without changing the result.
IntRect intRect =
IntRect::RoundOut(aSamplingRect.X(), aSamplingRect.Y(),
aSamplingRect.Width(), aSamplingRect.Height());
IntSize size = mSourceSurface->GetSize();
if (!IntRect(IntPoint(), size).Contains(intRect)) {
return false;
}
DrawInternal(aDrawTarget, aOp, aAntialiasMode, aFillRect, intRect,
ExtendMode::CLAMP, aSamplingFilter, aOpacity, gfxMatrix());
return true;
}
bool gfxSurfaceDrawable::Draw(gfxContext* aContext, const gfxRect& aFillRect,
ExtendMode aExtendMode,
const SamplingFilter aSamplingFilter,
gfxFloat aOpacity, const gfxMatrix& aTransform)
{
if (!mSourceSurface) {
return true;
}
DrawInternal(aContext->GetDrawTarget(), aContext->CurrentOp(),
aContext->CurrentAntialiasMode(), aFillRect, IntRect(),
aExtendMode, aSamplingFilter, aOpacity, aTransform);
return true;
}
void gfxSurfaceDrawable::DrawInternal(
DrawTarget* aDrawTarget, CompositionOp aOp, AntialiasMode aAntialiasMode,
const gfxRect& aFillRect, const IntRect& aSamplingRect,
ExtendMode aExtendMode, const SamplingFilter aSamplingFilter,
gfxFloat aOpacity, const gfxMatrix& aTransform) {
Matrix patternTransform = ToMatrix(aTransform * mTransform);
patternTransform.Invert();
SurfacePattern pattern(mSourceSurface, aExtendMode, patternTransform,
aSamplingFilter, aSamplingRect);
Rect fillRect = ToRect(aFillRect);
if (aOp == CompositionOp::OP_SOURCE && aOpacity == 1.0) {
// Emulate cairo operator source which is bound by mask!
aDrawTarget->ClearRect(fillRect);
aDrawTarget->FillRect(fillRect, pattern);
} else {
aDrawTarget->FillRect(fillRect, pattern,
DrawOptions(aOpacity, aOp, aAntialiasMode));
}
}
gfxCallbackDrawable::gfxCallbackDrawable(gfxDrawingCallback* aCallback,
const IntSize aSize)
: gfxDrawable(aSize), mCallback(aCallback) {}
already_AddRefed<gfxSurfaceDrawable> gfxCallbackDrawable::MakeSurfaceDrawable(
gfxContext* aContext, const SamplingFilter aSamplingFilter) {
SurfaceFormat format = gfxPlatform::GetPlatform()->Optimal2DFormatForContent(
gfxContentType::COLOR_ALPHA);
if (!aContext->GetDrawTarget()->CanCreateSimilarDrawTarget(mSize, format)) {
return nullptr;
}
RefPtr<DrawTarget> dt =
aContext->GetDrawTarget()->CreateSimilarDrawTarget(mSize, format);
if (!dt || !dt->IsValid()) return nullptr;
RefPtr<gfxContext> ctx = gfxContext::CreateOrNull(dt);
MOZ_ASSERT(ctx); // already checked for target above
Draw(ctx, gfxRect(0, 0, mSize.width, mSize.height), ExtendMode::CLAMP,
aSamplingFilter);
RefPtr<SourceSurface> surface = dt->Snapshot();
if (surface) {
RefPtr<gfxSurfaceDrawable> drawable =
new gfxSurfaceDrawable(surface, mSize);
return drawable.forget();
}
return nullptr;
}
static bool IsRepeatingExtendMode(ExtendMode aExtendMode) {
switch (aExtendMode) {
case ExtendMode::REPEAT:
case ExtendMode::REPEAT_X:
case ExtendMode::REPEAT_Y:
return true;
default:
return false;
}
}
bool gfxCallbackDrawable::Draw(gfxContext* aContext, const gfxRect& aFillRect,
ExtendMode aExtendMode,
const SamplingFilter aSamplingFilter,
gfxFloat aOpacity, const gfxMatrix& aTransform) {
if ((IsRepeatingExtendMode(aExtendMode) || aOpacity != 1.0 ||
aContext->CurrentOp() != CompositionOp::OP_OVER) &&
!mSurfaceDrawable) {
mSurfaceDrawable = MakeSurfaceDrawable(aContext, aSamplingFilter);
}
if (mSurfaceDrawable)
return mSurfaceDrawable->Draw(aContext, aFillRect, aExtendMode,
aSamplingFilter, aOpacity, aTransform);
if (mCallback)
return (*mCallback)(aContext, aFillRect, aSamplingFilter, aTransform);
return false;
}
gfxPatternDrawable::gfxPatternDrawable(gfxPattern* aPattern,
const IntSize aSize)
: gfxDrawable(aSize), mPattern(aPattern) {}
gfxPatternDrawable::~gfxPatternDrawable() = default;
class DrawingCallbackFromDrawable : public gfxDrawingCallback {
public:
explicit DrawingCallbackFromDrawable(gfxDrawable* aDrawable)
: mDrawable(aDrawable) {
NS_ASSERTION(aDrawable, "aDrawable is null!");
}
virtual ~DrawingCallbackFromDrawable() = default;
bool operator()(gfxContext* aContext, const gfxRect& aFillRect,
const SamplingFilter aSamplingFilter,
const gfxMatrix& aTransform = gfxMatrix()) override {
return mDrawable->Draw(aContext, aFillRect, ExtendMode::CLAMP,
aSamplingFilter, 1.0, aTransform);
}
private:
RefPtr<gfxDrawable> mDrawable;
};
already_AddRefed<gfxCallbackDrawable>
gfxPatternDrawable::MakeCallbackDrawable() {
RefPtr<gfxDrawingCallback> callback = new DrawingCallbackFromDrawable(this);
RefPtr<gfxCallbackDrawable> callbackDrawable =
new gfxCallbackDrawable(callback, mSize);
return callbackDrawable.forget();
}
bool gfxPatternDrawable::Draw(gfxContext* aContext, const gfxRect& aFillRect,
ExtendMode aExtendMode,
const SamplingFilter aSamplingFilter,
gfxFloat aOpacity, const gfxMatrix& aTransform) {
DrawTarget& aDrawTarget = *aContext->GetDrawTarget();
if (!mPattern) return false;
if (IsRepeatingExtendMode(aExtendMode)) {
// We can't use mPattern directly: We want our repeated tiles to have
// the size mSize, which might not be the case in mPattern.
// So we need to draw mPattern into a surface of size mSize, create
// a pattern from the surface and draw that pattern.
// gfxCallbackDrawable and gfxSurfaceDrawable already know how to do
// those things, so we use them here. Drawing mPattern into the surface
// will happen through this Draw() method with aRepeat = false.
RefPtr<gfxCallbackDrawable> callbackDrawable = MakeCallbackDrawable();
return callbackDrawable->Draw(aContext, aFillRect, aExtendMode,
aSamplingFilter, aOpacity, aTransform);
}
gfxMatrix oldMatrix = mPattern->GetMatrix();
mPattern->SetMatrix(aTransform * oldMatrix);
DrawOptions drawOptions(aOpacity);
aDrawTarget.FillRect(ToRect(aFillRect), *mPattern->GetPattern(&aDrawTarget),
drawOptions);
mPattern->SetMatrix(oldMatrix);
return true;
}