summaryrefslogtreecommitdiffstats
path: root/widget/nsPrintSettingsService.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'widget/nsPrintSettingsService.cpp')
-rw-r--r--widget/nsPrintSettingsService.cpp1090
1 files changed, 1090 insertions, 0 deletions
diff --git a/widget/nsPrintSettingsService.cpp b/widget/nsPrintSettingsService.cpp
new file mode 100644
index 0000000000..5f2dcd7c0a
--- /dev/null
+++ b/widget/nsPrintSettingsService.cpp
@@ -0,0 +1,1090 @@
+/* -*- 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 "nsPrintSettingsService.h"
+
+#include "mozilla/embedding/PPrintingTypes.h"
+#include "mozilla/layout/RemotePrintJobChild.h"
+#include "mozilla/RefPtr.h"
+#include "nsCoord.h"
+#include "nsIPrinterList.h"
+#include "nsReadableUtils.h"
+#include "nsPrintSettingsImpl.h"
+#include "nsServiceManagerUtils.h"
+#include "nsSize.h"
+
+#include "nsArray.h"
+#include "nsXPCOM.h"
+#include "nsXULAppAPI.h"
+
+#include "nsIStringEnumerator.h"
+#include "stdlib.h"
+#include "mozilla/StaticPrefs_print.h"
+#include "mozilla/Preferences.h"
+#include "nsPrintfCString.h"
+
+using namespace mozilla;
+using namespace mozilla::embedding;
+
+typedef mozilla::layout::RemotePrintJobChild RemotePrintJobChild;
+
+NS_IMPL_ISUPPORTS(nsPrintSettingsService, 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 kIgnoreUnwriteableMargins[] =
+ "print_ignore_unwriteable_margins";
+
+static const char kUnwriteableMarginTopTwips[] =
+ "print_unwriteable_margin_top_twips";
+static const char kUnwriteableMarginLeftTwips[] =
+ "print_unwriteable_margin_left_twips";
+static const char kUnwriteableMarginBottomTwips[] =
+ "print_unwriteable_margin_bottom_twips";
+static const char kUnwriteableMarginRightTwips[] =
+ "print_unwriteable_margin_right_twips";
+
+// These are legacy versions of the above UnwriteableMargin prefs. The new ones,
+// which are in twips, were introduced to more accurately record the values.
+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 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 kPrintPaperId[] = "print_paper_id";
+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 kPrintDuplex[] = "print_duplex";
+
+static const char kJustLeft[] = "left";
+static const char kJustCenter[] = "center";
+static const char kJustRight[] = "right";
+
+#define NS_PRINTER_LIST_CONTRACTID "@mozilla.org/gfx/printerlist;1"
+
+nsresult nsPrintSettingsService::Init() { return NS_OK; }
+
+NS_IMETHODIMP
+nsPrintSettingsService::SerializeToPrintData(nsIPrintSettings* aSettings,
+ PrintData* data) {
+ aSettings->GetPageRanges(data->pageRanges());
+
+ 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());
+
+ data->printBGColors() = aSettings->GetPrintBGColors();
+ data->printBGImages() = aSettings->GetPrintBGImages();
+
+ data->ignoreUnwriteableMargins() = aSettings->GetIgnoreUnwriteableMargins();
+ data->honorPageRuleMargins() = aSettings->GetHonorPageRuleMargins();
+ data->usePageRuleSizeAsPaperSize() =
+ aSettings->GetUsePageRuleSizeAsPaperSize();
+ data->showMarginGuides() = aSettings->GetShowMarginGuides();
+ data->printSelectionOnly() = aSettings->GetPrintSelectionOnly();
+
+ aSettings->GetTitle(data->title());
+ aSettings->GetDocURL(data->docURL());
+
+ aSettings->GetHeaderStrLeft(data->headerStrLeft());
+ aSettings->GetHeaderStrCenter(data->headerStrCenter());
+ aSettings->GetHeaderStrRight(data->headerStrRight());
+
+ aSettings->GetFooterStrLeft(data->footerStrLeft());
+ aSettings->GetFooterStrCenter(data->footerStrCenter());
+ aSettings->GetFooterStrRight(data->footerStrRight());
+
+ aSettings->GetPrintSilent(&data->printSilent());
+ aSettings->GetShrinkToFit(&data->shrinkToFit());
+
+ aSettings->GetPaperId(data->paperId());
+ 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());
+ aSettings->GetNumPagesPerSheet(&data->numPagesPerSheet());
+
+ data->outputDestination() = aSettings->GetOutputDestination();
+
+ data->outputFormat() = aSettings->GetOutputFormat();
+ data->printPageDelay() = aSettings->GetPrintPageDelay();
+ data->resolution() = aSettings->GetResolution();
+ data->duplex() = aSettings->GetDuplex();
+
+ aSettings->GetIsInitializedFromPrinter(&data->isInitializedFromPrinter());
+ aSettings->GetIsInitializedFromPrefs(&data->isInitializedFromPrefs());
+
+ // 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->GTKPrintSettings() default-initializes
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::DeserializeToPrintSettings(const PrintData& data,
+ nsIPrintSettings* settings) {
+ settings->SetPageRanges(data.pageRanges());
+
+ 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->SetHonorPageRuleMargins(data.honorPageRuleMargins());
+ settings->SetUsePageRuleSizeAsPaperSize(data.usePageRuleSizeAsPaperSize());
+ settings->SetIgnoreUnwriteableMargins(data.ignoreUnwriteableMargins());
+ settings->SetShowMarginGuides(data.showMarginGuides());
+ settings->SetPrintSelectionOnly(data.printSelectionOnly());
+
+ settings->SetTitle(data.title());
+ settings->SetDocURL(data.docURL());
+
+ // Header strings...
+ settings->SetHeaderStrLeft(data.headerStrLeft());
+ settings->SetHeaderStrCenter(data.headerStrCenter());
+ settings->SetHeaderStrRight(data.headerStrRight());
+
+ // Footer strings...
+ settings->SetFooterStrLeft(data.footerStrLeft());
+ settings->SetFooterStrCenter(data.footerStrCenter());
+ settings->SetFooterStrRight(data.footerStrRight());
+
+ settings->SetPrintSilent(data.printSilent());
+ settings->SetShrinkToFit(data.shrinkToFit());
+
+ settings->SetPaperId(data.paperId());
+
+ 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->SetNumPagesPerSheet(data.numPagesPerSheet());
+
+ settings->SetOutputDestination(
+ nsIPrintSettings::OutputDestinationType(data.outputDestination()));
+ // Output stream intentionally unset, child processes shouldn't care about it.
+
+ settings->SetOutputFormat(data.outputFormat());
+ settings->SetPrintPageDelay(data.printPageDelay());
+ settings->SetResolution(data.resolution());
+ settings->SetDuplex(data.duplex());
+ settings->SetIsInitializedFromPrinter(data.isInitializedFromPrinter());
+ settings->SetIsInitializedFromPrefs(data.isInitializedFromPrefs());
+
+ return NS_OK;
+}
+
+/** ---------------------------------------------------
+ * Helper function - Creates the "prefix" for the pref
+ * It is either "print."
+ * or "print.printer_<print name>."
+ */
+const char* nsPrintSettingsService::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();
+}
+
+/**
+ * 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 nsPrintSettingsService::ReadPrefs(nsIPrintSettings* aPS,
+ const nsAString& aPrinterName,
+ uint32_t aFlags) {
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ bool noValidPrefsFound = true;
+ 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))
+
+ bool gotPaperSizeFromPrefs = false;
+ int16_t paperSizeUnit;
+ double paperWidth, paperHeight;
+
+ // Paper size prefs are read as a group
+ if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
+ gotPaperSizeFromPrefs = GETINTPREF(kPrintPaperSizeUnit, &iVal) &&
+ GETDBLPREF(kPrintPaperWidth, paperWidth) &&
+ GETDBLPREF(kPrintPaperHeight, paperHeight) &&
+ GETSTRPREF(kPrintPaperId, str);
+ paperSizeUnit = (int16_t)iVal;
+
+ if (gotPaperSizeFromPrefs &&
+ paperSizeUnit != nsIPrintSettings::kPaperSizeInches &&
+ paperSizeUnit != nsIPrintSettings::kPaperSizeMillimeters) {
+ gotPaperSizeFromPrefs = false;
+ }
+
+ if (gotPaperSizeFromPrefs) {
+ // 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.
+ gotPaperSizeFromPrefs =
+ (paperSizeUnit != nsIPrintSettings::kPaperSizeInches) ||
+ (paperWidth < 100.0) || (paperHeight < 100.0);
+ }
+
+ if (gotPaperSizeFromPrefs) {
+ aPS->SetPaperSizeUnit(paperSizeUnit);
+ aPS->SetPaperWidth(paperWidth);
+ aPS->SetPaperHeight(paperHeight);
+ aPS->SetPaperId(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ nsIntSize pageSizeInTwips; // to sanity check margins
+ if (!gotPaperSizeFromPrefs) {
+ aPS->GetPaperSizeUnit(&paperSizeUnit);
+ aPS->GetPaperWidth(&paperWidth);
+ aPS->GetPaperHeight(&paperHeight);
+ }
+ if (paperSizeUnit == nsIPrintSettings::kPaperSizeMillimeters) {
+ pageSizeInTwips = nsIntSize((int)NS_MILLIMETERS_TO_TWIPS(paperWidth),
+ (int)NS_MILLIMETERS_TO_TWIPS(paperHeight));
+ } else {
+ pageSizeInTwips = nsIntSize((int)NS_INCHES_TO_TWIPS(paperWidth),
+ (int)NS_INCHES_TO_TWIPS(paperHeight));
+ }
+
+ auto MarginIsOK = [&pageSizeInTwips](const nsIntMargin& aMargin) {
+ return aMargin.top >= 0 && aMargin.right >= 0 && aMargin.bottom >= 0 &&
+ aMargin.left >= 0 && aMargin.LeftRight() < pageSizeInTwips.width &&
+ aMargin.TopBottom() < pageSizeInTwips.height;
+ };
+
+ if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
+ nsIntMargin margin;
+ bool allPrefsRead =
+ GETINTPREF(kUnwriteableMarginTopTwips, &margin.top.value) &&
+ GETINTPREF(kUnwriteableMarginRightTwips, &margin.right.value) &&
+ GETINTPREF(kUnwriteableMarginBottomTwips, &margin.bottom.value) &&
+ GETINTPREF(kUnwriteableMarginLeftTwips, &margin.left.value);
+ if (!allPrefsRead) {
+ // We failed to read the new unwritable margin twips prefs. Try to read
+ // the old ones in case they exist.
+ allPrefsRead = ReadInchesIntToTwipsPref(
+ GetPrefName(kUnwriteableMarginTop, aPrinterName),
+ margin.top.value) &&
+ ReadInchesIntToTwipsPref(
+ GetPrefName(kUnwriteableMarginLeft, aPrinterName),
+ margin.left.value) &&
+ ReadInchesIntToTwipsPref(
+ GetPrefName(kUnwriteableMarginBottom, aPrinterName),
+ margin.bottom.value) &&
+ ReadInchesIntToTwipsPref(
+ GetPrefName(kUnwriteableMarginRight, aPrinterName),
+ margin.right.value);
+ }
+ // SetUnwriteableMarginInTwips does its own validation and drops negative
+ // values individually. We still want to block overly large values though,
+ // so we do that part of MarginIsOK manually.
+ if (allPrefsRead && margin.LeftRight() < pageSizeInTwips.width &&
+ margin.TopBottom() < pageSizeInTwips.height) {
+ aPS->SetUnwriteableMarginInTwips(margin);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveMargins) {
+ int32_t halfInch = NS_INCHES_TO_INT_TWIPS(0.5);
+ nsIntMargin margin(halfInch, halfInch, halfInch, halfInch);
+ bool prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginTop, aPrinterName),
+ margin.top.value);
+ prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
+ margin.left.value) ||
+ prefRead;
+ prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
+ margin.bottom.value) ||
+ prefRead;
+
+ prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName),
+ margin.right.value) ||
+ prefRead;
+ if (prefRead && MarginIsOK(margin)) {
+ aPS->SetMarginInTwips(margin);
+ noValidPrefsFound = false;
+
+ prefRead = GETBOOLPREF(kIgnoreUnwriteableMargins, &b);
+ if (prefRead) {
+ aPS->SetIgnoreUnwriteableMargins(b);
+ }
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveEdges) {
+ nsIntMargin margin(0, 0, 0, 0);
+ bool prefRead = ReadInchesIntToTwipsPref(
+ GetPrefName(kEdgeTop, aPrinterName), margin.top.value);
+ prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
+ margin.left.value) ||
+ prefRead;
+
+ prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
+ margin.bottom.value) ||
+ prefRead;
+
+ prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
+ margin.right.value) ||
+ prefRead;
+ ;
+ if (prefRead && MarginIsOK(margin)) {
+ aPS->SetEdgeInTwips(margin);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
+ if (GETSTRPREF(kPrintHeaderStrLeft, str)) {
+ aPS->SetHeaderStrLeft(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
+ if (GETSTRPREF(kPrintHeaderStrCenter, str)) {
+ aPS->SetHeaderStrCenter(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
+ if (GETSTRPREF(kPrintHeaderStrRight, str)) {
+ aPS->SetHeaderStrRight(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
+ if (GETSTRPREF(kPrintFooterStrLeft, str)) {
+ aPS->SetFooterStrLeft(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
+ if (GETSTRPREF(kPrintFooterStrCenter, str)) {
+ aPS->SetFooterStrCenter(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
+ if (GETSTRPREF(kPrintFooterStrRight, str)) {
+ aPS->SetFooterStrRight(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
+ if (GETBOOLPREF(kPrintBGColors, &b)) {
+ aPS->SetPrintBGColors(b);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
+ if (GETBOOLPREF(kPrintBGImages, &b)) {
+ aPS->SetPrintBGImages(b);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveReversed) {
+ if (GETBOOLPREF(kPrintReversed, &b)) {
+ aPS->SetPrintReversed(b);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveInColor) {
+ if (GETBOOLPREF(kPrintInColor, &b)) {
+ aPS->SetPrintInColor(b);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
+ if (GETINTPREF(kPrintOrientation, &iVal) &&
+ (iVal == nsIPrintSettings::kPortraitOrientation ||
+ iVal == nsIPrintSettings::kLandscapeOrientation)) {
+ aPS->SetOrientation(iVal);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
+ if (GETBOOLPREF(kPrintToFile, &b)) {
+ aPS->SetOutputDestination(
+ b ? nsIPrintSettings::kOutputDestinationFile
+ : nsIPrintSettings::kOutputDestinationPrinter);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
+ if (GETSTRPREF(kPrintToFileName, str)) {
+ if (StringEndsWith(str, u".ps"_ns)) {
+ // We only support PDF since bug 1425188 landed. Users may still have
+ // prefs with .ps filenames if they last saved a file as Postscript
+ // though, so we fix that up here. (The pref values will be
+ // overwritten the next time they save to file as a PDF.)
+ str.Truncate(str.Length() - 2);
+ str.AppendLiteral("pdf");
+ }
+ aPS->SetToFileName(str);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
+ // milliseconds
+ if (GETINTPREF(kPrintPageDelay, &iVal) && iVal >= 0 && iVal <= 1000) {
+ aPS->SetPrintPageDelay(iVal);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
+ if (GETBOOLPREF(kPrintShrinkToFit, &b)) {
+ aPS->SetShrinkToFit(b);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveScaling) {
+ // The limits imposed here are fairly arbitrary and mainly intended to
+ // purge bad values which tend to be negative and/or very large. If we
+ // get complaints from users that settings outside these values "aren't
+ // saved" then we can consider increasing them.
+ if (GETDBLPREF(kPrintScaling, dbl) && dbl >= 0.05 && dbl <= 20) {
+ aPS->SetScaling(dbl);
+ noValidPrefsFound = false;
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
+ if (GETINTPREF(kPrintDuplex, &iVal)) {
+ aPS->SetDuplex(iVal);
+ noValidPrefsFound = false;
+ }
+ }
+
+ // Not Reading In:
+ // Number of Copies
+ // Print Resolution
+
+ return noValidPrefsFound ? NS_ERROR_NOT_AVAILABLE : NS_OK;
+}
+
+nsresult nsPrintSettingsService::WritePrefs(nsIPrintSettings* aPS,
+ const nsAString& aPrinterName,
+ uint32_t aFlags) {
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ if (aFlags & nsIPrintSettings::kInitSaveMargins) {
+ nsIntMargin margin = aPS->GetMarginInTwips();
+ WriteInchesFromTwipsPref(GetPrefName(kMarginTop, aPrinterName), margin.top);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginLeft, aPrinterName),
+ margin.left);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginBottom, aPrinterName),
+ margin.bottom);
+ WriteInchesFromTwipsPref(GetPrefName(kMarginRight, aPrinterName),
+ margin.right);
+ Preferences::SetBool(GetPrefName(kIgnoreUnwriteableMargins, aPrinterName),
+ aPS->GetIgnoreUnwriteableMargins());
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveEdges) {
+ nsIntMargin edge = aPS->GetEdgeInTwips();
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeTop, aPrinterName), edge.top);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeLeft, aPrinterName),
+ edge.left);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeBottom, aPrinterName),
+ edge.bottom);
+ WriteInchesIntFromTwipsPref(GetPrefName(kEdgeRight, aPrinterName),
+ edge.right);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveUnwriteableMargins) {
+ nsIntMargin unwriteableMargin = aPS->GetUnwriteableMarginInTwips();
+ Preferences::SetInt(GetPrefName(kUnwriteableMarginTopTwips, aPrinterName),
+ unwriteableMargin.top);
+ Preferences::SetInt(GetPrefName(kUnwriteableMarginLeftTwips, aPrinterName),
+ unwriteableMargin.left);
+ Preferences::SetInt(
+ GetPrefName(kUnwriteableMarginBottomTwips, aPrinterName),
+ unwriteableMargin.bottom);
+ Preferences::SetInt(GetPrefName(kUnwriteableMarginRightTwips, aPrinterName),
+ unwriteableMargin.right);
+
+ // Remove the old unwriteableMargin prefs.
+ Preferences::ClearUser(GetPrefName(kUnwriteableMarginTop, aPrinterName));
+ Preferences::ClearUser(GetPrefName(kUnwriteableMarginRight, aPrinterName));
+ Preferences::ClearUser(GetPrefName(kUnwriteableMarginBottom, aPrinterName));
+ Preferences::ClearUser(GetPrefName(kUnwriteableMarginLeft, aPrinterName));
+ }
+
+ // Paper size prefs are saved as a group
+ if (aFlags & nsIPrintSettings::kInitSavePaperSize) {
+ int16_t sizeUnit;
+ double width, height;
+ nsString name;
+
+ if (NS_SUCCEEDED(aPS->GetPaperSizeUnit(&sizeUnit)) &&
+ NS_SUCCEEDED(aPS->GetPaperWidth(&width)) &&
+ NS_SUCCEEDED(aPS->GetPaperHeight(&height)) &&
+ NS_SUCCEEDED(aPS->GetPaperId(name))) {
+ Preferences::SetInt(GetPrefName(kPrintPaperSizeUnit, aPrinterName),
+ int32_t(sizeUnit));
+ WritePrefDouble(GetPrefName(kPrintPaperWidth, aPrinterName), width);
+ WritePrefDouble(GetPrefName(kPrintPaperHeight, aPrinterName), height);
+ Preferences::SetString(GetPrefName(kPrintPaperId, aPrinterName), name);
+ }
+ }
+
+ bool b;
+ nsString uStr;
+ int32_t iVal;
+ double dbl;
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderLeft) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrLeft(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintHeaderStrLeft, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderCenter) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrCenter(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintHeaderStrCenter, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveHeaderRight) {
+ if (NS_SUCCEEDED(aPS->GetHeaderStrRight(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintHeaderStrRight, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterLeft) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrLeft(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintFooterStrLeft, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterCenter) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrCenter(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintFooterStrCenter, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveFooterRight) {
+ if (NS_SUCCEEDED(aPS->GetFooterStrRight(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintFooterStrRight, aPrinterName),
+ uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGColors) {
+ b = aPS->GetPrintBGColors();
+ Preferences::SetBool(GetPrefName(kPrintBGColors, aPrinterName), b);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveBGImages) {
+ b = aPS->GetPrintBGImages();
+ Preferences::SetBool(GetPrefName(kPrintBGImages, aPrinterName), b);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveReversed) {
+ if (NS_SUCCEEDED(aPS->GetPrintReversed(&b))) {
+ Preferences::SetBool(GetPrefName(kPrintReversed, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveInColor) {
+ if (NS_SUCCEEDED(aPS->GetPrintInColor(&b))) {
+ Preferences::SetBool(GetPrefName(kPrintInColor, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveOrientation) {
+ if (NS_SUCCEEDED(aPS->GetOrientation(&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))) {
+ Preferences::SetString(kPrinterName, uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePrintToFile) {
+ Preferences::SetBool(GetPrefName(kPrintToFile, aPrinterName),
+ aPS->GetOutputDestination() ==
+ nsIPrintSettings::kOutputDestinationFile);
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveToFileName) {
+ if (NS_SUCCEEDED(aPS->GetToFileName(uStr))) {
+ Preferences::SetString(GetPrefName(kPrintToFileName, aPrinterName), uStr);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSavePageDelay) {
+ if (NS_SUCCEEDED(aPS->GetPrintPageDelay(&iVal))) {
+ Preferences::SetInt(GetPrefName(kPrintPageDelay, aPrinterName), iVal);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveShrinkToFit) {
+ if (NS_SUCCEEDED(aPS->GetShrinkToFit(&b))) {
+ Preferences::SetBool(GetPrefName(kPrintShrinkToFit, aPrinterName), b);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveScaling) {
+ if (NS_SUCCEEDED(aPS->GetScaling(&dbl))) {
+ WritePrefDouble(GetPrefName(kPrintScaling, aPrinterName), dbl);
+ }
+ }
+
+ if (aFlags & nsIPrintSettings::kInitSaveDuplex) {
+ if (NS_SUCCEEDED(aPS->GetDuplex(&iVal))) {
+ Preferences::SetInt(GetPrefName(kPrintDuplex, aPrinterName), iVal);
+ }
+ }
+
+ // Not Writing Out:
+ // Number of Copies
+ // Print Resolution
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::GetDefaultPrintSettingsForPrinting(
+ nsIPrintSettings** aPrintSettings) {
+ nsresult rv = CreateNewPrintSettings(aPrintSettings);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ nsIPrintSettings* settings = *aPrintSettings;
+
+ // For security reasons, we don't pass the printer name to content processes.
+ // Once bug 1776169 is fixed, we can just assert that this is the parent
+ // process.
+ bool usePrinterName = XRE_IsParentProcess();
+
+ if (usePrinterName) {
+ nsAutoString printerName;
+ settings->GetPrinterName(printerName);
+ if (printerName.IsEmpty()) {
+ GetLastUsedPrinterName(printerName);
+ settings->SetPrinterName(printerName);
+ }
+ InitPrintSettingsFromPrinter(printerName, settings);
+ }
+
+ InitPrintSettingsFromPrefs(settings, usePrinterName,
+ nsIPrintSettings::kInitSaveAll);
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::CreateNewPrintSettings(
+ nsIPrintSettings** aNewPrintSettings) {
+ return _CreatePrintSettings(aNewPrintSettings);
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::GetLastUsedPrinterName(
+ nsAString& aLastUsedPrinterName) {
+ MOZ_ASSERT(XRE_IsParentProcess());
+
+ aLastUsedPrinterName.Truncate();
+ Preferences::GetString(kPrinterName, aLastUsedPrinterName);
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::InitPrintSettingsFromPrinter(
+ const nsAString& 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()) {
+ return NS_OK;
+ }
+
+ NS_ENSURE_ARG_POINTER(aPrintSettings);
+
+#ifdef DEBUG
+ nsString printerName;
+ aPrintSettings->GetPrinterName(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<nsIPrinterList> printerList =
+ do_GetService(NS_PRINTER_LIST_CONTRACTID, &rv);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ rv = printerList->InitPrintSettingsFromPrinter(aPrinterName, aPrintSettings);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ aPrintSettings->SetIsInitializedFromPrinter(true);
+ return rv;
+}
+
+/** ---------------------------------------------------
+ * 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
+ nsresult rv = aPS->GetPrinterName(aPrinterName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+ // Convert any whitespaces, carriage returns or newlines to _
+ // The below algorithm is supposedly faster than using iterators
+ constexpr auto replSubstr = u"_"_ns;
+ 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;
+}
+
+NS_IMETHODIMP
+nsPrintSettingsService::InitPrintSettingsFromPrefs(nsIPrintSettings* aPS,
+ bool aUsePNP,
+ uint32_t aFlags) {
+ NS_ENSURE_ARG_POINTER(aPS);
+
+ bool isInitialized;
+ aPS->GetIsInitializedFromPrefs(&isInitialized);
+
+ if (isInitialized) {
+ return NS_OK;
+ }
+
+ auto globalPrintSettings = aFlags;
+#ifndef MOZ_WIDGET_ANDROID
+ globalPrintSettings &= nsIPrintSettings::kGlobalSettings;
+#endif
+
+ nsAutoString prtName;
+ // read any non printer specific prefs
+ // with empty printer name
+ nsresult rv = ReadPrefs(aPS, prtName, globalPrintSettings);
+ if (NS_FAILED(rv) && rv != NS_ERROR_NOT_AVAILABLE) {
+ NS_WARNING("ReadPrefs failed");
+ }
+
+ // 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);
+ }
+
+ 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 nsPrintSettingsService::MaybeSavePrintSettingsToPrefs(
+ nsIPrintSettings* aPS, uint32_t aFlags) {
+ NS_ENSURE_ARG_POINTER(aPS);
+ MOZ_DIAGNOSTIC_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+ MOZ_ASSERT(!(aFlags & nsIPrintSettings::kInitSavePrinterName),
+ "Use SaveLastUsedPrintNameToPrefs");
+
+ if (!Preferences::GetBool("print.save_print_settings", false)) {
+ return NS_OK;
+ }
+
+ // Get the printer name from the PrinterSettings for an optional prefix.
+ nsAutoString prtName;
+ nsresult rv = GetAdjustedPrinterName(aPS, true, prtName);
+ NS_ENSURE_SUCCESS(rv, rv);
+
+#ifndef MOZ_WIDGET_ANDROID
+ // On most platforms we should always use a prefix when saving print settings
+ // to prefs. Saving without a prefix risks breaking printing for users
+ // without a good way for us to fix things for them (unprefixed prefs act as
+ // defaults and can result in values being inappropriately propagated to
+ // prefixed prefs).
+ if (prtName.IsEmpty()) {
+ MOZ_DIAGNOSTIC_ASSERT(false, "Print settings must be saved with a prefix");
+ return NS_ERROR_FAILURE;
+ }
+#endif
+
+ return WritePrefs(aPS, prtName, aFlags);
+}
+
+nsresult nsPrintSettingsService::MaybeSaveLastUsedPrinterNameToPrefs(
+ const nsAString& aPrinterName) {
+ MOZ_DIAGNOSTIC_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+
+ if (!Preferences::GetBool("print.save_print_settings", false)) {
+ return NS_OK;
+ }
+
+ if (!aPrinterName.IsEmpty()) {
+ Preferences::SetString(kPrinterName, aPrinterName);
+ }
+ return NS_OK;
+}
+
+//-----------------------------------------------------
+//-- Protected Methods --------------------------------
+//-----------------------------------------------------
+nsresult nsPrintSettingsService::ReadPrefDouble(const char* aPrefId,
+ double& aVal) {
+ NS_ENSURE_ARG_POINTER(aPrefId);
+
+ nsAutoCString str;
+ nsresult rv = Preferences::GetCString(aPrefId, str);
+ if (NS_FAILED(rv) || str.IsEmpty()) {
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ double value = str.ToDouble(&rv);
+ if (NS_FAILED(rv)) {
+ return rv;
+ }
+
+ aVal = value;
+ return NS_OK;
+}
+
+nsresult nsPrintSettingsService::WritePrefDouble(const char* aPrefId,
+ double aVal) {
+ NS_ENSURE_ARG_POINTER(aPrefId);
+
+ nsAutoCString str;
+ str.AppendFloat(aVal);
+ return Preferences::SetCString(aPrefId, str);
+}
+
+bool nsPrintSettingsService::ReadInchesToTwipsPref(const char* aPrefId,
+ int32_t& aTwips) {
+ nsAutoString str;
+ nsresult rv = Preferences::GetString(aPrefId, str);
+ if (NS_FAILED(rv) || str.IsEmpty()) {
+ return false;
+ }
+
+ float inches = str.ToFloat(&rv);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ aTwips = NS_INCHES_TO_INT_TWIPS(inches);
+ return true;
+}
+
+void nsPrintSettingsService::WriteInchesFromTwipsPref(const char* aPrefId,
+ int32_t aTwips) {
+ double inches = NS_TWIPS_TO_INCHES(aTwips);
+ nsAutoCString inchesStr;
+ inchesStr.AppendFloat(inches);
+
+ Preferences::SetCString(aPrefId, inchesStr);
+}
+
+bool nsPrintSettingsService::ReadInchesIntToTwipsPref(const char* aPrefId,
+ int32_t& aTwips) {
+ int32_t value;
+ nsresult rv = Preferences::GetInt(aPrefId, &value);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ aTwips = NS_INCHES_TO_INT_TWIPS(float(value) / 100.0f);
+ return true;
+}
+
+void nsPrintSettingsService::WriteInchesIntFromTwipsPref(const char* aPrefId,
+ int32_t aTwips) {
+ Preferences::SetInt(aPrefId,
+ int32_t(NS_TWIPS_TO_INCHES(aTwips) * 100.0f + 0.5f));
+}
+
+void nsPrintSettingsService::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 nsPrintSettingsService::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
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-20 19:30:37 +0000