/* -*- 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->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->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_." */ 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 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 }