layout/generic/nsPageSequenceFrame.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6 #ifndef nsPageSequenceFrame_h___
   7 #define nsPageSequenceFrame_h___
   8
   9 #include "mozilla/Attributes.h"
  10 #include "mozilla/UniquePtr.h"
  11 #include "nsContainerFrame.h"
  12 #include "nsIPrintSettings.h"
  13
  14 namespace mozilla {
  15
  16 class PresShell;
  17 class PrintedSheetFrame;
  18
  19 namespace dom {
  20
  21 class HTMLCanvasElement;
  22
  23 }  // namespace dom
  24 }  // namespace mozilla
  25
  26 //-----------------------------------------------
  27 // This class is used to manage some static data about the layout
  28 // characteristics of our various "Pages Per Sheet" options.
  29 struct nsPagesPerSheetInfo {
  30   static const nsPagesPerSheetInfo& LookupInfo(int32_t aPPS);
  31
  32   uint16_t mNumPages;
  33
  34   // This is the larger of the row-count vs. column-count for this layout
  35   // (if they aren't the same). We'll aim to stack this number of pages
  36   // in the sheet's longer axis.
  37   uint16_t mLargerNumTracks;
  38 };
  39
  40 /**
  41  * This class maintains various shared data that is used by printing-related
  42  * frames. The nsPageSequenceFrame strongly owns an instance of this class,
  43  * which lives for as long as the nsPageSequenceFrame does.
  44  */
  45 class nsSharedPageData {
  46  public:
  47   nsString mDateTimeStr;
  48   nsString mPageNumFormat;
  49   nsString mPageNumAndTotalsFormat;
  50   nsString mDocTitle;
  51   nsString mDocURL;
  52   nsFont mHeadFootFont;
  53
  54   // Total number of pages (populated by PrintedSheetFrame when it determines
  55   // that it's reflowed the final page):
  56   int32_t mRawNumPages = 0;
  57
  58   // If there's more than one page-range, then its components are stored here
  59   // as pairs of (start,end).  They're stored in the order provided (not
  60   // necessarily in ascending order).
  61   nsTArray<int32_t> mPageRanges;
  62
  63   // Margin for headers and footers; it defaults to 4/100 of an inch on UNIX
  64   // and 0 elsewhere; I think it has to do with some inconsistency in page size
  65   // computations
  66   nsMargin mEdgePaperMargin;
  67
  68   nsCOMPtr<nsIPrintSettings> mPrintSettings;
  69
  70   // The scaling ratio we need to apply to make all pages fit horizontally. It's
  71   // the minimum "ComputedWidth / OverflowWidth" ratio of all page content
  72   // frames that overflowed.  It's 1.0 if none overflowed horizontally.
  73   float mShrinkToFitRatio = 1.0f;
  74
  75   // Lazy getter, to look up our pages-per-sheet info based on mPrintSettings
  76   // (if it's available).  The result is stored in our mPagesPerSheetInfo
  77   // member-var to speed up subsequent lookups.
  78   // This API is infallible; in failure cases, it just returns the info struct
  79   // that corresponds to 1 page per sheet.
  80   const nsPagesPerSheetInfo* PagesPerSheetInfo();
  81
  82  private:
  83   const nsPagesPerSheetInfo* mPagesPerSheetInfo = nullptr;
  84 };
  85
  86 // Page sequence frame class. Manages a series of pages, in paginated mode.
  87 // (Strictly speaking, this frame's direct children are PrintedSheetFrame
  88 // instances, and each of those will usually contain one nsPageFrame, depending
  89 // on the "pages-per-sheet" setting and whether the print operation is
  90 // restricted to a custom page range.)
  91 class nsPageSequenceFrame final : public nsContainerFrame {
  92   using LogicalSize = mozilla::LogicalSize;
  93
  94  public:
  95   friend nsPageSequenceFrame* NS_NewPageSequenceFrame(
  96       mozilla::PresShell* aPresShell, ComputedStyle* aStyle);
  97
  98   NS_DECL_QUERYFRAME
  99   NS_DECL_FRAMEARENA_HELPERS(nsPageSequenceFrame)
 100
 101   // nsIFrame
 102   void Reflow(nsPresContext* aPresContext, ReflowOutput& aReflowOutput,
 103               const ReflowInput& aReflowInput,
 104               nsReflowStatus& aStatus) override;
 105
 106   void BuildDisplayList(nsDisplayListBuilder* aBuilder,
 107                         const nsDisplayListSet& aLists) override;
 108
 109   // For Shrink To Fit
 110   float GetSTFPercent() const { return mPageData->mShrinkToFitRatio; }
 111
 112   // Gets the final print preview scale that we're applying to the previewed
 113   // sheets of paper.
 114   float GetPrintPreviewScale() const;
 115
 116   // Async Printing
 117   nsresult StartPrint(nsPresContext* aPresContext,
 118                       nsIPrintSettings* aPrintSettings,
 119                       const nsAString& aDocTitle, const nsAString& aDocURL);
 120   nsresult PrePrintNextSheet(nsITimerCallback* aCallback, bool* aDone);
 121   nsresult PrintNextSheet();
 122   void ResetPrintCanvasList();
 123
 124   uint32_t GetCurrentSheetIdx() const { return mCurrentSheetIdx; }
 125
 126   int32_t GetRawNumPages() const { return mPageData->mRawNumPages; }
 127
 128   uint32_t GetPagesInFirstSheet() const;
 129
 130   nsresult DoPageEnd();
 131
 132   ComputeTransformFunction GetTransformGetter() const override;
 133
 134 #ifdef DEBUG_FRAME_DUMP
 135   nsresult GetFrameName(nsAString& aResult) const override;
 136 #endif
 137
 138  protected:
 139   nsPageSequenceFrame(ComputedStyle*, nsPresContext*);
 140   virtual ~nsPageSequenceFrame();
 141
 142   void SetPageNumberFormat(const char* aPropName, const char* aDefPropVal,
 143                            bool aPageNumOnly);
 144
 145   // SharedPageData Helper methods
 146   void SetDateTimeStr(const nsAString& aDateTimeStr);
 147   void SetPageNumberFormat(const nsAString& aFormatStr, bool aForPageNumOnly);
 148
 149   // Print scaling is applied in this function.
 150   void PopulateReflowOutput(ReflowOutput&, const ReflowInput&);
 151
 152   // Helper function to compute the offset needed to center a child
 153   // page-frame's margin-box inside our content-box.
 154   nscoord ComputeCenteringMargin(nscoord aContainerContentBoxWidth,
 155                                  nscoord aChildPaddingBoxWidth,
 156                                  const nsMargin& aChildPhysicalMargin);
 157
 158   mozilla::PrintedSheetFrame* GetCurrentSheetFrame();
 159
 160   nsSize mSize;
 161
 162   // These next two LogicalSize members are used when we're in print-preview to
 163   // ensure that each previewed sheet will fit in the print-preview scrollport:
 164   // -------
 165
 166   // Each component of this LogicalSize represents the maximum length of all
 167   // our print-previewed sheets in that axis, plus a little extra for the
 168   // print-preview margin.  Note that this LogicalSize doesn't necessarily
 169   // correspond to any one particular sheet's size (especially if our sheets
 170   // have different sizes), since the components are tracked independently such
 171   // that we end up storing the maximum in each dimension.
 172   LogicalSize mMaxSheetSize;
 173   // The size of the scrollport where we're print-previewing sheets.
 174   LogicalSize mScrollportSize;
 175
 176   // Data shared by all the nsPageFrames:
 177   mozilla::UniquePtr<nsSharedPageData> mPageData;
 178
 179   // The zero-based index of the PrintedSheetFrame child that is being printed
 180   // (or about-to-be-printed), in an async print operation.
 181   // This is an index into our PrincipalChildList, effectively.
 182   uint32_t mCurrentSheetIdx = 0;
 183
 184   nsTArray<RefPtr<mozilla::dom::HTMLCanvasElement> > mCurrentCanvasList;
 185
 186   bool mCalledBeginPage;
 187
 188   bool mCurrentCanvasListSetup;
 189 };
 190
 191 #endif /* nsPageSequenceFrame_h___ */