widget/nsPrintSettingsImpl.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsPrintSettingsImpl.h"
   7
   8 #include "prenv.h"
   9 #include "nsCoord.h"
  10 #include "nsPaper.h"
  11 #include "nsReadableUtils.h"
  12 #include "nsIPrintSession.h"
  13 #include "mozilla/ArrayUtils.h"
  14 #include "mozilla/DebugOnly.h"
  15 #include "mozilla/RefPtr.h"
  16
  17 using namespace mozilla;
  18
  19 #define DEFAULT_MARGIN_WIDTH 0.5
  20
  21 NS_IMPL_ISUPPORTS(nsPrintSettings, nsIPrintSettings)
  22
  23 nsPrintSettings::nsPrintSettings()
  24     : mScaling(1.0),
  25       mPrintBGColors(false),
  26       mPrintBGImages(false),
  27       mIsCancelled(false),
  28       mSaveOnCancel(true),
  29       mPrintSilent(false),
  30       mShrinkToFit(true),
  31       mShowMarginGuides(false),
  32       mHonorPageRuleMargins(true),
  33       mIsPrintSelectionRBEnabled(false),
  34       mPrintSelectionOnly(false),
  35       mPrintPageDelay(50),
  36       mPaperWidth(8.5),
  37       mPaperHeight(11.0),
  38       mPaperSizeUnit(kPaperSizeInches),
  39       mPrintReversed(false),
  40       mPrintInColor(true),
  41       mOrientation(kPortraitOrientation),
  42       mResolution(0),
  43       mDuplex(0),
  44       mNumCopies(1),
  45       mNumPagesPerSheet(1),
  46       mPrintToFile(false),
  47       mOutputFormat(kOutputFormatNative),
  48       mIsInitedFromPrinter(false),
  49       mIsInitedFromPrefs(false) {
  50   /* member initializers and constructor code */
  51   int32_t marginWidth = NS_INCHES_TO_INT_TWIPS(DEFAULT_MARGIN_WIDTH);
  52   mMargin.SizeTo(marginWidth, marginWidth, marginWidth, marginWidth);
  53   mEdge.SizeTo(0, 0, 0, 0);
  54   mUnwriteableMargin.SizeTo(0, 0, 0, 0);
  55
  56   mHeaderStrs[0].AssignLiteral("&T");
  57   mHeaderStrs[2].AssignLiteral("&U");
  58
  59   mFooterStrs[0].AssignLiteral(
  60       "&PT");  // Use &P (Page Num Only) or &PT (Page Num of Page Total)
  61   mFooterStrs[2].AssignLiteral("&D");
  62 }
  63
  64 void nsPrintSettings::InitWithInitializer(
  65     const PrintSettingsInitializer& aSettings) {
  66   const double kInchesPerPoint = 1.0 / 72.0;
  67
  68   SetPrinterName(aSettings.mPrinter);
  69   SetPrintInColor(aSettings.mPrintInColor);
  70   SetResolution(aSettings.mResolution);
  71   SetNumCopies(aSettings.mNumCopies);
  72   SetDuplex(aSettings.mDuplex);
  73   // The paper ID used by nsPrintSettings is the non-localizable identifier
  74   // exposed as "id" by the paper, not the potentially localized human-friendly
  75   // "name", which could change, e.g. if the user changes their system locale.
  76   SetPaperId(aSettings.mPaperInfo.mId);
  77
  78   // Set the paper sizes to match the unit.
  79   SetPaperSizeUnit(aSettings.mPaperSizeUnit);
  80   double sizeUnitsPerPoint =
  81       aSettings.mPaperSizeUnit == kPaperSizeInches ? 1.0 / 72.0 : 25.4 / 72.0;
  82   SetPaperWidth(aSettings.mPaperInfo.mSize.width * sizeUnitsPerPoint);
  83   SetPaperHeight(aSettings.mPaperInfo.mSize.height * sizeUnitsPerPoint);
  84
  85   // If our initializer says that we're producing portrait-mode sheets of
  86   // paper, then our page format must also be portrait-mode; unless we've got
  87   // a pages-per-sheet value with orthogonal pages/sheets, in which case it's
  88   // reversed.
  89   const bool areSheetsOfPaperPortraitMode =
  90       (aSettings.mSheetOrientation == kPortraitOrientation);
  91   const bool arePagesPortraitMode =
  92       (areSheetsOfPaperPortraitMode != HasOrthogonalSheetsAndPages());
  93   SetOrientation(arePagesPortraitMode ? kPortraitOrientation
  94                                       : kLandscapeOrientation);
  95
  96   if (aSettings.mPaperInfo.mUnwriteableMargin) {
  97     const auto& margin = aSettings.mPaperInfo.mUnwriteableMargin.value();
  98     // Margins are stored internally in TWIPS, but the setters expect inches.
  99     SetUnwriteableMarginTop(margin.top * kInchesPerPoint);
 100     SetUnwriteableMarginRight(margin.right * kInchesPerPoint);
 101     SetUnwriteableMarginBottom(margin.bottom * kInchesPerPoint);
 102     SetUnwriteableMarginLeft(margin.left * kInchesPerPoint);
 103   }
 104
 105   // Set this last because other setters may overwrite its value.
 106   SetIsInitializedFromPrinter(true);
 107 }
 108
 109 nsPrintSettings::nsPrintSettings(const nsPrintSettings& aPS) { *this = aPS; }
 110
 111 nsPrintSettings::~nsPrintSettings() = default;
 112
 113 NS_IMETHODIMP nsPrintSettings::GetPrintSession(
 114     nsIPrintSession** aPrintSession) {
 115   NS_ENSURE_ARG_POINTER(aPrintSession);
 116   *aPrintSession = nullptr;
 117
 118   nsCOMPtr<nsIPrintSession> session = do_QueryReferent(mSession);
 119   if (!session) return NS_ERROR_NOT_INITIALIZED;
 120   *aPrintSession = session;
 121   NS_ADDREF(*aPrintSession);
 122   return NS_OK;
 123 }
 124
 125 NS_IMETHODIMP nsPrintSettings::SetPrintSession(nsIPrintSession* aPrintSession) {
 126   // Clearing it by passing nullptr is not allowed. That's why we
 127   // use a weak ref so that it doesn't have to be cleared.
 128   NS_ENSURE_ARG(aPrintSession);
 129
 130   mSession = do_GetWeakReference(aPrintSession);
 131   if (!mSession) {
 132     // This may happen if the implementation of this object does
 133     // not support weak references - programmer error.
 134     NS_ERROR("Could not get a weak reference from aPrintSession");
 135     return NS_ERROR_FAILURE;
 136   }
 137   return NS_OK;
 138 }
 139
 140 NS_IMETHODIMP nsPrintSettings::GetPrintReversed(bool* aPrintReversed) {
 141   *aPrintReversed = mPrintReversed;
 142   return NS_OK;
 143 }
 144 NS_IMETHODIMP nsPrintSettings::SetPrintReversed(bool aPrintReversed) {
 145   mPrintReversed = aPrintReversed;
 146   return NS_OK;
 147 }
 148
 149 NS_IMETHODIMP nsPrintSettings::GetPrintInColor(bool* aPrintInColor) {
 150   *aPrintInColor = mPrintInColor;
 151   return NS_OK;
 152 }
 153 NS_IMETHODIMP nsPrintSettings::SetPrintInColor(bool aPrintInColor) {
 154   mPrintInColor = aPrintInColor;
 155   return NS_OK;
 156 }
 157
 158 NS_IMETHODIMP nsPrintSettings::GetOrientation(int32_t* aOrientation) {
 159   *aOrientation = mOrientation;
 160   return NS_OK;
 161 }
 162 NS_IMETHODIMP nsPrintSettings::SetOrientation(int32_t aOrientation) {
 163   mOrientation = aOrientation;
 164   return NS_OK;
 165 }
 166
 167 NS_IMETHODIMP nsPrintSettings::GetResolution(int32_t* aResolution) {
 168   NS_ENSURE_ARG_POINTER(aResolution);
 169   *aResolution = mResolution;
 170   return NS_OK;
 171 }
 172 NS_IMETHODIMP nsPrintSettings::SetResolution(const int32_t aResolution) {
 173   mResolution = aResolution;
 174   return NS_OK;
 175 }
 176
 177 NS_IMETHODIMP nsPrintSettings::GetDuplex(int32_t* aDuplex) {
 178   NS_ENSURE_ARG_POINTER(aDuplex);
 179   *aDuplex = mDuplex;
 180   return NS_OK;
 181 }
 182 NS_IMETHODIMP nsPrintSettings::SetDuplex(const int32_t aDuplex) {
 183   mDuplex = aDuplex;
 184   return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP nsPrintSettings::GetPrinterName(nsAString& aPrinter) {
 188   aPrinter = mPrinter;
 189   return NS_OK;
 190 }
 191
 192 NS_IMETHODIMP nsPrintSettings::SetPrinterName(const nsAString& aPrinter) {
 193   if (!mPrinter.Equals(aPrinter)) {
 194     mIsInitedFromPrinter = false;
 195     mIsInitedFromPrefs = false;
 196   }
 197
 198   mPrinter.Assign(aPrinter);
 199   return NS_OK;
 200 }
 201
 202 NS_IMETHODIMP nsPrintSettings::GetNumCopies(int32_t* aNumCopies) {
 203   NS_ENSURE_ARG_POINTER(aNumCopies);
 204   *aNumCopies = mNumCopies;
 205   return NS_OK;
 206 }
 207 NS_IMETHODIMP nsPrintSettings::SetNumCopies(int32_t aNumCopies) {
 208   mNumCopies = aNumCopies;
 209   return NS_OK;
 210 }
 211
 212 NS_IMETHODIMP nsPrintSettings::GetNumPagesPerSheet(int32_t* aNumPagesPerSheet) {
 213   NS_ENSURE_ARG_POINTER(aNumPagesPerSheet);
 214   *aNumPagesPerSheet = mNumPagesPerSheet;
 215   return NS_OK;
 216 }
 217 NS_IMETHODIMP nsPrintSettings::SetNumPagesPerSheet(int32_t aNumPagesPerSheet) {
 218   mNumPagesPerSheet = aNumPagesPerSheet;
 219   return NS_OK;
 220 }
 221
 222 NS_IMETHODIMP nsPrintSettings::GetPrintToFile(bool* aPrintToFile) {
 223   NS_ENSURE_ARG_POINTER(aPrintToFile);
 224   *aPrintToFile = mPrintToFile;
 225   return NS_OK;
 226 }
 227 NS_IMETHODIMP nsPrintSettings::SetPrintToFile(bool aPrintToFile) {
 228   mPrintToFile = aPrintToFile;
 229   return NS_OK;
 230 }
 231
 232 NS_IMETHODIMP nsPrintSettings::GetToFileName(nsAString& aToFileName) {
 233   aToFileName = mToFileName;
 234   return NS_OK;
 235 }
 236 NS_IMETHODIMP nsPrintSettings::SetToFileName(const nsAString& aToFileName) {
 237   mToFileName = aToFileName;
 238   return NS_OK;
 239 }
 240
 241 NS_IMETHODIMP nsPrintSettings::GetOutputFormat(int16_t* aOutputFormat) {
 242   NS_ENSURE_ARG_POINTER(aOutputFormat);
 243   *aOutputFormat = mOutputFormat;
 244   return NS_OK;
 245 }
 246 NS_IMETHODIMP nsPrintSettings::SetOutputFormat(int16_t aOutputFormat) {
 247   mOutputFormat = aOutputFormat;
 248   return NS_OK;
 249 }
 250
 251 NS_IMETHODIMP nsPrintSettings::GetPrintPageDelay(int32_t* aPrintPageDelay) {
 252   *aPrintPageDelay = mPrintPageDelay;
 253   return NS_OK;
 254 }
 255 NS_IMETHODIMP nsPrintSettings::SetPrintPageDelay(int32_t aPrintPageDelay) {
 256   mPrintPageDelay = aPrintPageDelay;
 257   return NS_OK;
 258 }
 259
 260 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrinter(
 261     bool* aIsInitializedFromPrinter) {
 262   NS_ENSURE_ARG_POINTER(aIsInitializedFromPrinter);
 263   *aIsInitializedFromPrinter = mIsInitedFromPrinter;
 264   return NS_OK;
 265 }
 266 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrinter(
 267     bool aIsInitializedFromPrinter) {
 268   mIsInitedFromPrinter = aIsInitializedFromPrinter;
 269   return NS_OK;
 270 }
 271
 272 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrefs(
 273     bool* aInitializedFromPrefs) {
 274   NS_ENSURE_ARG_POINTER(aInitializedFromPrefs);
 275   *aInitializedFromPrefs = mIsInitedFromPrefs;
 276   return NS_OK;
 277 }
 278 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrefs(
 279     bool aInitializedFromPrefs) {
 280   mIsInitedFromPrefs = aInitializedFromPrefs;
 281   return NS_OK;
 282 }
 283
 284 NS_IMETHODIMP nsPrintSettings::GetMarginTop(double* aMarginTop) {
 285   NS_ENSURE_ARG_POINTER(aMarginTop);
 286   *aMarginTop = NS_TWIPS_TO_INCHES(mMargin.top);
 287   return NS_OK;
 288 }
 289 NS_IMETHODIMP nsPrintSettings::SetMarginTop(double aMarginTop) {
 290   mMargin.top = NS_INCHES_TO_INT_TWIPS(float(aMarginTop));
 291   return NS_OK;
 292 }
 293
 294 NS_IMETHODIMP nsPrintSettings::GetMarginLeft(double* aMarginLeft) {
 295   NS_ENSURE_ARG_POINTER(aMarginLeft);
 296   *aMarginLeft = NS_TWIPS_TO_INCHES(mMargin.left);
 297   return NS_OK;
 298 }
 299 NS_IMETHODIMP nsPrintSettings::SetMarginLeft(double aMarginLeft) {
 300   mMargin.left = NS_INCHES_TO_INT_TWIPS(float(aMarginLeft));
 301   return NS_OK;
 302 }
 303
 304 NS_IMETHODIMP nsPrintSettings::GetMarginBottom(double* aMarginBottom) {
 305   NS_ENSURE_ARG_POINTER(aMarginBottom);
 306   *aMarginBottom = NS_TWIPS_TO_INCHES(mMargin.bottom);
 307   return NS_OK;
 308 }
 309 NS_IMETHODIMP nsPrintSettings::SetMarginBottom(double aMarginBottom) {
 310   mMargin.bottom = NS_INCHES_TO_INT_TWIPS(float(aMarginBottom));
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP nsPrintSettings::GetMarginRight(double* aMarginRight) {
 315   NS_ENSURE_ARG_POINTER(aMarginRight);
 316   *aMarginRight = NS_TWIPS_TO_INCHES(mMargin.right);
 317   return NS_OK;
 318 }
 319 NS_IMETHODIMP nsPrintSettings::SetMarginRight(double aMarginRight) {
 320   mMargin.right = NS_INCHES_TO_INT_TWIPS(float(aMarginRight));
 321   return NS_OK;
 322 }
 323
 324 NS_IMETHODIMP nsPrintSettings::GetEdgeTop(double* aEdgeTop) {
 325   NS_ENSURE_ARG_POINTER(aEdgeTop);
 326   *aEdgeTop = NS_TWIPS_TO_INCHES(mEdge.top);
 327   return NS_OK;
 328 }
 329 NS_IMETHODIMP nsPrintSettings::SetEdgeTop(double aEdgeTop) {
 330   mEdge.top = NS_INCHES_TO_INT_TWIPS(float(aEdgeTop));
 331   return NS_OK;
 332 }
 333
 334 NS_IMETHODIMP nsPrintSettings::GetEdgeLeft(double* aEdgeLeft) {
 335   NS_ENSURE_ARG_POINTER(aEdgeLeft);
 336   *aEdgeLeft = NS_TWIPS_TO_INCHES(mEdge.left);
 337   return NS_OK;
 338 }
 339 NS_IMETHODIMP nsPrintSettings::SetEdgeLeft(double aEdgeLeft) {
 340   mEdge.left = NS_INCHES_TO_INT_TWIPS(float(aEdgeLeft));
 341   return NS_OK;
 342 }
 343
 344 NS_IMETHODIMP nsPrintSettings::GetEdgeBottom(double* aEdgeBottom) {
 345   NS_ENSURE_ARG_POINTER(aEdgeBottom);
 346   *aEdgeBottom = NS_TWIPS_TO_INCHES(mEdge.bottom);
 347   return NS_OK;
 348 }
 349 NS_IMETHODIMP nsPrintSettings::SetEdgeBottom(double aEdgeBottom) {
 350   mEdge.bottom = NS_INCHES_TO_INT_TWIPS(float(aEdgeBottom));
 351   return NS_OK;
 352 }
 353
 354 NS_IMETHODIMP nsPrintSettings::GetEdgeRight(double* aEdgeRight) {
 355   NS_ENSURE_ARG_POINTER(aEdgeRight);
 356   *aEdgeRight = NS_TWIPS_TO_INCHES(mEdge.right);
 357   return NS_OK;
 358 }
 359 NS_IMETHODIMP nsPrintSettings::SetEdgeRight(double aEdgeRight) {
 360   mEdge.right = NS_INCHES_TO_INT_TWIPS(float(aEdgeRight));
 361   return NS_OK;
 362 }
 363
 364 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginTop(
 365     double* aUnwriteableMarginTop) {
 366   NS_ENSURE_ARG_POINTER(aUnwriteableMarginTop);
 367   *aUnwriteableMarginTop = NS_TWIPS_TO_INCHES(mUnwriteableMargin.top);
 368   return NS_OK;
 369 }
 370 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginTop(
 371     double aUnwriteableMarginTop) {
 372   if (aUnwriteableMarginTop >= 0.0) {
 373     mUnwriteableMargin.top = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginTop);
 374   }
 375   return NS_OK;
 376 }
 377
 378 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginLeft(
 379     double* aUnwriteableMarginLeft) {
 380   NS_ENSURE_ARG_POINTER(aUnwriteableMarginLeft);
 381   *aUnwriteableMarginLeft = NS_TWIPS_TO_INCHES(mUnwriteableMargin.left);
 382   return NS_OK;
 383 }
 384 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginLeft(
 385     double aUnwriteableMarginLeft) {
 386   if (aUnwriteableMarginLeft >= 0.0) {
 387     mUnwriteableMargin.left = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginLeft);
 388   }
 389   return NS_OK;
 390 }
 391
 392 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginBottom(
 393     double* aUnwriteableMarginBottom) {
 394   NS_ENSURE_ARG_POINTER(aUnwriteableMarginBottom);
 395   *aUnwriteableMarginBottom = NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom);
 396   return NS_OK;
 397 }
 398 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginBottom(
 399     double aUnwriteableMarginBottom) {
 400   if (aUnwriteableMarginBottom >= 0.0) {
 401     mUnwriteableMargin.bottom =
 402         NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginBottom);
 403   }
 404   return NS_OK;
 405 }
 406
 407 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginRight(
 408     double* aUnwriteableMarginRight) {
 409   NS_ENSURE_ARG_POINTER(aUnwriteableMarginRight);
 410   *aUnwriteableMarginRight = NS_TWIPS_TO_INCHES(mUnwriteableMargin.right);
 411   return NS_OK;
 412 }
 413 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginRight(
 414     double aUnwriteableMarginRight) {
 415   if (aUnwriteableMarginRight >= 0.0) {
 416     mUnwriteableMargin.right = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginRight);
 417   }
 418   return NS_OK;
 419 }
 420
 421 NS_IMETHODIMP nsPrintSettings::GetScaling(double* aScaling) {
 422   NS_ENSURE_ARG_POINTER(aScaling);
 423   *aScaling = mScaling;
 424   return NS_OK;
 425 }
 426
 427 NS_IMETHODIMP nsPrintSettings::SetScaling(double aScaling) {
 428   mScaling = aScaling;
 429   return NS_OK;
 430 }
 431
 432 NS_IMETHODIMP nsPrintSettings::GetPrintBGColors(bool* aPrintBGColors) {
 433   NS_ENSURE_ARG_POINTER(aPrintBGColors);
 434   *aPrintBGColors = mPrintBGColors;
 435   return NS_OK;
 436 }
 437 NS_IMETHODIMP nsPrintSettings::SetPrintBGColors(bool aPrintBGColors) {
 438   mPrintBGColors = aPrintBGColors;
 439   return NS_OK;
 440 }
 441
 442 NS_IMETHODIMP nsPrintSettings::GetPrintBGImages(bool* aPrintBGImages) {
 443   NS_ENSURE_ARG_POINTER(aPrintBGImages);
 444   *aPrintBGImages = mPrintBGImages;
 445   return NS_OK;
 446 }
 447 NS_IMETHODIMP nsPrintSettings::SetPrintBGImages(bool aPrintBGImages) {
 448   mPrintBGImages = aPrintBGImages;
 449   return NS_OK;
 450 }
 451
 452 NS_IMETHODIMP nsPrintSettings::GetTitle(nsAString& aTitle) {
 453   aTitle = mTitle;
 454   return NS_OK;
 455 }
 456 NS_IMETHODIMP nsPrintSettings::SetTitle(const nsAString& aTitle) {
 457   mTitle = aTitle;
 458   return NS_OK;
 459 }
 460
 461 NS_IMETHODIMP nsPrintSettings::GetDocURL(nsAString& aDocURL) {
 462   aDocURL = mURL;
 463   return NS_OK;
 464 }
 465 NS_IMETHODIMP nsPrintSettings::SetDocURL(const nsAString& aDocURL) {
 466   mURL = aDocURL;
 467   return NS_OK;
 468 }
 469
 470 NS_IMETHODIMP nsPrintSettings::GetHeaderStrLeft(nsAString& aTitle) {
 471   aTitle = mHeaderStrs[0];
 472   return NS_OK;
 473 }
 474 NS_IMETHODIMP nsPrintSettings::SetHeaderStrLeft(const nsAString& aTitle) {
 475   mHeaderStrs[0] = aTitle;
 476   return NS_OK;
 477 }
 478
 479 NS_IMETHODIMP nsPrintSettings::GetHeaderStrCenter(nsAString& aTitle) {
 480   aTitle = mHeaderStrs[1];
 481   return NS_OK;
 482 }
 483 NS_IMETHODIMP nsPrintSettings::SetHeaderStrCenter(const nsAString& aTitle) {
 484   mHeaderStrs[1] = aTitle;
 485   return NS_OK;
 486 }
 487
 488 NS_IMETHODIMP nsPrintSettings::GetHeaderStrRight(nsAString& aTitle) {
 489   aTitle = mHeaderStrs[2];
 490   return NS_OK;
 491 }
 492 NS_IMETHODIMP nsPrintSettings::SetHeaderStrRight(const nsAString& aTitle) {
 493   mHeaderStrs[2] = aTitle;
 494   return NS_OK;
 495 }
 496
 497 NS_IMETHODIMP nsPrintSettings::GetFooterStrLeft(nsAString& aTitle) {
 498   aTitle = mFooterStrs[0];
 499   return NS_OK;
 500 }
 501 NS_IMETHODIMP nsPrintSettings::SetFooterStrLeft(const nsAString& aTitle) {
 502   mFooterStrs[0] = aTitle;
 503   return NS_OK;
 504 }
 505
 506 NS_IMETHODIMP nsPrintSettings::GetFooterStrCenter(nsAString& aTitle) {
 507   aTitle = mFooterStrs[1];
 508   return NS_OK;
 509 }
 510 NS_IMETHODIMP nsPrintSettings::SetFooterStrCenter(const nsAString& aTitle) {
 511   mFooterStrs[1] = aTitle;
 512   return NS_OK;
 513 }
 514
 515 NS_IMETHODIMP nsPrintSettings::GetFooterStrRight(nsAString& aTitle) {
 516   aTitle = mFooterStrs[2];
 517   return NS_OK;
 518 }
 519 NS_IMETHODIMP nsPrintSettings::SetFooterStrRight(const nsAString& aTitle) {
 520   mFooterStrs[2] = aTitle;
 521   return NS_OK;
 522 }
 523
 524 NS_IMETHODIMP nsPrintSettings::GetPrintSilent(bool* aPrintSilent) {
 525   NS_ENSURE_ARG_POINTER(aPrintSilent);
 526   *aPrintSilent = mPrintSilent;
 527   return NS_OK;
 528 }
 529 NS_IMETHODIMP nsPrintSettings::SetPrintSilent(bool aPrintSilent) {
 530   mPrintSilent = aPrintSilent;
 531   return NS_OK;
 532 }
 533
 534 NS_IMETHODIMP nsPrintSettings::GetShrinkToFit(bool* aShrinkToFit) {
 535   NS_ENSURE_ARG_POINTER(aShrinkToFit);
 536   *aShrinkToFit = mShrinkToFit;
 537   return NS_OK;
 538 }
 539 NS_IMETHODIMP nsPrintSettings::SetShrinkToFit(bool aShrinkToFit) {
 540   mShrinkToFit = aShrinkToFit;
 541   return NS_OK;
 542 }
 543
 544 NS_IMETHODIMP nsPrintSettings::GetShowMarginGuides(bool* aShowMarginGuides) {
 545   *aShowMarginGuides = mShowMarginGuides;
 546   return NS_OK;
 547 }
 548
 549 NS_IMETHODIMP nsPrintSettings::SetShowMarginGuides(bool aShowMarginGuides) {
 550   mShowMarginGuides = aShowMarginGuides;
 551   return NS_OK;
 552 }
 553
 554 NS_IMETHODIMP nsPrintSettings::GetHonorPageRuleMargins(bool* aResult) {
 555   *aResult = mHonorPageRuleMargins;
 556   return NS_OK;
 557 }
 558
 559 NS_IMETHODIMP nsPrintSettings::SetHonorPageRuleMargins(bool aHonor) {
 560   mHonorPageRuleMargins = aHonor;
 561   return NS_OK;
 562 }
 563
 564 NS_IMETHODIMP nsPrintSettings::GetIsPrintSelectionRBEnabled(
 565     bool* aIsPrintSelectionRBEnabled) {
 566   *aIsPrintSelectionRBEnabled = mIsPrintSelectionRBEnabled;
 567   return NS_OK;
 568 }
 569 NS_IMETHODIMP nsPrintSettings::SetIsPrintSelectionRBEnabled(
 570     bool aIsPrintSelectionRBEnabled) {
 571   mIsPrintSelectionRBEnabled = aIsPrintSelectionRBEnabled;
 572   return NS_OK;
 573 }
 574
 575 NS_IMETHODIMP nsPrintSettings::GetPrintSelectionOnly(bool* aResult) {
 576   *aResult = mPrintSelectionOnly;
 577   return NS_OK;
 578 }
 579
 580 NS_IMETHODIMP nsPrintSettings::SetPrintSelectionOnly(bool aSelectionOnly) {
 581   mPrintSelectionOnly = aSelectionOnly;
 582   return NS_OK;
 583 }
 584
 585 NS_IMETHODIMP nsPrintSettings::GetPaperId(nsAString& aPaperId) {
 586   aPaperId = mPaperId;
 587   return NS_OK;
 588 }
 589 NS_IMETHODIMP nsPrintSettings::SetPaperId(const nsAString& aPaperId) {
 590   mPaperId = aPaperId;
 591   return NS_OK;
 592 }
 593
 594 NS_IMETHODIMP nsPrintSettings::GetIsCancelled(bool* aIsCancelled) {
 595   NS_ENSURE_ARG_POINTER(aIsCancelled);
 596   *aIsCancelled = mIsCancelled;
 597   return NS_OK;
 598 }
 599 NS_IMETHODIMP nsPrintSettings::SetIsCancelled(bool aIsCancelled) {
 600   mIsCancelled = aIsCancelled;
 601   return NS_OK;
 602 }
 603
 604 NS_IMETHODIMP nsPrintSettings::GetSaveOnCancel(bool* aSaveOnCancel) {
 605   *aSaveOnCancel = mSaveOnCancel;
 606   return NS_OK;
 607 }
 608
 609 NS_IMETHODIMP nsPrintSettings::GetPaperWidth(double* aPaperWidth) {
 610   NS_ENSURE_ARG_POINTER(aPaperWidth);
 611   *aPaperWidth = mPaperWidth;
 612   return NS_OK;
 613 }
 614 NS_IMETHODIMP nsPrintSettings::SetPaperWidth(double aPaperWidth) {
 615   mPaperWidth = aPaperWidth;
 616   return NS_OK;
 617 }
 618
 619 NS_IMETHODIMP nsPrintSettings::GetPaperHeight(double* aPaperHeight) {
 620   NS_ENSURE_ARG_POINTER(aPaperHeight);
 621   *aPaperHeight = mPaperHeight;
 622   return NS_OK;
 623 }
 624 NS_IMETHODIMP nsPrintSettings::SetPaperHeight(double aPaperHeight) {
 625   mPaperHeight = aPaperHeight;
 626   return NS_OK;
 627 }
 628
 629 NS_IMETHODIMP nsPrintSettings::GetPaperSizeUnit(int16_t* aPaperSizeUnit) {
 630   NS_ENSURE_ARG_POINTER(aPaperSizeUnit);
 631   *aPaperSizeUnit = mPaperSizeUnit;
 632   return NS_OK;
 633 }
 634 NS_IMETHODIMP nsPrintSettings::SetPaperSizeUnit(int16_t aPaperSizeUnit) {
 635   mPaperSizeUnit = aPaperSizeUnit;
 636   return NS_OK;
 637 }
 638
 639 /** ---------------------------------------------------
 640  *  See documentation in nsPrintSettingsService.h
 641  *      @update 6/21/00 dwc
 642  *      @update 1/12/01 rods
 643  */
 644 NS_IMETHODIMP
 645 nsPrintSettings::SetMarginInTwips(nsIntMargin& aMargin) {
 646   mMargin = aMargin;
 647   return NS_OK;
 648 }
 649
 650 NS_IMETHODIMP
 651 nsPrintSettings::SetEdgeInTwips(nsIntMargin& aEdge) {
 652   mEdge = aEdge;
 653   return NS_OK;
 654 }
 655
 656 // NOTE: Any subclass implementation of this function should make sure
 657 // to check for negative margin values in aUnwriteableMargin (which
 658 // would indicate that we should use the system default unwriteable margin.)
 659 NS_IMETHODIMP
 660 nsPrintSettings::SetUnwriteableMarginInTwips(nsIntMargin& aUnwriteableMargin) {
 661   if (aUnwriteableMargin.top >= 0) {
 662     mUnwriteableMargin.top = aUnwriteableMargin.top;
 663   }
 664   if (aUnwriteableMargin.left >= 0) {
 665     mUnwriteableMargin.left = aUnwriteableMargin.left;
 666   }
 667   if (aUnwriteableMargin.bottom >= 0) {
 668     mUnwriteableMargin.bottom = aUnwriteableMargin.bottom;
 669   }
 670   if (aUnwriteableMargin.right >= 0) {
 671     mUnwriteableMargin.right = aUnwriteableMargin.right;
 672   }
 673   return NS_OK;
 674 }
 675
 676 nsIntMargin nsPrintSettings::GetMarginInTwips() { return mMargin; }
 677
 678 nsIntMargin nsPrintSettings::GetEdgeInTwips() { return mEdge; }
 679
 680 nsIntMargin nsPrintSettings::GetUnwriteableMarginInTwips() {
 681   return mUnwriteableMargin;
 682 }
 683
 684 /** ---------------------------------------------------
 685  *  See documentation in nsPrintSettingsService.h
 686  */
 687 NS_IMETHODIMP
 688 nsPrintSettings::GetEffectivePageSize(double* aWidth, double* aHeight) {
 689   if (mPaperSizeUnit == kPaperSizeInches) {
 690     *aWidth = NS_INCHES_TO_TWIPS(float(mPaperWidth));
 691     *aHeight = NS_INCHES_TO_TWIPS(float(mPaperHeight));
 692   } else {
 693     MOZ_ASSERT(mPaperSizeUnit == kPaperSizeMillimeters,
 694                "unexpected paper size unit");
 695     *aWidth = NS_MILLIMETERS_TO_TWIPS(float(mPaperWidth));
 696     *aHeight = NS_MILLIMETERS_TO_TWIPS(float(mPaperHeight));
 697   }
 698   if (kLandscapeOrientation == mOrientation) {
 699     double temp = *aWidth;
 700     *aWidth = *aHeight;
 701     *aHeight = temp;
 702   }
 703   return NS_OK;
 704 }
 705
 706 bool nsPrintSettings::HasOrthogonalSheetsAndPages() {
 707   return mNumPagesPerSheet == 2 || mNumPagesPerSheet == 6;
 708 }
 709
 710 void nsPrintSettings::GetEffectiveSheetSize(double* aWidth, double* aHeight) {
 711   mozilla::DebugOnly<nsresult> rv = GetEffectivePageSize(aWidth, aHeight);
 712
 713   // Our GetEffectivePageSize impls only return NS_OK, so this should hold:
 714   MOZ_ASSERT(NS_SUCCEEDED(rv), "Uh oh, GetEffectivePageSize failed");
 715
 716   if (HasOrthogonalSheetsAndPages()) {
 717     std::swap(*aWidth, *aHeight);
 718   }
 719 }
 720
 721 int32_t nsPrintSettings::GetSheetOrientation() {
 722   if (HasOrthogonalSheetsAndPages()) {
 723     // Sheet orientation is rotated with respect to the page orientation.
 724     return kLandscapeOrientation == mOrientation ? kPortraitOrientation
 725                                                  : kLandscapeOrientation;
 726   }
 727
 728   // Sheet orientation is the same as the page orientation.
 729   return mOrientation;
 730 }
 731
 732 NS_IMETHODIMP
 733 nsPrintSettings::SetPageRanges(const nsTArray<int32_t>& aPages) {
 734   // Needs to be a set of (start, end) pairs.
 735   if (aPages.Length() % 2 != 0) {
 736     return NS_ERROR_FAILURE;
 737   }
 738   mPageRanges = aPages.Clone();
 739   return NS_OK;
 740 }
 741
 742 NS_IMETHODIMP
 743 nsPrintSettings::GetPageRanges(nsTArray<int32_t>& aPages) {
 744   aPages = mPageRanges.Clone();
 745   return NS_OK;
 746 }
 747
 748 bool nsIPrintSettings::IsPageSkipped(int32_t aPageNum,
 749                                      const nsTArray<int32_t>& aRanges) {
 750   MOZ_RELEASE_ASSERT(aRanges.Length() % 2 == 0);
 751   if (aRanges.IsEmpty()) {
 752     return false;
 753   }
 754   for (size_t i = 0; i < aRanges.Length(); i += 2) {
 755     if (aRanges[i] <= aPageNum && aPageNum <= aRanges[i + 1]) {
 756       // The page is included in this piece of the custom range,
 757       // so it's not skipped.
 758       return false;
 759     }
 760   }
 761   return true;
 762 }
 763
 764 nsresult nsPrintSettings::_Clone(nsIPrintSettings** _retval) {
 765   RefPtr<nsPrintSettings> printSettings = new nsPrintSettings(*this);
 766   printSettings.forget(_retval);
 767   return NS_OK;
 768 }
 769
 770 NS_IMETHODIMP
 771 nsPrintSettings::Clone(nsIPrintSettings** _retval) {
 772   NS_ENSURE_ARG_POINTER(_retval);
 773   return _Clone(_retval);
 774 }
 775
 776 nsresult nsPrintSettings::_Assign(nsIPrintSettings* aPS) {
 777   nsPrintSettings* ps = static_cast<nsPrintSettings*>(aPS);
 778   *this = *ps;
 779   return NS_OK;
 780 }
 781
 782 nsresult nsPrintSettings::EquivalentTo(nsIPrintSettings* aPrintSettings,
 783                                        bool* _retval) {
 784   MOZ_ASSERT(aPrintSettings);
 785   *_retval = false;
 786   auto* other = static_cast<nsPrintSettings*>(aPrintSettings);
 787   if (GetMarginInTwips() != aPrintSettings->GetMarginInTwips()) {
 788     return NS_OK;
 789   }
 790   if (GetEdgeInTwips() != aPrintSettings->GetEdgeInTwips()) {
 791     return NS_OK;
 792   }
 793   if (GetUnwriteableMarginInTwips() !=
 794       aPrintSettings->GetUnwriteableMarginInTwips()) {
 795     return NS_OK;
 796   }
 797   nsTArray<int32_t> ourPageRanges, otherPageRanges;
 798   if (NS_FAILED(GetPageRanges(ourPageRanges)) ||
 799       NS_FAILED(aPrintSettings->GetPageRanges(otherPageRanges)) ||
 800       ourPageRanges != otherPageRanges) {
 801     return NS_OK;
 802   }
 803   double ourScaling, otherScaling;
 804   if (NS_FAILED(GetScaling(&ourScaling)) ||
 805       NS_FAILED(aPrintSettings->GetScaling(&otherScaling)) ||
 806       ourScaling != otherScaling) {
 807     return NS_OK;
 808   }
 809   if (GetPrintBGColors() != aPrintSettings->GetPrintBGColors()) {
 810     return NS_OK;
 811   }
 812   if (GetPrintBGImages() != aPrintSettings->GetPrintBGImages()) {
 813     return NS_OK;
 814   }
 815   if (GetPrintSelectionOnly() != aPrintSettings->GetPrintSelectionOnly()) {
 816     return NS_OK;
 817   }
 818   if (GetShrinkToFit() != aPrintSettings->GetShrinkToFit()) {
 819     return NS_OK;
 820   }
 821   if (GetShowMarginGuides() != aPrintSettings->GetShowMarginGuides()) {
 822     return NS_OK;
 823   }
 824   if (GetHonorPageRuleMargins() != aPrintSettings->GetHonorPageRuleMargins()) {
 825     return NS_OK;
 826   }
 827   nsAutoString ourTitle, otherTitle;
 828   if (NS_FAILED(GetTitle(ourTitle)) ||
 829       NS_FAILED(aPrintSettings->GetTitle(otherTitle)) ||
 830       ourTitle != otherTitle) {
 831     return NS_OK;
 832   }
 833   nsAutoString ourUrl, otherUrl;
 834   if (NS_FAILED(GetDocURL(ourUrl)) ||
 835       NS_FAILED(aPrintSettings->GetDocURL(otherUrl)) || ourUrl != otherUrl) {
 836     return NS_OK;
 837   }
 838   if (!mozilla::ArrayEqual(mHeaderStrs, other->mHeaderStrs) ||
 839       !mozilla::ArrayEqual(mFooterStrs, other->mFooterStrs)) {
 840     return NS_OK;
 841   }
 842   nsAutoString ourPaperId, otherPaperId;
 843   if (NS_FAILED(GetPaperId(ourPaperId)) ||
 844       NS_FAILED(aPrintSettings->GetPaperId(otherPaperId)) ||
 845       ourPaperId != otherPaperId) {
 846     return NS_OK;
 847   }
 848   double ourWidth, ourHeight, otherWidth, otherHeight;
 849   if (NS_FAILED(GetEffectivePageSize(&ourWidth, &ourHeight)) ||
 850       NS_FAILED(other->GetEffectivePageSize(&otherWidth, &otherHeight)) ||
 851       std::abs(ourWidth - otherWidth) >= 1 ||
 852       std::abs(ourHeight - otherHeight) >= 1) {
 853     return NS_OK;
 854   }
 855   int32_t ourOrientation, otherOrientation;
 856   if (NS_FAILED(GetOrientation(&ourOrientation)) ||
 857       NS_FAILED(aPrintSettings->GetOrientation(&otherOrientation)) ||
 858       ourOrientation != otherOrientation) {
 859     return NS_OK;
 860   }
 861   int32_t ourResolution, otherResolution;
 862   if (NS_FAILED(GetResolution(&ourResolution)) ||
 863       NS_FAILED(aPrintSettings->GetResolution(&otherResolution)) ||
 864       ourResolution != otherResolution) {
 865     return NS_OK;
 866   }
 867   int32_t ourNumPagesPerSheet, otherNumPagesPerSheet;
 868   if (NS_FAILED(GetNumPagesPerSheet(&ourNumPagesPerSheet)) ||
 869       NS_FAILED(aPrintSettings->GetNumPagesPerSheet(&otherNumPagesPerSheet)) ||
 870       ourNumPagesPerSheet != otherNumPagesPerSheet) {
 871     return NS_OK;
 872   }
 873
 874   *_retval = true;
 875   return NS_OK;
 876 }
 877
 878 mozilla::PrintSettingsInitializer nsPrintSettings::GetSettingsInitializer() {
 879   mozilla::PrintSettingsInitializer settingsInitializer;
 880   settingsInitializer.mPrinter.Assign(mPrinter);
 881   settingsInitializer.mPaperInfo.mId = mPaperId;
 882
 883   double pointsPerSizeUnit =
 884       mPaperSizeUnit == kPaperSizeInches ? 72.0 : 72.0 / 25.4;
 885   settingsInitializer.mPaperInfo.mSize = {mPaperWidth * pointsPerSizeUnit,
 886                                           mPaperHeight * pointsPerSizeUnit};
 887
 888   // Unwritable margins are stored in TWIPS here and points in PaperInfo.
 889   settingsInitializer.mPaperInfo.mUnwriteableMargin =
 890       Some(mozilla::gfx::MarginDouble(
 891           mUnwriteableMargin.top / 20.0, mUnwriteableMargin.right / 20.0,
 892           mUnwriteableMargin.bottom / 20.0, mUnwriteableMargin.left / 20.0));
 893
 894   settingsInitializer.mPrintInColor = mPrintInColor;
 895   settingsInitializer.mResolution = mResolution;
 896   settingsInitializer.mSheetOrientation = GetSheetOrientation();
 897   settingsInitializer.mNumCopies = mNumCopies;
 898   settingsInitializer.mDuplex = mDuplex;
 899   RefPtr<nsIPrintSettings> settingsToInitialize;
 900   MOZ_ALWAYS_SUCCEEDS(Clone(getter_AddRefs(settingsToInitialize)));
 901   settingsInitializer.mPrintSettings =
 902       new nsMainThreadPtrHolder<nsPrintSettings>(
 903           "PrintSettingsInitializer::mPrintSettings",
 904           settingsToInitialize.forget().downcast<nsPrintSettings>());
 905   return settingsInitializer;
 906 }
 907
 908 NS_IMETHODIMP
 909 nsPrintSettings::Assign(nsIPrintSettings* aPS) {
 910   NS_ENSURE_ARG(aPS);
 911   return _Assign(aPS);
 912 }
 913
 914 //-------------------------------------------
 915 nsPrintSettings& nsPrintSettings::operator=(const nsPrintSettings& rhs) {
 916   if (this == &rhs) {
 917     return *this;
 918   }
 919
 920   mPageRanges = rhs.mPageRanges.Clone();
 921   mMargin = rhs.mMargin;
 922   mEdge = rhs.mEdge;
 923   mUnwriteableMargin = rhs.mUnwriteableMargin;
 924   mScaling = rhs.mScaling;
 925   mPrintBGColors = rhs.mPrintBGColors;
 926   mPrintBGImages = rhs.mPrintBGImages;
 927   mTitle = rhs.mTitle;
 928   mURL = rhs.mURL;
 929   mIsCancelled = rhs.mIsCancelled;
 930   mSaveOnCancel = rhs.mSaveOnCancel;
 931   mPrintSilent = rhs.mPrintSilent;
 932   mShrinkToFit = rhs.mShrinkToFit;
 933   mShowMarginGuides = rhs.mShowMarginGuides;
 934   mHonorPageRuleMargins = rhs.mHonorPageRuleMargins;
 935   mIsPrintSelectionRBEnabled = rhs.mIsPrintSelectionRBEnabled;
 936   mPrintSelectionOnly = rhs.mPrintSelectionOnly;
 937   mPaperId = rhs.mPaperId;
 938   mPaperWidth = rhs.mPaperWidth;
 939   mPaperHeight = rhs.mPaperHeight;
 940   mPaperSizeUnit = rhs.mPaperSizeUnit;
 941   mPrintReversed = rhs.mPrintReversed;
 942   mPrintInColor = rhs.mPrintInColor;
 943   mOrientation = rhs.mOrientation;
 944   mResolution = rhs.mResolution;
 945   mDuplex = rhs.mDuplex;
 946   mNumCopies = rhs.mNumCopies;
 947   mNumPagesPerSheet = rhs.mNumPagesPerSheet;
 948   mPrinter = rhs.mPrinter;
 949   mPrintToFile = rhs.mPrintToFile;
 950   mToFileName = rhs.mToFileName;
 951   mOutputFormat = rhs.mOutputFormat;
 952   mIsInitedFromPrinter = rhs.mIsInitedFromPrinter;
 953   mIsInitedFromPrefs = rhs.mIsInitedFromPrefs;
 954   mPrintPageDelay = rhs.mPrintPageDelay;
 955
 956   for (int32_t i = 0; i < NUM_HEAD_FOOT; i++) {
 957     mHeaderStrs[i] = rhs.mHeaderStrs[i];
 958     mFooterStrs[i] = rhs.mFooterStrs[i];
 959   }
 960
 961   return *this;
 962 }
 963
 964 void nsPrintSettings::SetDefaultFileName() {
 965   nsAutoString filename;
 966   nsresult rv = GetToFileName(filename);
 967   if (NS_FAILED(rv) || filename.IsEmpty()) {
 968     const char* path = PR_GetEnv("PWD");
 969     if (!path) {
 970       path = PR_GetEnv("HOME");
 971     }
 972
 973     if (path) {
 974       CopyUTF8toUTF16(mozilla::MakeStringSpan(path), filename);
 975       filename.AppendLiteral("/mozilla.pdf");
 976     } else {
 977       filename.AssignLiteral("mozilla.pdf");
 978     }
 979
 980     SetToFileName(filename);
 981   }
 982 }