Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 418 insertions, 0 deletions

diff --git a/layout/generic/PrintedSheetFrame.cpp b/layout/generic/PrintedSheetFrame.cpp
new file mode 100644
index 0000000000..06fdbad3f5
--- /dev/null
+++ b/layout/generic/PrintedSheetFrame.cpp
@@ -0,0 +1,418 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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 https://mozilla.org/MPL/2.0/. */
+
+/* Rendering object for a printed or print-previewed sheet of paper */
+
+#include "mozilla/PrintedSheetFrame.h"
+
+#include <tuple>
+
+#include "mozilla/StaticPrefs_print.h"
+#include "nsCSSFrameConstructor.h"
+#include "nsPageFrame.h"
+#include "nsPageSequenceFrame.h"
+
+using namespace mozilla;
+
+PrintedSheetFrame* NS_NewPrintedSheetFrame(PresShell* aPresShell,
+                                           ComputedStyle* aStyle) {
+  return new (aPresShell)
+      PrintedSheetFrame(aStyle, aPresShell->GetPresContext());
+}
+
+namespace mozilla {
+
+NS_QUERYFRAME_HEAD(PrintedSheetFrame)
+  NS_QUERYFRAME_ENTRY(PrintedSheetFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(PrintedSheetFrame)
+
+std::tuple<uint32_t, uint32_t> GetRowAndColFromIdx(uint32_t aIdxOnSheet,
+                                                   uint32_t aNumCols) {
+  // Compute the row index by *dividing* the item's ordinal position by how
+  // many items fit in each row (i.e. the number of columns), and flooring.
+  // Compute the column index by getting the remainder of that division:
+  // Notably, mNumRows is irrelevant to this computation; that's because
+  // we're adding new items column-by-column rather than row-by-row.
+  return {aIdxOnSheet / aNumCols, aIdxOnSheet % aNumCols};
+}
+
+// Helper for BuildDisplayList:
+gfx::Matrix4x4 ComputePagesPerSheetTransform(nsIFrame* aFrame,
+                                             float aAppUnitsPerPixel) {
+  MOZ_ASSERT(aFrame->IsPageFrame());
+  auto* pageFrame = static_cast<nsPageFrame*>(aFrame);
+
+  // Variables that we use in our transform (initialized with reasonable
+  // defaults that work for the regular one-page-per-sheet scenario):
+  float scale = 1.0f;
+  nsPoint gridOrigin;
+  uint32_t rowIdx = 0;
+  uint32_t colIdx = 0;
+
+  nsSharedPageData* pd = pageFrame->GetSharedPageData();
+  if (pd) {
+    const auto* ppsInfo = pd->PagesPerSheetInfo();
+    if (ppsInfo->mNumPages > 1) {
+      scale = pd->mPagesPerSheetScale;
+      gridOrigin = pd->mPagesPerSheetGridOrigin;
+      std::tie(rowIdx, colIdx) = GetRowAndColFromIdx(pageFrame->IndexOnSheet(),
+                                                     pd->mPagesPerSheetNumCols);
+    }
+  }
+
+  // Scale down the page based on the above-computed scale:
+  auto transform = gfx::Matrix4x4::Scaling(scale, scale, 1);
+
+  // Draw the page at an offset, to get it in its pages-per-sheet "cell":
+  nsSize pageSize = pageFrame->PresContext()->GetPageSize();
+  transform.PreTranslate(
+      NSAppUnitsToFloatPixels(colIdx * pageSize.width, aAppUnitsPerPixel),
+      NSAppUnitsToFloatPixels(rowIdx * pageSize.height, aAppUnitsPerPixel), 0);
+
+  // Also add the grid origin as an offset (so that we're not drawing into the
+  // sheet's unwritable area). Note that this is a PostTranslate operation
+  // (vs. PreTranslate above), since gridOrigin is an offset on the sheet
+  // itself, whereas the offset above was in the scaled coordinate space of the
+  // pages.
+  return transform.PostTranslate(
+      NSAppUnitsToFloatPixels(gridOrigin.x, aAppUnitsPerPixel),
+      NSAppUnitsToFloatPixels(gridOrigin.y, aAppUnitsPerPixel), 0);
+}
+
+void PrintedSheetFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+                                         const nsDisplayListSet& aLists) {
+  if (PresContext()->IsScreen()) {
+    // Draw the background/shadow/etc. of a blank sheet of paper, for
+    // print-preview.
+    DisplayBorderBackgroundOutline(aBuilder, aLists);
+  }
+
+  // Let each of our children (pages) draw itself, with a supplemental
+  // transform to shrink it & place it in its pages-per-sheet cell:
+  for (auto* frame : mFrames) {
+    if (!frame->HasAnyStateBits(NS_PAGE_SKIPPED_BY_CUSTOM_RANGE)) {
+      // We'll be drawing our nsPageFrame children with a (usually-trivial)
+      // N-pages-per-sheet transform applied, so our passed-in visible rect
+      // isn't meaningful while we're drawing our children, because the
+      // transform could scale down content whose coordinates are off-screen
+      // such that it ends up on-screen. So: we temporarily update the visible
+      // rect to be the child nsPageFrame's whole frame-rect (represented in
+      // this PrintedSheetFrame's coordinate space.
+      nsDisplayList content;
+      {
+        nsRect visibleRect = frame->GetRect();
+        nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild(
+            aBuilder, this, visibleRect, visibleRect);
+
+        frame->BuildDisplayListForStackingContext(aBuilder, &content);
+      }
+      content.AppendNewToTop<nsDisplayTransform>(aBuilder, frame, &content,
+                                                 content.GetBuildingRect(),
+                                                 ComputePagesPerSheetTransform);
+
+      aLists.Content()->AppendToTop(&content);
+    }
+  }
+}
+
+// If the given page is included in the user's page range, this function
+// returns false. Otherwise, it tags the page with the
+// NS_PAGE_SKIPPED_BY_CUSTOM_RANGE state bit and returns true.
+static bool TagIfSkippedByCustomRange(nsPageFrame* aPageFrame, int32_t aPageNum,
+                                      nsSharedPageData* aPD) {
+  if (!nsIPrintSettings::IsPageSkipped(aPageNum, aPD->mPageRanges)) {
+    MOZ_ASSERT(!aPageFrame->HasAnyStateBits(NS_PAGE_SKIPPED_BY_CUSTOM_RANGE),
+               "page frames NS_PAGE_SKIPPED_BY_CUSTOM_RANGE state should "
+               "only be set if we actually want to skip the page");
+    return false;
+  }
+
+  aPageFrame->AddStateBits(NS_PAGE_SKIPPED_BY_CUSTOM_RANGE);
+  return true;
+}
+
+void PrintedSheetFrame::Reflow(nsPresContext* aPresContext,
+                               ReflowOutput& aReflowOutput,
+                               const ReflowInput& aReflowInput,
+                               nsReflowStatus& aStatus) {
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("PrintedSheetFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aReflowOutput, aStatus);
+  MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+  // If we have a prev-in-flow, take its overflowing content:
+  MoveOverflowToChildList();
+
+  const WritingMode wm = aReflowInput.GetWritingMode();
+
+  // This is the app-unit size of each page (in physical & logical units):
+  const nsSize physPageSize = aPresContext->GetPageSize();
+  const LogicalSize pageSize(wm, physPageSize);
+
+  // Count the number of pages that are displayed on this sheet (i.e. how many
+  // child frames we end up laying out, excluding any pages that are skipped
+  // due to not being in the user's page-range selection).
+  uint32_t numPagesOnThisSheet = 0;
+
+  // Target for numPagesOnThisSheet.
+  const uint32_t desiredPagesPerSheet = mPD->PagesPerSheetInfo()->mNumPages;
+
+  // If we're the first continuation and we're doing >1 pages per sheet,
+  // precompute some metrics that we'll use when painting the pages:
+  if (desiredPagesPerSheet > 1 && !GetPrevContinuation()) {
+    ComputePagesPerSheetOriginAndScale();
+  }
+
+  // NOTE: I'm intentionally *not* using a range-based 'for' loop here, since
+  // we potentially mutate the frame list (appending to the end) during the
+  // list, which is not generally safe with range-based 'for' loops.
+  for (auto* childFrame = mFrames.FirstChild(); childFrame;
+       childFrame = childFrame->GetNextSibling()) {
+    MOZ_ASSERT(childFrame->IsPageFrame(),
+               "we're only expecting page frames as children");
+    auto* pageFrame = static_cast<nsPageFrame*>(childFrame);
+
+    // Be sure our child has a pointer to the nsSharedPageData and knows its
+    // page number:
+    pageFrame->SetSharedPageData(mPD);
+    pageFrame->DeterminePageNum();
+
+    if (!TagIfSkippedByCustomRange(pageFrame, pageFrame->GetPageNum(), mPD)) {
+      // The page is going to be displayed on this sheet. Tell it its index
+      // among the displayed pages, so we can use that to compute its "cell"
+      // when painting.
+      pageFrame->SetIndexOnSheet(numPagesOnThisSheet);
+      numPagesOnThisSheet++;
+    }
+
+    ReflowInput pageReflowInput(aPresContext, aReflowInput, pageFrame,
+                                pageSize);
+
+    // For layout purposes, we position *all* our nsPageFrame children at our
+    // origin. Then, if we have multiple pages-per-sheet, we'll shrink & shift
+    // each one into the right position as a paint-time effect, in
+    // BuildDisplayList.
+    LogicalPoint pagePos(wm);
+
+    // Outparams for reflow:
+    ReflowOutput pageReflowOutput(pageReflowInput);
+    nsReflowStatus status;
+
+    ReflowChild(pageFrame, aPresContext, pageReflowOutput, pageReflowInput, wm,
+                pagePos, physPageSize, ReflowChildFlags::Default, status);
+
+    FinishReflowChild(pageFrame, aPresContext, pageReflowOutput,
+                      &pageReflowInput, wm, pagePos, physPageSize,
+                      ReflowChildFlags::Default);
+
+    // Since we don't support incremental reflow in printed documents (see the
+    // early-return in nsPageSequenceFrame::Reflow), we can assume that this
+    // was the first time that pageFrame has been reflowed, and so there's no
+    // way that it could already have a next-in-flow. If it *did* have a
+    // next-in-flow, we would need to handle it in the 'status' logic below.
+    NS_ASSERTION(!pageFrame->GetNextInFlow(), "bad child flow list");
+
+    // Did this page complete the document, or do we need to generate
+    // another page frame?
+    if (status.IsFullyComplete()) {
+      // The page we just reflowed is the final page! Record its page number
+      // as the number of pages:
+      mPD->mRawNumPages = pageFrame->GetPageNum();
+    } else {
+      // Create a continuation for our page frame. We add the continuation to
+      // our child list, and then potentially push it to our overflow list, if
+      // it really belongs on the next sheet.
+      nsIFrame* continuingPage =
+          PresShell()->FrameConstructor()->CreateContinuingFrame(pageFrame,
+                                                                 this);
+      mFrames.InsertFrame(nullptr, pageFrame, continuingPage);
+      const bool isContinuingPageSkipped =
+          TagIfSkippedByCustomRange(static_cast<nsPageFrame*>(continuingPage),
+                                    pageFrame->GetPageNum() + 1, mPD);
+
+      // If we've already reached the target number of pages for this sheet,
+      // and this continuation page that we just created is meant to be
+      // displayed (i.e. it's in the chosen page range), then we need to push it
+      // to our overflow list so that it'll go onto a subsequent sheet.
+      // Otherwise we leave it on this sheet. This ensures we *only* generate
+      // another sheet IFF there's a displayable page that will end up on it.
+      if (numPagesOnThisSheet >= desiredPagesPerSheet &&
+          !isContinuingPageSkipped) {
+        PushChildrenToOverflow(continuingPage, pageFrame);
+        aStatus.SetIncomplete();
+      }
+    }
+  }
+
+  // This should hold for the first sheet, because our UI should prevent the
+  // user from creating a 0-length page range; and it should hold for
+  // subsequent sheets because we should only create an additional sheet when
+  // we discover a displayable (i.e. non-skipped) page that we need to push
+  // to that new sheet.
+
+  // XXXdholbert In certain edge cases (e.g. after a page-orientation-flip that
+  // reduces the page count), it's possible for us to be given a page range
+  // that is *entirely out-of-bounds* (with "from" & "to" both being larger
+  // than our actual page-number count).  This scenario produces a single
+  // PrintedSheetFrame with zero displayable pages on it, which is a weird
+  // state to be in. This is hopefully a scenario that the frontend code can
+  // detect and recover from (e.g. by clamping the range to our reported
+  // `rawNumPages`), but it can't do that until *after* we've completed this
+  // problematic reflow and can reported an up-to-date `rawNumPages` to the
+  // frontend.  So: to give the frontend a chance to intervene and apply some
+  // correction/clamping to its print-range parameters, we soften this
+  // assertion *specifically for the first printed sheet*.
+  if (!GetPrevContinuation()) {
+    NS_WARNING_ASSERTION(numPagesOnThisSheet > 0,
+                         "Shouldn't create a sheet with no displayable pages "
+                         "on it");
+  } else {
+    MOZ_ASSERT(numPagesOnThisSheet > 0,
+               "Shouldn't create a sheet with no displayable pages on it");
+  }
+
+  MOZ_ASSERT(numPagesOnThisSheet <= desiredPagesPerSheet,
+             "Shouldn't have more than desired number of displayable pages "
+             "on this sheet");
+  mNumPages = numPagesOnThisSheet;
+
+  // Populate our ReflowOutput outparam -- just use up all the
+  // available space, for both our desired size & overflow areas.
+  aReflowOutput.ISize(wm) = aReflowInput.AvailableISize();
+  if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE) {
+    aReflowOutput.BSize(wm) = aReflowInput.AvailableBSize();
+  }
+  aReflowOutput.SetOverflowAreasToDesiredBounds();
+
+  FinishAndStoreOverflow(&aReflowOutput);
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aReflowOutput);
+}
+
+void PrintedSheetFrame::ComputePagesPerSheetOriginAndScale() {
+  MOZ_ASSERT(mPD->PagesPerSheetInfo()->mNumPages > 1,
+             "Unnecessary to call this in a regular 1-page-per-sheet scenario; "
+             "the computed values won't ever be used in that case");
+  MOZ_ASSERT(!GetPrevContinuation(),
+             "Only needs to be called once, so 1st continuation handles it");
+
+  // The "full-scale" size of a page (if it weren't shrunk down into a grid):
+  const nsSize pageSize = PresContext()->GetPageSize();
+
+  // Compute the space available for the pages-per-sheet "page grid" (just
+  // subtract the sheet's unwriteable margin area):
+  nsSize availSpaceOnSheet = pageSize;
+  nsMargin uwm = nsPresContext::CSSTwipsToAppUnits(
+      mPD->mPrintSettings->GetUnwriteableMarginInTwips());
+
+  if (mPD->mPrintSettings->HasOrthogonalSheetsAndPages()) {
+    // The pages will be rotated to be orthogonal to the physical sheet.  To
+    // account for that, we rotate the components of availSpaceOnSheet and uwm,
+    // so that we can reason about them here from the perspective of a
+    // "pageSize"-oriented *page*.
+    std::swap(availSpaceOnSheet.width, availSpaceOnSheet.height);
+
+    // Note that the pages are rotated 90 degrees clockwise when placed onto a
+    // sheet (so that, e.g. in a scenario with two side-by-side portait pages
+    // that are rotated & placed onto a sheet, the "left" edge of the first
+    // page is at the "top" of the sheet and hence comes out of the printer
+    // first, etc).  So: given `nsMargin uwm` whose sides correspond to the
+    // physical sheet's sides, we have to rotate 90 degrees *counter-clockwise*
+    // in order to "cancel out" the page rotation and to represent it in the
+    // page's perspective. From a page's perspective, its own "top" side
+    // corresponds to the physical sheet's right side, which is why we're
+    // passing "uwm.right" as the "top" component here; and so on.
+    nsMargin rotated(uwm.right, uwm.bottom, uwm.left, uwm.top);
+    uwm = rotated;
+  }
+
+  availSpaceOnSheet.width -= uwm.LeftRight();
+  availSpaceOnSheet.height -= uwm.TopBottom();
+  nsPoint pageGridOrigin(uwm.left, uwm.top);
+
+  // If there are a different number of rows vs. cols, we'll aim to put
+  // the larger number of items in the longer axis.
+  const auto* ppsInfo = mPD->PagesPerSheetInfo();
+  uint32_t smallerNumTracks = ppsInfo->mNumPages / ppsInfo->mLargerNumTracks;
+  bool pageSizeIsPortraitLike = pageSize.width > pageSize.height;
+  auto numCols =
+      pageSizeIsPortraitLike ? smallerNumTracks : ppsInfo->mLargerNumTracks;
+  auto numRows =
+      pageSizeIsPortraitLike ? ppsInfo->mLargerNumTracks : smallerNumTracks;
+
+  // Compute the full size of the "page grid" that we'll be scaling down &
+  // placing onto a given sheet:
+  nsSize pageGridFullSize(numCols * pageSize.width, numRows * pageSize.height);
+
+  if (MOZ_UNLIKELY(availSpaceOnSheet.IsEmpty() || pageGridFullSize.IsEmpty())) {
+    // Either we have a 0-sized available area, or we have a 0-sized page-grid
+    // to draw into the available area. This sort of thing should be rare, but
+    // it can happen if there are bizarre page sizes, and/or if there's an
+    // unexpectedly large unwritable margin area. Regardless: if we get here,
+    // we shouldn't be drawing anything onto the sheet; so let's just use a
+    // scale factor of 0, and bail early to avoid division by 0 in hScale &
+    // vScale computations below.
+    NS_WARNING("Zero area for pages-per-sheet grid, or zero-sized grid");
+    mPD->mPagesPerSheetGridOrigin = pageGridOrigin;
+    mPD->mPagesPerSheetNumCols = 1;
+    mPD->mPagesPerSheetScale = 0.0f;
+    return;
+  }
+
+  // Compute the scale factors required in each axis:
+  float hScale =
+      availSpaceOnSheet.width / static_cast<float>(pageGridFullSize.width);
+  float vScale =
+      availSpaceOnSheet.height / static_cast<float>(pageGridFullSize.height);
+
+  // Choose the more restrictive scale factor (so that we don't overflow the
+  // sheet's printable area in either axis). And center the page-grid in the
+  // other axis (since it probably ends up with extra space).
+  float scale = std::min(hScale, vScale);
+  if (hScale < vScale) {
+    // hScale is the more restrictive scale-factor, so we'll be using that.
+    // Nudge the grid in the vertical axis to center it:
+    nscoord extraSpace = availSpaceOnSheet.height -
+                         NSToCoordFloor(scale * pageGridFullSize.height);
+    if (MOZ_LIKELY(extraSpace > 0)) {
+      pageGridOrigin.y += extraSpace / 2;
+    }
+  } else if (vScale < hScale) {
+    // vScale is the more restrictive scale-factor, so we'll be using that.
+    // Nudge the grid in the vertical axis to center it:
+    nscoord extraSpace = availSpaceOnSheet.width -
+                         NSToCoordFloor(scale * pageGridFullSize.width);
+    if (MOZ_LIKELY(extraSpace > 0)) {
+      pageGridOrigin.x += extraSpace / 2;
+    }
+  }
+  // else, we fit exactly in both axes, with the same scale factor, so there's
+  // no extra space in either axis, i.e. no need to center.
+
+  // Update the nsSharedPageData member data:
+  mPD->mPagesPerSheetGridOrigin = pageGridOrigin;
+  mPD->mPagesPerSheetNumCols = numCols;
+  mPD->mPagesPerSheetScale = scale;
+}
+
+void PrintedSheetFrame::AppendDirectlyOwnedAnonBoxes(
+    nsTArray<OwnedAnonBox>& aResult) {
+  MOZ_ASSERT(mFrames.FirstChild() && mFrames.FirstChild()->IsPageFrame(),
+             "PrintedSheetFrame must have a nsPageFrame child");
+  // Only append the first child; all our children are expected to be
+  // continuations of each other, and our anon box handling always walks
+  // continuations.
+  aResult.AppendElement(mFrames.FirstChild());
+}
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult PrintedSheetFrame::GetFrameName(nsAString& aResult) const {
+  return MakeFrameName(u"PrintedSheet"_ns, aResult);
+}
+#endif
+
+}  // namespace mozilla