gecko-dev/gfx/thebes/PrintTarget.cpp

200 строки
5.3 KiB
C++

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* 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 "PrintTarget.h"
#include "cairo.h"
#ifdef CAIRO_HAS_QUARTZ_SURFACE
#include "cairo-quartz.h"
#endif
#ifdef CAIRO_HAS_WIN32_SURFACE
#include "cairo-win32.h"
#endif
#include "mozilla/gfx/2D.h"
#include "mozilla/gfx/HelpersCairo.h"
#include "mozilla/gfx/Logging.h"
namespace mozilla {
namespace gfx {
PrintTarget::PrintTarget(cairo_surface_t* aCairoSurface, const IntSize& aSize)
: mCairoSurface(aCairoSurface)
, mSize(aSize)
, mIsFinished(false)
#ifdef DEBUG
, mHasActivePage(false)
, mRecorder(nullptr)
#endif
{
#if 0
// aCairoSurface is null when our PrintTargetThebes subclass's ctor calls us.
// Once PrintTargetThebes is removed, enable this assertion.
MOZ_ASSERT(aCairoSurface && !cairo_surface_status(aCairoSurface),
"CreateOrNull factory methods should not call us without a "
"valid cairo_surface_t*");
#endif
// CreateOrNull factory methods hand over ownership of aCairoSurface,
// so we don't call cairo_surface_reference(aSurface) here.
// This code was copied from gfxASurface::Init:
#ifdef MOZ_TREE_CAIRO
if (mCairoSurface &&
cairo_surface_get_content(mCairoSurface) != CAIRO_CONTENT_COLOR) {
cairo_surface_set_subpixel_antialiasing(mCairoSurface,
CAIRO_SUBPIXEL_ANTIALIASING_DISABLED);
}
#endif
}
PrintTarget::~PrintTarget()
{
// null surfaces are allowed here
cairo_surface_destroy(mCairoSurface);
mCairoSurface = nullptr;
}
already_AddRefed<DrawTarget>
PrintTarget::MakeDrawTarget(const IntSize& aSize,
DrawEventRecorder* aRecorder)
{
MOZ_ASSERT(mCairoSurface,
"We shouldn't have been constructed without a cairo surface");
// This should not be called outside of BeginPage()/EndPage() calls since
// some backends can only provide a valid DrawTarget at that time.
MOZ_ASSERT(mHasActivePage, "We can't guarantee a valid DrawTarget");
if (cairo_surface_status(mCairoSurface)) {
return nullptr;
}
// Note than aSize may not be the same as mSize (the size of mCairoSurface).
// See the comments in our header. If the sizes are different a clip will
// be applied to mCairoSurface.
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForCairoSurface(mCairoSurface, aSize);
if (!dt || !dt->IsValid()) {
return nullptr;
}
if (aRecorder) {
dt = CreateRecordingDrawTarget(aRecorder, dt);
if (!dt || !dt->IsValid()) {
return nullptr;
}
}
return dt.forget();
}
already_AddRefed<DrawTarget>
PrintTarget::GetReferenceDrawTarget(DrawEventRecorder* aRecorder)
{
if (!mRefDT) {
const IntSize size(1, 1);
cairo_surface_t* similar;
switch (cairo_surface_get_type(mCairoSurface)) {
#ifdef CAIRO_HAS_WIN32_SURFACE
case CAIRO_SURFACE_TYPE_WIN32:
similar = cairo_win32_surface_create_with_dib(
CairoContentToCairoFormat(cairo_surface_get_content(mCairoSurface)),
size.width, size.height);
break;
#endif
#ifdef CAIRO_HAS_QUARTZ_SURFACE
case CAIRO_SURFACE_TYPE_QUARTZ:
similar = cairo_quartz_surface_create_cg_layer(
mCairoSurface, cairo_surface_get_content(mCairoSurface),
size.width, size.height);
break;
#endif
default:
similar = cairo_surface_create_similar(
mCairoSurface, cairo_surface_get_content(mCairoSurface),
size.width, size.height);
break;
}
if (cairo_surface_status(similar)) {
return nullptr;
}
RefPtr<DrawTarget> dt =
Factory::CreateDrawTargetForCairoSurface(similar, size);
// The DT addrefs the surface, so we need drop our own reference to it:
cairo_surface_destroy(similar);
if (!dt || !dt->IsValid()) {
return nullptr;
}
mRefDT = dt.forget();
}
if (aRecorder) {
if (!mRecordingRefDT) {
RefPtr<DrawTarget> dt = CreateRecordingDrawTarget(aRecorder, mRefDT);
if (!dt || !dt->IsValid()) {
return nullptr;
}
mRecordingRefDT = dt.forget();
#ifdef DEBUG
mRecorder = aRecorder;
#endif
}
#ifdef DEBUG
else {
MOZ_ASSERT(aRecorder == mRecorder,
"Caching mRecordingRefDT assumes the aRecorder is an invariant");
}
#endif
return do_AddRef(mRecordingRefDT);
}
return do_AddRef(mRefDT);
}
/* static */ already_AddRefed<DrawTarget>
PrintTarget::CreateRecordingDrawTarget(DrawEventRecorder* aRecorder,
DrawTarget* aDrawTarget)
{
MOZ_ASSERT(aRecorder);
MOZ_ASSERT(aDrawTarget);
RefPtr<DrawTarget> dt;
if (aRecorder) {
// It doesn't really matter what we pass as the DrawTarget here.
dt = gfx::Factory::CreateRecordingDrawTarget(aRecorder, aDrawTarget);
}
if (!dt || !dt->IsValid()) {
gfxCriticalNote
<< "Failed to create a recording DrawTarget for PrintTarget";
return nullptr;
}
return dt.forget();
}
void
PrintTarget::Finish()
{
if (mIsFinished) {
return;
}
mIsFinished = true;
// null surfaces are allowed here
cairo_surface_finish(mCairoSurface);
}
} // namespace gfx
} // namespace mozilla