widget/src/xpwidgets/nsPrintOptionsImpl.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2000
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Jessica Blanco <jblanco@us.ibm.com>
  24  *   Bastiaan Jacques <b.jacques@planet.nl>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "nsPrintOptionsImpl.h"
  41 #include "nsCoord.h"
  42 #include "nsReadableUtils.h"
  43 #include "nsPrintSettingsImpl.h"
  44
  45 #include "nsIDOMWindow.h"
  46 #include "nsIServiceManager.h"
  47 #include "nsIDialogParamBlock.h"
  48 #include "nsXPCOM.h"
  49 #include "nsISupportsPrimitives.h"
  50 #include "nsIWindowWatcher.h"
  51 #include "nsIDOMWindowInternal.h"
  52 #include "nsVoidArray.h"
  53 #include "nsSupportsArray.h"
  54 #include "prprf.h"
  55
  56 // For Prefs
  57 #include "nsIPrefBranch.h"
  58 #include "nsIPrefService.h"
  59 #include "nsIServiceManager.h"
  60
  61 #include "nsIStringEnumerator.h"
  62 #include "nsISupportsPrimitives.h"
  63 #include "stdlib.h"
  64 #include "nsAutoPtr.h"
  65
  66 NS_IMPL_ISUPPORTS2(nsPrintOptions, nsIPrintOptions, nsIPrintSettingsService)
  67
  68 // Pref Constants
  69 static const char kMarginTop[]       = "print_margin_top";
  70 static const char kMarginLeft[]      = "print_margin_left";
  71 static const char kMarginBottom[]    = "print_margin_bottom";
  72 static const char kMarginRight[]     = "print_margin_right";
  73 static const char kEdgeTop[]         = "print_edge_top";
  74 static const char kEdgeLeft[]        = "print_edge_left";
  75 static const char kEdgeBottom[]      = "print_edge_bottom";
  76 static const char kEdgeRight[]       = "print_edge_right";
  77 static const char kUnwriteableMarginTop[]    = "print_unwriteable_margin_top";
  78 static const char kUnwriteableMarginLeft[]   = "print_unwriteable_margin_left";
  79 static const char kUnwriteableMarginBottom[] = "print_unwriteable_margin_bottom";
  80 static const char kUnwriteableMarginRight[]  = "print_unwriteable_margin_right";
  81
  82 // Prefs for Print Options
  83 static const char kPrintEvenPages[]       = "print_evenpages";
  84 static const char kPrintOddPages[]        = "print_oddpages";
  85 static const char kPrintHeaderStrLeft[]   = "print_headerleft";
  86 static const char kPrintHeaderStrCenter[] = "print_headercenter";
  87 static const char kPrintHeaderStrRight[]  = "print_headerright";
  88 static const char kPrintFooterStrLeft[]   = "print_footerleft";
  89 static const char kPrintFooterStrCenter[] = "print_footercenter";
  90 static const char kPrintFooterStrRight[]  = "print_footerright";
  91
  92 // Additional Prefs
  93 static const char kPrintReversed[]      = "print_reversed";
  94 static const char kPrintInColor[]       = "print_in_color";
  95 static const char kPrintPaperName[]     = "print_paper_name";
  96 static const char kPrintPlexName[]      = "print_plex_name";
  97 static const char kPrintPaperSizeType[] = "print_paper_size_type";
  98 static const char kPrintPaperData[]     = "print_paper_data";
  99 static const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
 100 static const char kPrintPaperWidth[]    = "print_paper_width";
 101 static const char kPrintPaperHeight[]   = "print_paper_height";
 102 static const char kPrintColorspace[]    = "print_colorspace";
 103 static const char kPrintResolutionName[]= "print_resolution_name";
 104 static const char kPrintDownloadFonts[] = "print_downloadfonts";
 105 static const char kPrintOrientation[]   = "print_orientation";
 106 static const char kPrintCommand[]       = "print_command";
 107 static const char kPrinterName[]        = "print_printer";
 108 static const char kPrintToFile[]        = "print_to_file";
 109 static const char kPrintToFileName[]    = "print_to_filename";
 110 static const char kPrintPageDelay[]     = "print_pagedelay";
 111 static const char kPrintBGColors[]      = "print_bgcolor";
 112 static const char kPrintBGImages[]      = "print_bgimages";
 113 static const char kPrintShrinkToFit[]   = "print_shrink_to_fit";
 114 static const char kPrintScaling[]       = "print_scaling";
 115
 116 static const char kJustLeft[]   = "left";
 117 static const char kJustCenter[] = "center";
 118 static const char kJustRight[]  = "right";
 119
 120 #define NS_PRINTER_ENUMERATOR_CONTRACTID "@mozilla.org/gfx/printerenumerator;1"
 121
 122 nsPrintOptions::nsPrintOptions()
 123 {
 124 }
 125
 126 nsPrintOptions::~nsPrintOptions()
 127 {
 128 }
 129
 130 nsresult
 131 nsPrintOptions::Init()
 132 {
 133   nsresult rv;
 134   nsCOMPtr<nsIPrefService> prefService =
 135       do_GetService(NS_PREFSERVICE_CONTRACTID, &rv);
 136   NS_ENSURE_SUCCESS(rv, rv);
 137
 138   return prefService->GetBranch("print.", getter_AddRefs(mPrefBranch));
 139 }
 140
 141 NS_IMETHODIMP
 142 nsPrintOptions::ShowPrintSetupDialog(nsIPrintSettings *aPS)
 143 {
 144   NS_ENSURE_ARG_POINTER(aPS);
 145   nsresult rv;
 146
 147   // create a nsISupportsArray of the parameters
 148   // being passed to the window
 149   nsCOMPtr<nsISupportsArray> array;
 150   rv = NS_NewISupportsArray(getter_AddRefs(array));
 151   NS_ENSURE_SUCCESS(rv, rv);
 152
 153   nsCOMPtr<nsISupports> psSupports = do_QueryInterface(aPS);
 154   NS_ASSERTION(psSupports, "PrintSettings must be a supports");
 155   array->AppendElement(psSupports);
 156
 157   nsCOMPtr<nsIDialogParamBlock> ioParamBlock =
 158       do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID, &rv);
 159   NS_ENSURE_SUCCESS(rv, rv);
 160
 161   ioParamBlock->SetInt(0, 0);
 162
 163   nsCOMPtr<nsISupports> blkSupps = do_QueryInterface(ioParamBlock);
 164   NS_ASSERTION(blkSupps, "IOBlk must be a supports");
 165   array->AppendElement(blkSupps);
 166
 167   nsCOMPtr<nsIWindowWatcher> wwatch =
 168       do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
 169   NS_ENSURE_SUCCESS(rv, rv);
 170
 171   nsCOMPtr<nsIDOMWindow> active;
 172   wwatch->GetActiveWindow(getter_AddRefs(active));
 173   nsCOMPtr<nsIDOMWindowInternal> parent = do_QueryInterface(active);
 174   // null |parent| is non-fatal
 175
 176   nsCOMPtr<nsIDOMWindow> newWindow;
 177
 178   return wwatch->OpenWindow(parent,
 179                             "chrome://global/content/printPageSetup.xul",
 180                             "_blank","chrome,modal,centerscreen", array,
 181                             getter_AddRefs(newWindow));
 182 }
 183
 184 /** ---------------------------------------------------
 185  *  Helper function - Creates the "prefix" for the pref
 186  *  It is either "print."
 187  *  or "print.printer_<print name>."
 188  */
 189 const char*
 190 nsPrintOptions::GetPrefName(const char * aPrefName,
 191                             const nsAString& aPrinterName)
 192 {
 193   if (!aPrefName || !*aPrefName) {
 194     NS_ERROR("Must have a valid pref name!");
 195     return aPrefName;
 196   }
 197
 198   mPrefName.Truncate(); /* mPrefName = ""; */
 199
 200   if (aPrinterName.Length()) {
 201     mPrefName.Append("printer_");
 202     AppendUTF16toUTF8(aPrinterName, mPrefName);
 203     mPrefName.Append(".");
 204   }
 205   mPrefName += aPrefName;
 206
 207   return mPrefName.get();
 208 }
 209
 210 //----------------------------------------------------------------------
 211 // Testing of read/write prefs
 212 // This define controls debug output
 213 #ifdef DEBUG_rods_X
 214 static void WriteDebugStr(const char* aArg1, const char* aArg2,
 215                           const PRUnichar* aStr)
 216 {
 217   nsString str(aStr);
 218   PRUnichar s = '&';
 219   PRUnichar r = '_';
 220   str.ReplaceChar(s, r);
 221
 222   printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
 223 }
 224 const char* kWriteStr = "Write Pref:";
 225 const char* kReadStr  = "Read Pref:";
 226 #define DUMP_STR(_a1, _a2, _a3)  WriteDebugStr((_a1), GetPrefName((_a2), \
 227 aPrefName), (_a3));
 228 #define DUMP_BOOL(_a1, _a2, _a3) printf("%s %s = %s \n", (_a1), \
 229 GetPrefName((_a2), aPrefName), (_a3)?"T":"F");
 230 #define DUMP_INT(_a1, _a2, _a3)  printf("%s %s = %d \n", (_a1), \
 231 GetPrefName((_a2), aPrefName), (_a3));
 232 #define DUMP_DBL(_a1, _a2, _a3)  printf("%s %s = %10.5f \n", (_a1), \
 233 GetPrefName((_a2), aPrefName), (_a3));
 234 #else
 235 #define DUMP_STR(_a1, _a2, _a3)
 236 #define DUMP_BOOL(_a1, _a2, _a3)
 237 #define DUMP_INT(_a1, _a2, _a3)
 238 #define DUMP_DBL(_a1, _a2, _a3)
 239 #endif /* DEBUG_rods_X */
 240 //----------------------------------------------------------------------
 241
 242 /**
 243  *  This will either read in the generic prefs (not specific to a printer)
 244  *  or read the prefs in using the printer name to qualify.
 245  *  It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
 246  */
 247 nsresult
 248 nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName,
 249                           PRUint32 aFlags)
 250 {
 251   NS_ENSURE_STATE(mPrefBranch);
 252   NS_ENSURE_ARG_POINTER(aPS);
 253
 254   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
 255     nscoord halfInch = NS_INCHES_TO_TWIPS(0.5);
 256     nsMargin margin;
 257     margin.SizeTo(halfInch, halfInch, halfInch, halfInch);
 258     ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
 259                           kMarginTop);
 260     DUMP_INT(kReadStr, kMarginTop, margin.top);
 261     ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
 262                           kMarginLeft);
 263     DUMP_INT(kReadStr, kMarginLeft, margin.left);
 264     ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
 265                           margin.bottom, kMarginBottom);
 266     DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
 267     ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
 268                           kMarginRight);
 269     DUMP_INT(kReadStr, kMarginRight, margin.right);
 270     aPS->SetMarginInTwips(margin);
 271   }
 272
 273   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
 274     nsMargin margin;
 275     margin.SizeTo(0,0,0,0);
 276     ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
 277                              kEdgeTop);
 278     DUMP_INT(kReadStr, kEdgeTop, margin.top);
 279     ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
 280                              kEdgeLeft);
 281     DUMP_INT(kReadStr, kEdgeLeft, margin.left);
 282     ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
 283                              margin.bottom, kEdgeBottom);
 284     DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
 285     ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), margin.right,
 286                              kEdgeRight);
 287     DUMP_INT(kReadStr, kEdgeRight, margin.right);
 288     aPS->SetEdgeInTwips(margin);
 289   }
 290
 291   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
 292     nsMargin margin;
 293     margin.SizeTo(0,0,0,0);
 294     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName), margin.top,
 295                              kUnwriteableMarginTop);
 296     DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
 297     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left,
 298                              kUnwriteableMarginLeft);
 299     DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
 300     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
 301                              margin.bottom, kUnwriteableMarginBottom);
 302     DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
 303     ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right,
 304                              kUnwriteableMarginRight);
 305     DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
 306     aPS->SetUnwriteableMarginInTwips(margin);
 307   }
 308
 309   PRBool   b;
 310   nsAutoString str;
 311   PRInt32  iVal;
 312   double   dbl;
 313
 314 #define GETBOOLPREF(_prefname, _retval)                 \
 315   NS_SUCCEEDED(                                         \
 316     mPrefBranch->GetBoolPref(                           \
 317       GetPrefName(_prefname, aPrinterName), _retval     \
 318     )                                                   \
 319   )
 320
 321 #define GETSTRPREF(_prefname, _retval)                  \
 322   NS_SUCCEEDED(                                         \
 323     ReadPrefString(                                     \
 324       GetPrefName(_prefname, aPrinterName), _retval     \
 325     )                                                   \
 326   )
 327
 328 #define GETINTPREF(_prefname, _retval)                  \
 329   NS_SUCCEEDED(                                         \
 330     mPrefBranch->GetIntPref(                            \
 331       GetPrefName(_prefname, aPrinterName), _retval     \
 332     )                                                   \
 333   )
 334
 335 #define GETDBLPREF(_prefname, _retval)                  \
 336   NS_SUCCEEDED(                                         \
 337     ReadPrefDouble(                                     \
 338       GetPrefName(_prefname, aPrinterName), _retval     \
 339     )                                                   \
 340   )
 341
 342   // Paper size prefs are read as a group
 343   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
 344     PRInt32 sizeUnit, sizeType;
 345     double width, height;
 346
 347     PRBool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit)
 348                   && GETINTPREF(kPrintPaperSizeType, &sizeType)
 349                   && GETDBLPREF(kPrintPaperWidth, width)
 350                   && GETDBLPREF(kPrintPaperHeight, height)
 351                   && GETSTRPREF(kPrintPaperName, str);
 352
 353     // Bug 315687: Sanity check paper size to avoid paper size values in
 354     // mm when the size unit flag is inches. The value 100 is arbitrary
 355     // and can be changed.
 356     if (success) {
 357       success = (sizeUnit != nsIPrintSettings::kPaperSizeInches)
 358              || (width < 100.0)
 359              || (height < 100.0);
 360     }
 361
 362     if (success) {
 363       aPS->SetPaperSizeUnit(sizeUnit);
 364       DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
 365       aPS->SetPaperSizeType(sizeType);
 366       DUMP_INT(kReadStr, kPrintPaperSizeType, sizeType);
 367       aPS->SetPaperWidth(width);
 368       DUMP_DBL(kReadStr, kPrintPaperWidth, width);
 369       aPS->SetPaperHeight(height);
 370       DUMP_DBL(kReadStr, kPrintPaperHeight, height);
 371       aPS->SetPaperName(str.get());
 372       DUMP_STR(kReadStr, kPrintPaperName, str.get());
 373     }
 374   }
 375
 376   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 377   if (GETBOOLPREF(kPrintEvenPages, &b)) {
 378     aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
 379     DUMP_BOOL(kReadStr, kPrintEvenPages, b);
 380   }
 381   }
 382
 383   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 384     if (GETBOOLPREF(kPrintOddPages, &b)) {
 385       aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
 386       DUMP_BOOL(kReadStr, kPrintOddPages, b);
 387     }
 388   }
 389
 390   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
 391     if (GETSTRPREF(kPrintHeaderStrLeft, str)) {
 392       aPS->SetHeaderStrLeft(str.get());
 393       DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
 394     }
 395   }
 396
 397   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
 398     if (GETSTRPREF(kPrintHeaderStrCenter, str)) {
 399       aPS->SetHeaderStrCenter(str.get());
 400       DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
 401     }
 402   }
 403
 404   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
 405     if (GETSTRPREF(kPrintHeaderStrRight, str)) {
 406       aPS->SetHeaderStrRight(str.get());
 407       DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
 408     }
 409   }
 410
 411   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
 412     if (GETSTRPREF(kPrintFooterStrLeft, str)) {
 413       aPS->SetFooterStrLeft(str.get());
 414       DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
 415     }
 416   }
 417
 418   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
 419     if (GETSTRPREF(kPrintFooterStrCenter, str)) {
 420       aPS->SetFooterStrCenter(str.get());
 421       DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
 422     }
 423   }
 424
 425   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
 426     if (GETSTRPREF(kPrintFooterStrRight, str)) {
 427       aPS->SetFooterStrRight(str.get());
 428       DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
 429     }
 430   }
 431
 432   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
 433     if (GETBOOLPREF(kPrintBGColors, &b)) {
 434       aPS->SetPrintBGColors(b);
 435       DUMP_BOOL(kReadStr, kPrintBGColors, b);
 436     }
 437   }
 438
 439   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
 440     if (GETBOOLPREF(kPrintBGImages, &b)) {
 441       aPS->SetPrintBGImages(b);
 442       DUMP_BOOL(kReadStr, kPrintBGImages, b);
 443     }
 444   }
 445
 446   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
 447     if (GETBOOLPREF(kPrintReversed, &b)) {
 448       aPS->SetPrintReversed(b);
 449       DUMP_BOOL(kReadStr, kPrintReversed, b);
 450     }
 451   }
 452
 453   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
 454     if (GETBOOLPREF(kPrintInColor, &b)) {
 455       aPS->SetPrintInColor(b);
 456       DUMP_BOOL(kReadStr, kPrintInColor, b);
 457     }
 458   }
 459
 460   if (aFlags & nsIPrintSettings::kInitSavePlexName) {
 461     if (GETSTRPREF(kPrintPlexName, str)) {
 462       aPS->SetPlexName(str.get());
 463       DUMP_STR(kReadStr, kPrintPlexName, str.get());
 464     }
 465   }
 466
 467   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
 468     if (GETINTPREF(kPrintPaperData, &iVal)) {
 469       aPS->SetPaperData(iVal);
 470       DUMP_INT(kReadStr, kPrintPaperData, iVal);
 471     }
 472   }
 473
 474   if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
 475     if (GETSTRPREF(kPrintColorspace, str)) {
 476       aPS->SetColorspace(str.get());
 477       DUMP_STR(kReadStr, kPrintColorspace, str.get());
 478     }
 479   }
 480
 481   if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
 482     if (GETSTRPREF(kPrintResolutionName, str)) {
 483       aPS->SetResolutionName(str.get());
 484       DUMP_STR(kReadStr, kPrintResolutionName, str.get());
 485     }
 486   }
 487
 488   if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
 489     if (GETBOOLPREF(kPrintDownloadFonts, &b)) {
 490       aPS->SetDownloadFonts(b);
 491       DUMP_BOOL(kReadStr, kPrintDownloadFonts, b);
 492     }
 493   }
 494
 495   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
 496     if (GETINTPREF(kPrintOrientation, &iVal)) {
 497       aPS->SetOrientation(iVal);
 498       DUMP_INT(kReadStr, kPrintOrientation, iVal);
 499     }
 500   }
 501
 502   if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
 503     if (GETSTRPREF(kPrintCommand, str)) {
 504       aPS->SetPrintCommand(str.get());
 505       DUMP_STR(kReadStr, kPrintCommand, str.get());
 506     }
 507   }
 508
 509   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
 510     if (GETBOOLPREF(kPrintToFile, &b)) {
 511       aPS->SetPrintToFile(b);
 512       DUMP_BOOL(kReadStr, kPrintToFile, b);
 513     }
 514   }
 515
 516   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
 517     if (GETSTRPREF(kPrintToFileName, str)) {
 518       aPS->SetToFileName(str.get());
 519       DUMP_STR(kReadStr, kPrintToFileName, str.get());
 520     }
 521   }
 522
 523   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
 524     if (GETINTPREF(kPrintPageDelay, &iVal)) {
 525       aPS->SetPrintPageDelay(iVal);
 526       DUMP_INT(kReadStr, kPrintPageDelay, iVal);
 527     }
 528   }
 529
 530   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
 531     if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
 532       aPS->SetShrinkToFit(b);
 533       DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
 534     }
 535   }
 536
 537   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
 538     if (GETDBLPREF(kPrintScaling, dbl)) {
 539       aPS->SetScaling(dbl);
 540       DUMP_DBL(kReadStr, kPrintScaling, dbl);
 541     }
 542   }
 543
 544   // Not Reading In:
 545   //   Number of Copies
 546
 547   return NS_OK;
 548 }
 549
 550 /** ---------------------------------------------------
 551  *  See documentation in nsPrintOptionsImpl.h
 552  *  @update 1/12/01 rods
 553  */
 554 nsresult
 555 nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsAString& aPrinterName,
 556                            PRUint32 aFlags)
 557 {
 558   NS_ENSURE_ARG_POINTER(aPS);
 559   NS_ENSURE_STATE(mPrefBranch);
 560
 561   nsMargin margin;
 562   if (aFlags & nsIPrintSettings::kInitSaveMargins) {
 563     if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
 564       WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
 565                                margin.top);
 566       DUMP_INT(kWriteStr, kMarginTop, margin.top);
 567       WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
 568                                margin.left);
 569       DUMP_INT(kWriteStr, kMarginLeft, margin.top);
 570       WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
 571                                margin.bottom);
 572       DUMP_INT(kWriteStr, kMarginBottom, margin.top);
 573       WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
 574                                margin.right);
 575       DUMP_INT(kWriteStr, kMarginRight, margin.top);
 576     }
 577   }
 578
 579   nsMargin edge;
 580   if (aFlags & nsIPrintSettings::kInitSaveEdges) {
 581     if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
 582       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
 583                                   edge.top);
 584       DUMP_INT(kWriteStr, kEdgeTop, edge.top);
 585       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
 586                                   edge.left);
 587       DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
 588       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
 589                                   edge.bottom);
 590       DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
 591       WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
 592                                   edge.right);
 593       DUMP_INT(kWriteStr, kEdgeRight, edge.top);
 594     }
 595   }
 596
 597   nsMargin unwriteableMargin;
 598   if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
 599     if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
 600       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
 601                                   unwriteableMargin.top);
 602       DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
 603       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
 604                                   unwriteableMargin.left);
 605       DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
 606       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
 607                                   unwriteableMargin.bottom);
 608       DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
 609       WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
 610                                   unwriteableMargin.right);
 611       DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
 612     }
 613   }
 614
 615   // Paper size prefs are saved as a group
 616   if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
 617     PRInt16 sizeUnit, sizeType;
 618     double width, height;
 619     PRUnichar *name;
 620
 621     if (
 622       NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
 623       NS_SUCCEEDED(aPS->GetPaperSizeType(&sizeType)) &&
 624       NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
 625       NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
 626       NS_SUCCEEDED(aPS->GetPaperName(&name))
 627     ) {
 628       DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
 629       mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
 630                               PRInt32(sizeUnit));
 631       DUMP_INT(kWriteStr, kPrintPaperSizeType, sizeType);
 632       mPrefBranch->SetIntPref(GetPrefName(kPrintPaperSizeType, aPrinterName),
 633                               PRInt32(sizeType));
 634       DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
 635       WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
 636       DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
 637       WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
 638       DUMP_STR(kWriteStr, kPrintPaperName, name);
 639       WritePrefString(name, GetPrefName(kPrintPaperName, aPrinterName));
 640     }
 641   }
 642
 643   PRBool     b;
 644   PRUnichar* uStr;
 645   PRInt32    iVal;
 646   PRInt16    iVal16;
 647   double     dbl;
 648
 649   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 650     if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages,
 651                                           &b))) {
 652           DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
 653           mPrefBranch->SetBoolPref(GetPrefName(kPrintEvenPages, aPrinterName),
 654                                    b);
 655         }
 656   }
 657
 658   if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
 659     if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages,
 660                                           &b))) {
 661           DUMP_BOOL(kWriteStr, kPrintOddPages, b);
 662           mPrefBranch->SetBoolPref(GetPrefName(kPrintOddPages, aPrinterName),
 663                                    b);
 664         }
 665   }
 666
 667   if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
 668     if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
 669       DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
 670       WritePrefString(uStr, GetPrefName(kPrintHeaderStrLeft, aPrinterName));
 671     }
 672   }
 673
 674   if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
 675     if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
 676       DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
 677       WritePrefString(uStr, GetPrefName(kPrintHeaderStrCenter, aPrinterName));
 678     }
 679   }
 680
 681   if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
 682     if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
 683       DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
 684       WritePrefString(uStr, GetPrefName(kPrintHeaderStrRight, aPrinterName));
 685     }
 686   }
 687
 688   if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
 689     if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
 690       DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
 691       WritePrefString(uStr, GetPrefName(kPrintFooterStrLeft, aPrinterName));
 692     }
 693   }
 694
 695   if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
 696     if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
 697       DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
 698       WritePrefString(uStr, GetPrefName(kPrintFooterStrCenter, aPrinterName));
 699     }
 700   }
 701
 702   if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
 703     if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
 704       DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
 705       WritePrefString(uStr, GetPrefName(kPrintFooterStrRight, aPrinterName));
 706     }
 707   }
 708
 709   if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
 710     if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
 711       DUMP_BOOL(kWriteStr, kPrintBGColors, b);
 712       mPrefBranch->SetBoolPref(GetPrefName(kPrintBGColors, aPrinterName), b);
 713     }
 714   }
 715
 716   if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
 717     if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
 718       DUMP_BOOL(kWriteStr, kPrintBGImages, b);
 719       mPrefBranch->SetBoolPref(GetPrefName(kPrintBGImages, aPrinterName), b);
 720     }
 721   }
 722
 723   if (aFlags & nsIPrintSettings::kInitSaveReversed) {
 724     if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
 725       DUMP_BOOL(kWriteStr, kPrintReversed, b);
 726       mPrefBranch->SetBoolPref(GetPrefName(kPrintReversed, aPrinterName), b);
 727     }
 728   }
 729
 730   if (aFlags & nsIPrintSettings::kInitSaveInColor) {
 731     if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
 732       DUMP_BOOL(kWriteStr, kPrintInColor, b);
 733       mPrefBranch->SetBoolPref(GetPrefName(kPrintInColor, aPrinterName), b);
 734     }
 735   }
 736
 737   if (aFlags & nsIPrintSettings::kInitSavePlexName) {
 738     if (NS_SUCCEEDED(aPS->GetPlexName(&uStr))) {
 739       DUMP_STR(kWriteStr, kPrintPlexName, uStr);
 740       WritePrefString(uStr, GetPrefName(kPrintPlexName, aPrinterName));
 741     }
 742   }
 743
 744   if (aFlags & nsIPrintSettings::kInitSavePaperData) {
 745     if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
 746       DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
 747       mPrefBranch->SetIntPref(GetPrefName(kPrintPaperData, aPrinterName),
 748                               PRInt32(iVal16));
 749     }
 750   }
 751
 752   if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
 753     if (NS_SUCCEEDED(aPS->GetColorspace(&uStr))) {
 754       DUMP_STR(kWriteStr, kPrintColorspace, uStr);
 755       WritePrefString(uStr, GetPrefName(kPrintColorspace, aPrinterName));
 756     }
 757   }
 758
 759   if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
 760     if (NS_SUCCEEDED(aPS->GetResolutionName(&uStr))) {
 761       DUMP_STR(kWriteStr, kPrintResolutionName, uStr);
 762       WritePrefString(uStr, GetPrefName(kPrintResolutionName, aPrinterName));
 763     }
 764   }
 765
 766   if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
 767     if (NS_SUCCEEDED(aPS->GetDownloadFonts(&b))) {
 768       DUMP_BOOL(kWriteStr, kPrintDownloadFonts, b);
 769       mPrefBranch->SetBoolPref(GetPrefName(kPrintDownloadFonts, aPrinterName),
 770                                b);
 771     }
 772   }
 773
 774   if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
 775     if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
 776       DUMP_INT(kWriteStr, kPrintOrientation, iVal);
 777       mPrefBranch->SetIntPref(GetPrefName(kPrintOrientation, aPrinterName),
 778                               iVal);
 779     }
 780   }
 781
 782   if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
 783     if (NS_SUCCEEDED(aPS->GetPrintCommand(&uStr))) {
 784       DUMP_STR(kWriteStr, kPrintCommand, uStr);
 785       WritePrefString(uStr, GetPrefName(kPrintCommand, aPrinterName));
 786     }
 787   }
 788
 789   // Only the general version of this pref is saved
 790   if ((aFlags & nsIPrintSettings::kInitSavePrinterName)
 791       && aPrinterName.IsEmpty()) {
 792     if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
 793       DUMP_STR(kWriteStr, kPrinterName, uStr);
 794       WritePrefString(uStr, kPrinterName);
 795     }
 796   }
 797
 798   if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
 799     if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
 800       DUMP_BOOL(kWriteStr, kPrintToFile, b);
 801       mPrefBranch->SetBoolPref(GetPrefName(kPrintToFile, aPrinterName), b);
 802     }
 803   }
 804
 805   if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
 806     if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
 807       DUMP_STR(kWriteStr, kPrintToFileName, uStr);
 808       WritePrefString(uStr, GetPrefName(kPrintToFileName, aPrinterName));
 809     }
 810   }
 811
 812   if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
 813     if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
 814       DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
 815       mPrefBranch->SetIntPref(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
 816     }
 817   }
 818
 819   if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
 820     if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
 821       DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
 822       mPrefBranch->SetBoolPref(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
 823     }
 824   }
 825
 826   if (aFlags & nsIPrintSettings::kInitSaveScaling) {
 827     if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
 828       DUMP_DBL(kWriteStr, kPrintScaling, dbl);
 829       WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
 830     }
 831   }
 832
 833   // Not Writing Out:
 834   //   Number of Copies
 835
 836   return NS_OK;
 837 }
 838
 839 NS_IMETHODIMP
 840 nsPrintOptions::DisplayJobProperties(const PRUnichar *aPrinter,
 841                                      nsIPrintSettings* aPrintSettings,
 842                                      PRBool *aDisplayed)
 843 {
 844   NS_ENSURE_ARG_POINTER(aPrinter);
 845   *aDisplayed = PR_FALSE;
 846
 847   nsresult rv;
 848   nsCOMPtr<nsIPrinterEnumerator> propDlg =
 849            do_CreateInstance(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
 850   NS_ENSURE_SUCCESS(rv, rv);
 851
 852   NS_ENSURE_ARG_POINTER(aPrintSettings);
 853   rv = propDlg->DisplayPropertiesDlg(aPrinter, aPrintSettings);
 854   NS_ENSURE_SUCCESS(rv, rv);
 855
 856   *aDisplayed = PR_TRUE;
 857
 858   return rv;
 859 }
 860
 861 NS_IMETHODIMP nsPrintOptions::GetNativeData(PRInt16 aDataType, void * *_retval)
 862 {
 863   return NS_ERROR_NOT_IMPLEMENTED;
 864 }
 865
 866 nsresult nsPrintOptions::_CreatePrintSettings(nsIPrintSettings **_retval)
 867 {
 868   // does not initially ref count
 869   nsPrintSettings * printSettings = new nsPrintSettings();
 870   NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
 871
 872   NS_ADDREF(*_retval = printSettings); // ref count
 873
 874   nsXPIDLString printerName;
 875   nsresult rv = GetDefaultPrinterName(getter_Copies(printerName));
 876   NS_ENSURE_SUCCESS(rv, rv);
 877   (*_retval)->SetPrinterName(printerName.get());
 878
 879   (void)InitPrintSettingsFromPrefs(*_retval, PR_FALSE,
 880                                    nsIPrintSettings::kInitSaveAll);
 881
 882   return NS_OK;
 883 }
 884
 885 NS_IMETHODIMP nsPrintOptions::CreatePrintSettings(nsIPrintSettings **_retval)
 886 {
 887   return _CreatePrintSettings(_retval);
 888 }
 889
 890 NS_IMETHODIMP
 891 nsPrintOptions::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
 892 {
 893   nsresult rv;
 894
 895   rv = CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
 896   NS_ENSURE_SUCCESS(rv, rv);
 897
 898   NS_ADDREF(*aGlobalPrintSettings = mGlobalPrintSettings.get());
 899
 900   return rv;
 901 }
 902
 903 NS_IMETHODIMP
 904 nsPrintOptions::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
 905 {
 906   return CreatePrintSettings(aNewPrintSettings);
 907 }
 908
 909 NS_IMETHODIMP
 910 nsPrintOptions::GetDefaultPrinterName(PRUnichar * *aDefaultPrinterName)
 911 {
 912   nsresult rv;
 913   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
 914            do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
 915   NS_ENSURE_SUCCESS(rv, rv);
 916
 917   // Look up the printer from the last print job
 918   nsAutoString lastPrinterName;
 919   ReadPrefString(kPrinterName, lastPrinterName);
 920   if (!lastPrinterName.IsEmpty()) {
 921     // Verify it's still a valid printer
 922     nsCOMPtr<nsIStringEnumerator> printers;
 923     rv = prtEnum->GetPrinterNameList(getter_AddRefs(printers));
 924     if (NS_SUCCEEDED(rv)) {
 925       PRBool isValid = PR_FALSE;
 926       PRBool hasMore;
 927       while (NS_SUCCEEDED(printers->HasMore(&hasMore)) && hasMore) {
 928         nsAutoString printer;
 929         if (NS_SUCCEEDED(printers->GetNext(printer)) && lastPrinterName.Equals(printer)) {
 930           isValid = PR_TRUE;
 931           break;
 932         }
 933       }
 934       if (isValid) {
 935         *aDefaultPrinterName = ToNewUnicode(lastPrinterName);
 936         return NS_OK;
 937       }
 938     }
 939   }
 940
 941   // There is no last printer preference, or it doesn't name a valid printer.
 942   // Return the default from the printer enumeration.
 943   return prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
 944 }
 945
 946 NS_IMETHODIMP
 947 nsPrintOptions::InitPrintSettingsFromPrinter(const PRUnichar *aPrinterName,
 948                                              nsIPrintSettings *aPrintSettings)
 949 {
 950   NS_ENSURE_ARG_POINTER(aPrintSettings);
 951   NS_ENSURE_ARG_POINTER(aPrinterName);
 952
 953 #ifdef NS_DEBUG
 954   nsXPIDLString printerName;
 955   aPrintSettings->GetPrinterName(getter_Copies(printerName));
 956   if (!printerName.Equals(aPrinterName)) {
 957     NS_WARNING("Printer names should match!");
 958   }
 959 #endif
 960
 961   PRBool isInitialized;
 962   aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
 963   if (isInitialized)
 964     return NS_OK;
 965
 966   nsresult rv;
 967   nsCOMPtr<nsIPrinterEnumerator> prtEnum =
 968            do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
 969   NS_ENSURE_SUCCESS(rv, rv);
 970
 971   rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
 972   NS_ENSURE_SUCCESS(rv, rv);
 973
 974   aPrintSettings->SetIsInitializedFromPrinter(PR_TRUE);
 975   return rv;
 976 }
 977
 978 /** ---------------------------------------------------
 979  *  Helper function - Returns either the name or sets the length to zero
 980  */
 981 static nsresult
 982 GetAdjustedPrinterName(nsIPrintSettings* aPS, PRBool aUsePNP,
 983                        nsAString& aPrinterName)
 984 {
 985   NS_ENSURE_ARG_POINTER(aPS);
 986
 987   aPrinterName.Truncate();
 988   if (!aUsePNP)
 989     return NS_OK;
 990
 991   // Get the Printer Name from the PrintSettings
 992   // to use as a prefix for Pref Names
 993   PRUnichar* prtName = nsnull;
 994
 995   nsresult rv = aPS->GetPrinterName(&prtName);
 996   NS_ENSURE_SUCCESS(rv, rv);
 997
 998   aPrinterName = nsDependentString(prtName);
 999
1000   // Convert any whitespaces, carriage returns or newlines to _
1001   // The below algorithm is supposedly faster than using iterators
1002   NS_NAMED_LITERAL_STRING(replSubstr, "_");
1003   const char* replaceStr = " \n\r";
1004
1005   PRInt32 x;
1006   for (x=0; x < (PRInt32)strlen(replaceStr); x++) {
1007     PRUnichar uChar = replaceStr[x];
1008
1009     PRInt32 i = 0;
1010     while ((i = aPrinterName.FindChar(uChar, i)) != kNotFound) {
1011       aPrinterName.Replace(i, 1, replSubstr);
1012       i++;
1013     }
1014   }
1015   return NS_OK;
1016 }
1017
1018 NS_IMETHODIMP
1019 nsPrintOptions::GetPrinterPrefInt(nsIPrintSettings *aPrintSettings,
1020                                   const PRUnichar *aPrefName, PRInt32 *_retval)
1021 {
1022   NS_ENSURE_STATE(mPrefBranch);
1023   NS_ENSURE_ARG_POINTER(aPrintSettings);
1024   NS_ENSURE_ARG_POINTER(aPrefName);
1025
1026   nsAutoString prtName;
1027   // Get the Printer Name from the PrintSettings
1028   // to use as a prefix for Pref Names
1029   GetAdjustedPrinterName(aPrintSettings, PR_TRUE, prtName);
1030
1031   const char* prefName =
1032     GetPrefName(NS_LossyConvertUTF16toASCII(aPrefName).get(), prtName);
1033
1034   NS_ENSURE_TRUE(prefName, NS_ERROR_FAILURE);
1035
1036   PRInt32 iVal;
1037   nsresult rv = mPrefBranch->GetIntPref(prefName, &iVal);
1038   NS_ENSURE_SUCCESS(rv, rv);
1039
1040   *_retval = iVal;
1041   return rv;
1042 }
1043
1044 NS_IMETHODIMP
1045 nsPrintOptions::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
1046                                            PRBool aUsePNP, PRUint32 aFlags)
1047 {
1048   NS_ENSURE_ARG_POINTER(aPS);
1049
1050   PRBool isInitialized;
1051   aPS->GetIsInitializedFromPrefs(&isInitialized);
1052
1053   if (isInitialized)
1054     return NS_OK;
1055
1056   nsAutoString prtName;
1057   // read any non printer specific prefs
1058   // with empty printer name
1059   nsresult rv = ReadPrefs(aPS, prtName, aFlags);
1060   NS_ENSURE_SUCCESS(rv, rv);
1061
1062   // Get the Printer Name from the PrintSettings
1063   // to use as a prefix for Pref Names
1064   rv = GetAdjustedPrinterName(aPS, aUsePNP, prtName);
1065   NS_ENSURE_SUCCESS(rv, rv);
1066
1067   if (prtName.IsEmpty()) {
1068     NS_WARNING("Caller should supply a printer name.");
1069     return NS_OK;
1070   }
1071
1072   // Now read any printer specific prefs
1073   rv = ReadPrefs(aPS, prtName, aFlags);
1074   if (NS_SUCCEEDED(rv))
1075     aPS->SetIsInitializedFromPrefs(PR_TRUE);
1076
1077   return NS_OK;
1078 }
1079
1080 /**
1081  *  Save all of the printer settings; if we can find a printer name, save
1082  *  printer-specific preferences. Otherwise, save generic ones.
1083  */
1084 nsresult
1085 nsPrintOptions::SavePrintSettingsToPrefs(nsIPrintSettings *aPS,
1086                                          PRBool aUsePrinterNamePrefix,
1087                                          PRUint32 aFlags)
1088 {
1089   NS_ENSURE_ARG_POINTER(aPS);
1090   nsAutoString prtName;
1091
1092   // Get the printer name from the PrinterSettings for an optional prefix.
1093   nsresult rv = GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
1094   NS_ENSURE_SUCCESS(rv, rv);
1095
1096   // Write the prefs, with or without a printer name prefix.
1097   return WritePrefs(aPS, prtName, aFlags);
1098 }
1099
1100
1101 //-----------------------------------------------------
1102 //-- Protected Methods --------------------------------
1103 //-----------------------------------------------------
1104 nsresult
1105 nsPrintOptions::ReadPrefString(const char * aPrefId, nsAString& aString)
1106 {
1107   NS_ENSURE_STATE(mPrefBranch);
1108   NS_ENSURE_ARG_POINTER(aPrefId);
1109
1110   nsXPIDLCString str;
1111   nsresult rv = mPrefBranch->GetCharPref(aPrefId, getter_Copies(str));
1112   NS_ENSURE_SUCCESS(rv, rv);
1113
1114   CopyUTF8toUTF16(str.get(), aString);
1115
1116   return rv;
1117 }
1118
1119 nsresult
1120 nsPrintOptions::WritePrefString(PRUnichar*& aStr, const char* aPrefId)
1121 {
1122   NS_ENSURE_STATE(mPrefBranch);
1123   NS_ENSURE_ARG_POINTER(aStr);
1124   NS_ENSURE_ARG_POINTER(aPrefId);
1125
1126   nsresult rv = mPrefBranch->SetCharPref(aPrefId,
1127                                          NS_ConvertUTF16toUTF8(aStr).get());
1128
1129   nsMemory::Free(aStr);
1130   aStr = nsnull;
1131   return rv;
1132 }
1133
1134 nsresult
1135 nsPrintOptions::WritePrefString(const char * aPrefId, const nsAString& aString)
1136 {
1137   NS_ENSURE_STATE(mPrefBranch);
1138   NS_ENSURE_ARG_POINTER(aPrefId);
1139
1140   return mPrefBranch->SetCharPref(aPrefId,
1141                                   NS_ConvertUTF16toUTF8(aString).get());
1142 }
1143
1144 nsresult
1145 nsPrintOptions::ReadPrefDouble(const char * aPrefId, double& aVal)
1146 {
1147   NS_ENSURE_STATE(mPrefBranch);
1148   NS_ENSURE_ARG_POINTER(aPrefId);
1149
1150   char * str;
1151   nsresult rv = mPrefBranch->GetCharPref(aPrefId, &str);
1152   if (NS_SUCCEEDED(rv) && str) {
1153     aVal = atof(str);
1154     nsMemory::Free(str);
1155   }
1156   return rv;
1157 }
1158
1159 nsresult
1160 nsPrintOptions::WritePrefDouble(const char * aPrefId, double aVal)
1161 {
1162   NS_ENSURE_STATE(mPrefBranch);
1163   NS_ENSURE_ARG_POINTER(aPrefId);
1164
1165   char str[16]; // max 9 chars in below snprintf(), 16 will do nicely
1166   int ret = PR_snprintf(str, sizeof(str), "%6.2f", aVal);
1167   NS_ENSURE_TRUE(ret >= 0, NS_ERROR_FAILURE);
1168
1169   return mPrefBranch->SetCharPref(aPrefId, str);
1170 }
1171
1172 void
1173 nsPrintOptions::ReadInchesToTwipsPref(const char * aPrefId, nscoord& aTwips,
1174                                       const char * aMarginPref)
1175 {
1176   if (!mPrefBranch) {
1177     return;
1178   }
1179
1180   char * str = nsnull;
1181   nsresult rv = mPrefBranch->GetCharPref(aPrefId, &str);
1182   if (NS_FAILED(rv) || !str)
1183     rv = mPrefBranch->GetCharPref(aMarginPref, &str);
1184   if (NS_SUCCEEDED(rv) && str) {
1185     nsAutoString justStr;
1186     justStr.AssignWithConversion(str);
1187     PRInt32 errCode;
1188     float inches = justStr.ToFloat(&errCode);
1189     if (NS_SUCCEEDED(errCode)) {
1190       aTwips = NS_INCHES_TO_TWIPS(inches);
1191     } else {
1192       aTwips = 0;
1193     }
1194     nsMemory::Free(str);
1195   }
1196 }
1197
1198 void
1199 nsPrintOptions::WriteInchesFromTwipsPref(const char * aPrefId, nscoord aTwips)
1200 {
1201   if (!mPrefBranch) {
1202     return;
1203   }
1204
1205   double inches = NS_TWIPS_TO_INCHES(aTwips);
1206   nsCAutoString inchesStr;
1207   inchesStr.AppendFloat(inches);
1208
1209   mPrefBranch->SetCharPref(aPrefId, inchesStr.get());
1210 }
1211
1212 void
1213 nsPrintOptions::ReadInchesIntToTwipsPref(const char * aPrefId, nscoord& aTwips,
1214                                          const char * aMarginPref)
1215 {
1216   if (!mPrefBranch) {
1217     return;
1218   }
1219
1220   PRInt32 value;
1221   nsresult rv = mPrefBranch->GetIntPref(aPrefId, &value);
1222   if (NS_FAILED(rv)) {
1223     rv = mPrefBranch->GetIntPref(aMarginPref, &value);
1224   }
1225   if (NS_SUCCEEDED(rv)) {
1226     aTwips = NS_INCHES_TO_TWIPS(float(value)/100.0f);
1227   } else {
1228     aTwips = 0;
1229   }
1230 }
1231
1232 void
1233 nsPrintOptions::WriteInchesIntFromTwipsPref(const char * aPrefId, nscoord aTwips)
1234 {
1235   if (!mPrefBranch) {
1236     return;
1237   }
1238
1239   mPrefBranch->SetIntPref(aPrefId, PRInt32(NS_TWIPS_TO_INCHES(aTwips)*100.0f + 0.5f));
1240 }
1241
1242 void
1243 nsPrintOptions::ReadJustification(const char * aPrefId, PRInt16& aJust,
1244                                   PRInt16 aInitValue)
1245 {
1246   aJust = aInitValue;
1247   nsAutoString justStr;
1248   if (NS_SUCCEEDED(ReadPrefString(aPrefId, justStr))) {
1249     if (justStr.EqualsASCII(kJustRight)) {
1250       aJust = nsIPrintSettings::kJustRight;
1251
1252     } else if (justStr.EqualsASCII(kJustCenter)) {
1253       aJust = nsIPrintSettings::kJustCenter;
1254
1255     } else {
1256       aJust = nsIPrintSettings::kJustLeft;
1257     }
1258   }
1259 }
1260
1261 //---------------------------------------------------
1262 void
1263 nsPrintOptions::WriteJustification(const char * aPrefId, PRInt16 aJust)
1264 {
1265   switch (aJust) {
1266     case nsIPrintSettings::kJustLeft:
1267       mPrefBranch->SetCharPref(aPrefId, kJustLeft);
1268       break;
1269
1270     case nsIPrintSettings::kJustCenter:
1271       mPrefBranch->SetCharPref(aPrefId, kJustCenter);
1272       break;
1273
1274     case nsIPrintSettings::kJustRight:
1275       mPrefBranch->SetCharPref(aPrefId, kJustRight);
1276       break;
1277   } //switch
1278 }
1279
1280 //----------------------------------------------------------------------
1281 // Testing of read/write prefs
1282 // This define turns on the testing module below
1283 // so at start up it writes and reads the prefs.
1284 #ifdef DEBUG_rods_X
1285 class Tester {
1286   public:
1287     Tester();
1288 };
1289 Tester::Tester()
1290 {
1291   nsCOMPtr<nsIPrintSettings> ps;
1292   nsresult rv;
1293   nsCOMPtr<nsIPrintOptions> printService =
1294       do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
1295   if (NS_SUCCEEDED(rv)) {
1296     rv = printService->CreatePrintSettings(getter_AddRefs(ps));
1297   }
1298
1299   if (ps) {
1300     ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages,  PR_TRUE);
1301     ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages,  PR_FALSE);
1302     ps->SetMarginTop(1.0);
1303     ps->SetMarginLeft(1.0);
1304     ps->SetMarginBottom(1.0);
1305     ps->SetMarginRight(1.0);
1306     ps->SetScaling(0.5);
1307     ps->SetPrintBGColors(PR_TRUE);
1308     ps->SetPrintBGImages(PR_TRUE);
1309     ps->SetPrintRange(15);
1310     ps->SetHeaderStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1311     ps->SetHeaderStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1312     ps->SetHeaderStrRight(NS_ConvertUTF8toUTF16("Right").get());
1313     ps->SetFooterStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1314     ps->SetFooterStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1315     ps->SetFooterStrRight(NS_ConvertUTF8toUTF16("Right").get());
1316     ps->SetPaperName(NS_ConvertUTF8toUTF16("Paper Name").get());
1317     ps->SetPlexName(NS_ConvertUTF8toUTF16("Plex Name").get());
1318     ps->SetPaperSizeType(10);
1319     ps->SetPaperData(1);
1320     ps->SetPaperWidth(100.0);
1321     ps->SetPaperHeight(50.0);
1322     ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
1323     ps->SetPrintReversed(PR_TRUE);
1324     ps->SetPrintInColor(PR_TRUE);
1325     ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
1326     ps->SetPrintCommand(NS_ConvertUTF8toUTF16("Command").get());
1327     ps->SetNumCopies(2);
1328     ps->SetPrinterName(NS_ConvertUTF8toUTF16("Printer Name").get());
1329     ps->SetPrintToFile(PR_TRUE);
1330     ps->SetToFileName(NS_ConvertUTF8toUTF16("File Name").get());
1331     ps->SetPrintPageDelay(1000);
1332     ps->SetShrinkToFit(PR_TRUE);
1333
1334     struct SettingsType {
1335       const char* mName;
1336       PRUint32    mFlag;
1337     };
1338     SettingsType gSettings[] = {
1339       {"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
1340       {kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
1341       {kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
1342       {kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
1343       {kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
1344       {kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
1345       {kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
1346       {kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
1347       {kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
1348       {kPrintShrinkToFit, nsIPrintSettings::kInitSaveShrinkToFit},
1349       {kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
1350       {kPrintPlexName, nsIPrintSettings::kInitSavePlexName},
1351       {kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
1352       {kPrintReversed, nsIPrintSettings::kInitSaveReversed},
1353       {kPrintInColor, nsIPrintSettings::kInitSaveInColor},
1354       {kPrintColorspace, nsIPrintSettings::kInitSaveColorspace},
1355       {kPrintResolutionName, nsIPrintSettings::kInitSaveResolutionName},
1356       {kPrintDownloadFonts, nsIPrintSettings::kInitSaveDownloadFonts},
1357       {kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
1358       {kPrintCommand, nsIPrintSettings::kInitSavePrintCommand},
1359       {kPrinterName, nsIPrintSettings::kInitSavePrinterName},
1360       {kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
1361       {kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
1362       {kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
1363       {"Margins", nsIPrintSettings::kInitSaveMargins},
1364       {"All", nsIPrintSettings::kInitSaveAll},
1365       {nsnull, 0}};
1366
1367       nsString prefix; prefix.AssignLiteral("Printer Name");
1368       PRInt32 i = 0;
1369       while (gSettings[i].mName != nsnull) {
1370         printf("------------------------------------------------\n");
1371         printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
1372         printService->SavePrintSettingsToPrefs(ps, PR_TRUE, gSettings[i].mFlag);
1373         printService->InitPrintSettingsFromPrefs(ps, PR_TRUE,
1374                                                  gSettings[i].mFlag);
1375         i++;
1376       }
1377   }
1378
1379 }
1380 Tester gTester;
1381 #endif