summaryrefslogtreecommitdiffstats
path: root/widget/nsPrintOptionsImpl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/nsPrintOptionsImpl.cpp')
-rw-r--r--widget/nsPrintOptionsImpl.cpp1418
1 files changed, 1418 insertions, 0 deletions
diff --git a/widget/nsPrintOptionsImpl.cpp b/widget/nsPrintOptionsImpl.cpp
new file mode 100644
index 000000000..97d699a93
--- /dev/null
+++ b/widget/nsPrintOptionsImpl.cpp
@@ -0,0 +1,1418 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsPrintOptionsImpl.h"
+
+#include "mozilla/embedding/PPrinting.h"
+#include "mozilla/layout/RemotePrintJobChild.h"
+#include "mozilla/RefPtr.h"
+#include "nsIPrinterEnumerator.h"
+#include "nsPrintingProxy.h"
+#include "nsReadableUtils.h"
+#include "nsPrintSettingsImpl.h"
+#include "nsIPrintSession.h"
+#include "nsServiceManagerUtils.h"
+
+#include "nsArray.h"
+#include "nsIDOMWindow.h"
+#include "nsIDialogParamBlock.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIWindowWatcher.h"
+#include "prprf.h"
+
+#include "nsIStringEnumerator.h"
+#include "nsISupportsPrimitives.h"
+#include "stdlib.h"
+#include "mozilla/Preferences.h"
+#include "nsPrintfCString.h"
+#include "nsIWebBrowserPrint.h"
+
+using namespace mozilla;
+using namespace mozilla::embedding;
+
+typedef mozilla::layout::RemotePrintJobChild RemotePrintJobChild;
+
+NS_IMPL_ISUPPORTS(nsPrintOptions, nsIPrintSettingsService)
+
+// Pref Constants
+static const char kMarginTop[] = "print_margin_top";
+static const char kMarginLeft[] = "print_margin_left";
+static const char kMarginBottom[] = "print_margin_bottom";
+static const char kMarginRight[] = "print_margin_right";
+static const char kEdgeTop[] = "print_edge_top";
+static const char kEdgeLeft[] = "print_edge_left";
+static const char kEdgeBottom[] = "print_edge_bottom";
+static const char kEdgeRight[] = "print_edge_right";
+static const char kUnwriteableMarginTop[] = "print_unwriteable_margin_top";
+static const char kUnwriteableMarginLeft[] = "print_unwriteable_margin_left";
+static const char kUnwriteableMarginBottom[] = "print_unwriteable_margin_bottom";
+static const char kUnwriteableMarginRight[] = "print_unwriteable_margin_right";
+
+// Prefs for Print Options
+static const char kPrintEvenPages[] = "print_evenpages";
+static const char kPrintOddPages[] = "print_oddpages";
+static const char kPrintHeaderStrLeft[] = "print_headerleft";
+static const char kPrintHeaderStrCenter[] = "print_headercenter";
+static const char kPrintHeaderStrRight[] = "print_headerright";
+static const char kPrintFooterStrLeft[] = "print_footerleft";
+static const char kPrintFooterStrCenter[] = "print_footercenter";
+static const char kPrintFooterStrRight[] = "print_footerright";
+
+// Additional Prefs
+static const char kPrintReversed[] = "print_reversed";
+static const char kPrintInColor[] = "print_in_color";
+static const char kPrintPaperName[] = "print_paper_name";
+static const char kPrintPaperData[] = "print_paper_data";
+static const char kPrintPaperSizeUnit[] = "print_paper_size_unit";
+static const char kPrintPaperWidth[] = "print_paper_width";
+static const char kPrintPaperHeight[] = "print_paper_height";
+static const char kPrintOrientation[] = "print_orientation";
+static const char kPrinterName[] = "print_printer";
+static const char kPrintToFile[] = "print_to_file";
+static const char kPrintToFileName[] = "print_to_filename";
+static const char kPrintPageDelay[] = "print_page_delay";
+static const char kPrintBGColors[] = "print_bgcolor";
+static const char kPrintBGImages[] = "print_bgimages";
+static const char kPrintShrinkToFit[] = "print_shrink_to_fit";
+static const char kPrintScaling[] = "print_scaling";
+static const char kPrintResolution[] = "print_resolution";
+static const char kPrintDuplex[] = "print_duplex";
+
+static const char kJustLeft[] = "left";
+static const char kJustCenter[] = "center";
+static const char kJustRight[] = "right";
+
+#define NS_PRINTER_ENUMERATOR_CONTRACTID "@mozilla.org/gfx/printerenumerator;1"
+
+nsPrintOptions::nsPrintOptions()
+{
+}
+
+nsPrintOptions::~nsPrintOptions()
+{
+}
+
+nsresult
+nsPrintOptions::Init()
+{
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintOptions::SerializeToPrintData(nsIPrintSettings* aSettings,
+ nsIWebBrowserPrint* aWBP,
+ PrintData* data)
+{
+ nsCOMPtr<nsIPrintSession> session;
+ nsresult rv = aSettings->GetPrintSession(getter_AddRefs(session));
+ if (NS_SUCCEEDED(rv) && session) {
+ RefPtr<RemotePrintJobChild> remotePrintJob;
+ rv = session->GetRemotePrintJob(getter_AddRefs(remotePrintJob));
+ if (NS_SUCCEEDED(rv)) {
+ data->remotePrintJobChild() = remotePrintJob;
+ }
+ }
+
+ aSettings->GetStartPageRange(&data->startPageRange());
+ aSettings->GetEndPageRange(&data->endPageRange());
+
+ aSettings->GetEdgeTop(&data->edgeTop());
+ aSettings->GetEdgeLeft(&data->edgeLeft());
+ aSettings->GetEdgeBottom(&data->edgeBottom());
+ aSettings->GetEdgeRight(&data->edgeRight());
+
+ aSettings->GetMarginTop(&data->marginTop());
+ aSettings->GetMarginLeft(&data->marginLeft());
+ aSettings->GetMarginBottom(&data->marginBottom());
+ aSettings->GetMarginRight(&data->marginRight());
+ aSettings->GetUnwriteableMarginTop(&data->unwriteableMarginTop());
+ aSettings->GetUnwriteableMarginLeft(&data->unwriteableMarginLeft());
+ aSettings->GetUnwriteableMarginBottom(&data->unwriteableMarginBottom());
+ aSettings->GetUnwriteableMarginRight(&data->unwriteableMarginRight());
+
+ aSettings->GetScaling(&data->scaling());
+
+ aSettings->GetPrintBGColors(&data->printBGColors());
+ aSettings->GetPrintBGImages(&data->printBGImages());
+ aSettings->GetPrintRange(&data->printRange());
+
+ // I have no idea if I'm doing this string copying correctly...
+ nsXPIDLString title;
+ aSettings->GetTitle(getter_Copies(title));
+ data->title() = title;
+
+ nsXPIDLString docURL;
+ aSettings->GetDocURL(getter_Copies(docURL));
+ data->docURL() = docURL;
+
+ // Header strings...
+ nsXPIDLString headerStrLeft;
+ aSettings->GetHeaderStrLeft(getter_Copies(headerStrLeft));
+ data->headerStrLeft() = headerStrLeft;
+
+ nsXPIDLString headerStrCenter;
+ aSettings->GetHeaderStrCenter(getter_Copies(headerStrCenter));
+ data->headerStrCenter() = headerStrCenter;
+
+ nsXPIDLString headerStrRight;
+ aSettings->GetHeaderStrRight(getter_Copies(headerStrRight));
+ data->headerStrRight() = headerStrRight;
+
+ // Footer strings...
+ nsXPIDLString footerStrLeft;
+ aSettings->GetFooterStrLeft(getter_Copies(footerStrLeft));
+ data->footerStrLeft() = footerStrLeft;
+
+ nsXPIDLString footerStrCenter;
+ aSettings->GetFooterStrCenter(getter_Copies(footerStrCenter));
+ data->footerStrCenter() = footerStrCenter;
+
+ nsXPIDLString footerStrRight;
+ aSettings->GetFooterStrRight(getter_Copies(footerStrRight));
+ data->footerStrRight() = footerStrRight;
+
+ aSettings->GetHowToEnableFrameUI(&data->howToEnableFrameUI());
+ aSettings->GetIsCancelled(&data->isCancelled());
+ aSettings->GetPrintFrameTypeUsage(&data->printFrameTypeUsage());
+ aSettings->GetPrintFrameType(&data->printFrameType());
+ aSettings->GetPrintSilent(&data->printSilent());
+ aSettings->GetShrinkToFit(&data->shrinkToFit());
+ aSettings->GetShowPrintProgress(&data->showPrintProgress());
+
+ nsXPIDLString paperName;
+ aSettings->GetPaperName(getter_Copies(paperName));
+ data->paperName() = paperName;
+
+ aSettings->GetPaperData(&data->paperData());
+ aSettings->GetPaperWidth(&data->paperWidth());
+ aSettings->GetPaperHeight(&data->paperHeight());
+ aSettings->GetPaperSizeUnit(&data->paperSizeUnit());
+
+ aSettings->GetPrintReversed(&data->printReversed());
+ aSettings->GetPrintInColor(&data->printInColor());
+ aSettings->GetOrientation(&data->orientation());
+
+ aSettings->GetNumCopies(&data->numCopies());
+
+ nsXPIDLString printerName;
+ aSettings->GetPrinterName(getter_Copies(printerName));
+ data->printerName() = printerName;
+
+ aSettings->GetPrintToFile(&data->printToFile());
+
+ nsXPIDLString toFileName;
+ aSettings->GetToFileName(getter_Copies(toFileName));
+ data->toFileName() = toFileName;
+
+ aSettings->GetOutputFormat(&data->outputFormat());
+ aSettings->GetPrintPageDelay(&data->printPageDelay());
+ aSettings->GetResolution(&data->resolution());
+ aSettings->GetDuplex(&data->duplex());
+ aSettings->GetIsInitializedFromPrinter(&data->isInitializedFromPrinter());
+ aSettings->GetIsInitializedFromPrefs(&data->isInitializedFromPrefs());
+
+ aSettings->GetPrintOptionsBits(&data->optionFlags());
+
+ // Initialize the platform-specific values that don't
+ // default-initialize, so that we don't send uninitialized data over
+ // IPC (which leads to valgrind warnings, and, for bools, fatal
+ // assertions).
+ // data->driverName() default-initializes
+ // data->deviceName() default-initializes
+ data->printableWidthInInches() = 0;
+ data->printableHeightInInches() = 0;
+ data->isFramesetDocument() = false;
+ data->isFramesetFrameSelected() = false;
+ data->isIFrameSelected() = false;
+ data->isRangeSelection() = false;
+ // data->GTKPrintSettings() default-initializes
+ // data->printJobName() default-initializes
+ data->printAllPages() = true;
+ data->mustCollate() = false;
+ // data->disposition() default-initializes
+ data->pagesAcross() = 1;
+ data->pagesDown() = 1;
+ data->printTime() = 0;
+ data->detailedErrorReporting() = true;
+ // data->faxNumber() default-initializes
+ data->addHeaderAndFooter() = false;
+ data->fileNameExtensionHidden() = false;
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintOptions::DeserializeToPrintSettings(const PrintData& data,
+ nsIPrintSettings* settings)
+{
+ nsCOMPtr<nsIPrintSession> session;
+ nsresult rv = settings->GetPrintSession(getter_AddRefs(session));
+ if (NS_SUCCEEDED(rv) && session) {
+ session->SetRemotePrintJob(
+ static_cast<RemotePrintJobChild*>(data.remotePrintJobChild()));
+ }
+ settings->SetStartPageRange(data.startPageRange());
+ settings->SetEndPageRange(data.endPageRange());
+
+ settings->SetEdgeTop(data.edgeTop());
+ settings->SetEdgeLeft(data.edgeLeft());
+ settings->SetEdgeBottom(data.edgeBottom());
+ settings->SetEdgeRight(data.edgeRight());
+
+ settings->SetMarginTop(data.marginTop());
+ settings->SetMarginLeft(data.marginLeft());
+ settings->SetMarginBottom(data.marginBottom());
+ settings->SetMarginRight(data.marginRight());
+ settings->SetUnwriteableMarginTop(data.unwriteableMarginTop());
+ settings->SetUnwriteableMarginLeft(data.unwriteableMarginLeft());
+ settings->SetUnwriteableMarginBottom(data.unwriteableMarginBottom());
+ settings->SetUnwriteableMarginRight(data.unwriteableMarginRight());
+
+ settings->SetScaling(data.scaling());
+
+ settings->SetPrintBGColors(data.printBGColors());
+ settings->SetPrintBGImages(data.printBGImages());
+ settings->SetPrintRange(data.printRange());
+
+ // I have no idea if I'm doing this string copying correctly...
+ settings->SetTitle(data.title().get());
+ settings->SetDocURL(data.docURL().get());
+
+ // Header strings...
+ settings->SetHeaderStrLeft(data.headerStrLeft().get());
+ settings->SetHeaderStrCenter(data.headerStrCenter().get());
+ settings->SetHeaderStrRight(data.headerStrRight().get());
+
+ // Footer strings...
+ settings->SetFooterStrLeft(data.footerStrLeft().get());
+ settings->SetFooterStrCenter(data.footerStrCenter().get());
+ settings->SetFooterStrRight(data.footerStrRight().get());
+
+ settings->SetHowToEnableFrameUI(data.howToEnableFrameUI());
+ settings->SetIsCancelled(data.isCancelled());
+ settings->SetPrintFrameTypeUsage(data.printFrameTypeUsage());
+ settings->SetPrintFrameType(data.printFrameType());
+ settings->SetPrintSilent(data.printSilent());
+ settings->SetShrinkToFit(data.shrinkToFit());
+ settings->SetShowPrintProgress(data.showPrintProgress());
+
+ settings->SetPaperName(data.paperName().get());
+
+ settings->SetPaperData(data.paperData());
+ settings->SetPaperWidth(data.paperWidth());
+ settings->SetPaperHeight(data.paperHeight());
+ settings->SetPaperSizeUnit(data.paperSizeUnit());
+
+ settings->SetPrintReversed(data.printReversed());
+ settings->SetPrintInColor(data.printInColor());
+ settings->SetOrientation(data.orientation());
+
+ settings->SetNumCopies(data.numCopies());
+
+ settings->SetPrinterName(data.printerName().get());
+
+ settings->SetPrintToFile(data.printToFile());
+
+ settings->SetToFileName(data.toFileName().get());
+
+ settings->SetOutputFormat(data.outputFormat());
+ settings->SetPrintPageDelay(data.printPageDelay());
+ settings->SetResolution(data.resolution());
+ settings->SetDuplex(data.duplex());
+ settings->SetIsInitializedFromPrinter(data.isInitializedFromPrinter());
+ settings->SetIsInitializedFromPrefs(data.isInitializedFromPrefs());
+
+ settings->SetPrintOptionsBits(data.optionFlags());
+
+ return NS_OK;
+}
+
+
+/** ---------------------------------------------------
+ * Helper function - Creates the "prefix" for the pref
+ * It is either "print."
+ * or "print.printer_<print name>."
+ */
+const char*
+nsPrintOptions::GetPrefName(const char * aPrefName,
+ const nsAString& aPrinterName)
+{
+ if (!aPrefName || !*aPrefName) {
+ NS_ERROR("Must have a valid pref name!");
+ return aPrefName;
+ }
+
+ mPrefName.AssignLiteral("print.");
+
+ if (aPrinterName.Length()) {
+ mPrefName.AppendLiteral("printer_");
+ AppendUTF16toUTF8(aPrinterName, mPrefName);
+ mPrefName.Append('.');
+ }
+ mPrefName += aPrefName;
+
+ return mPrefName.get();
+}
+
+//----------------------------------------------------------------------
+// Testing of read/write prefs
+// This define controls debug output
+#ifdef DEBUG_rods_X
+static void WriteDebugStr(const char* aArg1, const char* aArg2,
+ const char16_t* aStr)
+{
+ nsString str(aStr);
+ char16_t s = '&';
+ char16_t r = '_';
+ str.ReplaceChar(s, r);
+
+ printf("%s %s = %s \n", aArg1, aArg2, ToNewUTF8String(str));
+}
+const char* kWriteStr = "Write Pref:";
+const char* kReadStr = "Read Pref:";
+#define DUMP_STR(_a1, _a2, _a3) WriteDebugStr((_a1), GetPrefName((_a2), \
+aPrefName), (_a3));
+#define DUMP_BOOL(_a1, _a2, _a3) printf("%s %s = %s \n", (_a1), \
+GetPrefName((_a2), aPrefName), (_a3)?"T":"F");
+#define DUMP_INT(_a1, _a2, _a3) printf("%s %s = %d \n", (_a1), \
+GetPrefName((_a2), aPrefName), (_a3));
+#define DUMP_DBL(_a1, _a2, _a3) printf("%s %s = %10.5f \n", (_a1), \
+GetPrefName((_a2), aPrefName), (_a3));
+#else
+#define DUMP_STR(_a1, _a2, _a3)
+#define DUMP_BOOL(_a1, _a2, _a3)
+#define DUMP_INT(_a1, _a2, _a3)
+#define DUMP_DBL(_a1, _a2, _a3)
+#endif /* DEBUG_rods_X */
+//----------------------------------------------------------------------
+
+/**
+ * This will either read in the generic prefs (not specific to a printer)
+ * or read the prefs in using the printer name to qualify.
+ * It is either "print.attr_name" or "print.printer_HPLasr5.attr_name"
+ */
+nsresult
+nsPrintOptions::ReadPrefs(nsIPrintSettings* aPS, const nsAString& aPrinterName,
+ uint32_t aFlags)
+{
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ if (aFlags & nsIPrintSettings::kInitSaveMargins) {
+ int32_t halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
+ nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
+ ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top,
+ kMarginTop);
+ DUMP_INT(kReadStr, kMarginTop, margin.top);
+ ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), margin.left,
+ kMarginLeft);
+ DUMP_INT(kReadStr, kMarginLeft, margin.left);
+ ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
+ margin.bottom, kMarginBottom);
+ DUMP_INT(kReadStr, kMarginBottom, margin.bottom);
+ ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), margin.right,
+ kMarginRight);
+ DUMP_INT(kReadStr, kMarginRight, margin.right);
+ aPS->SetMarginInTwips(margin);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveEdges) {
+ nsIntMargin margin(0,0,0,0);
+ ReadInchesIntToTwipsPref(GetPrefName(kEdgeTop, aPrinterName), margin.top,
+ kEdgeTop);
+ DUMP_INT(kReadStr, kEdgeTop, margin.top);
+ ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), margin.left,
+ kEdgeLeft);
+ DUMP_INT(kReadStr, kEdgeLeft, margin.left);
+ ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
+ margin.bottom, kEdgeBottom);
+ DUMP_INT(kReadStr, kEdgeBottom, margin.bottom);
+ ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), margin.right,
+ kEdgeRight);
+ DUMP_INT(kReadStr, kEdgeRight, margin.right);
+ aPS->SetEdgeInTwips(margin);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
+ nsIntMargin margin;
+ ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName), margin.top,
+ kUnwriteableMarginTop);
+ DUMP_INT(kReadStr, kUnwriteableMarginTop, margin.top);
+ ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left,
+ kUnwriteableMarginLeft);
+ DUMP_INT(kReadStr, kUnwriteableMarginLeft, margin.left);
+ ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
+ margin.bottom, kUnwriteableMarginBottom);
+ DUMP_INT(kReadStr, kUnwriteableMarginBottom, margin.bottom);
+ ReadInchesIntToTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right,
+ kUnwriteableMarginRight);
+ DUMP_INT(kReadStr, kUnwriteableMarginRight, margin.right);
+ aPS->SetUnwriteableMarginInTwips(margin);
+ }
+
+ bool b;
+ nsAutoString str;
+ int32_t iVal;
+ double dbl;
+
+#define GETBOOLPREF(_prefname, _retval) \
+ NS_SUCCEEDED( \
+ Preferences::GetBool( \
+ GetPrefName(_prefname, aPrinterName), _retval \
+ ) \
+ )
+
+#define GETSTRPREF(_prefname, _retval) \
+ NS_SUCCEEDED( \
+ Preferences::GetString( \
+ GetPrefName(_prefname, aPrinterName), _retval \
+ ) \
+ )
+
+#define GETINTPREF(_prefname, _retval) \
+ NS_SUCCEEDED( \
+ Preferences::GetInt( \
+ GetPrefName(_prefname, aPrinterName), _retval \
+ ) \
+ )
+
+#define GETDBLPREF(_prefname, _retval) \
+ NS_SUCCEEDED( \
+ ReadPrefDouble( \
+ GetPrefName(_prefname, aPrinterName), _retval \
+ ) \
+ )
+
+ // Paper size prefs are read as a group
+ if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
+ int32_t sizeUnit;
+ double width, height;
+
+ bool success = GETINTPREF(kPrintPaperSizeUnit, &sizeUnit)
+ && GETDBLPREF(kPrintPaperWidth, width)
+ && GETDBLPREF(kPrintPaperHeight, height)
+ && GETSTRPREF(kPrintPaperName, &str);
+
+ // Bug 315687: Sanity check paper size to avoid paper size values in
+ // mm when the size unit flag is inches. The value 100 is arbitrary
+ // and can be changed.
+#if defined(XP_WIN)
+ bool saveSanitizedSizePrefs = false;
+#endif
+ if (success) {
+ success = (sizeUnit != nsIPrintSettings::kPaperSizeInches)
+ || (width < 100.0)
+ || (height < 100.0);
+#if defined(XP_WIN)
+ // Work around legacy invalid prefs where the size unit gets set to
+ // millimeters, but the height and width remains as the previous inches
+ // settings. See bug 1276717 and bug 1369386 for details.
+ if (sizeUnit == nsIPrintSettings::kPaperSizeMillimeters &&
+ height >= 0L && height < 25L &&
+ width >= 0L && width < 25L) {
+
+ // As small pages sizes can be valid we only override when the old
+ // (now no longer set) pref print_paper_size_type exists. This will be
+ // removed when we save the prefs below.
+ const char* paperSizeTypePref =
+ GetPrefName("print_paper_size_type", aPrinterName);
+ if (Preferences::HasUserValue(paperSizeTypePref)) {
+ saveSanitizedSizePrefs = true;
+ height = -1L;
+ width = -1L;
+ }
+ }
+#endif
+ }
+
+ if (success) {
+ aPS->SetPaperSizeUnit(sizeUnit);
+ DUMP_INT(kReadStr, kPrintPaperSizeUnit, sizeUnit);
+ aPS->SetPaperWidth(width);
+ DUMP_DBL(kReadStr, kPrintPaperWidth, width);
+ aPS->SetPaperHeight(height);
+ DUMP_DBL(kReadStr, kPrintPaperHeight, height);
+ aPS->SetPaperName(str.get());
+ DUMP_STR(kReadStr, kPrintPaperName, str.get());
+#if defined(XP_WIN)
+ if (saveSanitizedSizePrefs) {
+ SavePrintSettingsToPrefs(aPS, !aPrinterName.IsEmpty(),
+ nsIPrintSettings::kInitSavePaperSize);
+ }
+#endif
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
+ if (GETBOOLPREF(kPrintEvenPages, &b)) {
+ aPS->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, b);
+ DUMP_BOOL(kReadStr, kPrintEvenPages, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
+ if (GETBOOLPREF(kPrintOddPages, &b)) {
+ aPS->SetPrintOptions(nsIPrintSettings::kPrintOddPages, b);
+ DUMP_BOOL(kReadStr, kPrintOddPages, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
+ if (GETSTRPREF(kPrintHeaderStrLeft, &str)) {
+ aPS->SetHeaderStrLeft(str.get());
+ DUMP_STR(kReadStr, kPrintHeaderStrLeft, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
+ if (GETSTRPREF(kPrintHeaderStrCenter, &str)) {
+ aPS->SetHeaderStrCenter(str.get());
+ DUMP_STR(kReadStr, kPrintHeaderStrCenter, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
+ if (GETSTRPREF(kPrintHeaderStrRight, &str)) {
+ aPS->SetHeaderStrRight(str.get());
+ DUMP_STR(kReadStr, kPrintHeaderStrRight, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
+ if (GETSTRPREF(kPrintFooterStrLeft, &str)) {
+ aPS->SetFooterStrLeft(str.get());
+ DUMP_STR(kReadStr, kPrintFooterStrLeft, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
+ if (GETSTRPREF(kPrintFooterStrCenter, &str)) {
+ aPS->SetFooterStrCenter(str.get());
+ DUMP_STR(kReadStr, kPrintFooterStrCenter, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
+ if (GETSTRPREF(kPrintFooterStrRight, &str)) {
+ aPS->SetFooterStrRight(str.get());
+ DUMP_STR(kReadStr, kPrintFooterStrRight, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
+ if (GETBOOLPREF(kPrintBGColors, &b)) {
+ aPS->SetPrintBGColors(b);
+ DUMP_BOOL(kReadStr, kPrintBGColors, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
+ if (GETBOOLPREF(kPrintBGImages, &b)) {
+ aPS->SetPrintBGImages(b);
+ DUMP_BOOL(kReadStr, kPrintBGImages, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveReversed) {
+ if (GETBOOLPREF(kPrintReversed, &b)) {
+ aPS->SetPrintReversed(b);
+ DUMP_BOOL(kReadStr, kPrintReversed, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveInColor) {
+ if (GETBOOLPREF(kPrintInColor, &b)) {
+ aPS->SetPrintInColor(b);
+ DUMP_BOOL(kReadStr, kPrintInColor, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePaperData) {
+ if (GETINTPREF(kPrintPaperData, &iVal)) {
+ aPS->SetPaperData(iVal);
+ DUMP_INT(kReadStr, kPrintPaperData, iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
+ if (GETINTPREF(kPrintOrientation, &iVal)) {
+ aPS->SetOrientation(iVal);
+ DUMP_INT(kReadStr, kPrintOrientation, iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
+ if (GETBOOLPREF(kPrintToFile, &b)) {
+ aPS->SetPrintToFile(b);
+ DUMP_BOOL(kReadStr, kPrintToFile, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
+ if (GETSTRPREF(kPrintToFileName, &str)) {
+ aPS->SetToFileName(str.get());
+ DUMP_STR(kReadStr, kPrintToFileName, str.get());
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
+ if (GETINTPREF(kPrintPageDelay, &iVal)) {
+ aPS->SetPrintPageDelay(iVal);
+ DUMP_INT(kReadStr, kPrintPageDelay, iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
+ if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
+ aPS->SetShrinkToFit(b);
+ DUMP_BOOL(kReadStr, kPrintShrinkToFit, b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveScaling) {
+ if (GETDBLPREF(kPrintScaling, dbl)) {
+ aPS->SetScaling(dbl);
+ DUMP_DBL(kReadStr, kPrintScaling, dbl);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveResolution) {
+ if (GETINTPREF(kPrintResolution, &iVal)) {
+ aPS->SetResolution(iVal);
+ DUMP_INT(kReadStr, kPrintResolution, iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
+ if (GETINTPREF(kPrintDuplex, &iVal)) {
+ aPS->SetDuplex(iVal);
+ DUMP_INT(kReadStr, kPrintDuplex, iVal);
+ }
+ }
+
+ // Not Reading In:
+ // Number of Copies
+
+ return NS_OK;
+}
+
+/** ---------------------------------------------------
+ * See documentation in nsPrintOptionsImpl.h
+ * @update 1/12/01 rods
+ */
+nsresult
+nsPrintOptions::WritePrefs(nsIPrintSettings *aPS, const nsAString& aPrinterName,
+ uint32_t aFlags)
+{
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ nsIntMargin margin;
+ if (aFlags & nsIPrintSettings::kInitSaveMargins) {
+ if (NS_SUCCEEDED(aPS->GetMarginInTwips(margin))) {
+ WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName),
+ margin.top);
+ DUMP_INT(kWriteStr, kMarginTop, margin.top);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
+ margin.left);
+ DUMP_INT(kWriteStr, kMarginLeft, margin.top);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
+ margin.bottom);
+ DUMP_INT(kWriteStr, kMarginBottom, margin.top);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
+ margin.right);
+ DUMP_INT(kWriteStr, kMarginRight, margin.top);
+ }
+ }
+
+ nsIntMargin edge;
+ if (aFlags & nsIPrintSettings::kInitSaveEdges) {
+ if (NS_SUCCEEDED(aPS->GetEdgeInTwips(edge))) {
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName),
+ edge.top);
+ DUMP_INT(kWriteStr, kEdgeTop, edge.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
+ edge.left);
+ DUMP_INT(kWriteStr, kEdgeLeft, edge.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
+ edge.bottom);
+ DUMP_INT(kWriteStr, kEdgeBottom, edge.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
+ edge.right);
+ DUMP_INT(kWriteStr, kEdgeRight, edge.top);
+ }
+ }
+
+ nsIntMargin unwriteableMargin;
+ if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
+ if (NS_SUCCEEDED(aPS->GetUnwriteableMarginInTwips(unwriteableMargin))) {
+ WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginTop, aPrinterName),
+ unwriteableMargin.top);
+ DUMP_INT(kWriteStr, kUnwriteableMarginTop, unwriteableMargin.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginLeft, aPrinterName),
+ unwriteableMargin.left);
+ DUMP_INT(kWriteStr, kUnwriteableMarginLeft, unwriteableMargin.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginBottom, aPrinterName),
+ unwriteableMargin.bottom);
+ DUMP_INT(kWriteStr, kUnwriteableMarginBottom, unwriteableMargin.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kUnwriteableMarginRight, aPrinterName),
+ unwriteableMargin.right);
+ DUMP_INT(kWriteStr, kUnwriteableMarginRight, unwriteableMargin.top);
+ }
+ }
+
+ // Paper size prefs are saved as a group
+ if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
+ int16_t sizeUnit;
+ double width, height;
+ char16_t *name;
+
+ if (
+ NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
+ NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
+ NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
+ NS_SUCCEEDED(aPS->GetPaperName(&name))
+ ) {
+ DUMP_INT(kWriteStr, kPrintPaperSizeUnit, sizeUnit);
+ Preferences::SetInt(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
+ int32_t(sizeUnit));
+ DUMP_DBL(kWriteStr, kPrintPaperWidth, width);
+ WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
+ DUMP_DBL(kWriteStr, kPrintPaperHeight, height);
+ WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
+ DUMP_STR(kWriteStr, kPrintPaperName, name);
+ Preferences::SetString(GetPrefName(kPrintPaperName, aPrinterName), name);
+#if defined(XP_WIN)
+ // If the height and width are -1 then this might be a save triggered by
+ // print pref sanitizing code. This is done as a one off and is partly
+ // triggered by the existence of an old (now no longer set) pref. We
+ // remove that pref if it exists here, so that we don't try and sanitize
+ // what might be valid prefs. See bug 1276717 and bug 1369386 for details.
+ if (height == -1L && width == -1L) {
+ const char* paperSizeTypePref =
+ GetPrefName("print_paper_size_type", aPrinterName);
+ if (Preferences::HasUserValue(paperSizeTypePref)) {
+ Preferences::ClearUser(paperSizeTypePref);
+ }
+ }
+#endif
+ }
+ }
+
+ bool b;
+ char16_t* uStr;
+ int32_t iVal;
+ int16_t iVal16;
+ double dbl;
+
+ if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
+ if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintEvenPages,
+ &b))) {
+ DUMP_BOOL(kWriteStr, kPrintEvenPages, b);
+ Preferences::SetBool(GetPrefName(kPrintEvenPages, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOddEvenPages) {
+ if (NS_SUCCEEDED(aPS->GetPrintOptions(nsIPrintSettings::kPrintOddPages,
+ &b))) {
+ DUMP_BOOL(kWriteStr, kPrintOddPages, b);
+ Preferences::SetBool(GetPrefName(kPrintOddPages, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintHeaderStrLeft, uStr);
+ Preferences::SetString(GetPrefName(kPrintHeaderStrLeft, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintHeaderStrCenter, uStr);
+ Preferences::SetString(GetPrefName(kPrintHeaderStrCenter, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrRight(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintHeaderStrRight, uStr);
+ Preferences::SetString(GetPrefName(kPrintHeaderStrRight, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrLeft(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintFooterStrLeft, uStr);
+ Preferences::SetString(GetPrefName(kPrintFooterStrLeft, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrCenter(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintFooterStrCenter, uStr);
+ Preferences::SetString(GetPrefName(kPrintFooterStrCenter, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrRight(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintFooterStrRight, uStr);
+ Preferences::SetString(GetPrefName(kPrintFooterStrRight, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
+ if (NS_SUCCEEDED(aPS->GetPrintBGColors(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintBGColors, b);
+ Preferences::SetBool(GetPrefName(kPrintBGColors, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
+ if (NS_SUCCEEDED(aPS->GetPrintBGImages(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintBGImages, b);
+ Preferences::SetBool(GetPrefName(kPrintBGImages, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveReversed) {
+ if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintReversed, b);
+ Preferences::SetBool(GetPrefName(kPrintReversed, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveInColor) {
+ if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintInColor, b);
+ Preferences::SetBool(GetPrefName(kPrintInColor, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePaperData) {
+ if (NS_SUCCEEDED(aPS->GetPaperData(&iVal16))) {
+ DUMP_INT(kWriteStr, kPrintPaperData, iVal16);
+ Preferences::SetInt(GetPrefName(kPrintPaperData, aPrinterName),
+ int32_t(iVal16));
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
+ if (NS_SUCCEEDED(aPS->GetOrientation(&iVal))) {
+ DUMP_INT(kWriteStr, kPrintOrientation, iVal);
+ Preferences::SetInt(GetPrefName(kPrintOrientation, aPrinterName), iVal);
+ }
+ }
+
+ // Only the general version of this pref is saved
+ if ((aFlags & nsIPrintSettings::kInitSavePrinterName)
+ && aPrinterName.IsEmpty()) {
+ if (NS_SUCCEEDED(aPS->GetPrinterName(&uStr))) {
+ DUMP_STR(kWriteStr, kPrinterName, uStr);
+ Preferences::SetString(kPrinterName, uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
+ if (NS_SUCCEEDED(aPS->GetPrintToFile(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintToFile, b);
+ Preferences::SetBool(GetPrefName(kPrintToFile, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
+ if (NS_SUCCEEDED(aPS->GetToFileName(&uStr))) {
+ DUMP_STR(kWriteStr, kPrintToFileName, uStr);
+ Preferences::SetString(GetPrefName(kPrintToFileName, aPrinterName), uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
+ if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
+ DUMP_INT(kWriteStr, kPrintPageDelay, iVal);
+ Preferences::SetInt(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
+ if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
+ DUMP_BOOL(kWriteStr, kPrintShrinkToFit, b);
+ Preferences::SetBool(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveScaling) {
+ if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
+ DUMP_DBL(kWriteStr, kPrintScaling, dbl);
+ WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveResolution) {
+ if (NS_SUCCEEDED(aPS->GetResolution(&iVal))) {
+ DUMP_INT(kWriteStr, kPrintResolution, iVal);
+ Preferences::SetInt(GetPrefName(kPrintResolution, aPrinterName), iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
+ if (NS_SUCCEEDED(aPS->GetDuplex(&iVal))) {
+ DUMP_INT(kWriteStr, kPrintDuplex, iVal);
+ Preferences::SetInt(GetPrefName(kPrintDuplex, aPrinterName), iVal);
+ }
+ }
+
+ // Not Writing Out:
+ // Number of Copies
+
+ return NS_OK;
+}
+
+nsresult nsPrintOptions::_CreatePrintSettings(nsIPrintSettings **_retval)
+{
+ // does not initially ref count
+ nsPrintSettings * printSettings = new nsPrintSettings();
+ NS_ENSURE_TRUE(printSettings, NS_ERROR_OUT_OF_MEMORY);
+
+ NS_ADDREF(*_retval = printSettings); // ref count
+
+ nsXPIDLString printerName;
+ nsresult rv = GetDefaultPrinterName(getter_Copies(printerName));
+ NS_ENSURE_SUCCESS(rv, rv);
+ (*_retval)->SetPrinterName(printerName.get());
+
+ (void)InitPrintSettingsFromPrefs(*_retval, false,
+ nsIPrintSettings::kInitSaveAll);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintOptions::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
+{
+ nsresult rv;
+
+ rv = _CreatePrintSettings(getter_AddRefs(mGlobalPrintSettings));
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ NS_ADDREF(*aGlobalPrintSettings = mGlobalPrintSettings.get());
+
+ return rv;
+}
+
+NS_IMETHODIMP
+nsPrintOptions::GetNewPrintSettings(nsIPrintSettings * *aNewPrintSettings)
+{
+ return _CreatePrintSettings(aNewPrintSettings);
+}
+
+NS_IMETHODIMP
+nsPrintOptions::GetDefaultPrinterName(char16_t * *aDefaultPrinterName)
+{
+ nsresult rv;
+ nsCOMPtr<nsIPrinterEnumerator> prtEnum =
+ do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Look up the printer from the last print job
+ nsAutoString lastPrinterName;
+ Preferences::GetString(kPrinterName, &lastPrinterName);
+ if (!lastPrinterName.IsEmpty()) {
+ // Verify it's still a valid printer
+ nsCOMPtr<nsIStringEnumerator> printers;
+ rv = prtEnum->GetPrinterNameList(getter_AddRefs(printers));
+ if (NS_SUCCEEDED(rv)) {
+ bool isValid = false;
+ bool hasMore;
+ while (NS_SUCCEEDED(printers->HasMore(&hasMore)) && hasMore) {
+ nsAutoString printer;
+ if (NS_SUCCEEDED(printers->GetNext(printer)) && lastPrinterName.Equals(printer)) {
+ isValid = true;
+ break;
+ }
+ }
+ if (isValid) {
+ *aDefaultPrinterName = ToNewUnicode(lastPrinterName);
+ return NS_OK;
+ }
+ }
+ }
+
+ // There is no last printer preference, or it doesn't name a valid printer.
+ // Return the default from the printer enumeration.
+ return prtEnum->GetDefaultPrinterName(aDefaultPrinterName);
+}
+
+NS_IMETHODIMP
+nsPrintOptions::InitPrintSettingsFromPrinter(const char16_t *aPrinterName,
+ nsIPrintSettings *aPrintSettings)
+{
+ // Don't get print settings from the printer in the child when printing via
+ // parent, these will be retrieved in the parent later in the print process.
+ if (XRE_IsContentProcess() && Preferences::GetBool("print.print_via_parent")) {
+ return NS_OK;
+ }
+
+ NS_ENSURE_ARG_POINTER(aPrintSettings);
+ NS_ENSURE_ARG_POINTER(aPrinterName);
+
+#ifdef DEBUG
+ nsXPIDLString printerName;
+ aPrintSettings->GetPrinterName(getter_Copies(printerName));
+ if (!printerName.Equals(aPrinterName)) {
+ NS_WARNING("Printer names should match!");
+ }
+#endif
+
+ bool isInitialized;
+ aPrintSettings->GetIsInitializedFromPrinter(&isInitialized);
+ if (isInitialized)
+ return NS_OK;
+
+ nsresult rv;
+ nsCOMPtr<nsIPrinterEnumerator> prtEnum =
+ do_GetService(NS_PRINTER_ENUMERATOR_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = prtEnum->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aPrintSettings->SetIsInitializedFromPrinter(true);
+ return rv;
+}
+
+#ifndef MOZ_X11
+/** ---------------------------------------------------
+ * Helper function - Returns either the name or sets the length to zero
+ */
+static nsresult
+GetAdjustedPrinterName(nsIPrintSettings* aPS, bool aUsePNP,
+ nsAString& aPrinterName)
+{
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ aPrinterName.Truncate();
+ if (!aUsePNP)
+ return NS_OK;
+
+ // Get the Printer Name from the PrintSettings
+ // to use as a prefix for Pref Names
+ char16_t* prtName = nullptr;
+
+ nsresult rv = aPS->GetPrinterName(&prtName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aPrinterName = nsDependentString(prtName);
+
+ // Convert any whitespaces, carriage returns or newlines to _
+ // The below algorithm is supposedly faster than using iterators
+ NS_NAMED_LITERAL_STRING(replSubstr, "_");
+ const char* replaceStr = " \n\r";
+
+ int32_t x;
+ for (x=0; x < (int32_t)strlen(replaceStr); x++) {
+ char16_t uChar = replaceStr[x];
+
+ int32_t i = 0;
+ while ((i = aPrinterName.FindChar(uChar, i)) != kNotFound) {
+ aPrinterName.Replace(i, 1, replSubstr);
+ i++;
+ }
+ }
+ return NS_OK;
+}
+#endif
+
+NS_IMETHODIMP
+nsPrintOptions::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
+ bool aUsePNP, uint32_t aFlags)
+{
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ bool isInitialized;
+ aPS->GetIsInitializedFromPrefs(&isInitialized);
+
+ if (isInitialized)
+ return NS_OK;
+
+ nsAutoString prtName;
+ // read any non printer specific prefs
+ // with empty printer name
+ nsresult rv = ReadPrefs(aPS, prtName, aFlags);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Do not use printer name in Linux because GTK backend does not support
+ // per printer settings.
+#ifndef MOZ_X11
+ // Get the Printer Name from the PrintSettings
+ // to use as a prefix for Pref Names
+ rv = GetAdjustedPrinterName(aPS, aUsePNP, prtName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ if (prtName.IsEmpty()) {
+ NS_WARNING("Caller should supply a printer name.");
+ return NS_OK;
+ }
+
+ // Now read any printer specific prefs
+ rv = ReadPrefs(aPS, prtName, aFlags);
+ if (NS_SUCCEEDED(rv))
+ aPS->SetIsInitializedFromPrefs(true);
+#endif
+
+ return NS_OK;
+}
+
+/**
+ * Save all of the printer settings; if we can find a printer name, save
+ * printer-specific preferences. Otherwise, save generic ones.
+ */
+nsresult
+nsPrintOptions::SavePrintSettingsToPrefs(nsIPrintSettings *aPS,
+ bool aUsePrinterNamePrefix,
+ uint32_t aFlags)
+{
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ if (GeckoProcessType_Content == XRE_GetProcessType()) {
+ // If we're in the content process, we can't directly write to the
+ // Preferences service - we have to proxy the save up to the
+ // parent process.
+ RefPtr<nsPrintingProxy> proxy = nsPrintingProxy::GetInstance();
+ return proxy->SavePrintSettings(aPS, aUsePrinterNamePrefix, aFlags);
+ }
+
+ nsAutoString prtName;
+
+ // Do not use printer name in Linux because GTK backend does not support
+ // per printer settings.
+#ifndef MOZ_X11
+ // Get the printer name from the PrinterSettings for an optional prefix.
+ nsresult rv = GetAdjustedPrinterName(aPS, aUsePrinterNamePrefix, prtName);
+ NS_ENSURE_SUCCESS(rv, rv);
+#endif
+
+ // Write the prefs, with or without a printer name prefix.
+ return WritePrefs(aPS, prtName, aFlags);
+}
+
+
+//-----------------------------------------------------
+//-- Protected Methods --------------------------------
+//-----------------------------------------------------
+nsresult
+nsPrintOptions::ReadPrefDouble(const char * aPrefId, double& aVal)
+{
+ NS_ENSURE_ARG_POINTER(aPrefId);
+
+ nsAutoCString str;
+ nsresult rv = Preferences::GetCString(aPrefId, &str);
+ if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
+ aVal = atof(str.get());
+ }
+ return rv;
+}
+
+nsresult
+nsPrintOptions::WritePrefDouble(const char * aPrefId, double aVal)
+{
+ NS_ENSURE_ARG_POINTER(aPrefId);
+
+ nsPrintfCString str("%6.2f", aVal);
+ NS_ENSURE_TRUE(!str.IsEmpty(), NS_ERROR_FAILURE);
+
+ return Preferences::SetCString(aPrefId, str);
+}
+
+void
+nsPrintOptions::ReadInchesToTwipsPref(const char * aPrefId, int32_t& aTwips,
+ const char * aMarginPref)
+{
+ nsAutoString str;
+ nsresult rv = Preferences::GetString(aPrefId, &str);
+ if (NS_FAILED(rv) || str.IsEmpty()) {
+ rv = Preferences::GetString(aMarginPref, &str);
+ }
+ if (NS_SUCCEEDED(rv) && !str.IsEmpty()) {
+ nsresult errCode;
+ float inches = str.ToFloat(&errCode);
+ if (NS_SUCCEEDED(errCode)) {
+ aTwips = NS_INCHES_TO_INT_TWIPS(inches);
+ } else {
+ aTwips = 0;
+ }
+ }
+}
+
+void
+nsPrintOptions::WriteInchesFromTwipsPref(const char * aPrefId, int32_t aTwips)
+{
+ double inches = NS_TWIPS_TO_INCHES(aTwips);
+ nsAutoCString inchesStr;
+ inchesStr.AppendFloat(inches);
+
+ Preferences::SetCString(aPrefId, inchesStr);
+}
+
+void
+nsPrintOptions::ReadInchesIntToTwipsPref(const char * aPrefId, int32_t& aTwips,
+ const char * aMarginPref)
+{
+ int32_t value;
+ nsresult rv = Preferences::GetInt(aPrefId, &value);
+ if (NS_FAILED(rv)) {
+ rv = Preferences::GetInt(aMarginPref, &value);
+ }
+ if (NS_SUCCEEDED(rv)) {
+ aTwips = NS_INCHES_TO_INT_TWIPS(float(value)/100.0f);
+ } else {
+ aTwips = 0;
+ }
+}
+
+void
+nsPrintOptions::WriteInchesIntFromTwipsPref(const char * aPrefId, int32_t aTwips)
+{
+ Preferences::SetInt(aPrefId,
+ int32_t(NS_TWIPS_TO_INCHES(aTwips) * 100.0f + 0.5f));
+}
+
+void
+nsPrintOptions::ReadJustification(const char * aPrefId, int16_t& aJust,
+ int16_t aInitValue)
+{
+ aJust = aInitValue;
+ nsAutoString justStr;
+ if (NS_SUCCEEDED(Preferences::GetString(aPrefId, &justStr))) {
+ if (justStr.EqualsASCII(kJustRight)) {
+ aJust = nsIPrintSettings::kJustRight;
+ } else if (justStr.EqualsASCII(kJustCenter)) {
+ aJust = nsIPrintSettings::kJustCenter;
+ } else {
+ aJust = nsIPrintSettings::kJustLeft;
+ }
+ }
+}
+
+//---------------------------------------------------
+void
+nsPrintOptions::WriteJustification(const char * aPrefId, int16_t aJust)
+{
+ switch (aJust) {
+ case nsIPrintSettings::kJustLeft:
+ Preferences::SetCString(aPrefId, kJustLeft);
+ break;
+
+ case nsIPrintSettings::kJustCenter:
+ Preferences::SetCString(aPrefId, kJustCenter);
+ break;
+
+ case nsIPrintSettings::kJustRight:
+ Preferences::SetCString(aPrefId, kJustRight);
+ break;
+ } //switch
+}
+
+//----------------------------------------------------------------------
+// Testing of read/write prefs
+// This define turns on the testing module below
+// so at start up it writes and reads the prefs.
+#ifdef DEBUG_rods_X
+class Tester {
+ public:
+ Tester();
+};
+Tester::Tester()
+{
+ nsCOMPtr<nsIPrintSettings> ps;
+ nsresult rv;
+ nsCOMPtr<nsIPrintOptions> printService =
+ do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
+ if (NS_SUCCEEDED(rv)) {
+ rv = printService->CreatePrintSettings(getter_AddRefs(ps));
+ }
+
+ if (ps) {
+ ps->SetPrintOptions(nsIPrintSettings::kPrintOddPages, true);
+ ps->SetPrintOptions(nsIPrintSettings::kPrintEvenPages, false);
+ ps->SetMarginTop(1.0);
+ ps->SetMarginLeft(1.0);
+ ps->SetMarginBottom(1.0);
+ ps->SetMarginRight(1.0);
+ ps->SetScaling(0.5);
+ ps->SetPrintBGColors(true);
+ ps->SetPrintBGImages(true);
+ ps->SetPrintRange(15);
+ ps->SetHeaderStrLeft(NS_ConvertUTF8toUTF16("Left").get());
+ ps->SetHeaderStrCenter(NS_ConvertUTF8toUTF16("Center").get());
+ ps->SetHeaderStrRight(NS_ConvertUTF8toUTF16("Right").get());
+ ps->SetFooterStrLeft(NS_ConvertUTF8toUTF16("Left").get());
+ ps->SetFooterStrCenter(NS_ConvertUTF8toUTF16("Center").get());
+ ps->SetFooterStrRight(NS_ConvertUTF8toUTF16("Right").get());
+ ps->SetPaperName(NS_ConvertUTF8toUTF16("Paper Name").get());
+ ps->SetPaperData(1);
+ ps->SetPaperWidth(100.0);
+ ps->SetPaperHeight(50.0);
+ ps->SetPaperSizeUnit(nsIPrintSettings::kPaperSizeMillimeters);
+ ps->SetPrintReversed(true);
+ ps->SetPrintInColor(true);
+ ps->SetOrientation(nsIPrintSettings::kLandscapeOrientation);
+ ps->SetNumCopies(2);
+ ps->SetPrinterName(NS_ConvertUTF8toUTF16("Printer Name").get());
+ ps->SetPrintToFile(true);
+ ps->SetToFileName(NS_ConvertUTF8toUTF16("File Name").get());
+ ps->SetPrintPageDelay(1000);
+ ps->SetShrinkToFit(true);
+
+ struct SettingsType {
+ const char* mName;
+ uint32_t mFlag;
+ };
+ SettingsType gSettings[] = {
+ {"OddEven", nsIPrintSettings::kInitSaveOddEvenPages},
+ {kPrintHeaderStrLeft, nsIPrintSettings::kInitSaveHeaderLeft},
+ {kPrintHeaderStrCenter, nsIPrintSettings::kInitSaveHeaderCenter},
+ {kPrintHeaderStrRight, nsIPrintSettings::kInitSaveHeaderRight},
+ {kPrintFooterStrLeft, nsIPrintSettings::kInitSaveFooterLeft},
+ {kPrintFooterStrCenter, nsIPrintSettings::kInitSaveFooterCenter},
+ {kPrintFooterStrRight, nsIPrintSettings::kInitSaveFooterRight},
+ {kPrintBGColors, nsIPrintSettings::kInitSaveBGColors},
+ {kPrintBGImages, nsIPrintSettings::kInitSaveBGImages},
+ {kPrintShrinkToFit, nsIPrintSettings::kInitSaveShrinkToFit},
+ {kPrintPaperSize, nsIPrintSettings::kInitSavePaperSize},
+ {kPrintPaperData, nsIPrintSettings::kInitSavePaperData},
+ {kPrintReversed, nsIPrintSettings::kInitSaveReversed},
+ {kPrintInColor, nsIPrintSettings::kInitSaveInColor},
+ {kPrintOrientation, nsIPrintSettings::kInitSaveOrientation},
+ {kPrinterName, nsIPrintSettings::kInitSavePrinterName},
+ {kPrintToFile, nsIPrintSettings::kInitSavePrintToFile},
+ {kPrintToFileName, nsIPrintSettings::kInitSaveToFileName},
+ {kPrintPageDelay, nsIPrintSettings::kInitSavePageDelay},
+ {"Margins", nsIPrintSettings::kInitSaveMargins},
+ {"All", nsIPrintSettings::kInitSaveAll},
+ {nullptr, 0}};
+
+ nsString prefix; prefix.AssignLiteral("Printer Name");
+ int32_t i = 0;
+ while (gSettings[i].mName != nullptr) {
+ printf("------------------------------------------------\n");
+ printf("%d) %s -> 0x%X\n", i, gSettings[i].mName, gSettings[i].mFlag);
+ printService->SavePrintSettingsToPrefs(ps, true, gSettings[i].mFlag);
+ printService->InitPrintSettingsFromPrefs(ps, true,
+ gSettings[i].mFlag);
+ i++;
+ }
+ }
+
+}
+Tester gTester;
+#endif