mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-25 11:15:34 +00:00
3654a24e84
Before we introduce PrintTargetEMF, all PrintTargets finish page printing task before the end of PrintTarget::EndPage(). Unlike others, a page printing in PrintTargetEMF is done after receiving an async callback from the pdfium process. So we have both async and sync page printing behavior now. This patch is trying to make both of them work correctly while priting a content document. MozReview-Commit-ID: 2PHJToFlvtu --HG-- extra : rebase_source : 9d2d7cf7330a157a0e5c6a414c75de94ca3fb5a1 extra : source : f61eb00f83acf45511d8448922212dccb12b05aa
247 lines
6.5 KiB
C++
247 lines
6.5 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"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsString.h"
|
|
#include "nsUTF8Utils.h"
|
|
|
|
// IPP spec disallow the job-name which is over 255 characters.
|
|
// RFC: https://tools.ietf.org/html/rfc2911#section-4.1.2
|
|
#define IPP_JOB_NAME_LIMIT_LENGTH 255
|
|
|
|
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 = CreateWrapAndRecordDrawTarget(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 = CreateWrapAndRecordDrawTarget(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 */
|
|
void
|
|
PrintTarget::AdjustPrintJobNameForIPP(const nsAString& aJobName,
|
|
nsCString& aAdjustedJobName)
|
|
{
|
|
CopyUTF16toUTF8(aJobName, aAdjustedJobName);
|
|
|
|
if (aAdjustedJobName.Length() > IPP_JOB_NAME_LIMIT_LENGTH) {
|
|
uint32_t length =
|
|
RewindToPriorUTF8Codepoint(aAdjustedJobName.get(),
|
|
(IPP_JOB_NAME_LIMIT_LENGTH - 3U));
|
|
aAdjustedJobName.SetLength(length);
|
|
aAdjustedJobName.AppendLiteral("...");
|
|
}
|
|
}
|
|
|
|
/* static */
|
|
void
|
|
PrintTarget::AdjustPrintJobNameForIPP(const nsAString& aJobName,
|
|
nsString& aAdjustedJobName)
|
|
{
|
|
nsAutoCString jobName;
|
|
AdjustPrintJobNameForIPP(aJobName, jobName);
|
|
|
|
CopyUTF8toUTF16(jobName, aAdjustedJobName);
|
|
}
|
|
|
|
/* static */ already_AddRefed<DrawTarget>
|
|
PrintTarget::CreateWrapAndRecordDrawTarget(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::CreateWrapAndRecordDrawTarget(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);
|
|
}
|
|
|
|
void
|
|
PrintTarget::RegisterPageDoneCallback(PageDoneCallback&& aCallback)
|
|
{
|
|
MOZ_ASSERT(aCallback && !IsSyncPagePrinting());
|
|
mPageDoneCallback = Move(aCallback);
|
|
}
|
|
|
|
void
|
|
PrintTarget::UnregisterPageDoneCallback()
|
|
{
|
|
mPageDoneCallback = nullptr;
|
|
}
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|