diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/thebes/PrintTarget.cpp | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/gfx/thebes/PrintTarget.cpp b/gfx/thebes/PrintTarget.cpp new file mode 100644 index 0000000000..7ab6984d8d --- /dev/null +++ b/gfx/thebes/PrintTarget.cpp @@ -0,0 +1,200 @@ +/* -*- 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 "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 "mozilla/StaticPrefs_gfx.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::gfx { + +PrintTarget::PrintTarget(cairo_surface_t* aCairoSurface, const IntSize& aSize) + : mCairoSurface(aCairoSurface), + mSize(aSize), + mIsFinished(false) +#ifdef DEBUG + , + mHasActivePage(false) +#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: + if (mCairoSurface && + cairo_surface_get_content(mCairoSurface) != CAIRO_CONTENT_COLOR) { + cairo_surface_set_subpixel_antialiasing( + mCairoSurface, CAIRO_SUBPIXEL_ANTIALIASING_DISABLED); + } +} + +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() { + 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: + if (StaticPrefs::gfx_cairo_quartz_cg_layer_enabled()) { + similar = cairo_quartz_surface_create_cg_layer( + mCairoSurface, cairo_surface_get_content(mCairoSurface), + size.width, size.height); + break; + } + [[fallthrough]]; +#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 = std::move(dt); + } + + 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::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, + aDrawTarget->GetRect()); + } + + 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 mozilla::gfx |