summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsSimplePageSequenceFrame.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/nsSimplePageSequenceFrame.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/nsSimplePageSequenceFrame.cpp')
-rw-r--r--layout/generic/nsSimplePageSequenceFrame.cpp884
1 files changed, 884 insertions, 0 deletions
diff --git a/layout/generic/nsSimplePageSequenceFrame.cpp b/layout/generic/nsSimplePageSequenceFrame.cpp
new file mode 100644
index 000000000..2e74afc3b
--- /dev/null
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -0,0 +1,884 @@
+/* -*- Mode: C++; tab-width: 2; 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 "nsSimplePageSequenceFrame.h"
+
+#include "nsCOMPtr.h"
+#include "nsDeviceContext.h"
+#include "nsPresContext.h"
+#include "gfxContext.h"
+#include "nsRenderingContext.h"
+#include "nsGkAtoms.h"
+#include "nsIPresShell.h"
+#include "nsIPrintSettings.h"
+#include "nsPageFrame.h"
+#include "nsSubDocumentFrame.h"
+#include "nsRegion.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "nsHTMLCanvasFrame.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "nsICanvasRenderingContextInternal.h"
+#include "nsIDateTimeFormat.h"
+#include "nsServiceManagerUtils.h"
+#include <algorithm>
+
+#define OFFSET_NOT_SET -1
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#include "mozilla/Logging.h"
+mozilla::LazyLogModule gLayoutPrintingLog("printing-layout");
+
+#define PR_PL(_p1) MOZ_LOG(gLayoutPrintingLog, mozilla::LogLevel::Debug, _p1)
+
+nsSimplePageSequenceFrame*
+NS_NewSimplePageSequenceFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+ return new (aPresShell) nsSimplePageSequenceFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsSimplePageSequenceFrame)
+
+nsSimplePageSequenceFrame::nsSimplePageSequenceFrame(nsStyleContext* aContext) :
+ nsContainerFrame(aContext),
+ mTotalPages(-1),
+ mSelectionHeight(-1),
+ mYSelOffset(0),
+ mCalledBeginPage(false),
+ mCurrentCanvasListSetup(false)
+{
+ nscoord halfInch = PresContext()->CSSTwipsToAppUnits(NS_INCHES_TO_TWIPS(0.5));
+ mMargin.SizeTo(halfInch, halfInch, halfInch, halfInch);
+
+ // XXX Unsafe to assume successful allocation
+ mPageData = new nsSharedPageData();
+ mPageData->mHeadFootFont =
+ *PresContext()->GetDefaultFont(kGenericFont_serif,
+ aContext->StyleFont()->mLanguage);
+ mPageData->mHeadFootFont.size = nsPresContext::CSSPointsToAppUnits(10);
+
+ // Doing this here so we only have to go get these formats once
+ SetPageNumberFormat("pagenumber", "%1$d", true);
+ SetPageNumberFormat("pageofpages", "%1$d of %2$d", false);
+}
+
+nsSimplePageSequenceFrame::~nsSimplePageSequenceFrame()
+{
+ delete mPageData;
+ ResetPrintCanvasList();
+}
+
+NS_QUERYFRAME_HEAD(nsSimplePageSequenceFrame)
+ NS_QUERYFRAME_ENTRY(nsIPageSequenceFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+//----------------------------------------------------------------------
+
+void
+nsSimplePageSequenceFrame::SetDesiredSize(ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nscoord aWidth,
+ nscoord aHeight)
+{
+ // Aim to fill the whole size of the document, not only so we
+ // can act as a background in print preview but also handle overflow
+ // in child page frames correctly.
+ // Use availableWidth so we don't cause a needless horizontal scrollbar.
+ aDesiredSize.Width() = std::max(aReflowInput.AvailableWidth(),
+ nscoord(aWidth * PresContext()->GetPrintPreviewScale()));
+ aDesiredSize.Height() = std::max(aReflowInput.ComputedHeight(),
+ nscoord(aHeight * PresContext()->GetPrintPreviewScale()));
+}
+
+// Helper function to compute the offset needed to center a child
+// page-frame's margin-box inside our content-box.
+nscoord
+nsSimplePageSequenceFrame::ComputeCenteringMargin(
+ nscoord aContainerContentBoxWidth,
+ nscoord aChildPaddingBoxWidth,
+ const nsMargin& aChildPhysicalMargin)
+{
+ // We'll be centering our child's margin-box, so get the size of that:
+ nscoord childMarginBoxWidth =
+ aChildPaddingBoxWidth + aChildPhysicalMargin.LeftRight();
+
+ // When rendered, our child's rect will actually be scaled up by the
+ // print-preview scale factor, via ComputePageSequenceTransform().
+ // We really want to center *that scaled-up rendering* inside of
+ // aContainerContentBoxWidth. So, we scale up its margin-box here...
+ auto ppScale = PresContext()->GetPrintPreviewScale();
+ nscoord scaledChildMarginBoxWidth =
+ NSToCoordRound(childMarginBoxWidth * ppScale);
+
+ // ...and see we how much space is left over, when we subtract that scaled-up
+ // size from the container width:
+ nscoord scaledExtraSpace =
+ aContainerContentBoxWidth - scaledChildMarginBoxWidth;
+
+ if (scaledExtraSpace <= 0) {
+ // (Don't bother centering if there's zero/negative space.)
+ return 0;
+ }
+
+ // To center the child, we want to give it an additional left-margin of half
+ // of the extra space. And then, we have to scale that space back down, so
+ // that it'll produce the correct scaled-up amount when we render (because
+ // rendering will scale it back up):
+ return NSToCoordRound(scaledExtraSpace * 0.5 / ppScale);
+}
+
+void
+nsSimplePageSequenceFrame::Reflow(nsPresContext* aPresContext,
+ ReflowOutput& aDesiredSize,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus)
+{
+ MarkInReflow();
+ NS_PRECONDITION(aPresContext->IsRootPaginatedDocument(),
+ "A Page Sequence is only for real pages");
+ DO_GLOBAL_REFLOW_COUNT("nsSimplePageSequenceFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+ NS_FRAME_TRACE_REFLOW_IN("nsSimplePageSequenceFrame::Reflow");
+
+ aStatus = NS_FRAME_COMPLETE; // we're always complete
+
+ // Don't do incremental reflow until we've taught tables how to do
+ // it right in paginated mode.
+ if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
+ // Return our desired size
+ SetDesiredSize(aDesiredSize, aReflowInput, mSize.width, mSize.height);
+ aDesiredSize.SetOverflowAreasToDesiredBounds();
+ FinishAndStoreOverflow(&aDesiredSize);
+
+ if (GetRect().Width() != aDesiredSize.Width()) {
+ // Our width is changing; we need to re-center our children (our pages).
+ for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
+ nsIFrame* child = e.get();
+ nsMargin pageCSSMargin = child->GetUsedMargin();
+ nscoord centeringMargin =
+ ComputeCenteringMargin(aReflowInput.ComputedWidth(),
+ child->GetRect().width,
+ pageCSSMargin);
+ nscoord newX = pageCSSMargin.left + centeringMargin;
+
+ // Adjust the child's x-position:
+ child->MovePositionBy(nsPoint(newX - child->GetNormalPosition().x, 0));
+ }
+ }
+ return;
+ }
+
+ // See if we can get a Print Settings from the Context
+ if (!mPageData->mPrintSettings &&
+ aPresContext->Medium() == nsGkAtoms::print) {
+ mPageData->mPrintSettings = aPresContext->GetPrintSettings();
+ }
+
+ // now get out margins & edges
+ if (mPageData->mPrintSettings) {
+ nsIntMargin unwriteableTwips;
+ mPageData->mPrintSettings->GetUnwriteableMarginInTwips(unwriteableTwips);
+ NS_ASSERTION(unwriteableTwips.left >= 0 && unwriteableTwips.top >= 0 &&
+ unwriteableTwips.right >= 0 && unwriteableTwips.bottom >= 0,
+ "Unwriteable twips should be non-negative");
+
+ nsIntMargin marginTwips;
+ mPageData->mPrintSettings->GetMarginInTwips(marginTwips);
+ mMargin = aPresContext->CSSTwipsToAppUnits(marginTwips + unwriteableTwips);
+
+ int16_t printType;
+ mPageData->mPrintSettings->GetPrintRange(&printType);
+ mPrintRangeType = printType;
+
+ nsIntMargin edgeTwips;
+ mPageData->mPrintSettings->GetEdgeInTwips(edgeTwips);
+
+ // sanity check the values. three inches are sometimes needed
+ int32_t inchInTwips = NS_INCHES_TO_INT_TWIPS(3.0);
+ edgeTwips.top = clamped(edgeTwips.top, 0, inchInTwips);
+ edgeTwips.bottom = clamped(edgeTwips.bottom, 0, inchInTwips);
+ edgeTwips.left = clamped(edgeTwips.left, 0, inchInTwips);
+ edgeTwips.right = clamped(edgeTwips.right, 0, inchInTwips);
+
+ mPageData->mEdgePaperMargin =
+ aPresContext->CSSTwipsToAppUnits(edgeTwips + unwriteableTwips);
+ }
+
+ // *** Special Override ***
+ // If this is a sub-sdoc (meaning it doesn't take the whole page)
+ // and if this Document is in the upper left hand corner
+ // we need to suppress the top margin or it will reflow too small
+
+ nsSize pageSize = aPresContext->GetPageSize();
+
+ mPageData->mReflowSize = pageSize;
+ // If we're printing a selection, we need to reflow with
+ // unconstrained height, to make sure we'll get to the selection
+ // even if it's beyond the first page of content.
+ if (nsIPrintSettings::kRangeSelection == mPrintRangeType) {
+ mPageData->mReflowSize.height = NS_UNCONSTRAINEDSIZE;
+ }
+ mPageData->mReflowMargin = mMargin;
+
+ // We use the CSS "margin" property on the -moz-page pseudoelement
+ // to determine the space between each page in print preview.
+ // Keep a running y-offset for each page.
+ nscoord y = 0;
+ nscoord maxXMost = 0;
+
+ // Tile the pages vertically
+ ReflowOutput kidSize(aReflowInput);
+ for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
+ nsIFrame* kidFrame = e.get();
+ // Set the shared data into the page frame before reflow
+ nsPageFrame * pf = static_cast<nsPageFrame*>(kidFrame);
+ pf->SetSharedPageData(mPageData);
+
+ // Reflow the page
+ ReflowInput kidReflowInput(aPresContext, aReflowInput, kidFrame,
+ LogicalSize(kidFrame->GetWritingMode(),
+ pageSize));
+ nsReflowStatus status;
+
+ kidReflowInput.SetComputedWidth(kidReflowInput.AvailableWidth());
+ //kidReflowInput.SetComputedHeight(kidReflowInput.AvailableHeight());
+ PR_PL(("AV W: %d H: %d\n", kidReflowInput.AvailableWidth(), kidReflowInput.AvailableHeight()));
+
+ nsMargin pageCSSMargin = kidReflowInput.ComputedPhysicalMargin();
+ y += pageCSSMargin.top;
+
+ nscoord x = pageCSSMargin.left;
+
+ // Place and size the page.
+ ReflowChild(kidFrame, aPresContext, kidSize, kidReflowInput, x, y, 0, status);
+
+ // If the page is narrower than our width, then center it horizontally:
+ x += ComputeCenteringMargin(aReflowInput.ComputedWidth(),
+ kidSize.Width(), pageCSSMargin);
+
+ FinishReflowChild(kidFrame, aPresContext, kidSize, nullptr, x, y, 0);
+ y += kidSize.Height();
+ y += pageCSSMargin.bottom;
+
+ maxXMost = std::max(maxXMost, x + kidSize.Width() + pageCSSMargin.right);
+
+ // Is the page complete?
+ nsIFrame* kidNextInFlow = kidFrame->GetNextInFlow();
+
+ if (NS_FRAME_IS_FULLY_COMPLETE(status)) {
+ NS_ASSERTION(!kidNextInFlow, "bad child flow list");
+ } else if (!kidNextInFlow) {
+ // The page isn't complete and it doesn't have a next-in-flow, so
+ // create a continuing page.
+ nsIFrame* continuingPage = aPresContext->PresShell()->FrameConstructor()->
+ CreateContinuingFrame(aPresContext, kidFrame, this);
+
+ // Add it to our child list
+ mFrames.InsertFrame(nullptr, kidFrame, continuingPage);
+ }
+ }
+
+ // Get Total Page Count
+ // XXXdholbert technically we could calculate this in the loop above,
+ // instead of needing a separate walk.
+ int32_t pageTot = mFrames.GetLength();
+
+ // Set Page Number Info
+ int32_t pageNum = 1;
+ for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
+ MOZ_ASSERT(e.get()->GetType() == nsGkAtoms::pageFrame,
+ "only expecting nsPageFrame children. Other children will make "
+ "this static_cast bogus & probably violate other assumptions");
+ nsPageFrame* pf = static_cast<nsPageFrame*>(e.get());
+ pf->SetPageNumInfo(pageNum, pageTot);
+ pageNum++;
+ }
+
+ // Create current Date/Time String
+ if (!mDateFormatter) {
+ mDateFormatter = nsIDateTimeFormat::Create();
+ }
+ if (!mDateFormatter) {
+ return;
+ }
+ nsAutoString formattedDateString;
+ time_t ltime;
+ time( &ltime );
+ if (NS_SUCCEEDED(mDateFormatter->FormatTime(nullptr /* nsILocale* locale */,
+ kDateFormatShort,
+ kTimeFormatNoSeconds,
+ ltime,
+ formattedDateString))) {
+ SetDateTimeStr(formattedDateString);
+ }
+
+ // Return our desired size
+ // Adjust the reflow size by PrintPreviewScale so the scrollbars end up the
+ // correct size
+ SetDesiredSize(aDesiredSize, aReflowInput, maxXMost, y);
+
+ aDesiredSize.SetOverflowAreasToDesiredBounds();
+ FinishAndStoreOverflow(&aDesiredSize);
+
+ // cache the size so we can set the desired size
+ // for the other reflows that happen
+ mSize.width = maxXMost;
+ mSize.height = y;
+
+ NS_FRAME_TRACE_REFLOW_OUT("nsSimplePageSequeceFrame::Reflow", aStatus);
+ NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+//----------------------------------------------------------------------
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult
+nsSimplePageSequenceFrame::GetFrameName(nsAString& aResult) const
+{
+ return MakeFrameName(NS_LITERAL_STRING("SimplePageSequence"), aResult);
+}
+#endif
+
+//====================================================================
+//== Asynch Printing
+//====================================================================
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::GetCurrentPageNum(int32_t* aPageNum)
+{
+ NS_ENSURE_ARG_POINTER(aPageNum);
+
+ *aPageNum = mPageNum;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::GetNumPages(int32_t* aNumPages)
+{
+ NS_ENSURE_ARG_POINTER(aNumPages);
+
+ *aNumPages = mTotalPages;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::IsDoingPrintRange(bool* aDoing)
+{
+ NS_ENSURE_ARG_POINTER(aDoing);
+
+ *aDoing = mDoingPageRange;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::GetPrintRange(int32_t* aFromPage, int32_t* aToPage)
+{
+ NS_ENSURE_ARG_POINTER(aFromPage);
+ NS_ENSURE_ARG_POINTER(aToPage);
+
+ *aFromPage = mFromPageNum;
+ *aToPage = mToPageNum;
+ return NS_OK;
+}
+
+// Helper Function
+void
+nsSimplePageSequenceFrame::SetPageNumberFormat(const char* aPropName, const char* aDefPropVal, bool aPageNumOnly)
+{
+ // Doing this here so we only have to go get these formats once
+ nsXPIDLString pageNumberFormat;
+ // Now go get the Localized Page Formating String
+ nsresult rv =
+ nsContentUtils::GetLocalizedString(nsContentUtils::ePRINTING_PROPERTIES,
+ aPropName, pageNumberFormat);
+ if (NS_FAILED(rv)) { // back stop formatting
+ pageNumberFormat.AssignASCII(aDefPropVal);
+ }
+
+ SetPageNumberFormat(pageNumberFormat, aPageNumOnly);
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::StartPrint(nsPresContext* aPresContext,
+ nsIPrintSettings* aPrintSettings,
+ const nsAString& aDocTitle,
+ const nsAString& aDocURL)
+{
+ NS_ENSURE_ARG_POINTER(aPresContext);
+ NS_ENSURE_ARG_POINTER(aPrintSettings);
+
+ if (!mPageData->mPrintSettings) {
+ mPageData->mPrintSettings = aPrintSettings;
+ }
+
+ if (!aDocTitle.IsEmpty()) {
+ mPageData->mDocTitle = aDocTitle;
+ }
+ if (!aDocURL.IsEmpty()) {
+ mPageData->mDocURL = aDocURL;
+ }
+
+ aPrintSettings->GetStartPageRange(&mFromPageNum);
+ aPrintSettings->GetEndPageRange(&mToPageNum);
+ aPrintSettings->GetPageRanges(mPageRanges);
+
+ mDoingPageRange = nsIPrintSettings::kRangeSpecifiedPageRange == mPrintRangeType ||
+ nsIPrintSettings::kRangeSelection == mPrintRangeType;
+
+ // If printing a range of pages make sure at least the starting page
+ // number is valid
+ int32_t totalPages = mFrames.GetLength();
+
+ if (mDoingPageRange) {
+ if (mFromPageNum > totalPages) {
+ return NS_ERROR_INVALID_ARG;
+ }
+ }
+
+ // Begin printing of the document
+ nsresult rv = NS_OK;
+
+ // Determine if we are rendering only the selection
+ aPresContext->SetIsRenderingOnlySelection(nsIPrintSettings::kRangeSelection == mPrintRangeType);
+
+
+ if (mDoingPageRange) {
+ // XXX because of the hack for making the selection all print on one page
+ // we must make sure that the page is sized correctly before printing.
+ nscoord height = aPresContext->GetPageSize().height;
+
+ int32_t pageNum = 1;
+ nscoord y = 0;//mMargin.top;
+
+ for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
+ nsIFrame* page = e.get();
+ if (pageNum >= mFromPageNum && pageNum <= mToPageNum) {
+ nsRect rect = page->GetRect();
+ rect.y = y;
+ rect.height = height;
+ page->SetRect(rect);
+ y += rect.height + mMargin.top + mMargin.bottom;
+ }
+ pageNum++;
+ }
+
+ // adjust total number of pages
+ if (nsIPrintSettings::kRangeSelection != mPrintRangeType) {
+ totalPages = pageNum - 1;
+ }
+ }
+
+ mPageNum = 1;
+
+ if (mTotalPages == -1) {
+ mTotalPages = totalPages;
+ }
+
+ return rv;
+}
+
+void
+GetPrintCanvasElementsInFrame(nsIFrame* aFrame, nsTArray<RefPtr<HTMLCanvasElement> >* aArr)
+{
+ if (!aFrame) {
+ return;
+ }
+ for (nsIFrame::ChildListIterator childLists(aFrame);
+ !childLists.IsDone(); childLists.Next()) {
+
+ nsFrameList children = childLists.CurrentList();
+ for (nsFrameList::Enumerator e(children); !e.AtEnd(); e.Next()) {
+ nsIFrame* child = e.get();
+
+ // Check if child is a nsHTMLCanvasFrame.
+ nsHTMLCanvasFrame* canvasFrame = do_QueryFrame(child);
+
+ // If there is a canvasFrame, try to get actual canvas element.
+ if (canvasFrame) {
+ HTMLCanvasElement* canvas =
+ HTMLCanvasElement::FromContentOrNull(canvasFrame->GetContent());
+ if (canvas && canvas->GetMozPrintCallback()) {
+ aArr->AppendElement(canvas);
+ continue;
+ }
+ }
+
+ if (!child->PrincipalChildList().FirstChild()) {
+ nsSubDocumentFrame* subdocumentFrame = do_QueryFrame(child);
+ if (subdocumentFrame) {
+ // Descend into the subdocument
+ nsIFrame* root = subdocumentFrame->GetSubdocumentRootFrame();
+ child = root;
+ }
+ }
+ // The current child is not a nsHTMLCanvasFrame OR it is but there is
+ // no HTMLCanvasElement on it. Check if children of `child` might
+ // contain a HTMLCanvasElement.
+ GetPrintCanvasElementsInFrame(child, aArr);
+ }
+ }
+}
+
+void
+nsSimplePageSequenceFrame::DetermineWhetherToPrintPage()
+{
+ // See whether we should print this page
+ mPrintThisPage = true;
+ bool printEvenPages, printOddPages;
+ mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintEvenPages, &printEvenPages);
+ mPageData->mPrintSettings->GetPrintOptions(nsIPrintSettings::kPrintOddPages, &printOddPages);
+
+ // If printing a range of pages check whether the page number is in the
+ // range of pages to print
+ if (mDoingPageRange) {
+ if (mPageNum < mFromPageNum) {
+ mPrintThisPage = false;
+ } else if (mPageNum > mToPageNum) {
+ mPageNum++;
+ mPrintThisPage = false;
+ return;
+ } else {
+ int32_t length = mPageRanges.Length();
+
+ // Page ranges are pairs (start, end)
+ if (length && (length % 2 == 0)) {
+ mPrintThisPage = false;
+
+ int32_t i;
+ for (i = 0; i < length; i += 2) {
+ if (mPageRanges[i] <= mPageNum && mPageNum <= mPageRanges[i+1]) {
+ mPrintThisPage = true;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Check for printing of odd and even pages
+ if (mPageNum & 0x1) {
+ if (!printOddPages) {
+ mPrintThisPage = false; // don't print odd numbered page
+ }
+ } else {
+ if (!printEvenPages) {
+ mPrintThisPage = false; // don't print even numbered page
+ }
+ }
+
+ if (nsIPrintSettings::kRangeSelection == mPrintRangeType) {
+ mPrintThisPage = true;
+ }
+}
+
+nsIFrame*
+nsSimplePageSequenceFrame::GetCurrentPageFrame()
+{
+ int32_t i = 1;
+ for (nsFrameList::Enumerator childFrames(mFrames); !childFrames.AtEnd();
+ childFrames.Next()) {
+ if (i == mPageNum) {
+ return childFrames.get();
+ }
+ ++i;
+ }
+ return nullptr;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::PrePrintNextPage(nsITimerCallback* aCallback, bool* aDone)
+{
+ nsIFrame* currentPage = GetCurrentPageFrame();
+ if (!currentPage) {
+ *aDone = true;
+ return NS_ERROR_FAILURE;
+ }
+
+ DetermineWhetherToPrintPage();
+ // Nothing to do if the current page doesn't get printed OR rendering to
+ // preview. For preview, the `CallPrintCallback` is called from within the
+ // HTMLCanvasElement::HandlePrintCallback.
+ if (!mPrintThisPage || !PresContext()->IsRootPaginatedDocument()) {
+ *aDone = true;
+ return NS_OK;
+ }
+
+ // If the canvasList is null, then generate it and start the render
+ // process for all the canvas.
+ if (!mCurrentCanvasListSetup) {
+ mCurrentCanvasListSetup = true;
+ GetPrintCanvasElementsInFrame(currentPage, &mCurrentCanvasList);
+
+ if (mCurrentCanvasList.Length() != 0) {
+ nsresult rv = NS_OK;
+
+ // Begin printing of the document
+ nsDeviceContext *dc = PresContext()->DeviceContext();
+ PR_PL(("\n"));
+ PR_PL(("***************** BeginPage *****************\n"));
+ rv = dc->BeginPage();
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ mCalledBeginPage = true;
+
+ RefPtr<gfxContext> renderingContext = dc->CreateRenderingContext();
+ NS_ENSURE_TRUE(renderingContext, NS_ERROR_OUT_OF_MEMORY);
+
+ DrawTarget* drawTarget = renderingContext->GetDrawTarget();
+ if (NS_WARN_IF(!drawTarget)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ for (int32_t i = mCurrentCanvasList.Length() - 1; i >= 0 ; i--) {
+ HTMLCanvasElement* canvas = mCurrentCanvasList[i];
+ nsIntSize size = canvas->GetSize();
+
+ RefPtr<DrawTarget> canvasTarget =
+ drawTarget->CreateSimilarDrawTarget(size, drawTarget->GetFormat());
+ if (!canvasTarget) {
+ continue;
+ }
+
+ nsICanvasRenderingContextInternal* ctx = canvas->GetContextAtIndex(0);
+ if (!ctx) {
+ continue;
+ }
+
+ // Initialize the context with the new DrawTarget.
+ ctx->InitializeWithDrawTarget(nullptr, WrapNotNull(canvasTarget));
+
+ // Start the rendering process.
+ nsWeakFrame weakFrame = this;
+ canvas->DispatchPrintCallback(aCallback);
+ NS_ENSURE_STATE(weakFrame.IsAlive());
+ }
+ }
+ }
+ uint32_t doneCounter = 0;
+ for (int32_t i = mCurrentCanvasList.Length() - 1; i >= 0 ; i--) {
+ HTMLCanvasElement* canvas = mCurrentCanvasList[i];
+
+ if (canvas->IsPrintCallbackDone()) {
+ doneCounter++;
+ }
+ }
+ // If all canvas have finished rendering, return true, otherwise false.
+ *aDone = doneCounter == mCurrentCanvasList.Length();
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::ResetPrintCanvasList()
+{
+ for (int32_t i = mCurrentCanvasList.Length() - 1; i >= 0 ; i--) {
+ HTMLCanvasElement* canvas = mCurrentCanvasList[i];
+ canvas->ResetPrintCallback();
+ }
+
+ mCurrentCanvasList.Clear();
+ mCurrentCanvasListSetup = false;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::PrintNextPage()
+{
+ // Print each specified page
+ // pageNum keeps track of the current page and what pages are printing
+ //
+ // printedPageNum keeps track of the current page number to be printed
+ // Note: When print al the pages or a page range the printed page shows the
+ // actual page number, when printing selection it prints the page number starting
+ // with the first page of the selection. For example if the user has a
+ // selection that starts on page 2 and ends on page 3, the page numbers when
+ // print are 1 and then two (which is different than printing a page range, where
+ // the page numbers would have been 2 and then 3)
+
+ nsIFrame* currentPage = GetCurrentPageFrame();
+ if (!currentPage) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsresult rv = NS_OK;
+
+ DetermineWhetherToPrintPage();
+
+ if (mPrintThisPage) {
+ // Begin printing of the document
+ nsDeviceContext* dc = PresContext()->DeviceContext();
+
+ // XXX This is temporary fix for printing more than one page of a selection
+ // This does a poor man's "dump" pagination (see Bug 89353)
+ // It has laid out as one long page and now we are just moving or view up/down
+ // one page at a time and printing the contents of what is exposed by the rect.
+ // currently this does not work for IFrames
+ // I will soon improve this to work with IFrames
+ bool continuePrinting = true;
+ nscoord width, height;
+ width = PresContext()->GetPageSize().width;
+ height = PresContext()->GetPageSize().height;
+ height -= mMargin.top + mMargin.bottom;
+ width -= mMargin.left + mMargin.right;
+ nscoord selectionY = height;
+ nsIFrame* conFrame = currentPage->PrincipalChildList().FirstChild();
+ if (mSelectionHeight >= 0) {
+ conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -mYSelOffset));
+ nsContainerFrame::PositionChildViews(conFrame);
+ }
+
+ // cast the frame to be a page frame
+ nsPageFrame * pf = static_cast<nsPageFrame*>(currentPage);
+ pf->SetPageNumInfo(mPageNum, mTotalPages);
+ pf->SetSharedPageData(mPageData);
+
+ int32_t printedPageNum = 1;
+ while (continuePrinting) {
+ if (PresContext()->IsRootPaginatedDocument()) {
+ if (!mCalledBeginPage) {
+ PR_PL(("\n"));
+ PR_PL(("***************** BeginPage *****************\n"));
+ rv = dc->BeginPage();
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ mCalledBeginPage = false;
+ }
+ }
+
+ PR_PL(("SeqFr::PrintNextPage -> %p PageNo: %d", pf, mPageNum));
+
+ // CreateRenderingContext can fail
+ RefPtr<gfxContext> gCtx = dc->CreateRenderingContext();
+ NS_ENSURE_TRUE(gCtx, NS_ERROR_OUT_OF_MEMORY);
+
+ nsRenderingContext renderingContext(gCtx);
+
+ nsRect drawingRect(nsPoint(0, 0), currentPage->GetSize());
+ nsRegion drawingRegion(drawingRect);
+ nsLayoutUtils::PaintFrame(&renderingContext, currentPage,
+ drawingRegion, NS_RGBA(0,0,0,0),
+ nsDisplayListBuilderMode::PAINTING,
+ nsLayoutUtils::PaintFrameFlags::PAINT_SYNC_DECODE_IMAGES);
+
+ if (mSelectionHeight >= 0 && selectionY < mSelectionHeight) {
+ selectionY += height;
+ printedPageNum++;
+ pf->SetPageNumInfo(printedPageNum, mTotalPages);
+ conFrame->SetPosition(conFrame->GetPosition() + nsPoint(0, -height));
+ nsContainerFrame::PositionChildViews(conFrame);
+
+ PR_PL(("***************** End Page (PrintNextPage) *****************\n"));
+ rv = dc->EndPage();
+ NS_ENSURE_SUCCESS(rv, rv);
+ } else {
+ continuePrinting = false;
+ }
+ }
+ }
+ return rv;
+}
+
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::DoPageEnd()
+{
+ nsresult rv = NS_OK;
+ if (PresContext()->IsRootPaginatedDocument() && mPrintThisPage) {
+ PR_PL(("***************** End Page (DoPageEnd) *****************\n"));
+ rv = PresContext()->DeviceContext()->EndPage();
+ NS_ENSURE_SUCCESS(rv, rv);
+ }
+
+ ResetPrintCanvasList();
+
+ mPageNum++;
+
+ return rv;
+}
+
+inline gfx::Matrix4x4
+ComputePageSequenceTransform(nsIFrame* aFrame, float aAppUnitsPerPixel)
+{
+ float scale = aFrame->PresContext()->GetPrintPreviewScale();
+ return gfx::Matrix4x4::Scaling(scale, scale, 1);
+}
+
+void
+nsSimplePageSequenceFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsRect& aDirtyRect,
+ const nsDisplayListSet& aLists)
+{
+ DisplayBorderBackgroundOutline(aBuilder, aLists);
+
+ nsDisplayList content;
+
+ {
+ // Clear clip state while we construct the children of the
+ // nsDisplayTransform, since they'll be in a different coordinate system.
+ DisplayListClipState::AutoSaveRestore clipState(aBuilder);
+ clipState.Clear();
+
+ nsIFrame* child = PrincipalChildList().FirstChild();
+ nsRect dirty = aDirtyRect;
+ dirty.ScaleInverseRoundOut(PresContext()->GetPrintPreviewScale());
+
+ while (child) {
+ if (child->GetVisualOverflowRectRelativeToParent().Intersects(dirty)) {
+ child->BuildDisplayListForStackingContext(aBuilder,
+ dirty - child->GetPosition(), &content);
+ aBuilder->ResetMarkedFramesForDisplayList();
+ }
+ child = child->GetNextSibling();
+ }
+ }
+
+ content.AppendNewToTop(new (aBuilder)
+ nsDisplayTransform(aBuilder, this, &content, content.GetVisibleRect(),
+ ::ComputePageSequenceTransform));
+
+ aLists.Content()->AppendToTop(&content);
+}
+
+nsIAtom*
+nsSimplePageSequenceFrame::GetType() const
+{
+ return nsGkAtoms::sequenceFrame;
+}
+
+//------------------------------------------------------------------------------
+void
+nsSimplePageSequenceFrame::SetPageNumberFormat(const nsAString& aFormatStr, bool aForPageNumOnly)
+{
+ NS_ASSERTION(mPageData != nullptr, "mPageData string cannot be null!");
+
+ if (aForPageNumOnly) {
+ mPageData->mPageNumFormat = aFormatStr;
+ } else {
+ mPageData->mPageNumAndTotalsFormat = aFormatStr;
+ }
+}
+
+//------------------------------------------------------------------------------
+void
+nsSimplePageSequenceFrame::SetDateTimeStr(const nsAString& aDateTimeStr)
+{
+ NS_ASSERTION(mPageData != nullptr, "mPageData string cannot be null!");
+
+ mPageData->mDateTimeStr = aDateTimeStr;
+}
+
+//------------------------------------------------------------------------------
+// For Shrink To Fit
+//
+// Return the percentage that the page needs to shrink to
+//
+NS_IMETHODIMP
+nsSimplePageSequenceFrame::GetSTFPercent(float& aSTFPercent)
+{
+ NS_ENSURE_TRUE(mPageData, NS_ERROR_UNEXPECTED);
+ aSTFPercent = mPageData->mShrinkToFitRatio;
+ return NS_OK;
+}