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 #include "nsReadableUtils.h"
   8 #include "nsIPrintSession.h"
   9 #include "mozilla/RefPtr.h"
  10
  11 #define DEFAULT_MARGIN_WIDTH 0.5
  12
  13 NS_IMPL_ISUPPORTS(nsPrintSettings, nsIPrintSettings)
  14
  15 nsPrintSettings::nsPrintSettings()
  16     : mPrintOptions(0L),
  17       mPrintRange(kRangeAllPages),
  18       mStartPageNum(1),
  19       mEndPageNum(1),
  20       mScaling(1.0),
  21       mPrintBGColors(false),
  22       mPrintBGImages(false),
  23       mPrintFrameTypeUsage(kUseInternalDefault),
  24       mPrintFrameType(kFramesAsIs),
  25       mHowToEnableFrameUI(kFrameEnableNone),
  26       mIsCancelled(false),
  27       mPrintSilent(false),
  28       mPrintPreview(false),
  29       mShrinkToFit(true),
  30       mShowPrintProgress(true),
  31       mPrintPageDelay(50),
  32       mPaperData(0),
  33       mPaperWidth(8.5),
  34       mPaperHeight(11.0),
  35       mPaperSizeUnit(kPaperSizeInches),
  36       mPrintReversed(false),
  37       mPrintInColor(true),
  38       mOrientation(kPortraitOrientation),
  39       mResolution(0),
  40       mDuplex(0),
  41       mNumCopies(1),
  42       mPrintToFile(false),
  43       mOutputFormat(kOutputFormatNative),
  44       mIsInitedFromPrinter(false),
  45       mIsInitedFromPrefs(false) {
  46   /* member initializers and constructor code */
  47   int32_t marginWidth = NS_INCHES_TO_INT_TWIPS(DEFAULT_MARGIN_WIDTH);
  48   mMargin.SizeTo(marginWidth, marginWidth, marginWidth, marginWidth);
  49   mEdge.SizeTo(0, 0, 0, 0);
  50   mUnwriteableMargin.SizeTo(0, 0, 0, 0);
  51
  52   mPrintOptions = kPrintOddPages | kPrintEvenPages;
  53
  54   mHeaderStrs[0].AssignLiteral("&T");
  55   mHeaderStrs[2].AssignLiteral("&U");
  56
  57   mFooterStrs[0].AssignLiteral(
  58       "&PT");  // Use &P (Page Num Only) or &PT (Page Num of Page Total)
  59   mFooterStrs[2].AssignLiteral("&D");
  60 }
  61
  62 nsPrintSettings::nsPrintSettings(const nsPrintSettings &aPS) { *this = aPS; }
  63
  64 nsPrintSettings::~nsPrintSettings() {}
  65
  66 NS_IMETHODIMP nsPrintSettings::GetPrintSession(
  67     nsIPrintSession **aPrintSession) {
  68   NS_ENSURE_ARG_POINTER(aPrintSession);
  69   *aPrintSession = nullptr;
  70
  71   nsCOMPtr<nsIPrintSession> session = do_QueryReferent(mSession);
  72   if (!session) return NS_ERROR_NOT_INITIALIZED;
  73   *aPrintSession = session;
  74   NS_ADDREF(*aPrintSession);
  75   return NS_OK;
  76 }
  77 NS_IMETHODIMP nsPrintSettings::SetPrintSession(nsIPrintSession *aPrintSession) {
  78   // Clearing it by passing nullptr is not allowed. That's why we
  79   // use a weak ref so that it doesn't have to be cleared.
  80   NS_ENSURE_ARG(aPrintSession);
  81
  82   mSession = do_GetWeakReference(aPrintSession);
  83   if (!mSession) {
  84     // This may happen if the implementation of this object does
  85     // not support weak references - programmer error.
  86     NS_ERROR("Could not get a weak reference from aPrintSession");
  87     return NS_ERROR_FAILURE;
  88   }
  89   return NS_OK;
  90 }
  91
  92 NS_IMETHODIMP nsPrintSettings::GetStartPageRange(int32_t *aStartPageRange) {
  93   // NS_ENSURE_ARG_POINTER(aStartPageRange);
  94   *aStartPageRange = mStartPageNum;
  95   return NS_OK;
  96 }
  97 NS_IMETHODIMP nsPrintSettings::SetStartPageRange(int32_t aStartPageRange) {
  98   mStartPageNum = aStartPageRange;
  99   return NS_OK;
 100 }
 101
 102 NS_IMETHODIMP nsPrintSettings::GetEndPageRange(int32_t *aEndPageRange) {
 103   // NS_ENSURE_ARG_POINTER(aEndPageRange);
 104   *aEndPageRange = mEndPageNum;
 105   return NS_OK;
 106 }
 107 NS_IMETHODIMP nsPrintSettings::SetEndPageRange(int32_t aEndPageRange) {
 108   mEndPageNum = aEndPageRange;
 109   return NS_OK;
 110 }
 111
 112 NS_IMETHODIMP nsPrintSettings::GetPrintReversed(bool *aPrintReversed) {
 113   // NS_ENSURE_ARG_POINTER(aPrintReversed);
 114   *aPrintReversed = mPrintReversed;
 115   return NS_OK;
 116 }
 117 NS_IMETHODIMP nsPrintSettings::SetPrintReversed(bool aPrintReversed) {
 118   mPrintReversed = aPrintReversed;
 119   return NS_OK;
 120 }
 121
 122 NS_IMETHODIMP nsPrintSettings::GetPrintInColor(bool *aPrintInColor) {
 123   // NS_ENSURE_ARG_POINTER(aPrintInColor);
 124   *aPrintInColor = mPrintInColor;
 125   return NS_OK;
 126 }
 127 NS_IMETHODIMP nsPrintSettings::SetPrintInColor(bool aPrintInColor) {
 128   mPrintInColor = aPrintInColor;
 129   return NS_OK;
 130 }
 131
 132 NS_IMETHODIMP nsPrintSettings::GetOrientation(int32_t *aOrientation) {
 133   NS_ENSURE_ARG_POINTER(aOrientation);
 134   *aOrientation = mOrientation;
 135   return NS_OK;
 136 }
 137 NS_IMETHODIMP nsPrintSettings::SetOrientation(int32_t aOrientation) {
 138   mOrientation = aOrientation;
 139   return NS_OK;
 140 }
 141
 142 NS_IMETHODIMP nsPrintSettings::GetResolution(int32_t *aResolution) {
 143   NS_ENSURE_ARG_POINTER(aResolution);
 144   *aResolution = mResolution;
 145   return NS_OK;
 146 }
 147 NS_IMETHODIMP nsPrintSettings::SetResolution(const int32_t aResolution) {
 148   mResolution = aResolution;
 149   return NS_OK;
 150 }
 151
 152 NS_IMETHODIMP nsPrintSettings::GetDuplex(int32_t *aDuplex) {
 153   NS_ENSURE_ARG_POINTER(aDuplex);
 154   *aDuplex = mDuplex;
 155   return NS_OK;
 156 }
 157 NS_IMETHODIMP nsPrintSettings::SetDuplex(const int32_t aDuplex) {
 158   mDuplex = aDuplex;
 159   return NS_OK;
 160 }
 161
 162 NS_IMETHODIMP nsPrintSettings::GetPrinterName(nsAString &aPrinter) {
 163   aPrinter = mPrinter;
 164   return NS_OK;
 165 }
 166
 167 NS_IMETHODIMP nsPrintSettings::SetPrinterName(const nsAString &aPrinter) {
 168   if (!mPrinter.Equals(aPrinter)) {
 169     mIsInitedFromPrinter = false;
 170     mIsInitedFromPrefs = false;
 171   }
 172
 173   mPrinter.Assign(aPrinter);
 174   return NS_OK;
 175 }
 176
 177 NS_IMETHODIMP nsPrintSettings::GetNumCopies(int32_t *aNumCopies) {
 178   NS_ENSURE_ARG_POINTER(aNumCopies);
 179   *aNumCopies = mNumCopies;
 180   return NS_OK;
 181 }
 182 NS_IMETHODIMP nsPrintSettings::SetNumCopies(int32_t aNumCopies) {
 183   mNumCopies = aNumCopies;
 184   return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP nsPrintSettings::GetPrintToFile(bool *aPrintToFile) {
 188   // NS_ENSURE_ARG_POINTER(aPrintToFile);
 189   *aPrintToFile = mPrintToFile;
 190   return NS_OK;
 191 }
 192 NS_IMETHODIMP nsPrintSettings::SetPrintToFile(bool aPrintToFile) {
 193   mPrintToFile = aPrintToFile;
 194   return NS_OK;
 195 }
 196
 197 NS_IMETHODIMP nsPrintSettings::GetToFileName(nsAString &aToFileName) {
 198   aToFileName = mToFileName;
 199   return NS_OK;
 200 }
 201 NS_IMETHODIMP nsPrintSettings::SetToFileName(const nsAString &aToFileName) {
 202   mToFileName = aToFileName;
 203   return NS_OK;
 204 }
 205
 206 NS_IMETHODIMP nsPrintSettings::GetOutputFormat(int16_t *aOutputFormat) {
 207   NS_ENSURE_ARG_POINTER(aOutputFormat);
 208   *aOutputFormat = mOutputFormat;
 209   return NS_OK;
 210 }
 211 NS_IMETHODIMP nsPrintSettings::SetOutputFormat(int16_t aOutputFormat) {
 212   mOutputFormat = aOutputFormat;
 213   return NS_OK;
 214 }
 215
 216 NS_IMETHODIMP nsPrintSettings::GetPrintPageDelay(int32_t *aPrintPageDelay) {
 217   *aPrintPageDelay = mPrintPageDelay;
 218   return NS_OK;
 219 }
 220 NS_IMETHODIMP nsPrintSettings::SetPrintPageDelay(int32_t aPrintPageDelay) {
 221   mPrintPageDelay = aPrintPageDelay;
 222   return NS_OK;
 223 }
 224
 225 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrinter(
 226     bool *aIsInitializedFromPrinter) {
 227   NS_ENSURE_ARG_POINTER(aIsInitializedFromPrinter);
 228   *aIsInitializedFromPrinter = (bool)mIsInitedFromPrinter;
 229   return NS_OK;
 230 }
 231 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrinter(
 232     bool aIsInitializedFromPrinter) {
 233   mIsInitedFromPrinter = (bool)aIsInitializedFromPrinter;
 234   return NS_OK;
 235 }
 236
 237 NS_IMETHODIMP nsPrintSettings::GetIsInitializedFromPrefs(
 238     bool *aInitializedFromPrefs) {
 239   NS_ENSURE_ARG_POINTER(aInitializedFromPrefs);
 240   *aInitializedFromPrefs = (bool)mIsInitedFromPrefs;
 241   return NS_OK;
 242 }
 243 NS_IMETHODIMP nsPrintSettings::SetIsInitializedFromPrefs(
 244     bool aInitializedFromPrefs) {
 245   mIsInitedFromPrefs = (bool)aInitializedFromPrefs;
 246   return NS_OK;
 247 }
 248
 249 NS_IMETHODIMP nsPrintSettings::GetMarginTop(double *aMarginTop) {
 250   NS_ENSURE_ARG_POINTER(aMarginTop);
 251   *aMarginTop = NS_TWIPS_TO_INCHES(mMargin.top);
 252   return NS_OK;
 253 }
 254 NS_IMETHODIMP nsPrintSettings::SetMarginTop(double aMarginTop) {
 255   mMargin.top = NS_INCHES_TO_INT_TWIPS(float(aMarginTop));
 256   return NS_OK;
 257 }
 258
 259 NS_IMETHODIMP nsPrintSettings::GetMarginLeft(double *aMarginLeft) {
 260   NS_ENSURE_ARG_POINTER(aMarginLeft);
 261   *aMarginLeft = NS_TWIPS_TO_INCHES(mMargin.left);
 262   return NS_OK;
 263 }
 264 NS_IMETHODIMP nsPrintSettings::SetMarginLeft(double aMarginLeft) {
 265   mMargin.left = NS_INCHES_TO_INT_TWIPS(float(aMarginLeft));
 266   return NS_OK;
 267 }
 268
 269 NS_IMETHODIMP nsPrintSettings::GetMarginBottom(double *aMarginBottom) {
 270   NS_ENSURE_ARG_POINTER(aMarginBottom);
 271   *aMarginBottom = NS_TWIPS_TO_INCHES(mMargin.bottom);
 272   return NS_OK;
 273 }
 274 NS_IMETHODIMP nsPrintSettings::SetMarginBottom(double aMarginBottom) {
 275   mMargin.bottom = NS_INCHES_TO_INT_TWIPS(float(aMarginBottom));
 276   return NS_OK;
 277 }
 278
 279 NS_IMETHODIMP nsPrintSettings::GetMarginRight(double *aMarginRight) {
 280   NS_ENSURE_ARG_POINTER(aMarginRight);
 281   *aMarginRight = NS_TWIPS_TO_INCHES(mMargin.right);
 282   return NS_OK;
 283 }
 284 NS_IMETHODIMP nsPrintSettings::SetMarginRight(double aMarginRight) {
 285   mMargin.right = NS_INCHES_TO_INT_TWIPS(float(aMarginRight));
 286   return NS_OK;
 287 }
 288
 289 NS_IMETHODIMP nsPrintSettings::GetEdgeTop(double *aEdgeTop) {
 290   NS_ENSURE_ARG_POINTER(aEdgeTop);
 291   *aEdgeTop = NS_TWIPS_TO_INCHES(mEdge.top);
 292   return NS_OK;
 293 }
 294 NS_IMETHODIMP nsPrintSettings::SetEdgeTop(double aEdgeTop) {
 295   mEdge.top = NS_INCHES_TO_INT_TWIPS(float(aEdgeTop));
 296   return NS_OK;
 297 }
 298
 299 NS_IMETHODIMP nsPrintSettings::GetEdgeLeft(double *aEdgeLeft) {
 300   NS_ENSURE_ARG_POINTER(aEdgeLeft);
 301   *aEdgeLeft = NS_TWIPS_TO_INCHES(mEdge.left);
 302   return NS_OK;
 303 }
 304 NS_IMETHODIMP nsPrintSettings::SetEdgeLeft(double aEdgeLeft) {
 305   mEdge.left = NS_INCHES_TO_INT_TWIPS(float(aEdgeLeft));
 306   return NS_OK;
 307 }
 308
 309 NS_IMETHODIMP nsPrintSettings::GetEdgeBottom(double *aEdgeBottom) {
 310   NS_ENSURE_ARG_POINTER(aEdgeBottom);
 311   *aEdgeBottom = NS_TWIPS_TO_INCHES(mEdge.bottom);
 312   return NS_OK;
 313 }
 314 NS_IMETHODIMP nsPrintSettings::SetEdgeBottom(double aEdgeBottom) {
 315   mEdge.bottom = NS_INCHES_TO_INT_TWIPS(float(aEdgeBottom));
 316   return NS_OK;
 317 }
 318
 319 NS_IMETHODIMP nsPrintSettings::GetEdgeRight(double *aEdgeRight) {
 320   NS_ENSURE_ARG_POINTER(aEdgeRight);
 321   *aEdgeRight = NS_TWIPS_TO_INCHES(mEdge.right);
 322   return NS_OK;
 323 }
 324 NS_IMETHODIMP nsPrintSettings::SetEdgeRight(double aEdgeRight) {
 325   mEdge.right = NS_INCHES_TO_INT_TWIPS(float(aEdgeRight));
 326   return NS_OK;
 327 }
 328
 329 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginTop(
 330     double *aUnwriteableMarginTop) {
 331   NS_ENSURE_ARG_POINTER(aUnwriteableMarginTop);
 332   *aUnwriteableMarginTop = NS_TWIPS_TO_INCHES(mUnwriteableMargin.top);
 333   return NS_OK;
 334 }
 335 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginTop(
 336     double aUnwriteableMarginTop) {
 337   if (aUnwriteableMarginTop >= 0.0) {
 338     mUnwriteableMargin.top = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginTop);
 339   }
 340   return NS_OK;
 341 }
 342
 343 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginLeft(
 344     double *aUnwriteableMarginLeft) {
 345   NS_ENSURE_ARG_POINTER(aUnwriteableMarginLeft);
 346   *aUnwriteableMarginLeft = NS_TWIPS_TO_INCHES(mUnwriteableMargin.left);
 347   return NS_OK;
 348 }
 349 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginLeft(
 350     double aUnwriteableMarginLeft) {
 351   if (aUnwriteableMarginLeft >= 0.0) {
 352     mUnwriteableMargin.left = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginLeft);
 353   }
 354   return NS_OK;
 355 }
 356
 357 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginBottom(
 358     double *aUnwriteableMarginBottom) {
 359   NS_ENSURE_ARG_POINTER(aUnwriteableMarginBottom);
 360   *aUnwriteableMarginBottom = NS_TWIPS_TO_INCHES(mUnwriteableMargin.bottom);
 361   return NS_OK;
 362 }
 363 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginBottom(
 364     double aUnwriteableMarginBottom) {
 365   if (aUnwriteableMarginBottom >= 0.0) {
 366     mUnwriteableMargin.bottom =
 367         NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginBottom);
 368   }
 369   return NS_OK;
 370 }
 371
 372 NS_IMETHODIMP nsPrintSettings::GetUnwriteableMarginRight(
 373     double *aUnwriteableMarginRight) {
 374   NS_ENSURE_ARG_POINTER(aUnwriteableMarginRight);
 375   *aUnwriteableMarginRight = NS_TWIPS_TO_INCHES(mUnwriteableMargin.right);
 376   return NS_OK;
 377 }
 378 NS_IMETHODIMP nsPrintSettings::SetUnwriteableMarginRight(
 379     double aUnwriteableMarginRight) {
 380   if (aUnwriteableMarginRight >= 0.0) {
 381     mUnwriteableMargin.right = NS_INCHES_TO_INT_TWIPS(aUnwriteableMarginRight);
 382   }
 383   return NS_OK;
 384 }
 385
 386 NS_IMETHODIMP nsPrintSettings::GetScaling(double *aScaling) {
 387   NS_ENSURE_ARG_POINTER(aScaling);
 388   *aScaling = mScaling;
 389   return NS_OK;
 390 }
 391
 392 NS_IMETHODIMP nsPrintSettings::SetScaling(double aScaling) {
 393   mScaling = aScaling;
 394   return NS_OK;
 395 }
 396
 397 NS_IMETHODIMP nsPrintSettings::GetPrintBGColors(bool *aPrintBGColors) {
 398   NS_ENSURE_ARG_POINTER(aPrintBGColors);
 399   *aPrintBGColors = mPrintBGColors;
 400   return NS_OK;
 401 }
 402 NS_IMETHODIMP nsPrintSettings::SetPrintBGColors(bool aPrintBGColors) {
 403   mPrintBGColors = aPrintBGColors;
 404   return NS_OK;
 405 }
 406
 407 NS_IMETHODIMP nsPrintSettings::GetPrintBGImages(bool *aPrintBGImages) {
 408   NS_ENSURE_ARG_POINTER(aPrintBGImages);
 409   *aPrintBGImages = mPrintBGImages;
 410   return NS_OK;
 411 }
 412 NS_IMETHODIMP nsPrintSettings::SetPrintBGImages(bool aPrintBGImages) {
 413   mPrintBGImages = aPrintBGImages;
 414   return NS_OK;
 415 }
 416
 417 NS_IMETHODIMP nsPrintSettings::GetPrintRange(int16_t *aPrintRange) {
 418   NS_ENSURE_ARG_POINTER(aPrintRange);
 419   *aPrintRange = mPrintRange;
 420   return NS_OK;
 421 }
 422 NS_IMETHODIMP nsPrintSettings::SetPrintRange(int16_t aPrintRange) {
 423   mPrintRange = aPrintRange;
 424   return NS_OK;
 425 }
 426
 427 NS_IMETHODIMP nsPrintSettings::GetTitle(nsAString &aTitle) {
 428   aTitle = mTitle;
 429   return NS_OK;
 430 }
 431 NS_IMETHODIMP nsPrintSettings::SetTitle(const nsAString &aTitle) {
 432   mTitle = aTitle;
 433   return NS_OK;
 434 }
 435
 436 NS_IMETHODIMP nsPrintSettings::GetDocURL(nsAString &aDocURL) {
 437   aDocURL = mURL;
 438   return NS_OK;
 439 }
 440 NS_IMETHODIMP nsPrintSettings::SetDocURL(const nsAString &aDocURL) {
 441   mURL = aDocURL;
 442   return NS_OK;
 443 }
 444
 445 /** ---------------------------------------------------
 446  *  See documentation in nsPrintSettingsImpl.h
 447  *      @update 1/12/01 rods
 448  */
 449 NS_IMETHODIMP
 450 nsPrintSettings::GetPrintOptions(int32_t aType, bool *aTurnOnOff) {
 451   NS_ENSURE_ARG_POINTER(aTurnOnOff);
 452   *aTurnOnOff = mPrintOptions & aType ? true : false;
 453   return NS_OK;
 454 }
 455 /** ---------------------------------------------------
 456  *  See documentation in nsPrintSettingsImpl.h
 457  *      @update 1/12/01 rods
 458  */
 459 NS_IMETHODIMP
 460 nsPrintSettings::SetPrintOptions(int32_t aType, bool aTurnOnOff) {
 461   if (aTurnOnOff) {
 462     mPrintOptions |= aType;
 463   } else {
 464     mPrintOptions &= ~aType;
 465   }
 466   return NS_OK;
 467 }
 468
 469 /** ---------------------------------------------------
 470  *  See documentation in nsPrintSettingsImpl.h
 471  *      @update 1/12/01 rods
 472  */
 473 NS_IMETHODIMP
 474 nsPrintSettings::GetPrintOptionsBits(int32_t *aBits) {
 475   NS_ENSURE_ARG_POINTER(aBits);
 476   *aBits = mPrintOptions;
 477   return NS_OK;
 478 }
 479
 480 NS_IMETHODIMP
 481 nsPrintSettings::SetPrintOptionsBits(int32_t aBits) {
 482   mPrintOptions = aBits;
 483   return NS_OK;
 484 }
 485
 486 NS_IMETHODIMP nsPrintSettings::GetHeaderStrLeft(nsAString &aTitle) {
 487   aTitle = mHeaderStrs[0];
 488   return NS_OK;
 489 }
 490 NS_IMETHODIMP nsPrintSettings::SetHeaderStrLeft(const nsAString &aTitle) {
 491   mHeaderStrs[0] = aTitle;
 492   return NS_OK;
 493 }
 494
 495 NS_IMETHODIMP nsPrintSettings::GetHeaderStrCenter(nsAString &aTitle) {
 496   aTitle = mHeaderStrs[1];
 497   return NS_OK;
 498 }
 499 NS_IMETHODIMP nsPrintSettings::SetHeaderStrCenter(const nsAString &aTitle) {
 500   mHeaderStrs[1] = aTitle;
 501   return NS_OK;
 502 }
 503
 504 NS_IMETHODIMP nsPrintSettings::GetHeaderStrRight(nsAString &aTitle) {
 505   aTitle = mHeaderStrs[2];
 506   return NS_OK;
 507 }
 508 NS_IMETHODIMP nsPrintSettings::SetHeaderStrRight(const nsAString &aTitle) {
 509   mHeaderStrs[2] = aTitle;
 510   return NS_OK;
 511 }
 512
 513 NS_IMETHODIMP nsPrintSettings::GetFooterStrLeft(nsAString &aTitle) {
 514   aTitle = mFooterStrs[0];
 515   return NS_OK;
 516 }
 517 NS_IMETHODIMP nsPrintSettings::SetFooterStrLeft(const nsAString &aTitle) {
 518   mFooterStrs[0] = aTitle;
 519   return NS_OK;
 520 }
 521
 522 NS_IMETHODIMP nsPrintSettings::GetFooterStrCenter(nsAString &aTitle) {
 523   aTitle = mFooterStrs[1];
 524   return NS_OK;
 525 }
 526 NS_IMETHODIMP nsPrintSettings::SetFooterStrCenter(const nsAString &aTitle) {
 527   mFooterStrs[1] = aTitle;
 528   return NS_OK;
 529 }
 530
 531 NS_IMETHODIMP nsPrintSettings::GetFooterStrRight(nsAString &aTitle) {
 532   aTitle = mFooterStrs[2];
 533   return NS_OK;
 534 }
 535 NS_IMETHODIMP nsPrintSettings::SetFooterStrRight(const nsAString &aTitle) {
 536   mFooterStrs[2] = aTitle;
 537   return NS_OK;
 538 }
 539
 540 NS_IMETHODIMP nsPrintSettings::GetPrintFrameTypeUsage(
 541     int16_t *aPrintFrameTypeUsage) {
 542   NS_ENSURE_ARG_POINTER(aPrintFrameTypeUsage);
 543   *aPrintFrameTypeUsage = mPrintFrameTypeUsage;
 544   return NS_OK;
 545 }
 546 NS_IMETHODIMP nsPrintSettings::SetPrintFrameTypeUsage(
 547     int16_t aPrintFrameTypeUsage) {
 548   mPrintFrameTypeUsage = aPrintFrameTypeUsage;
 549   return NS_OK;
 550 }
 551
 552 NS_IMETHODIMP nsPrintSettings::GetPrintFrameType(int16_t *aPrintFrameType) {
 553   NS_ENSURE_ARG_POINTER(aPrintFrameType);
 554   *aPrintFrameType = (int32_t)mPrintFrameType;
 555   return NS_OK;
 556 }
 557 NS_IMETHODIMP nsPrintSettings::SetPrintFrameType(int16_t aPrintFrameType) {
 558   mPrintFrameType = aPrintFrameType;
 559   return NS_OK;
 560 }
 561
 562 NS_IMETHODIMP nsPrintSettings::GetPrintSilent(bool *aPrintSilent) {
 563   NS_ENSURE_ARG_POINTER(aPrintSilent);
 564   *aPrintSilent = mPrintSilent;
 565   return NS_OK;
 566 }
 567 NS_IMETHODIMP nsPrintSettings::SetPrintSilent(bool aPrintSilent) {
 568   mPrintSilent = aPrintSilent;
 569   return NS_OK;
 570 }
 571
 572 NS_IMETHODIMP nsPrintSettings::GetShrinkToFit(bool *aShrinkToFit) {
 573   NS_ENSURE_ARG_POINTER(aShrinkToFit);
 574   *aShrinkToFit = mShrinkToFit;
 575   return NS_OK;
 576 }
 577 NS_IMETHODIMP nsPrintSettings::SetShrinkToFit(bool aShrinkToFit) {
 578   mShrinkToFit = aShrinkToFit;
 579   return NS_OK;
 580 }
 581
 582 NS_IMETHODIMP nsPrintSettings::GetShowPrintProgress(bool *aShowPrintProgress) {
 583   NS_ENSURE_ARG_POINTER(aShowPrintProgress);
 584   *aShowPrintProgress = mShowPrintProgress;
 585   return NS_OK;
 586 }
 587 NS_IMETHODIMP nsPrintSettings::SetShowPrintProgress(bool aShowPrintProgress) {
 588   mShowPrintProgress = aShowPrintProgress;
 589   return NS_OK;
 590 }
 591
 592 NS_IMETHODIMP nsPrintSettings::GetPaperName(nsAString &aPaperName) {
 593   aPaperName = mPaperName;
 594   return NS_OK;
 595 }
 596 NS_IMETHODIMP nsPrintSettings::SetPaperName(const nsAString &aPaperName) {
 597   mPaperName = aPaperName;
 598   return NS_OK;
 599 }
 600
 601 NS_IMETHODIMP nsPrintSettings::GetHowToEnableFrameUI(
 602     int16_t *aHowToEnableFrameUI) {
 603   NS_ENSURE_ARG_POINTER(aHowToEnableFrameUI);
 604   *aHowToEnableFrameUI = mHowToEnableFrameUI;
 605   return NS_OK;
 606 }
 607 NS_IMETHODIMP nsPrintSettings::SetHowToEnableFrameUI(
 608     int16_t aHowToEnableFrameUI) {
 609   mHowToEnableFrameUI = aHowToEnableFrameUI;
 610   return NS_OK;
 611 }
 612
 613 NS_IMETHODIMP nsPrintSettings::GetIsCancelled(bool *aIsCancelled) {
 614   NS_ENSURE_ARG_POINTER(aIsCancelled);
 615   *aIsCancelled = mIsCancelled;
 616   return NS_OK;
 617 }
 618 NS_IMETHODIMP nsPrintSettings::SetIsCancelled(bool aIsCancelled) {
 619   mIsCancelled = aIsCancelled;
 620   return NS_OK;
 621 }
 622
 623 NS_IMETHODIMP nsPrintSettings::GetPaperWidth(double *aPaperWidth) {
 624   NS_ENSURE_ARG_POINTER(aPaperWidth);
 625   *aPaperWidth = mPaperWidth;
 626   return NS_OK;
 627 }
 628 NS_IMETHODIMP nsPrintSettings::SetPaperWidth(double aPaperWidth) {
 629   mPaperWidth = aPaperWidth;
 630   return NS_OK;
 631 }
 632
 633 NS_IMETHODIMP nsPrintSettings::GetPaperHeight(double *aPaperHeight) {
 634   NS_ENSURE_ARG_POINTER(aPaperHeight);
 635   *aPaperHeight = mPaperHeight;
 636   return NS_OK;
 637 }
 638 NS_IMETHODIMP nsPrintSettings::SetPaperHeight(double aPaperHeight) {
 639   mPaperHeight = aPaperHeight;
 640   return NS_OK;
 641 }
 642
 643 NS_IMETHODIMP nsPrintSettings::GetPaperSizeUnit(int16_t *aPaperSizeUnit) {
 644   NS_ENSURE_ARG_POINTER(aPaperSizeUnit);
 645   *aPaperSizeUnit = mPaperSizeUnit;
 646   return NS_OK;
 647 }
 648 NS_IMETHODIMP nsPrintSettings::SetPaperSizeUnit(int16_t aPaperSizeUnit) {
 649   mPaperSizeUnit = aPaperSizeUnit;
 650   return NS_OK;
 651 }
 652
 653 NS_IMETHODIMP nsPrintSettings::GetPaperData(int16_t *aPaperData) {
 654   NS_ENSURE_ARG_POINTER(aPaperData);
 655   *aPaperData = mPaperData;
 656   return NS_OK;
 657 }
 658 NS_IMETHODIMP nsPrintSettings::SetPaperData(int16_t aPaperData) {
 659   mPaperData = aPaperData;
 660   return NS_OK;
 661 }
 662
 663 /** ---------------------------------------------------
 664  *  See documentation in nsPrintSettingsService.h
 665  *      @update 6/21/00 dwc
 666  *      @update 1/12/01 rods
 667  */
 668 NS_IMETHODIMP
 669 nsPrintSettings::SetMarginInTwips(nsIntMargin &aMargin) {
 670   mMargin = aMargin;
 671   return NS_OK;
 672 }
 673
 674 NS_IMETHODIMP
 675 nsPrintSettings::SetEdgeInTwips(nsIntMargin &aEdge) {
 676   mEdge = aEdge;
 677   return NS_OK;
 678 }
 679
 680 // NOTE: Any subclass implementation of this function should make sure
 681 // to check for negative margin values in aUnwriteableMargin (which
 682 // would indicate that we should use the system default unwriteable margin.)
 683 NS_IMETHODIMP
 684 nsPrintSettings::SetUnwriteableMarginInTwips(nsIntMargin &aUnwriteableMargin) {
 685   if (aUnwriteableMargin.top >= 0) {
 686     mUnwriteableMargin.top = aUnwriteableMargin.top;
 687   }
 688   if (aUnwriteableMargin.left >= 0) {
 689     mUnwriteableMargin.left = aUnwriteableMargin.left;
 690   }
 691   if (aUnwriteableMargin.bottom >= 0) {
 692     mUnwriteableMargin.bottom = aUnwriteableMargin.bottom;
 693   }
 694   if (aUnwriteableMargin.right >= 0) {
 695     mUnwriteableMargin.right = aUnwriteableMargin.right;
 696   }
 697   return NS_OK;
 698 }
 699
 700 /** ---------------------------------------------------
 701  *  See documentation in nsPrintSettingsService.h
 702  *      @update 6/21/00 dwc
 703  */
 704 NS_IMETHODIMP
 705 nsPrintSettings::GetMarginInTwips(nsIntMargin &aMargin) {
 706   aMargin = mMargin;
 707   return NS_OK;
 708 }
 709
 710 NS_IMETHODIMP
 711 nsPrintSettings::GetEdgeInTwips(nsIntMargin &aEdge) {
 712   aEdge = mEdge;
 713   return NS_OK;
 714 }
 715
 716 NS_IMETHODIMP
 717 nsPrintSettings::GetUnwriteableMarginInTwips(nsIntMargin &aUnwriteableMargin) {
 718   aUnwriteableMargin = mUnwriteableMargin;
 719   return NS_OK;
 720 }
 721
 722 /** ---------------------------------------------------
 723  * Stub - platform-specific implementations can use this function.
 724  */
 725 NS_IMETHODIMP
 726 nsPrintSettings::SetupSilentPrinting() { return NS_OK; }
 727
 728 /** ---------------------------------------------------
 729  *  See documentation in nsPrintSettingsService.h
 730  */
 731 NS_IMETHODIMP
 732 nsPrintSettings::GetEffectivePageSize(double *aWidth, double *aHeight) {
 733   if (mPaperSizeUnit == kPaperSizeInches) {
 734     *aWidth = NS_INCHES_TO_TWIPS(float(mPaperWidth));
 735     *aHeight = NS_INCHES_TO_TWIPS(float(mPaperHeight));
 736   } else {
 737     *aWidth = NS_MILLIMETERS_TO_TWIPS(float(mPaperWidth));
 738     *aHeight = NS_MILLIMETERS_TO_TWIPS(float(mPaperHeight));
 739   }
 740   if (kLandscapeOrientation == mOrientation) {
 741     double temp = *aWidth;
 742     *aWidth = *aHeight;
 743     *aHeight = temp;
 744   }
 745   return NS_OK;
 746 }
 747
 748 NS_IMETHODIMP
 749 nsPrintSettings::GetPageRanges(nsTArray<int32_t> &aPages) {
 750   aPages.Clear();
 751   return NS_OK;
 752 }
 753
 754 nsresult nsPrintSettings::_Clone(nsIPrintSettings **_retval) {
 755   RefPtr<nsPrintSettings> printSettings = new nsPrintSettings(*this);
 756   printSettings.forget(_retval);
 757   return NS_OK;
 758 }
 759
 760 NS_IMETHODIMP
 761 nsPrintSettings::Clone(nsIPrintSettings **_retval) {
 762   NS_ENSURE_ARG_POINTER(_retval);
 763   return _Clone(_retval);
 764 }
 765
 766 nsresult nsPrintSettings::_Assign(nsIPrintSettings *aPS) {
 767   nsPrintSettings *ps = static_cast<nsPrintSettings *>(aPS);
 768   *this = *ps;
 769   return NS_OK;
 770 }
 771
 772 NS_IMETHODIMP
 773 nsPrintSettings::Assign(nsIPrintSettings *aPS) {
 774   NS_ENSURE_ARG(aPS);
 775   return _Assign(aPS);
 776 }
 777
 778 //-------------------------------------------
 779 nsPrintSettings &nsPrintSettings::operator=(const nsPrintSettings &rhs) {
 780   if (this == &rhs) {
 781     return *this;
 782   }
 783
 784   mStartPageNum = rhs.mStartPageNum;
 785   mEndPageNum = rhs.mEndPageNum;
 786   mMargin = rhs.mMargin;
 787   mEdge = rhs.mEdge;
 788   mUnwriteableMargin = rhs.mUnwriteableMargin;
 789   mScaling = rhs.mScaling;
 790   mPrintBGColors = rhs.mPrintBGColors;
 791   mPrintBGImages = rhs.mPrintBGImages;
 792   mPrintRange = rhs.mPrintRange;
 793   mTitle = rhs.mTitle;
 794   mURL = rhs.mURL;
 795   mHowToEnableFrameUI = rhs.mHowToEnableFrameUI;
 796   mIsCancelled = rhs.mIsCancelled;
 797   mPrintFrameTypeUsage = rhs.mPrintFrameTypeUsage;
 798   mPrintFrameType = rhs.mPrintFrameType;
 799   mPrintSilent = rhs.mPrintSilent;
 800   mShrinkToFit = rhs.mShrinkToFit;
 801   mShowPrintProgress = rhs.mShowPrintProgress;
 802   mPaperName = rhs.mPaperName;
 803   mPaperData = rhs.mPaperData;
 804   mPaperWidth = rhs.mPaperWidth;
 805   mPaperHeight = rhs.mPaperHeight;
 806   mPaperSizeUnit = rhs.mPaperSizeUnit;
 807   mPrintReversed = rhs.mPrintReversed;
 808   mPrintInColor = rhs.mPrintInColor;
 809   mOrientation = rhs.mOrientation;
 810   mNumCopies = rhs.mNumCopies;
 811   mPrinter = rhs.mPrinter;
 812   mPrintToFile = rhs.mPrintToFile;
 813   mToFileName = rhs.mToFileName;
 814   mOutputFormat = rhs.mOutputFormat;
 815   mPrintPageDelay = rhs.mPrintPageDelay;
 816
 817   for (int32_t i = 0; i < NUM_HEAD_FOOT; i++) {
 818     mHeaderStrs[i] = rhs.mHeaderStrs[i];
 819     mFooterStrs[i] = rhs.mFooterStrs[i];
 820   }
 821
 822   return *this;
 823 }