Quelle nsPrintSettingsService.cpp Sprache: C

/* -*- 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_CRASH("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
}

quality99%

¤ Dauer der Verarbeitung: 0.20 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.