widget/xpwidgets/nsPrintOptionsImpl.cpp@97036ab72558
widget/xpwidgets/nsPrintOptionsImpl.cpp
Tue, 06 Jan 2015 21:39:09 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Tue, 06 Jan 2015 21:39:09 +0100
- branch
- TOR_BUG_9701
- changeset 8
- 97036ab72558
- permissions
- -rw-r--r--
Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.
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/. */
6 #include "nsPrintOptionsImpl.h"
7 #include "nsReadableUtils.h"
8 #include "nsPrintSettingsImpl.h"
10 #include "nsIDOMWindow.h"
11 #include "nsIServiceManager.h"
12 #include "nsIDialogParamBlock.h"
13 #include "nsXPCOM.h"
14 #include "nsISupportsPrimitives.h"
15 #include "nsIWindowWatcher.h"
16 #include "nsISupportsArray.h"
17 #include "prprf.h"
19 #include "nsIStringEnumerator.h"
20 #include "nsISupportsPrimitives.h"
21 #include "stdlib.h"
22 #include "nsAutoPtr.h"
23 #include "mozilla/Preferences.h"
24 #include "nsPrintfCString.h"
26 using namespace mozilla;
28 NS_IMPL_ISUPPORTS(nsPrintOptions, nsIPrintOptions, nsIPrintSettingsService)
30 // Pref Constants
31 static const char kMarginTop[] = "print_margin_top";
32 static const char kMarginLeft[] = "print_margin_left";
33 static const char kMarginBottom[] = "print_margin_bottom";
34 static const char kMarginRight[] = "print_margin_right";
35 static const char kEdgeTop[] = "print_edge_top";
36 static const char kEdgeLeft[] = "print_edge_left";
37 static const char kEdgeBottom[] = "print_edge_bottom";
38 static const char kEdgeRight[] = "print_edge_right";
39 static const char kUnwriteableMarginTop[] = "print_unwriteable_margin_top";
40 static const char kUnwriteableMarginLeft[] = "print_unwriteable_margin_left";
41 static const char kUnwriteableMarginBottom[] = "print_unwriteable_margin_bottom";
42 static const char kUnwriteableMarginRight[] = "print_unwriteable_margin_right";
44 // Prefs for Print Options
45 static const char kPrintEvenPages[] = "print_evenpages";
46 static const char kPrintOddPages[] = "print_oddpages";
47 static const char kPrintHeaderStrLeft[] = "print_headerleft";
48 static const char kPrintHeaderStrCenter[] = "print_headercenter";
49 static const char kPrintHeaderStrRight[] = "print_headerright";
50 static const char kPrintFooterStrLeft[] = "print_footerleft";
51 static const char kPrintFooterStrCenter[] = "print_footercenter";
52 static const char kPrintFooterStrRight[] = "print_footerright";
54 // Additional Prefs
55 static const char kPrintReversed[] = "print_reversed";
56 static const char kPrintInColor[] = "print_in_color";
57 static const char kPrintPaperName[] = "print_paper_name";
58 static const char kPrintPlexName[] = "print_plex_name";
59 static const char kPrintPaperSizeType[] = "print_paper_size_type";
60 static const char kPrintPaperData[] = "print_paper_data";
61 static const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
62 static const char kPrintPaperWidth[] = "print_paper_width";
63 static const char kPrintPaperHeight[] = "print_paper_height";
64 static const char kPrintColorspace[] = "print_colorspace";
65 static const char kPrintResolutionName[]= "print_resolution_name";
66 static const char kPrintDownloadFonts[] = "print_downloadfonts";
67 static const char kPrintOrientation[] = "print_orientation";
68 static const char kPrintCommand[] = "print_command";
69 static const char kPrinterName[] = "print_printer";
70 static const char kPrintToFile[] = "print_to_file";
71 static const char kPrintToFileName[] = "print_to_filename";
72 static const char kPrintPageDelay[] = "print_page_delay";
73 static const char kPrintBGColors[] = "print_bgcolor";
74 static const char kPrintBGImages[] = "print_bgimages";
75 static const char kPrintShrinkToFit[] = "print_shrink_to_fit";
76 static const char kPrintScaling[] = "print_scaling";
77 static const char kPrintResolution[] = "print_resolution";
78 static const char kPrintDuplex[] = "print_duplex";
80 static const char kJustLeft[] = "left";
81 static const char kJustCenter[] = "center";
82 static const char kJustRight[] = "right";
84 #define NS_PRINTER_ENUMERATOR_CONTRACTID "@mozilla.org/gfx/printerenumerator;1"
86 nsPrintOptions::nsPrintOptions()
87 {
88 }
90 nsPrintOptions::~nsPrintOptions()
91 {
92 }
94 nsresult
95 nsPrintOptions::Init()
96 {
97 return NS_OK;
98 }
100 NS_IMETHODIMP
101 nsPrintOptions::ShowPrintSetupDialog(nsIPrintSettings *aPS)
102 {
103 NS_ENSURE_ARG_POINTER(aPS);
104 nsresult rv;
106 // create a nsISupportsArray of the parameters
107 // being passed to the window
108 nsCOMPtr<nsISupportsArray> array;
109 rv = NS_NewISupportsArray(getter_AddRefs(array));
110 NS_ENSURE_SUCCESS(rv, rv);
112 nsCOMPtr<nsISupports> psSupports = do_QueryInterface(aPS);
113 NS_ASSERTION(psSupports, "PrintSettings must be a supports");
114 array->AppendElement(psSupports);
116 nsCOMPtr<nsIDialogParamBlock> ioParamBlock =
117 do_CreateInstance(NS_DIALOGPARAMBLOCK_CONTRACTID, &rv);
118 NS_ENSURE_SUCCESS(rv, rv);
120 ioParamBlock->SetInt(0, 0);
122 nsCOMPtr<nsISupports> blkSupps = do_QueryInterface(ioParamBlock);
123 NS_ASSERTION(blkSupps, "IOBlk must be a supports");
124 array->AppendElement(blkSupps);
126 nsCOMPtr<nsIWindowWatcher> wwatch =
127 do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
128 NS_ENSURE_SUCCESS(rv, rv);
130 nsCOMPtr<nsIDOMWindow> parent;
131 wwatch->GetActiveWindow(getter_AddRefs(parent));
132 // null |parent| is non-fatal
134 nsCOMPtr<nsIDOMWindow> newWindow;
136 return wwatch->OpenWindow(parent,
137 "chrome://global/content/printPageSetup.xul",
138 "_blank","chrome,modal,centerscreen", array,
139 getter_AddRefs(newWindow));
140 }
142 /** ---------------------------------------------------
143 * Helper function - Creates the "prefix" for the pref
144 * It is either "print."
145 * or "print.printer_<print name>."
146 */
147 const char*
148 nsPrintOptions::GetPrefName(const char * aPrefName,
149 const nsAString& aPrinterName)
150 {
151 if (!aPrefName || !*aPrefName) {
152 NS_ERROR("Must have a valid pref name!");
153 return aPrefName;
154 }
156 mPrefName.AssignLiteral("print.");
158 if (aPrinterName.Length()) {
159 mPrefName.AppendLiteral("printer_");
160 AppendUTF16toUTF8(aPrinterName, mPrefName);
161 mPrefName.AppendLiteral(".");
162 }
163 mPrefName += aPrefName;
165 return mPrefName.get();
166 }
168 //----------------------------------------------------------------------
169 // Testing of read/write prefs
170 // This define controls debug output
171 #ifdef DEBUG_rods_X
172 static void WriteDebugStr(const char* aArg1, const char* aArg2,
173 const char16_t* aStr)
174 {
175 nsString str(aStr);
176 char16_t s = '&';
177 char16_t r = '_';
178 str.ReplaceChar(s, r);
180 printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
181 }
182 const char* kWriteStr = "Write Pref:";
183 const char* kReadStr = "Read Pref:";
184 #define DUMP_STR(_a1, _a2, _a3) WriteDebugStr((_a1), GetPrefName((_a2), \
185 aPrefName), (_a3));
186 #define DUMP_BOOL(_a1, _a2, _a3) printf("%s %s = %s \n", (_a1), \
187 GetPrefName((_a2), aPrefName), (_a3)?"T":"F");
188 #define DUMP_INT(_a1, _a2, _a3) printf("%s %s = %d \n", (_a1), \
189 GetPrefName((_a2), aPrefName), (_a3));
190 #define DUMP_DBL(_a1, _a2, _a3) printf("%s %s = %10.5f \n", (_a1), \
191 GetPrefName((_a2), aPrefName), (_a3));
192 #else
193 #define DUMP_STR(_a1, _a2, _a3)
194 #define DUMP_BOOL(_a1, _a2, _a3)
195 #define DUMP_INT(_a1, _a2, _a3)
196 #define DUMP_DBL(_a1, _a2, _a3)
197 #endif /* DEBUG_rods_X */
198 //----------------------------------------------------------------------
200 /**
201 * This will either read in the generic prefs (not specific to a printer)
202 * or read the prefs in using the printer name to qualify.
203 * It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
204 */
205 nsresult
206 nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName,
207 uint32_t aFlags)
208 {
209 NS_ENSURE_ARG_POINTER(aPS);
211 if (aFlags & nsIPrintSettings::kInitSaveMargins) {
212 int32_t halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
213 nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
214 ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
215 kMarginTop);
216 DUMP_INT(kReadStr, kMarginTop, margin.top);
217 ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
218 kMarginLeft);
219 DUMP_INT(kReadStr, kMarginLeft, margin.left);
220 ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
221 margin.bottom, kMarginBottom);
222 DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
223 ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
224 kMarginRight);
225 DUMP_INT(kReadStr, kMarginRight, margin.right);
226 aPS->SetMarginInTwips(margin);
227 }
229 if (aFlags & nsIPrintSettings::kInitSaveEdges) {
230 nsIntMargin margin(0,0,0,0);
231 ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
232 kEdgeTop);
233 DUMP_INT(kReadStr, kEdgeTop, margin.top);
234 ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
235 kEdgeLeft);
236 DUMP_INT(kReadStr, kEdgeLeft, margin.left);
237 ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
238 margin.bottom, kEdgeBottom);
239 DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
240 ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), margin.right,
241 kEdgeRight);
242 DUMP_INT(kReadStr, kEdgeRight, margin.right);
243 aPS->SetEdgeInTwips(margin);
244 }
246 if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
247 nsIntMargin margin;
248 ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName), margin.top,
249 kUnwriteableMarginTop);
250 DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
251 ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left,
252 kUnwriteableMarginLeft);
253 DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
254 ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
255 margin.bottom, kUnwriteableMarginBottom);
256 DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
257 ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right,
258 kUnwriteableMarginRight);
259 DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
260 aPS->SetUnwriteableMarginInTwips(margin);
261 }
263 bool b;
264 nsAutoString str;
265 int32_t iVal;
266 double dbl;
268 #define GETBOOLPREF(_prefname, _retval) \
269 NS_SUCCEEDED( \
270 Preferences::GetBool( \
271 GetPrefName(_prefname, aPrinterName), _retval \
272 ) \
273 )
275 #define GETSTRPREF(_prefname, _retval) \
276 NS_SUCCEEDED( \
277 Preferences::GetString( \
278 GetPrefName(_prefname, aPrinterName), _retval \
279 ) \
280 )
282 #define GETINTPREF(_prefname, _retval) \
283 NS_SUCCEEDED( \
284 Preferences::GetInt( \
285 GetPrefName(_prefname, aPrinterName), _retval \
286 ) \
287 )
289 #define GETDBLPREF(_prefname, _retval) \
290 NS_SUCCEEDED( \
291 ReadPrefDouble( \
292 GetPrefName(_prefname, aPrinterName), _retval \
293 ) \
294 )
296 // Paper size prefs are read as a group
297 if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
298 int32_t sizeUnit, sizeType;
299 double width, height;
301 bool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit)
302 && GETINTPREF(kPrintPaperSizeType, &sizeType)
303 && GETDBLPREF(kPrintPaperWidth, width)
304 && GETDBLPREF(kPrintPaperHeight, height)
305 && GETSTRPREF(kPrintPaperName, &str);
307 // Bug 315687: Sanity check paper size to avoid paper size values in
308 // mm when the size unit flag is inches. The value 100 is arbitrary
309 // and can be changed.
310 if (success) {
311 success = (sizeUnit != nsIPrintSettings::kPaperSizeInches)
312 || (width < 100.0)
313 || (height < 100.0);
314 }
316 if (success) {
317 aPS->SetPaperSizeUnit(sizeUnit);
318 DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
319 aPS->SetPaperSizeType(sizeType);
320 DUMP_INT(kReadStr, kPrintPaperSizeType, sizeType);
321 aPS->SetPaperWidth(width);
322 DUMP_DBL(kReadStr, kPrintPaperWidth, width);
323 aPS->SetPaperHeight(height);
324 DUMP_DBL(kReadStr, kPrintPaperHeight, height);
325 aPS->SetPaperName(str.get());
326 DUMP_STR(kReadStr, kPrintPaperName, str.get());
327 }
328 }
330 if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
331 if (GETBOOLPREF(kPrintEvenPages, &b)) {
332 aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
333 DUMP_BOOL(kReadStr, kPrintEvenPages, b);
334 }
335 }
337 if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
338 if (GETBOOLPREF(kPrintOddPages, &b)) {
339 aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
340 DUMP_BOOL(kReadStr, kPrintOddPages, b);
341 }
342 }
344 if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
345 if (GETSTRPREF(kPrintHeaderStrLeft, &str)) {
346 aPS->SetHeaderStrLeft(str.get());
347 DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
348 }
349 }
351 if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
352 if (GETSTRPREF(kPrintHeaderStrCenter, &str)) {
353 aPS->SetHeaderStrCenter(str.get());
354 DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
355 }
356 }
358 if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
359 if (GETSTRPREF(kPrintHeaderStrRight, &str)) {
360 aPS->SetHeaderStrRight(str.get());
361 DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
362 }
363 }
365 if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
366 if (GETSTRPREF(kPrintFooterStrLeft, &str)) {
367 aPS->SetFooterStrLeft(str.get());
368 DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
369 }
370 }
372 if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
373 if (GETSTRPREF(kPrintFooterStrCenter, &str)) {
374 aPS->SetFooterStrCenter(str.get());
375 DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
376 }
377 }
379 if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
380 if (GETSTRPREF(kPrintFooterStrRight, &str)) {
381 aPS->SetFooterStrRight(str.get());
382 DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
383 }
384 }
386 if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
387 if (GETBOOLPREF(kPrintBGColors, &b)) {
388 aPS->SetPrintBGColors(b);
389 DUMP_BOOL(kReadStr, kPrintBGColors, b);
390 }
391 }
393 if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
394 if (GETBOOLPREF(kPrintBGImages, &b)) {
395 aPS->SetPrintBGImages(b);
396 DUMP_BOOL(kReadStr, kPrintBGImages, b);
397 }
398 }
400 if (aFlags & nsIPrintSettings::kInitSaveReversed) {
401 if (GETBOOLPREF(kPrintReversed, &b)) {
402 aPS->SetPrintReversed(b);
403 DUMP_BOOL(kReadStr, kPrintReversed, b);
404 }
405 }
407 if (aFlags & nsIPrintSettings::kInitSaveInColor) {
408 if (GETBOOLPREF(kPrintInColor, &b)) {
409 aPS->SetPrintInColor(b);
410 DUMP_BOOL(kReadStr, kPrintInColor, b);
411 }
412 }
414 if (aFlags & nsIPrintSettings::kInitSavePlexName) {
415 if (GETSTRPREF(kPrintPlexName, &str)) {
416 aPS->SetPlexName(str.get());
417 DUMP_STR(kReadStr, kPrintPlexName, str.get());
418 }
419 }
421 if (aFlags & nsIPrintSettings::kInitSavePaperData) {
422 if (GETINTPREF(kPrintPaperData, &iVal)) {
423 aPS->SetPaperData(iVal);
424 DUMP_INT(kReadStr, kPrintPaperData, iVal);
425 }
426 }
428 if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
429 if (GETSTRPREF(kPrintColorspace, &str)) {
430 aPS->SetColorspace(str.get());
431 DUMP_STR(kReadStr, kPrintColorspace, str.get());
432 }
433 }
435 if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
436 if (GETSTRPREF(kPrintResolutionName, &str)) {
437 aPS->SetResolutionName(str.get());
438 DUMP_STR(kReadStr, kPrintResolutionName, str.get());
439 }
440 }
442 if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
443 if (GETBOOLPREF(kPrintDownloadFonts, &b)) {
444 aPS->SetDownloadFonts(b);
445 DUMP_BOOL(kReadStr, kPrintDownloadFonts, b);
446 }
447 }
449 if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
450 if (GETINTPREF(kPrintOrientation, &iVal)) {
451 aPS->SetOrientation(iVal);
452 DUMP_INT(kReadStr, kPrintOrientation, iVal);
453 }
454 }
456 if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
457 if (GETSTRPREF(kPrintCommand, &str)) {
458 aPS->SetPrintCommand(str.get());
459 DUMP_STR(kReadStr, kPrintCommand, str.get());
460 }
461 }
463 if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
464 if (GETBOOLPREF(kPrintToFile, &b)) {
465 aPS->SetPrintToFile(b);
466 DUMP_BOOL(kReadStr, kPrintToFile, b);
467 }
468 }
470 if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
471 if (GETSTRPREF(kPrintToFileName, &str)) {
472 aPS->SetToFileName(str.get());
473 DUMP_STR(kReadStr, kPrintToFileName, str.get());
474 }
475 }
477 if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
478 if (GETINTPREF(kPrintPageDelay, &iVal)) {
479 aPS->SetPrintPageDelay(iVal);
480 DUMP_INT(kReadStr, kPrintPageDelay, iVal);
481 }
482 }
484 if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
485 if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
486 aPS->SetShrinkToFit(b);
487 DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
488 }
489 }
491 if (aFlags & nsIPrintSettings::kInitSaveScaling) {
492 if (GETDBLPREF(kPrintScaling, dbl)) {
493 aPS->SetScaling(dbl);
494 DUMP_DBL(kReadStr, kPrintScaling, dbl);
495 }
496 }
498 if (aFlags & nsIPrintSettings::kInitSaveResolution) {
499 if (GETINTPREF(kPrintResolution, &iVal)) {
500 aPS->SetResolution(iVal);
501 DUMP_INT(kReadStr, kPrintResolution, iVal);
502 }
503 }
505 if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
506 if (GETINTPREF(kPrintDuplex, &iVal)) {
507 aPS->SetDuplex(iVal);
508 DUMP_INT(kReadStr, kPrintDuplex, iVal);
509 }
510 }
512 // Not Reading In:
513 // Number of Copies
515 return NS_OK;
516 }
518 /** ---------------------------------------------------
519 * See documentation in nsPrintOptionsImpl.h
520 * @update 1/12/01 rods
521 */
522 nsresult
523 nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsAString& aPrinterName,
524 uint32_t aFlags)
525 {
526 NS_ENSURE_ARG_POINTER(aPS);
528 bool persistMarginBoxSettings;
529 aPS->GetPersistMarginBoxSettings(&persistMarginBoxSettings);
531 nsIntMargin margin;
532 if (aFlags & nsIPrintSettings::kInitSaveMargins) {
533 if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
534 WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
535 margin.top);
536 DUMP_INT(kWriteStr, kMarginTop, margin.top);
537 WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
538 margin.left);
539 DUMP_INT(kWriteStr, kMarginLeft, margin.top);
540 WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
541 margin.bottom);
542 DUMP_INT(kWriteStr, kMarginBottom, margin.top);
543 WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
544 margin.right);
545 DUMP_INT(kWriteStr, kMarginRight, margin.top);
546 }
547 }
549 nsIntMargin edge;
550 if (aFlags & nsIPrintSettings::kInitSaveEdges) {
551 if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
552 WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
553 edge.top);
554 DUMP_INT(kWriteStr, kEdgeTop, edge.top);
555 WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
556 edge.left);
557 DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
558 WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
559 edge.bottom);
560 DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
561 WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
562 edge.right);
563 DUMP_INT(kWriteStr, kEdgeRight, edge.top);
564 }
565 }
567 nsIntMargin unwriteableMargin;
568 if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
569 if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
570 WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
571 unwriteableMargin.top);
572 DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
573 WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
574 unwriteableMargin.left);
575 DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
576 WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
577 unwriteableMargin.bottom);
578 DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
579 WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
580 unwriteableMargin.right);
581 DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
582 }
583 }
585 // Paper size prefs are saved as a group
586 if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
587 int16_t sizeUnit, sizeType;
588 double width, height;
589 char16_t *name;
591 if (
592 NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
593 NS_SUCCEEDED(aPS->GetPaperSizeType(&sizeType)) &&
594 NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
595 NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
596 NS_SUCCEEDED(aPS->GetPaperName(&name))
597 ) {
598 DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
599 Preferences::SetInt(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
600 int32_t(sizeUnit));
601 DUMP_INT(kWriteStr, kPrintPaperSizeType, sizeType);
602 Preferences::SetInt(GetPrefName(kPrintPaperSizeType, aPrinterName),
603 int32_t(sizeType));
604 DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
605 WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
606 DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
607 WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
608 DUMP_STR(kWriteStr, kPrintPaperName, name);
609 Preferences::SetString(GetPrefName(kPrintPaperName, aPrinterName), name);
610 }
611 }
613 bool b;
614 char16_t* uStr;
615 int32_t iVal;
616 int16_t iVal16;
617 double dbl;
619 if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
620 if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages,
621 &b))) {
622 DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
623 Preferences::SetBool(GetPrefName(kPrintEvenPages, aPrinterName), b);
624 }
625 }
627 if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
628 if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages,
629 &b))) {
630 DUMP_BOOL(kWriteStr, kPrintOddPages, b);
631 Preferences::SetBool(GetPrefName(kPrintOddPages, aPrinterName), b);
632 }
633 }
635 if (persistMarginBoxSettings) {
636 if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
637 if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
638 DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
639 Preferences::SetString(GetPrefName(kPrintHeaderStrLeft, aPrinterName),
640 uStr);
641 }
642 }
644 if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
645 if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
646 DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
647 Preferences::SetString(GetPrefName(kPrintHeaderStrCenter, aPrinterName),
648 uStr);
649 }
650 }
652 if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
653 if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
654 DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
655 Preferences::SetString(GetPrefName(kPrintHeaderStrRight, aPrinterName),
656 uStr);
657 }
658 }
660 if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
661 if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
662 DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
663 Preferences::SetString(GetPrefName(kPrintFooterStrLeft, aPrinterName),
664 uStr);
665 }
666 }
668 if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
669 if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
670 DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
671 Preferences::SetString(GetPrefName(kPrintFooterStrCenter, aPrinterName),
672 uStr);
673 }
674 }
676 if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
677 if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
678 DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
679 Preferences::SetString(GetPrefName(kPrintFooterStrRight, aPrinterName),
680 uStr);
681 }
682 }
683 }
685 if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
686 if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
687 DUMP_BOOL(kWriteStr, kPrintBGColors, b);
688 Preferences::SetBool(GetPrefName(kPrintBGColors, aPrinterName), b);
689 }
690 }
692 if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
693 if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
694 DUMP_BOOL(kWriteStr, kPrintBGImages, b);
695 Preferences::SetBool(GetPrefName(kPrintBGImages, aPrinterName), b);
696 }
697 }
699 if (aFlags & nsIPrintSettings::kInitSaveReversed) {
700 if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
701 DUMP_BOOL(kWriteStr, kPrintReversed, b);
702 Preferences::SetBool(GetPrefName(kPrintReversed, aPrinterName), b);
703 }
704 }
706 if (aFlags & nsIPrintSettings::kInitSaveInColor) {
707 if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
708 DUMP_BOOL(kWriteStr, kPrintInColor, b);
709 Preferences::SetBool(GetPrefName(kPrintInColor, aPrinterName), b);
710 }
711 }
713 if (aFlags & nsIPrintSettings::kInitSavePlexName) {
714 if (NS_SUCCEEDED(aPS->GetPlexName(&uStr))) {
715 DUMP_STR(kWriteStr, kPrintPlexName, uStr);
716 Preferences::SetString(GetPrefName(kPrintPlexName, aPrinterName), uStr);
717 }
718 }
720 if (aFlags & nsIPrintSettings::kInitSavePaperData) {
721 if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
722 DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
723 Preferences::SetInt(GetPrefName(kPrintPaperData, aPrinterName),
724 int32_t(iVal16));
725 }
726 }
728 if (aFlags & nsIPrintSettings::kInitSaveColorspace) {
729 if (NS_SUCCEEDED(aPS->GetColorspace(&uStr))) {
730 DUMP_STR(kWriteStr, kPrintColorspace, uStr);
731 Preferences::SetString(GetPrefName(kPrintColorspace, aPrinterName), uStr);
732 }
733 }
735 if (aFlags & nsIPrintSettings::kInitSaveResolutionName) {
736 if (NS_SUCCEEDED(aPS->GetResolutionName(&uStr))) {
737 DUMP_STR(kWriteStr, kPrintResolutionName, uStr);
738 Preferences::SetString(GetPrefName(kPrintResolutionName, aPrinterName),
739 uStr);
740 }
741 }
743 if (aFlags & nsIPrintSettings::kInitSaveDownloadFonts) {
744 if (NS_SUCCEEDED(aPS->GetDownloadFonts(&b))) {
745 DUMP_BOOL(kWriteStr, kPrintDownloadFonts, b);
746 Preferences::SetBool(GetPrefName(kPrintDownloadFonts, aPrinterName), b);
747 }
748 }
750 if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
751 if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
752 DUMP_INT(kWriteStr, kPrintOrientation, iVal);
753 Preferences::SetInt(GetPrefName(kPrintOrientation, aPrinterName), iVal);
754 }
755 }
757 if (aFlags & nsIPrintSettings::kInitSavePrintCommand) {
758 if (NS_SUCCEEDED(aPS->GetPrintCommand(&uStr))) {
759 DUMP_STR(kWriteStr, kPrintCommand, uStr);
760 Preferences::SetString(GetPrefName(kPrintCommand, aPrinterName), uStr);
761 }
762 }
764 // Only the general version of this pref is saved
765 if ((aFlags & nsIPrintSettings::kInitSavePrinterName)
766 && aPrinterName.IsEmpty()) {
767 if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
768 DUMP_STR(kWriteStr, kPrinterName, uStr);
769 Preferences::SetString(kPrinterName, uStr);
770 }
771 }
773 if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
774 if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
775 DUMP_BOOL(kWriteStr, kPrintToFile, b);
776 Preferences::SetBool(GetPrefName(kPrintToFile, aPrinterName), b);
777 }
778 }
780 if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
781 if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
782 DUMP_STR(kWriteStr, kPrintToFileName, uStr);
783 Preferences::SetString(GetPrefName(kPrintToFileName, aPrinterName), uStr);
784 }
785 }
787 if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
788 if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
789 DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
790 Preferences::SetInt(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
791 }
792 }
794 if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
795 if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
796 DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
797 Preferences::SetBool(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
798 }
799 }
801 if (aFlags & nsIPrintSettings::kInitSaveScaling) {
802 if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
803 DUMP_DBL(kWriteStr, kPrintScaling, dbl);
804 WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
805 }
806 }
808 if (aFlags & nsIPrintSettings::kInitSaveResolution) {
809 if (NS_SUCCEEDED(aPS->GetResolution(&iVal))) {
810 DUMP_INT(kWriteStr, kPrintResolution, iVal);
811 Preferences::SetInt(GetPrefName(kPrintResolution, aPrinterName), iVal);
812 }
813 }
815 if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
816 if (NS_SUCCEEDED(aPS->GetDuplex(&iVal))) {
817 DUMP_INT(kWriteStr, kPrintDuplex, iVal);
818 Preferences::SetInt(GetPrefName(kPrintDuplex, aPrinterName), iVal);
819 }
820 }
822 // Not Writing Out:
823 // Number of Copies
825 return NS_OK;
826 }
828 NS_IMETHODIMP
829 nsPrintOptions::DisplayJobProperties(const char16_t *aPrinter,
830 nsIPrintSettings* aPrintSettings,
831 bool *aDisplayed)
832 {
833 NS_ENSURE_ARG_POINTER(aPrinter);
834 *aDisplayed = false;
836 nsresult rv;
837 nsCOMPtr<nsIPrinterEnumerator> propDlg =
838 do_CreateInstance(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
839 NS_ENSURE_SUCCESS(rv, rv);
841 NS_ENSURE_ARG_POINTER(aPrintSettings);
842 rv = propDlg->DisplayPropertiesDlg(aPrinter, aPrintSettings);
843 NS_ENSURE_SUCCESS(rv, rv);
845 *aDisplayed = true;
847 return rv;
848 }
850 NS_IMETHODIMP nsPrintOptions::GetNativeData(int16_t aDataType, void * *_retval)
851 {
852 return NS_ERROR_NOT_IMPLEMENTED;
853 }
855 nsresult nsPrintOptions::_CreatePrintSettings(nsIPrintSettings **_retval)
856 {
857 // does not initially ref count
858 nsPrintSettings * printSettings = new nsPrintSettings();
859 NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
861 NS_ADDREF(*_retval = printSettings); // ref count
863 nsXPIDLString printerName;
864 nsresult rv = GetDefaultPrinterName(getter_Copies(printerName));
865 NS_ENSURE_SUCCESS(rv, rv);
866 (*_retval)->SetPrinterName(printerName.get());
868 (void)InitPrintSettingsFromPrefs(*_retval, false,
869 nsIPrintSettings::kInitSaveAll);
871 return NS_OK;
872 }
874 NS_IMETHODIMP nsPrintOptions::CreatePrintSettings(nsIPrintSettings **_retval)
875 {
876 return _CreatePrintSettings(_retval);
877 }
879 NS_IMETHODIMP
880 nsPrintOptions::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
881 {
882 nsresult rv;
884 rv = CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
885 NS_ENSURE_SUCCESS(rv, rv);
887 NS_ADDREF(*aGlobalPrintSettings = mGlobalPrintSettings.get());
889 return rv;
890 }
892 NS_IMETHODIMP
893 nsPrintOptions::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
894 {
895 return CreatePrintSettings(aNewPrintSettings);
896 }
898 NS_IMETHODIMP
899 nsPrintOptions::GetDefaultPrinterName(char16_t * *aDefaultPrinterName)
900 {
901 nsresult rv;
902 nsCOMPtr<nsIPrinterEnumerator> prtEnum =
903 do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
904 NS_ENSURE_SUCCESS(rv, rv);
906 // Look up the printer from the last print job
907 nsAutoString lastPrinterName;
908 Preferences::GetString(kPrinterName, &lastPrinterName);
909 if (!lastPrinterName.IsEmpty()) {
910 // Verify it's still a valid printer
911 nsCOMPtr<nsIStringEnumerator> printers;
912 rv = prtEnum->GetPrinterNameList(getter_AddRefs(printers));
913 if (NS_SUCCEEDED(rv)) {
914 bool isValid = false;
915 bool hasMore;
916 while (NS_SUCCEEDED(printers->HasMore(&hasMore)) && hasMore) {
917 nsAutoString printer;
918 if (NS_SUCCEEDED(printers->GetNext(printer)) && lastPrinterName.Equals(printer)) {
919 isValid = true;
920 break;
921 }
922 }
923 if (isValid) {
924 *aDefaultPrinterName = ToNewUnicode(lastPrinterName);
925 return NS_OK;
926 }
927 }
928 }
930 // There is no last printer preference, or it doesn't name a valid printer.
931 // Return the default from the printer enumeration.
932 return prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
933 }
935 NS_IMETHODIMP
936 nsPrintOptions::InitPrintSettingsFromPrinter(const char16_t *aPrinterName,
937 nsIPrintSettings *aPrintSettings)
938 {
939 NS_ENSURE_ARG_POINTER(aPrintSettings);
940 NS_ENSURE_ARG_POINTER(aPrinterName);
942 #ifdef DEBUG
943 nsXPIDLString printerName;
944 aPrintSettings->GetPrinterName(getter_Copies(printerName));
945 if (!printerName.Equals(aPrinterName)) {
946 NS_WARNING("Printer names should match!");
947 }
948 #endif
950 bool isInitialized;
951 aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
952 if (isInitialized)
953 return NS_OK;
955 nsresult rv;
956 nsCOMPtr<nsIPrinterEnumerator> prtEnum =
957 do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
958 NS_ENSURE_SUCCESS(rv, rv);
960 rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
961 NS_ENSURE_SUCCESS(rv, rv);
963 aPrintSettings->SetIsInitializedFromPrinter(true);
964 return rv;
965 }
967 /** ---------------------------------------------------
968 * Helper function - Returns either the name or sets the length to zero
969 */
970 static nsresult
971 GetAdjustedPrinterName(nsIPrintSettings* aPS, bool aUsePNP,
972 nsAString& aPrinterName)
973 {
974 NS_ENSURE_ARG_POINTER(aPS);
976 aPrinterName.Truncate();
977 if (!aUsePNP)
978 return NS_OK;
980 // Get the Printer Name from the PrintSettings
981 // to use as a prefix for Pref Names
982 char16_t* prtName = nullptr;
984 nsresult rv = aPS->GetPrinterName(&prtName);
985 NS_ENSURE_SUCCESS(rv, rv);
987 aPrinterName = nsDependentString(prtName);
989 // Convert any whitespaces, carriage returns or newlines to _
990 // The below algorithm is supposedly faster than using iterators
991 NS_NAMED_LITERAL_STRING(replSubstr, "_");
992 const char* replaceStr = " \n\r";
994 int32_t x;
995 for (x=0; x < (int32_t)strlen(replaceStr); x++) {
996 char16_t uChar = replaceStr[x];
998 int32_t i = 0;
999 while ((i = aPrinterName.FindChar(uChar, i)) != kNotFound) {
1000 aPrinterName.Replace(i, 1, replSubstr);
1001 i++;
1002 }
1003 }
1004 return NS_OK;
1005 }
1007 NS_IMETHODIMP
1008 nsPrintOptions::GetPrinterPrefInt(nsIPrintSettings *aPrintSettings,
1009 const char16_t *aPrefName, int32_t *_retval)
1010 {
1011 NS_ENSURE_ARG_POINTER(aPrintSettings);
1012 NS_ENSURE_ARG_POINTER(aPrefName);
1014 nsAutoString prtName;
1015 // Get the Printer Name from the PrintSettings
1016 // to use as a prefix for Pref Names
1017 GetAdjustedPrinterName(aPrintSettings, true, prtName);
1019 const char* prefName =
1020 GetPrefName(NS_LossyConvertUTF16toASCII(aPrefName).get(), prtName);
1022 NS_ENSURE_TRUE(prefName, NS_ERROR_FAILURE);
1024 int32_t iVal;
1025 nsresult rv = Preferences::GetInt(prefName, &iVal);
1026 NS_ENSURE_SUCCESS(rv, rv);
1028 *_retval = iVal;
1029 return rv;
1030 }
1032 NS_IMETHODIMP
1033 nsPrintOptions::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
1034 bool aUsePNP, uint32_t aFlags)
1035 {
1036 NS_ENSURE_ARG_POINTER(aPS);
1038 bool isInitialized;
1039 aPS->GetIsInitializedFromPrefs(&isInitialized);
1041 if (isInitialized)
1042 return NS_OK;
1044 nsAutoString prtName;
1045 // read any non printer specific prefs
1046 // with empty printer name
1047 nsresult rv = ReadPrefs(aPS, prtName, aFlags);
1048 NS_ENSURE_SUCCESS(rv, rv);
1050 // Do not use printer name in Linux because GTK backend does not support
1051 // per printer settings.
1052 #ifndef MOZ_X11
1053 // Get the Printer Name from the PrintSettings
1054 // to use as a prefix for Pref Names
1055 rv = GetAdjustedPrinterName(aPS, aUsePNP, prtName);
1056 NS_ENSURE_SUCCESS(rv, rv);
1058 if (prtName.IsEmpty()) {
1059 NS_WARNING("Caller should supply a printer name.");
1060 return NS_OK;
1061 }
1063 // Now read any printer specific prefs
1064 rv = ReadPrefs(aPS, prtName, aFlags);
1065 if (NS_SUCCEEDED(rv))
1066 aPS->SetIsInitializedFromPrefs(true);
1067 #endif
1069 return NS_OK;
1070 }
1072 /**
1073 * Save all of the printer settings; if we can find a printer name, save
1074 * printer-specific preferences. Otherwise, save generic ones.
1075 */
1076 nsresult
1077 nsPrintOptions::SavePrintSettingsToPrefs(nsIPrintSettings *aPS,
1078 bool aUsePrinterNamePrefix,
1079 uint32_t aFlags)
1080 {
1081 NS_ENSURE_ARG_POINTER(aPS);
1082 nsAutoString prtName;
1084 // Do not use printer name in Linux because GTK backend does not support
1085 // per printer settings.
1086 #ifndef MOZ_X11
1087 // Get the printer name from the PrinterSettings for an optional prefix.
1088 nsresult rv = GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
1089 NS_ENSURE_SUCCESS(rv, rv);
1090 #endif
1092 // Write the prefs, with or without a printer name prefix.
1093 return WritePrefs(aPS, prtName, aFlags);
1094 }
1097 //-----------------------------------------------------
1098 //-- Protected Methods --------------------------------
1099 //-----------------------------------------------------
1100 nsresult
1101 nsPrintOptions::ReadPrefDouble(const char * aPrefId, double& aVal)
1102 {
1103 NS_ENSURE_ARG_POINTER(aPrefId);
1105 nsAutoCString str;
1106 nsresult rv = Preferences::GetCString(aPrefId, &str);
1107 if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
1108 aVal = atof(str.get());
1109 }
1110 return rv;
1111 }
1113 nsresult
1114 nsPrintOptions::WritePrefDouble(const char * aPrefId, double aVal)
1115 {
1116 NS_ENSURE_ARG_POINTER(aPrefId);
1118 nsPrintfCString str("%6.2f", aVal);
1119 NS_ENSURE_TRUE(!str.IsEmpty(), NS_ERROR_FAILURE);
1121 return Preferences::SetCString(aPrefId, str);
1122 }
1124 void
1125 nsPrintOptions::ReadInchesToTwipsPref(const char * aPrefId, int32_t& aTwips,
1126 const char * aMarginPref)
1127 {
1128 nsAutoString str;
1129 nsresult rv = Preferences::GetString(aPrefId, &str);
1130 if (NS_FAILED(rv) || str.IsEmpty()) {
1131 rv = Preferences::GetString(aMarginPref, &str);
1132 }
1133 if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
1134 nsresult errCode;
1135 float inches = str.ToFloat(&errCode);
1136 if (NS_SUCCEEDED(errCode)) {
1137 aTwips = NS_INCHES_TO_INT_TWIPS(inches);
1138 } else {
1139 aTwips = 0;
1140 }
1141 }
1142 }
1144 void
1145 nsPrintOptions::WriteInchesFromTwipsPref(const char * aPrefId, int32_t aTwips)
1146 {
1147 double inches = NS_TWIPS_TO_INCHES(aTwips);
1148 nsAutoCString inchesStr;
1149 inchesStr.AppendFloat(inches);
1151 Preferences::SetCString(aPrefId, inchesStr);
1152 }
1154 void
1155 nsPrintOptions::ReadInchesIntToTwipsPref(const char * aPrefId, int32_t& aTwips,
1156 const char * aMarginPref)
1157 {
1158 int32_t value;
1159 nsresult rv = Preferences::GetInt(aPrefId, &value);
1160 if (NS_FAILED(rv)) {
1161 rv = Preferences::GetInt(aMarginPref, &value);
1162 }
1163 if (NS_SUCCEEDED(rv)) {
1164 aTwips = NS_INCHES_TO_INT_TWIPS(float(value)/100.0f);
1165 } else {
1166 aTwips = 0;
1167 }
1168 }
1170 void
1171 nsPrintOptions::WriteInchesIntFromTwipsPref(const char * aPrefId, int32_t aTwips)
1172 {
1173 Preferences::SetInt(aPrefId,
1174 int32_t(NS_TWIPS_TO_INCHES(aTwips) * 100.0f + 0.5f));
1175 }
1177 void
1178 nsPrintOptions::ReadJustification(const char * aPrefId, int16_t& aJust,
1179 int16_t aInitValue)
1180 {
1181 aJust = aInitValue;
1182 nsAutoString justStr;
1183 if (NS_SUCCEEDED(Preferences::GetString(aPrefId, &justStr))) {
1184 if (justStr.EqualsASCII(kJustRight)) {
1185 aJust = nsIPrintSettings::kJustRight;
1186 } else if (justStr.EqualsASCII(kJustCenter)) {
1187 aJust = nsIPrintSettings::kJustCenter;
1188 } else {
1189 aJust = nsIPrintSettings::kJustLeft;
1190 }
1191 }
1192 }
1194 //---------------------------------------------------
1195 void
1196 nsPrintOptions::WriteJustification(const char * aPrefId, int16_t aJust)
1197 {
1198 switch (aJust) {
1199 case nsIPrintSettings::kJustLeft:
1200 Preferences::SetCString(aPrefId, kJustLeft);
1201 break;
1203 case nsIPrintSettings::kJustCenter:
1204 Preferences::SetCString(aPrefId, kJustCenter);
1205 break;
1207 case nsIPrintSettings::kJustRight:
1208 Preferences::SetCString(aPrefId, kJustRight);
1209 break;
1210 } //switch
1211 }
1213 //----------------------------------------------------------------------
1214 // Testing of read/write prefs
1215 // This define turns on the testing module below
1216 // so at start up it writes and reads the prefs.
1217 #ifdef DEBUG_rods_X
1218 class Tester {
1219 public:
1220 Tester();
1221 };
1222 Tester::Tester()
1223 {
1224 nsCOMPtr<nsIPrintSettings> ps;
1225 nsresult rv;
1226 nsCOMPtr<nsIPrintOptions> printService =
1227 do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
1228 if (NS_SUCCEEDED(rv)) {
1229 rv = printService->CreatePrintSettings(getter_AddRefs(ps));
1230 }
1232 if (ps) {
1233 ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages, true);
1234 ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, false);
1235 ps->SetMarginTop(1.0);
1236 ps->SetMarginLeft(1.0);
1237 ps->SetMarginBottom(1.0);
1238 ps->SetMarginRight(1.0);
1239 ps->SetScaling(0.5);
1240 ps->SetPrintBGColors(true);
1241 ps->SetPrintBGImages(true);
1242 ps->SetPrintRange(15);
1243 ps->SetHeaderStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1244 ps->SetHeaderStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1245 ps->SetHeaderStrRight(NS_ConvertUTF8toUTF16("Right").get());
1246 ps->SetFooterStrLeft(NS_ConvertUTF8toUTF16("Left").get());
1247 ps->SetFooterStrCenter(NS_ConvertUTF8toUTF16("Center").get());
1248 ps->SetFooterStrRight(NS_ConvertUTF8toUTF16("Right").get());
1249 ps->SetPaperName(NS_ConvertUTF8toUTF16("Paper Name").get());
1250 ps->SetPlexName(NS_ConvertUTF8toUTF16("Plex Name").get());
1251 ps->SetPaperSizeType(10);
1252 ps->SetPaperData(1);
1253 ps->SetPaperWidth(100.0);
1254 ps->SetPaperHeight(50.0);
1255 ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
1256 ps->SetPrintReversed(true);
1257 ps->SetPrintInColor(true);
1258 ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
1259 ps->SetPrintCommand(NS_ConvertUTF8toUTF16("Command").get());
1260 ps->SetNumCopies(2);
1261 ps->SetPrinterName(NS_ConvertUTF8toUTF16("Printer Name").get());
1262 ps->SetPrintToFile(true);
1263 ps->SetToFileName(NS_ConvertUTF8toUTF16("File Name").get());
1264 ps->SetPrintPageDelay(1000);
1265 ps->SetShrinkToFit(true);
1267 struct SettingsType {
1268 const char* mName;
1269 uint32_t mFlag;
1270 };
1271 SettingsType gSettings[] = {
1272 {"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
1273 {kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
1274 {kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
1275 {kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
1276 {kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
1277 {kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
1278 {kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
1279 {kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
1280 {kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
1281 {kPrintShrinkToFit, nsIPrintSettings::kInitSaveShrinkToFit},
1282 {kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
1283 {kPrintPlexName, nsIPrintSettings::kInitSavePlexName},
1284 {kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
1285 {kPrintReversed, nsIPrintSettings::kInitSaveReversed},
1286 {kPrintInColor, nsIPrintSettings::kInitSaveInColor},
1287 {kPrintColorspace, nsIPrintSettings::kInitSaveColorspace},
1288 {kPrintResolutionName, nsIPrintSettings::kInitSaveResolutionName},
1289 {kPrintDownloadFonts, nsIPrintSettings::kInitSaveDownloadFonts},
1290 {kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
1291 {kPrintCommand, nsIPrintSettings::kInitSavePrintCommand},
1292 {kPrinterName, nsIPrintSettings::kInitSavePrinterName},
1293 {kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
1294 {kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
1295 {kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
1296 {"Margins", nsIPrintSettings::kInitSaveMargins},
1297 {"All", nsIPrintSettings::kInitSaveAll},
1298 {nullptr, 0}};
1300 nsString prefix; prefix.AssignLiteral("Printer Name");
1301 int32_t i = 0;
1302 while (gSettings[i].mName != nullptr) {
1303 printf("------------------------------------------------\n");
1304 printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
1305 printService->SavePrintSettingsToPrefs(ps, true, gSettings[i].mFlag);
1306 printService->InitPrintSettingsFromPrefs(ps, true,
1307 gSettings[i].mFlag);
1308 i++;
1309 }
1310 }
1312 }
1313 Tester gTester;
1314 #endif
