widget/nsPrintSettingsService.cpp

   1 /* -*- Mode: C++; tab-width: 2; 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 "nsPrintSettingsService.h"
   7
   8 #include "mozilla/embedding/PPrinting.h"
   9 #include "mozilla/layout/RemotePrintJobChild.h"
  10 #include "mozilla/RefPtr.h"
  11 #include "nsIPrinterEnumerator.h"
  12 #include "nsPrintingProxy.h"
  13 #include "nsReadableUtils.h"
  14 #include "nsPrintSettingsImpl.h"
  15 #include "nsIPrintSession.h"
  16 #include "nsServiceManagerUtils.h"
  17
  18 #include "nsArray.h"
  19 #include "nsXPCOM.h"
  20
  21 #include "nsIStringEnumerator.h"
  22 #include "stdlib.h"
  23 #include "mozilla/Preferences.h"
  24 #include "nsPrintfCString.h"
  25
  26 using namespace mozilla;
  27 using namespace mozilla::embedding;
  28
  29 typedef mozilla::layout::RemotePrintJobChild RemotePrintJobChild;
  30
  31 NS_IMPL_ISUPPORTS(nsPrintSettingsService, nsIPrintSettingsService)
  32
  33 // Pref Constants
  34 static const char kMarginTop[] = "print_margin_top";
  35 static const char kMarginLeft[] = "print_margin_left";
  36 static const char kMarginBottom[] = "print_margin_bottom";
  37 static const char kMarginRight[] = "print_margin_right";
  38 static const char kEdgeTop[] = "print_edge_top";
  39 static const char kEdgeLeft[] = "print_edge_left";
  40 static const char kEdgeBottom[] = "print_edge_bottom";
  41 static const char kEdgeRight[] = "print_edge_right";
  42 static const char kUnwriteableMarginTop[] = "print_unwriteable_margin_top";
  43 static const char kUnwriteableMarginLeft[] = "print_unwriteable_margin_left";
  44 static const char kUnwriteableMarginBottom[] =
  45     "print_unwriteable_margin_bottom";
  46 static const char kUnwriteableMarginRight[] = "print_unwriteable_margin_right";
  47
  48 // Prefs for Print Options
  49 static const char kPrintEvenPages[] = "print_evenpages";
  50 static const char kPrintOddPages[] = "print_oddpages";
  51 static const char kPrintHeaderStrLeft[] = "print_headerleft";
  52 static const char kPrintHeaderStrCenter[] = "print_headercenter";
  53 static const char kPrintHeaderStrRight[] = "print_headerright";
  54 static const char kPrintFooterStrLeft[] = "print_footerleft";
  55 static const char kPrintFooterStrCenter[] = "print_footercenter";
  56 static const char kPrintFooterStrRight[] = "print_footerright";
  57
  58 // Additional Prefs
  59 static const char kPrintReversed[] = "print_reversed";
  60 static const char kPrintInColor[] = "print_in_color";
  61 static const char kPrintPaperName[] = "print_paper_name";
  62 static const char kPrintPaperData[] = "print_paper_data";
  63 static const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
  64 static const char kPrintPaperWidth[] = "print_paper_width";
  65 static const char kPrintPaperHeight[] = "print_paper_height";
  66 static const char kPrintOrientation[] = "print_orientation";
  67 static const char kPrinterName[] = "print_printer";
  68 static const char kPrintToFile[] = "print_to_file";
  69 static const char kPrintToFileName[] = "print_to_filename";
  70 static const char kPrintPageDelay[] = "print_page_delay";
  71 static const char kPrintBGColors[] = "print_bgcolor";
  72 static const char kPrintBGImages[] = "print_bgimages";
  73 static const char kPrintShrinkToFit[] = "print_shrink_to_fit";
  74 static const char kPrintScaling[] = "print_scaling";
  75 static const char kPrintResolution[] = "print_resolution";
  76 static const char kPrintDuplex[] = "print_duplex";
  77
  78 static const char kJustLeft[] = "left";
  79 static const char kJustCenter[] = "center";
  80 static const char kJustRight[] = "right";
  81
  82 #define NS_PRINTER_ENUMERATOR_CONTRACTID "@mozilla.org/gfx/printerenumerator;1"
  83
  84 nsresult nsPrintSettingsService::Init() { return NS_OK; }
  85
  86 NS_IMETHODIMP
  87 nsPrintSettingsService::SerializeToPrintData(nsIPrintSettings* aSettings,
  88                                              PrintData* data) {
  89   nsCOMPtr<nsIPrintSession> session;
  90   nsresult rv = aSettings->GetPrintSession(getter_AddRefs(session));
  91   if (NS_SUCCEEDED(rv) && session) {
  92     data->remotePrintJobChild() = session->GetRemotePrintJob();
  93   }
  94
  95   aSettings->GetStartPageRange(&data->startPageRange());
  96   aSettings->GetEndPageRange(&data->endPageRange());
  97
  98   aSettings->GetEdgeTop(&data->edgeTop());
  99   aSettings->GetEdgeLeft(&data->edgeLeft());
 100   aSettings->GetEdgeBottom(&data->edgeBottom());
 101   aSettings->GetEdgeRight(&data->edgeRight());
 102
 103   aSettings->GetMarginTop(&data->marginTop());
 104   aSettings->GetMarginLeft(&data->marginLeft());
 105   aSettings->GetMarginBottom(&data->marginBottom());
 106   aSettings->GetMarginRight(&data->marginRight());
 107   aSettings->GetUnwriteableMarginTop(&data->unwriteableMarginTop());
 108   aSettings->GetUnwriteableMarginLeft(&data->unwriteableMarginLeft());
 109   aSettings->GetUnwriteableMarginBottom(&data->unwriteableMarginBottom());
 110   aSettings->GetUnwriteableMarginRight(&data->unwriteableMarginRight());
 111
 112   aSettings->GetScaling(&data->scaling());
 113
 114   aSettings->GetPrintBGColors(&data->printBGColors());
 115   aSettings->GetPrintBGImages(&data->printBGImages());
 116   aSettings->GetPrintRange(&data->printRange());
 117
 118   aSettings->GetTitle(data->title());
 119   aSettings->GetDocURL(data->docURL());
 120
 121   aSettings->GetHeaderStrLeft(data->headerStrLeft());
 122   aSettings->GetHeaderStrCenter(data->headerStrCenter());
 123   aSettings->GetHeaderStrRight(data->headerStrRight());
 124
 125   aSettings->GetFooterStrLeft(data->footerStrLeft());
 126   aSettings->GetFooterStrCenter(data->footerStrCenter());
 127   aSettings->GetFooterStrRight(data->footerStrRight());
 128
 129   aSettings->GetIsCancelled(&data->isCancelled());
 130   aSettings->GetPrintSilent(&data->printSilent());
 131   aSettings->GetShrinkToFit(&data->shrinkToFit());
 132   aSettings->GetShowPrintProgress(&data->showPrintProgress());
 133
 134   aSettings->GetPaperName(data->paperName());
 135   aSettings->GetPaperData(&data->paperData());
 136   aSettings->GetPaperWidth(&data->paperWidth());
 137   aSettings->GetPaperHeight(&data->paperHeight());
 138   aSettings->GetPaperSizeUnit(&data->paperSizeUnit());
 139
 140   aSettings->GetPrintReversed(&data->printReversed());
 141   aSettings->GetPrintInColor(&data->printInColor());
 142   aSettings->GetOrientation(&data->orientation());
 143
 144   aSettings->GetNumCopies(&data->numCopies());
 145
 146   aSettings->GetPrinterName(data->printerName());
 147
 148   aSettings->GetPrintToFile(&data->printToFile());
 149
 150   aSettings->GetToFileName(data->toFileName());
 151
 152   aSettings->GetOutputFormat(&data->outputFormat());
 153   aSettings->GetPrintPageDelay(&data->printPageDelay());
 154   aSettings->GetResolution(&data->resolution());
 155   aSettings->GetDuplex(&data->duplex());
 156   aSettings->GetIsInitializedFromPrinter(&data->isInitializedFromPrinter());
 157   aSettings->GetIsInitializedFromPrefs(&data->isInitializedFromPrefs());
 158
 159   aSettings->GetPrintOptionsBits(&data->optionFlags());
 160
 161   // Initialize the platform-specific values that don't
 162   // default-initialize, so that we don't send uninitialized data over
 163   // IPC (which leads to valgrind warnings, and, for bools, fatal
 164   // assertions).
 165   // data->driverName() default-initializes
 166   // data->deviceName() default-initializes
 167   data->printableWidthInInches() = 0;
 168   data->printableHeightInInches() = 0;
 169   data->isIFrameSelected() = false;
 170   data->isRangeSelection() = false;
 171   // data->GTKPrintSettings() default-initializes
 172   // data->printJobName() default-initializes
 173   data->printAllPages() = true;
 174   data->mustCollate() = false;
 175   // data->disposition() default-initializes
 176   data->pagesAcross() = 1;
 177   data->pagesDown() = 1;
 178   data->printTime() = 0;
 179   data->detailedErrorReporting() = true;
 180   // data->faxNumber() default-initializes
 181   data->addHeaderAndFooter() = false;
 182   data->fileNameExtensionHidden() = false;
 183
 184   return NS_OK;
 185 }
 186
 187 NS_IMETHODIMP
 188 nsPrintSettingsService::DeserializeToPrintSettings(const PrintData& data,
 189                                                    nsIPrintSettings* settings) {
 190   nsCOMPtr<nsIPrintSession> session;
 191   nsresult rv = settings->GetPrintSession(getter_AddRefs(session));
 192   if (NS_SUCCEEDED(rv) && session) {
 193     session->SetRemotePrintJob(
 194         static_cast<RemotePrintJobChild*>(data.remotePrintJobChild()));
 195   }
 196   settings->SetStartPageRange(data.startPageRange());
 197   settings->SetEndPageRange(data.endPageRange());
 198
 199   settings->SetEdgeTop(data.edgeTop());
 200   settings->SetEdgeLeft(data.edgeLeft());
 201   settings->SetEdgeBottom(data.edgeBottom());
 202   settings->SetEdgeRight(data.edgeRight());
 203
 204   settings->SetMarginTop(data.marginTop());
 205   settings->SetMarginLeft(data.marginLeft());
 206   settings->SetMarginBottom(data.marginBottom());
 207   settings->SetMarginRight(data.marginRight());
 208   settings->SetUnwriteableMarginTop(data.unwriteableMarginTop());
 209   settings->SetUnwriteableMarginLeft(data.unwriteableMarginLeft());
 210   settings->SetUnwriteableMarginBottom(data.unwriteableMarginBottom());
 211   settings->SetUnwriteableMarginRight(data.unwriteableMarginRight());
 212
 213   settings->SetScaling(data.scaling());
 214
 215   settings->SetPrintBGColors(data.printBGColors());
 216   settings->SetPrintBGImages(data.printBGImages());
 217   settings->SetPrintRange(data.printRange());
 218
 219   settings->SetTitle(data.title());
 220   settings->SetDocURL(data.docURL());
 221
 222   // Header strings...
 223   settings->SetHeaderStrLeft(data.headerStrLeft());
 224   settings->SetHeaderStrCenter(data.headerStrCenter());
 225   settings->SetHeaderStrRight(data.headerStrRight());
 226
 227   // Footer strings...
 228   settings->SetFooterStrLeft(data.footerStrLeft());
 229   settings->SetFooterStrCenter(data.footerStrCenter());
 230   settings->SetFooterStrRight(data.footerStrRight());
 231
 232   settings->SetIsCancelled(data.isCancelled());
 233   settings->SetPrintSilent(data.printSilent());
 234   settings->SetShrinkToFit(data.shrinkToFit());
 235   settings->SetShowPrintProgress(data.showPrintProgress());
 236
 237   settings->SetPaperName(data.paperName());
 238
 239   settings->SetPaperData(data.paperData());
 240   settings->SetPaperWidth(data.paperWidth());
 241   settings->SetPaperHeight(data.paperHeight());
 242   settings->SetPaperSizeUnit(data.paperSizeUnit());
 243
 244   settings->SetPrintReversed(data.printReversed());
 245   settings->SetPrintInColor(data.printInColor());
 246   settings->SetOrientation(data.orientation());
 247
 248   settings->SetNumCopies(data.numCopies());
 249
 250   settings->SetPrinterName(data.printerName());
 251
 252   settings->SetPrintToFile(data.printToFile());
 253
 254   settings->SetToFileName(data.toFileName());
 255
 256   settings->SetOutputFormat(data.outputFormat());
 257   settings->SetPrintPageDelay(data.printPageDelay());
 258   settings->SetResolution(data.resolution());
 259   settings->SetDuplex(data.duplex());
 260   settings->SetIsInitializedFromPrinter(data.isInitializedFromPrinter());
 261   settings->SetIsInitializedFromPrefs(data.isInitializedFromPrefs());
 262
 263   settings->SetPrintOptionsBits(data.optionFlags());
 264
 265   return NS_OK;
 266 }
 267
 268 /** ---------------------------------------------------
 269  *  Helper function - Creates the "prefix" for the pref
 270  *  It is either "print."
 271  *  or "print.printer_<print name>."
 272  */
 273 const char* nsPrintSettingsService::GetPrefName(const char* aPrefName,
 274                                                 const nsAString& aPrinterName) {
 275   if (!aPrefName || !*aPrefName) {
 276     NS_ERROR("Must have a valid pref name!");
 277     return aPrefName;
 278   }
 279
 280   mPrefName.AssignLiteral("print.");
 281
 282   if (aPrinterName.Length()) {
 283     mPrefName.AppendLiteral("printer_");
 284     AppendUTF16toUTF8(aPrinterName, mPrefName);
 285     mPrefName.Append('.');
 286   }
 287   mPrefName += aPrefName;
 288
 289   return mPrefName.get();
 290 }
 291
 292 //----------------------------------------------------------------------
 293 // Testing of read/write prefs
 294 // This define controls debug output
 295 #ifdef DEBUG_rods_X
 296 static void WriteDebugStr(const char* aArg1, const char* aArg2,
 297                           const char16_t* aStr) {
 298   nsString str(aStr);
 299   char16_t s = '&';
 300   char16_t r = '_';
 301   str.ReplaceChar(s, r);
 302
 303   printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
 304 }
 305 const char* kWriteStr = "Write Pref:";
 306 const char* kReadStr = "Read Pref:";
 307 #  define DUMP_STR(_a1, _a2, _a3) \
 308     WriteDebugStr((_a1), GetPrefName((_a2), aPrefName), (_a3));
 309 #  define DUMP_BOOL(_a1, _a2, _a3)                                \
 310     printf("%s %s = %s \n", (_a1), GetPrefName((_a2), aPrefName), \
 311            (_a3) ? "T" : "F");
 312 #  define DUMP_INT(_a1, _a2, _a3) \
 313     printf("%s %s = %d \n", (_a1), GetPrefName((_a2), aPrefName), (_a3));
 314 #  define DUMP_DBL(_a1, _a2, _a3) \
 315     printf("%s %s = %10.5f \n", (_a1), GetPrefName((_a2), aPrefName), (_a3));
 316 #else
 317 #  define DUMP_STR(_a1, _a2, _a3)
 318 #  define DUMP_BOOL(_a1, _a2, _a3)
 319 #  define DUMP_INT(_a1, _a2, _a3)
 320 #  define DUMP_DBL(_a1, _a2, _a3)
 321 #endif /* DEBUG_rods_X */
 322 //----------------------------------------------------------------------
 323
 324 /**
 325  *  This will either read in the generic prefs (not specific to a printer)
 326  *  or read the prefs in using the printer name to qualify.
 327  *  It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
 328  */
 329 nsresult nsPrintSettingsService::ReadPrefs(nsIPrintSettings* aPS,
 330                                            const nsAString& aPrinterName,
 331                                            uint32_t aFlags) {
 332   NS_ENSURE_ARG_POINTER(aPS);
 333
 334   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
 335     int32_t halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
 336     nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
 337     ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
 338                           kMarginTop);
 339     DUMP_INT(kReadStr, kMarginTop, margin.top);
 340     ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
 341                           kMarginLeft);
 342     DUMP_INT(kReadStr, kMarginLeft, margin.left);
 343     ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
 344                           margin.bottom, kMarginBottom);
 345     DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
 346     ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
 347                           kMarginRight);
 348     DUMP_INT(kReadStr, kMarginRight, margin.right);
 349     aPS->SetMarginInTwips(margin);
 350   }
 351
 352   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
 353     nsIntMargin margin(0, 0, 0, 0);
 354     ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
 355                              kEdgeTop);
 356     DUMP_INT(kReadStr, kEdgeTop, margin.top);
 357     ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
 358                              kEdgeLeft);
 359     DUMP_INT(kReadStr, kEdgeLeft, margin.left);
 360     ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
 361                              margin.bottom, kEdgeBottom);
 362     DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
 363     ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
 364                              margin.right, kEdgeRight);
 365     DUMP_INT(kReadStr, kEdgeRight, margin.right);
 366     aPS->SetEdgeInTwips(margin);
 367   }
 368
 369   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
 370     nsIntMargin margin;
 371     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
 372                              margin.top, kUnwriteableMarginTop);
 373     DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
 374     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
 375                              margin.left, kUnwriteableMarginLeft);
 376     DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
 377     ReadInchesIntToTwipsPref(
 378         GetPrefName(kUnwriteableMarginBottom, aPrinterName), margin.bottom,
 379         kUnwriteableMarginBottom);
 380     DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
 381     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
 382                              margin.right, kUnwriteableMarginRight);
 383     DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
 384     aPS->SetUnwriteableMarginInTwips(margin);
 385   }
 386
 387   bool b;
 388   nsAutoString str;
 389   int32_t iVal;
 390   double dbl;
 391
 392 #define GETBOOLPREF(_prefname, _retval) \
 393   NS_SUCCEEDED(                         \
 394       Preferences::GetBool(GetPrefName(_prefname, aPrinterName), _retval))
 395
 396 #define GETSTRPREF(_prefname, _retval) \
 397   NS_SUCCEEDED(                        \
 398       Preferences::GetString(GetPrefName(_prefname, aPrinterName), _retval))
 399
 400 #define GETINTPREF(_prefname, _retval) \
 401   NS_SUCCEEDED(                        \
 402       Preferences::GetInt(GetPrefName(_prefname, aPrinterName), _retval))
 403
 404 #define GETDBLPREF(_prefname, _retval) \
 405   NS_SUCCEEDED(ReadPrefDouble(GetPrefName(_prefname, aPrinterName), _retval))
 406
 407   // Paper size prefs are read as a group
 408   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
 409     int32_t sizeUnit;
 410     double width, height;
 411
 412     bool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit) &&
 413                    GETDBLPREF(kPrintPaperWidth, width) &&
 414                    GETDBLPREF(kPrintPaperHeight, height) &&
 415                    GETSTRPREF(kPrintPaperName, str);
 416
 417     // Bug 315687: Sanity check paper size to avoid paper size values in
 418     // mm when the size unit flag is inches. The value 100 is arbitrary
 419     // and can be changed.
 420 #if defined(XP_WIN)
 421     bool saveSanitizedSizePrefs = false;
 422 #endif
 423     if (success) {
 424       success = (sizeUnit != nsIPrintSettings::kPaperSizeInches) ||
 425                 (width < 100.0) || (height < 100.0);
 426 #if defined(XP_WIN)
 427       // Work around legacy invalid prefs where the size unit gets set to
 428       // millimeters, but the height and width remains as the previous inches
 429       // settings. See bug 1276717 and bug 1369386 for details.
 430       if (sizeUnit == nsIPrintSettings::kPaperSizeMillimeters && height >= 0L &&
 431           height < 25L && width >= 0L && width < 25L) {
 432         // As small pages sizes can be valid we only override when the old
 433         // (now no longer set) pref print_paper_size_type exists. This will be
 434         // removed when we save the prefs below.
 435         const char* paperSizeTypePref =
 436             GetPrefName("print_paper_size_type", aPrinterName);
 437         if (Preferences::HasUserValue(paperSizeTypePref)) {
 438           saveSanitizedSizePrefs = true;
 439           height = -1L;
 440           width = -1L;
 441         }
 442       }
 443 #endif
 444     }
 445
 446     if (success) {
 447       aPS->SetPaperSizeUnit(sizeUnit);
 448       DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
 449       aPS->SetPaperWidth(width);
 450       DUMP_DBL(kReadStr, kPrintPaperWidth, width);
 451       aPS->SetPaperHeight(height);
 452       DUMP_DBL(kReadStr, kPrintPaperHeight, height);
 453       aPS->SetPaperName(str);
 454       DUMP_STR(kReadStr, kPrintPaperName, str.get());
 455 #if defined(XP_WIN)
 456       if (saveSanitizedSizePrefs) {
 457         SavePrintSettingsToPrefs(aPS, !aPrinterName.IsEmpty(),
 458                                  nsIPrintSettings::kInitSavePaperSize);
 459       }
 460 #endif
 461     }
 462   }
 463
 464   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 465     if (GETBOOLPREF(kPrintEvenPages, &b)) {
 466       aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
 467       DUMP_BOOL(kReadStr, kPrintEvenPages, b);
 468     }
 469   }
 470
 471   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 472     if (GETBOOLPREF(kPrintOddPages, &b)) {
 473       aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
 474       DUMP_BOOL(kReadStr, kPrintOddPages, b);
 475     }
 476   }
 477
 478   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
 479     if (GETSTRPREF(kPrintHeaderStrLeft, str)) {
 480       aPS->SetHeaderStrLeft(str);
 481       DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
 482     }
 483   }
 484
 485   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
 486     if (GETSTRPREF(kPrintHeaderStrCenter, str)) {
 487       aPS->SetHeaderStrCenter(str);
 488       DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
 489     }
 490   }
 491
 492   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
 493     if (GETSTRPREF(kPrintHeaderStrRight, str)) {
 494       aPS->SetHeaderStrRight(str);
 495       DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
 496     }
 497   }
 498
 499   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
 500     if (GETSTRPREF(kPrintFooterStrLeft, str)) {
 501       aPS->SetFooterStrLeft(str);
 502       DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
 503     }
 504   }
 505
 506   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
 507     if (GETSTRPREF(kPrintFooterStrCenter, str)) {
 508       aPS->SetFooterStrCenter(str);
 509       DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
 510     }
 511   }
 512
 513   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
 514     if (GETSTRPREF(kPrintFooterStrRight, str)) {
 515       aPS->SetFooterStrRight(str);
 516       DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
 517     }
 518   }
 519
 520   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
 521     if (GETBOOLPREF(kPrintBGColors, &b)) {
 522       aPS->SetPrintBGColors(b);
 523       DUMP_BOOL(kReadStr, kPrintBGColors, b);
 524     }
 525   }
 526
 527   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
 528     if (GETBOOLPREF(kPrintBGImages, &b)) {
 529       aPS->SetPrintBGImages(b);
 530       DUMP_BOOL(kReadStr, kPrintBGImages, b);
 531     }
 532   }
 533
 534   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
 535     if (GETBOOLPREF(kPrintReversed, &b)) {
 536       aPS->SetPrintReversed(b);
 537       DUMP_BOOL(kReadStr, kPrintReversed, b);
 538     }
 539   }
 540
 541   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
 542     if (GETBOOLPREF(kPrintInColor, &b)) {
 543       aPS->SetPrintInColor(b);
 544       DUMP_BOOL(kReadStr, kPrintInColor, b);
 545     }
 546   }
 547
 548   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
 549     if (GETINTPREF(kPrintPaperData, &iVal)) {
 550       aPS->SetPaperData(iVal);
 551       DUMP_INT(kReadStr, kPrintPaperData, iVal);
 552     }
 553   }
 554
 555   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
 556     if (GETINTPREF(kPrintOrientation, &iVal)) {
 557       aPS->SetOrientation(iVal);
 558       DUMP_INT(kReadStr, kPrintOrientation, iVal);
 559     }
 560   }
 561
 562   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
 563     if (GETBOOLPREF(kPrintToFile, &b)) {
 564       aPS->SetPrintToFile(b);
 565       DUMP_BOOL(kReadStr, kPrintToFile, b);
 566     }
 567   }
 568
 569   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
 570     if (GETSTRPREF(kPrintToFileName, str)) {
 571       if (StringEndsWith(str, NS_LITERAL_STRING(".ps"))) {
 572         // We only support PDF since bug 1425188 landed.  Users may still have
 573         // prefs with .ps filenames if they last saved a file as Postscript
 574         // though, so we fix that up here.  (The pref values will be
 575         // overwritten the next time they save to file as a PDF.)
 576         str.Truncate(str.Length() - 2);
 577         str.AppendLiteral("pdf");
 578       }
 579       aPS->SetToFileName(str);
 580       DUMP_STR(kReadStr, kPrintToFileName, str.get());
 581     }
 582   }
 583
 584   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
 585     if (GETINTPREF(kPrintPageDelay, &iVal)) {
 586       aPS->SetPrintPageDelay(iVal);
 587       DUMP_INT(kReadStr, kPrintPageDelay, iVal);
 588     }
 589   }
 590
 591   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
 592     if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
 593       aPS->SetShrinkToFit(b);
 594       DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
 595     }
 596   }
 597
 598   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
 599     if (GETDBLPREF(kPrintScaling, dbl)) {
 600       aPS->SetScaling(dbl);
 601       DUMP_DBL(kReadStr, kPrintScaling, dbl);
 602     }
 603   }
 604
 605   if (aFlags & nsIPrintSettings::kInitSaveResolution) {
 606     if (GETINTPREF(kPrintResolution, &iVal)) {
 607       aPS->SetResolution(iVal);
 608       DUMP_INT(kReadStr, kPrintResolution, iVal);
 609     }
 610   }
 611
 612   if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
 613     if (GETINTPREF(kPrintDuplex, &iVal)) {
 614       aPS->SetDuplex(iVal);
 615       DUMP_INT(kReadStr, kPrintDuplex, iVal);
 616     }
 617   }
 618
 619   // Not Reading In:
 620   //   Number of Copies
 621
 622   return NS_OK;
 623 }
 624
 625 nsresult nsPrintSettingsService::WritePrefs(nsIPrintSettings* aPS,
 626                                             const nsAString& aPrinterName,
 627                                             uint32_t aFlags) {
 628   NS_ENSURE_ARG_POINTER(aPS);
 629
 630   nsIntMargin margin;
 631   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
 632     if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
 633       WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
 634                                margin.top);
 635       DUMP_INT(kWriteStr, kMarginTop, margin.top);
 636       WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
 637                                margin.left);
 638       DUMP_INT(kWriteStr, kMarginLeft, margin.top);
 639       WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
 640                                margin.bottom);
 641       DUMP_INT(kWriteStr, kMarginBottom, margin.top);
 642       WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
 643                                margin.right);
 644       DUMP_INT(kWriteStr, kMarginRight, margin.top);
 645     }
 646   }
 647
 648   nsIntMargin edge;
 649   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
 650     if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
 651       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
 652                                   edge.top);
 653       DUMP_INT(kWriteStr, kEdgeTop, edge.top);
 654       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
 655                                   edge.left);
 656       DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
 657       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
 658                                   edge.bottom);
 659       DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
 660       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
 661                                   edge.right);
 662       DUMP_INT(kWriteStr, kEdgeRight, edge.top);
 663     }
 664   }
 665
 666   nsIntMargin unwriteableMargin;
 667   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
 668     if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
 669       WriteInchesIntFromTwipsPref(
 670           GetPrefName(kUnwriteableMarginTop, aPrinterName),
 671           unwriteableMargin.top);
 672       DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
 673       WriteInchesIntFromTwipsPref(
 674           GetPrefName(kUnwriteableMarginLeft, aPrinterName),
 675           unwriteableMargin.left);
 676       DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
 677       WriteInchesIntFromTwipsPref(
 678           GetPrefName(kUnwriteableMarginBottom, aPrinterName),
 679           unwriteableMargin.bottom);
 680       DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
 681       WriteInchesIntFromTwipsPref(
 682           GetPrefName(kUnwriteableMarginRight, aPrinterName),
 683           unwriteableMargin.right);
 684       DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
 685     }
 686   }
 687
 688   // Paper size prefs are saved as a group
 689   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
 690     int16_t sizeUnit;
 691     double width, height;
 692     nsString name;
 693
 694     if (NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
 695         NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
 696         NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
 697         NS_SUCCEEDED(aPS->GetPaperName(name))) {
 698       DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
 699       Preferences::SetInt(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
 700                           int32_t(sizeUnit));
 701       DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
 702       WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
 703       DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
 704       WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
 705       DUMP_STR(kWriteStr, kPrintPaperName, name.get());
 706       Preferences::SetString(GetPrefName(kPrintPaperName, aPrinterName), name);
 707 #if defined(XP_WIN)
 708       // If the height and width are -1 then this might be a save triggered by
 709       // print pref sanitizing code. This is done as a one off and is partly
 710       // triggered by the existence of an old (now no longer set) pref. We
 711       // remove that pref if it exists here, so that we don't try and sanitize
 712       // what might be valid prefs. See bug 1276717 and bug 1369386 for details.
 713       if (height == -1L && width == -1L) {
 714         const char* paperSizeTypePref =
 715             GetPrefName("print_paper_size_type", aPrinterName);
 716         if (Preferences::HasUserValue(paperSizeTypePref)) {
 717           Preferences::ClearUser(paperSizeTypePref);
 718         }
 719       }
 720 #endif
 721     }
 722   }
 723
 724   bool b;
 725   nsString uStr;
 726   int32_t iVal;
 727   int16_t iVal16;
 728   double dbl;
 729
 730   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 731     if (NS_SUCCEEDED(
 732             aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages, &b))) {
 733       DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
 734       Preferences::SetBool(GetPrefName(kPrintEvenPages, aPrinterName), b);
 735     }
 736   }
 737
 738   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 739     if (NS_SUCCEEDED(
 740             aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages, &b))) {
 741       DUMP_BOOL(kWriteStr, kPrintOddPages, b);
 742       Preferences::SetBool(GetPrefName(kPrintOddPages, aPrinterName), b);
 743     }
 744   }
 745
 746   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
 747     if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(uStr))) {
 748       DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr.get());
 749       Preferences::SetString(GetPrefName(kPrintHeaderStrLeft, aPrinterName),
 750                              uStr);
 751     }
 752   }
 753
 754   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
 755     if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(uStr))) {
 756       DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr.get());
 757       Preferences::SetString(GetPrefName(kPrintHeaderStrCenter, aPrinterName),
 758                              uStr);
 759     }
 760   }
 761
 762   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
 763     if (NS_SUCCEEDED(aPS->GetHeaderStrRight(uStr))) {
 764       DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr.get());
 765       Preferences::SetString(GetPrefName(kPrintHeaderStrRight, aPrinterName),
 766                              uStr);
 767     }
 768   }
 769
 770   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
 771     if (NS_SUCCEEDED(aPS->GetFooterStrLeft(uStr))) {
 772       DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr.get());
 773       Preferences::SetString(GetPrefName(kPrintFooterStrLeft, aPrinterName),
 774                              uStr);
 775     }
 776   }
 777
 778   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
 779     if (NS_SUCCEEDED(aPS->GetFooterStrCenter(uStr))) {
 780       DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr.get());
 781       Preferences::SetString(GetPrefName(kPrintFooterStrCenter, aPrinterName),
 782                              uStr);
 783     }
 784   }
 785
 786   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
 787     if (NS_SUCCEEDED(aPS->GetFooterStrRight(uStr))) {
 788       DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr.get());
 789       Preferences::SetString(GetPrefName(kPrintFooterStrRight, aPrinterName),
 790                              uStr);
 791     }
 792   }
 793
 794   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
 795     if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
 796       DUMP_BOOL(kWriteStr, kPrintBGColors, b);
 797       Preferences::SetBool(GetPrefName(kPrintBGColors, aPrinterName), b);
 798     }
 799   }
 800
 801   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
 802     if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
 803       DUMP_BOOL(kWriteStr, kPrintBGImages, b);
 804       Preferences::SetBool(GetPrefName(kPrintBGImages, aPrinterName), b);
 805     }
 806   }
 807
 808   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
 809     if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
 810       DUMP_BOOL(kWriteStr, kPrintReversed, b);
 811       Preferences::SetBool(GetPrefName(kPrintReversed, aPrinterName), b);
 812     }
 813   }
 814
 815   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
 816     if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
 817       DUMP_BOOL(kWriteStr, kPrintInColor, b);
 818       Preferences::SetBool(GetPrefName(kPrintInColor, aPrinterName), b);
 819     }
 820   }
 821
 822   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
 823     if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
 824       DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
 825       Preferences::SetInt(GetPrefName(kPrintPaperData, aPrinterName),
 826                           int32_t(iVal16));
 827     }
 828   }
 829
 830   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
 831     if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
 832       DUMP_INT(kWriteStr, kPrintOrientation, iVal);
 833       Preferences::SetInt(GetPrefName(kPrintOrientation, aPrinterName), iVal);
 834     }
 835   }
 836
 837   // Only the general version of this pref is saved
 838   if ((aFlags & nsIPrintSettings::kInitSavePrinterName) &&
 839       aPrinterName.IsEmpty()) {
 840     if (NS_SUCCEEDED(aPS->GetPrinterName(uStr))) {
 841       DUMP_STR(kWriteStr, kPrinterName, uStr.get());
 842       Preferences::SetString(kPrinterName, uStr);
 843     }
 844   }
 845
 846   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
 847     if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
 848       DUMP_BOOL(kWriteStr, kPrintToFile, b);
 849       Preferences::SetBool(GetPrefName(kPrintToFile, aPrinterName), b);
 850     }
 851   }
 852
 853   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
 854     if (NS_SUCCEEDED(aPS->GetToFileName(uStr))) {
 855       DUMP_STR(kWriteStr, kPrintToFileName, uStr.get());
 856       Preferences::SetString(GetPrefName(kPrintToFileName, aPrinterName), uStr);
 857     }
 858   }
 859
 860   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
 861     if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
 862       DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
 863       Preferences::SetInt(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
 864     }
 865   }
 866
 867   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
 868     if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
 869       DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
 870       Preferences::SetBool(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
 871     }
 872   }
 873
 874   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
 875     if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
 876       DUMP_DBL(kWriteStr, kPrintScaling, dbl);
 877       WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
 878     }
 879   }
 880
 881   if (aFlags & nsIPrintSettings::kInitSaveResolution) {
 882     if (NS_SUCCEEDED(aPS->GetResolution(&iVal))) {
 883       DUMP_INT(kWriteStr, kPrintResolution, iVal);
 884       Preferences::SetInt(GetPrefName(kPrintResolution, aPrinterName), iVal);
 885     }
 886   }
 887
 888   if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
 889     if (NS_SUCCEEDED(aPS->GetDuplex(&iVal))) {
 890       DUMP_INT(kWriteStr, kPrintDuplex, iVal);
 891       Preferences::SetInt(GetPrefName(kPrintDuplex, aPrinterName), iVal);
 892     }
 893   }
 894
 895   // Not Writing Out:
 896   //   Number of Copies
 897
 898   return NS_OK;
 899 }
 900
 901 nsresult nsPrintSettingsService::_CreatePrintSettings(
 902     nsIPrintSettings** _retval) {
 903   // does not initially ref count
 904   nsPrintSettings* printSettings = new nsPrintSettings();
 905   NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
 906
 907   NS_ADDREF(*_retval = printSettings);  // ref count
 908
 909   nsString printerName;
 910   nsresult rv = GetDefaultPrinterName(printerName);
 911   NS_ENSURE_SUCCESS(rv, rv);
 912   (*_retval)->SetPrinterName(printerName);
 913
 914   (void)InitPrintSettingsFromPrefs(*_retval, false,
 915                                    nsIPrintSettings::kInitSaveAll);
 916
 917   return NS_OK;
 918 }
 919
 920 NS_IMETHODIMP
 921 nsPrintSettingsService::GetGlobalPrintSettings(
 922     nsIPrintSettings** aGlobalPrintSettings) {
 923   nsresult rv;
 924
 925   rv = _CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
 926   NS_ENSURE_SUCCESS(rv, rv);
 927
 928   NS_ADDREF(*aGlobalPrintSettings = mGlobalPrintSettings.get());
 929
 930   return rv;
 931 }
 932
 933 NS_IMETHODIMP
 934 nsPrintSettingsService::GetNewPrintSettings(
 935     nsIPrintSettings** aNewPrintSettings) {
 936   return _CreatePrintSettings(aNewPrintSettings);
 937 }
 938
 939 NS_IMETHODIMP
 940 nsPrintSettingsService::GetDefaultPrinterName(nsAString& aDefaultPrinterName) {
 941   nsresult rv;
 942   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
 943       do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
 944   NS_ENSURE_SUCCESS(rv, rv);
 945
 946   // Look up the printer from the last print job
 947   nsAutoString lastPrinterName;
 948   Preferences::GetString(kPrinterName, lastPrinterName);
 949   if (!lastPrinterName.IsEmpty()) {
 950     // Verify it's still a valid printer
 951     nsCOMPtr<nsIStringEnumerator> printers;
 952     rv = prtEnum->GetPrinterNameList(getter_AddRefs(printers));
 953     if (NS_SUCCEEDED(rv)) {
 954       bool isValid = false;
 955       bool hasMore;
 956       while (NS_SUCCEEDED(printers->HasMore(&hasMore)) && hasMore) {
 957         nsAutoString printer;
 958         if (NS_SUCCEEDED(printers->GetNext(printer)) &&
 959             lastPrinterName.Equals(printer)) {
 960           isValid = true;
 961           break;
 962         }
 963       }
 964       if (isValid) {
 965         aDefaultPrinterName = lastPrinterName;
 966         return NS_OK;
 967       }
 968     }
 969   }
 970
 971   // There is no last printer preference, or it doesn't name a valid printer.
 972   // Return the default from the printer enumeration.
 973   return prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
 974 }
 975
 976 NS_IMETHODIMP
 977 nsPrintSettingsService::InitPrintSettingsFromPrinter(
 978     const nsAString& aPrinterName, nsIPrintSettings* aPrintSettings) {
 979   // Don't get print settings from the printer in the child when printing via
 980   // parent, these will be retrieved in the parent later in the print process.
 981   if (XRE_IsContentProcess() &&
 982       Preferences::GetBool("print.print_via_parent")) {
 983     return NS_OK;
 984   }
 985
 986   NS_ENSURE_ARG_POINTER(aPrintSettings);
 987
 988 #ifdef DEBUG
 989   nsString printerName;
 990   aPrintSettings->GetPrinterName(printerName);
 991   if (!printerName.Equals(aPrinterName)) {
 992     NS_WARNING("Printer names should match!");
 993   }
 994 #endif
 995
 996   bool isInitialized;
 997   aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
 998   if (isInitialized) return NS_OK;
 999
1000   nsresult rv;
1001   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
1002       do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
1003   NS_ENSURE_SUCCESS(rv, rv);
1004
1005   rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
1006   NS_ENSURE_SUCCESS(rv, rv);
1007
1008   aPrintSettings->SetIsInitializedFromPrinter(true);
1009   return rv;
1010 }
1011
1012 #ifndef MOZ_X11
1013 /** ---------------------------------------------------
1014  *  Helper function - Returns either the name or sets the length to zero
1015  */
1016 static nsresult GetAdjustedPrinterName(nsIPrintSettings* aPS, bool aUsePNP,
1017                                        nsAString& aPrinterName) {
1018   NS_ENSURE_ARG_POINTER(aPS);
1019
1020   aPrinterName.Truncate();
1021   if (!aUsePNP) return NS_OK;
1022
1023   // Get the Printer Name from the PrintSettings
1024   // to use as a prefix for Pref Names
1025   nsresult rv = aPS->GetPrinterName(aPrinterName);
1026   NS_ENSURE_SUCCESS(rv, rv);
1027
1028   // Convert any whitespaces, carriage returns or newlines to _
1029   // The below algorithm is supposedly faster than using iterators
1030   NS_NAMED_LITERAL_STRING(replSubstr, "_");
1031   const char* replaceStr = " \n\r";
1032
1033   int32_t x;
1034   for (x = 0; x < (int32_t)strlen(replaceStr); x++) {
1035     char16_t uChar = replaceStr[x];
1036
1037     int32_t i = 0;
1038     while ((i = aPrinterName.FindChar(uChar, i)) != kNotFound) {
1039       aPrinterName.Replace(i, 1, replSubstr);
1040       i++;
1041     }
1042   }
1043   return NS_OK;
1044 }
1045 #endif
1046
1047 NS_IMETHODIMP
1048 nsPrintSettingsService::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
1049                                                    bool aUsePNP,
1050                                                    uint32_t aFlags) {
1051   NS_ENSURE_ARG_POINTER(aPS);
1052
1053   bool isInitialized;
1054   aPS->GetIsInitializedFromPrefs(&isInitialized);
1055
1056   if (isInitialized) return NS_OK;
1057
1058   nsAutoString prtName;
1059   // read any non printer specific prefs
1060   // with empty printer name
1061   nsresult rv = ReadPrefs(aPS, prtName, aFlags);
1062   NS_ENSURE_SUCCESS(rv, rv);
1063
1064   // Do not use printer name in Linux because GTK backend does not support
1065   // per printer settings.
1066 #ifndef MOZ_X11
1067   // Get the Printer Name from the PrintSettings
1068   // to use as a prefix for Pref Names
1069   rv = GetAdjustedPrinterName(aPS, aUsePNP, prtName);
1070   NS_ENSURE_SUCCESS(rv, rv);
1071
1072   if (prtName.IsEmpty()) {
1073     NS_WARNING("Caller should supply a printer name.");
1074     return NS_OK;
1075   }
1076
1077   // Now read any printer specific prefs
1078   rv = ReadPrefs(aPS, prtName, aFlags);
1079   if (NS_SUCCEEDED(rv)) aPS->SetIsInitializedFromPrefs(true);
1080 #endif
1081
1082   return NS_OK;
1083 }
1084
1085 /**
1086  *  Save all of the printer settings; if we can find a printer name, save
1087  *  printer-specific preferences. Otherwise, save generic ones.
1088  */
1089 nsresult nsPrintSettingsService::SavePrintSettingsToPrefs(
1090     nsIPrintSettings* aPS, bool aUsePrinterNamePrefix, uint32_t aFlags) {
1091   NS_ENSURE_ARG_POINTER(aPS);
1092
1093   if (GeckoProcessType_Content == XRE_GetProcessType()) {
1094     // If we're in the content process, we can't directly write to the
1095     // Preferences service - we have to proxy the save up to the
1096     // parent process.
1097     RefPtr<nsPrintingProxy> proxy = nsPrintingProxy::GetInstance();
1098     return proxy->SavePrintSettings(aPS, aUsePrinterNamePrefix, aFlags);
1099   }
1100
1101   nsAutoString prtName;
1102
1103   // Do not use printer name in Linux because GTK backend does not support
1104   // per printer settings.
1105 #ifndef MOZ_X11
1106   // Get the printer name from the PrinterSettings for an optional prefix.
1107   nsresult rv = GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
1108   NS_ENSURE_SUCCESS(rv, rv);
1109 #endif
1110
1111   // Write the prefs, with or without a printer name prefix.
1112   return WritePrefs(aPS, prtName, aFlags);
1113 }
1114
1115 //-----------------------------------------------------
1116 //-- Protected Methods --------------------------------
1117 //-----------------------------------------------------
1118 nsresult nsPrintSettingsService::ReadPrefDouble(const char* aPrefId,
1119                                                 double& aVal) {
1120   NS_ENSURE_ARG_POINTER(aPrefId);
1121
1122   nsAutoCString str;
1123   nsresult rv = Preferences::GetCString(aPrefId, str);
1124   if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
1125     aVal = atof(str.get());
1126   }
1127   return rv;
1128 }
1129
1130 nsresult nsPrintSettingsService::WritePrefDouble(const char* aPrefId,
1131                                                  double aVal) {
1132   NS_ENSURE_ARG_POINTER(aPrefId);
1133
1134   nsPrintfCString str("%6.2f", aVal);
1135   NS_ENSURE_TRUE(!str.IsEmpty(), NS_ERROR_FAILURE);
1136
1137   return Preferences::SetCString(aPrefId, str);
1138 }
1139
1140 void nsPrintSettingsService::ReadInchesToTwipsPref(const char* aPrefId,
1141                                                    int32_t& aTwips,
1142                                                    const char* aMarginPref) {
1143   nsAutoString str;
1144   nsresult rv = Preferences::GetString(aPrefId, str);
1145   if (NS_FAILED(rv) || str.IsEmpty()) {
1146     rv = Preferences::GetString(aMarginPref, str);
1147   }
1148   if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
1149     nsresult errCode;
1150     float inches = str.ToFloat(&errCode);
1151     if (NS_SUCCEEDED(errCode)) {
1152       aTwips = NS_INCHES_TO_INT_TWIPS(inches);
1153     } else {
1154       aTwips = 0;
1155     }
1156   }
1157 }
1158
1159 void nsPrintSettingsService::WriteInchesFromTwipsPref(const char* aPrefId,
1160                                                       int32_t aTwips) {
1161   double inches = NS_TWIPS_TO_INCHES(aTwips);
1162   nsAutoCString inchesStr;
1163   inchesStr.AppendFloat(inches);
1164
1165   Preferences::SetCString(aPrefId, inchesStr);
1166 }
1167
1168 void nsPrintSettingsService::ReadInchesIntToTwipsPref(const char* aPrefId,
1169                                                       int32_t& aTwips,
1170                                                       const char* aMarginPref) {
1171   int32_t value;
1172   nsresult rv = Preferences::GetInt(aPrefId, &value);
1173   if (NS_FAILED(rv)) {
1174     rv = Preferences::GetInt(aMarginPref, &value);
1175   }
1176   if (NS_SUCCEEDED(rv)) {
1177     aTwips = NS_INCHES_TO_INT_TWIPS(float(value) / 100.0f);
1178   } else {
1179     aTwips = 0;
1180   }
1181 }
1182
1183 void nsPrintSettingsService::WriteInchesIntFromTwipsPref(const char* aPrefId,
1184                                                          int32_t aTwips) {
1185   Preferences::SetInt(aPrefId,
1186                       int32_t(NS_TWIPS_TO_INCHES(aTwips) * 100.0f + 0.5f));
1187 }
1188
1189 void nsPrintSettingsService::ReadJustification(const char* aPrefId,
1190                                                int16_t& aJust,
1191                                                int16_t aInitValue) {
1192   aJust = aInitValue;
1193   nsAutoString justStr;
1194   if (NS_SUCCEEDED(Preferences::GetString(aPrefId, justStr))) {
1195     if (justStr.EqualsASCII(kJustRight)) {
1196       aJust = nsIPrintSettings::kJustRight;
1197     } else if (justStr.EqualsASCII(kJustCenter)) {
1198       aJust = nsIPrintSettings::kJustCenter;
1199     } else {
1200       aJust = nsIPrintSettings::kJustLeft;
1201     }
1202   }
1203 }
1204
1205 //---------------------------------------------------
1206 void nsPrintSettingsService::WriteJustification(const char* aPrefId,
1207                                                 int16_t aJust) {
1208   switch (aJust) {
1209     case nsIPrintSettings::kJustLeft:
1210       Preferences::SetCString(aPrefId, kJustLeft);
1211       break;
1212
1213     case nsIPrintSettings::kJustCenter:
1214       Preferences::SetCString(aPrefId, kJustCenter);
1215       break;
1216
1217     case nsIPrintSettings::kJustRight:
1218       Preferences::SetCString(aPrefId, kJustRight);
1219       break;
1220   }  // switch
1221 }
1222
1223 //----------------------------------------------------------------------
1224 // Testing of read/write prefs
1225 // This define turns on the testing module below
1226 // so at start up it writes and reads the prefs.
1227 #ifdef DEBUG_rods_X
1228 class Tester {
1229  public:
1230   Tester();
1231 };
1232 Tester::Tester() {
1233   nsCOMPtr<nsIPrintSettings> ps;
1234   nsresult rv;
1235   nsCOMPtr<nsIPrintSettingsService> printService =
1236       do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
1237   if (NS_SUCCEEDED(rv)) {
1238     rv = printService->CreatePrintSettings(getter_AddRefs(ps));
1239   }
1240
1241   if (ps) {
1242     ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages, true);
1243     ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, false);
1244     ps->SetMarginTop(1.0);
1245     ps->SetMarginLeft(1.0);
1246     ps->SetMarginBottom(1.0);
1247     ps->SetMarginRight(1.0);
1248     ps->SetScaling(0.5);
1249     ps->SetPrintBGColors(true);
1250     ps->SetPrintBGImages(true);
1251     ps->SetPrintRange(15);
1252     ps->SetHeaderStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1253     ps->SetHeaderStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1254     ps->SetHeaderStrRight(NS_ConvertUTF8toUTF16("Right").get());
1255     ps->SetFooterStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1256     ps->SetFooterStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1257     ps->SetFooterStrRight(NS_ConvertUTF8toUTF16("Right").get());
1258     ps->SetPaperName(NS_ConvertUTF8toUTF16("Paper Name").get());
1259     ps->SetPaperData(1);
1260     ps->SetPaperWidth(100.0);
1261     ps->SetPaperHeight(50.0);
1262     ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
1263     ps->SetPrintReversed(true);
1264     ps->SetPrintInColor(true);
1265     ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
1266     ps->SetNumCopies(2);
1267     ps->SetPrinterName(NS_ConvertUTF8toUTF16("Printer Name").get());
1268     ps->SetPrintToFile(true);
1269     ps->SetToFileName(NS_ConvertUTF8toUTF16("File Name").get());
1270     ps->SetPrintPageDelay(1000);
1271     ps->SetShrinkToFit(true);
1272
1273     struct SettingsType {
1274       const char* mName;
1275       uint32_t mFlag;
1276     };
1277     SettingsType gSettings[] = {
1278         {"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
1279         {kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
1280         {kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
1281         {kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
1282         {kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
1283         {kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
1284         {kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
1285         {kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
1286         {kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
1287         {kPrintShrinkToFit, nsIPrintSettings::kInitSaveShrinkToFit},
1288         {kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
1289         {kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
1290         {kPrintReversed, nsIPrintSettings::kInitSaveReversed},
1291         {kPrintInColor, nsIPrintSettings::kInitSaveInColor},
1292         {kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
1293         {kPrinterName, nsIPrintSettings::kInitSavePrinterName},
1294         {kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
1295         {kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
1296         {kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
1297         {"Margins", nsIPrintSettings::kInitSaveMargins},
1298         {"All", nsIPrintSettings::kInitSaveAll},
1299         {nullptr, 0}};
1300
1301     nsString prefix;
1302     prefix.AssignLiteral("Printer Name");
1303     int32_t i = 0;
1304     while (gSettings[i].mName != nullptr) {
1305       printf("------------------------------------------------\n");
1306       printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
1307       printService->SavePrintSettingsToPrefs(ps, true, gSettings[i].mFlag);
1308       printService->InitPrintSettingsFromPrefs(ps, true, gSettings[i].mFlag);
1309       i++;
1310     }
1311   }
1312 }
1313 Tester gTester;
1314 #endif