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