diff options
Diffstat (limited to '')
| -rw-r--r-- | widget/nsPrintSettingsService.cpp | 1088 |
1 files changed, 1088 insertions, 0 deletions
diff --git a/widget/nsPrintSettingsService.cpp b/widget/nsPrintSettingsService.cpp new file mode 100644 index 0000000000..c33b05be0e --- /dev/null +++ b/widget/nsPrintSettingsService.cpp @@ -0,0 +1,1088 @@ +/* -*- 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) && + GETINTPREF(kUnwriteableMarginRightTwips, &margin.right) && + GETINTPREF(kUnwriteableMarginBottomTwips, &margin.bottom) && + GETINTPREF(kUnwriteableMarginLeftTwips, &margin.left); + 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) && + ReadInchesIntToTwipsPref( + GetPrefName(kUnwriteableMarginLeft, aPrinterName), margin.left) && + ReadInchesIntToTwipsPref( + GetPrefName(kUnwriteableMarginBottom, aPrinterName), + margin.bottom) && + ReadInchesIntToTwipsPref( + GetPrefName(kUnwriteableMarginRight, aPrinterName), margin.right); + } + // 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); + prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginLeft, aPrinterName), + margin.left) || + prefRead; + prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginBottom, aPrinterName), + margin.bottom) || + prefRead; + + prefRead = ReadInchesToTwipsPref(GetPrefName(kMarginRight, aPrinterName), + margin.right) || + 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); + prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeLeft, aPrinterName), + margin.left) || + prefRead; + + prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeBottom, aPrinterName), + margin.bottom) || + prefRead; + + prefRead = ReadInchesIntToTwipsPref(GetPrefName(kEdgeRight, aPrinterName), + margin.right) || + 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 +} |