summaryrefslogtreecommitdiffstats
path: root/widget/windows/nsDeviceContextSpecWin.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--widget/windows/nsDeviceContextSpecWin.cpp673
1 files changed, 673 insertions, 0 deletions
diff --git a/widget/windows/nsDeviceContextSpecWin.cpp b/widget/windows/nsDeviceContextSpecWin.cpp
new file mode 100644
index 0000000000..9382098acc
--- /dev/null
+++ b/widget/windows/nsDeviceContextSpecWin.cpp
@@ -0,0 +1,673 @@
+/* -*- 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 "nsDeviceContextSpecWin.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/gfx/PrintPromise.h"
+#include "mozilla/gfx/PrintTargetPDF.h"
+#include "mozilla/gfx/PrintTargetWindows.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Telemetry.h"
+#include "nsAnonymousTemporaryFile.h"
+
+#include <wchar.h>
+#include <windef.h>
+#include <winspool.h>
+
+#include "nsIWidget.h"
+
+#include "nsTArray.h"
+#include "nsIPrintSettingsWin.h"
+
+#include "nsComponentManagerUtils.h"
+#include "nsPrinterWin.h"
+#include "nsReadableUtils.h"
+#include "nsString.h"
+
+#include "gfxWindowsSurface.h"
+
+#include "nsIFileStreams.h"
+#include "nsWindowsHelpers.h"
+
+#include "mozilla/gfx/Logging.h"
+
+#ifdef MOZ_ENABLE_SKIA_PDF
+# include "mozilla/gfx/PrintTargetSkPDF.h"
+# include "mozilla/gfx/PrintTargetEMF.h"
+# include "nsIUUIDGenerator.h"
+# include "nsDirectoryServiceDefs.h"
+# include "nsPrintfCString.h"
+# include "nsThreadUtils.h"
+#endif
+
+extern mozilla::LazyLogModule gPrintingLog;
+#define PR_PL(_p1) MOZ_LOG(gPrintingLog, mozilla::LogLevel::Debug, _p1)
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+#ifdef MOZ_ENABLE_SKIA_PDF
+using namespace mozilla::widget;
+#endif
+
+static const wchar_t kDriverName[] = L"WINSPOOL";
+
+//----------------------------------------------------------------------------------
+//---------------
+// static members
+//----------------------------------------------------------------------------------
+nsDeviceContextSpecWin::nsDeviceContextSpecWin() = default;
+
+//----------------------------------------------------------------------------------
+
+NS_IMPL_ISUPPORTS(nsDeviceContextSpecWin, nsIDeviceContextSpec)
+
+nsDeviceContextSpecWin::~nsDeviceContextSpecWin() {
+ SetDevMode(nullptr);
+
+ if (mTempFile) {
+ mTempFile->Remove(/* recursive = */ false);
+ }
+
+ if (nsCOMPtr<nsIPrintSettingsWin> ps = do_QueryInterface(mPrintSettings)) {
+ ps->SetDeviceName(u""_ns);
+ ps->SetDriverName(u""_ns);
+ ps->SetDevMode(nullptr);
+ }
+}
+
+static bool GetDefaultPrinterName(nsAString& aDefaultPrinterName) {
+ DWORD length = 0;
+ GetDefaultPrinterW(nullptr, &length);
+
+ if (length) {
+ aDefaultPrinterName.SetLength(length);
+ if (GetDefaultPrinterW((LPWSTR)aDefaultPrinterName.BeginWriting(),
+ &length)) {
+ // `length` includes the terminating null, so we subtract that from our
+ // string length.
+ aDefaultPrinterName.SetLength(length - 1);
+ PR_PL(("DEFAULT PRINTER [%s]\n",
+ NS_ConvertUTF16toUTF8(aDefaultPrinterName).get()));
+ return true;
+ }
+ }
+
+ aDefaultPrinterName.Truncate();
+ PR_PL(("NO DEFAULT PRINTER\n"));
+ return false;
+}
+
+//----------------------------------------------------------------------------------
+NS_IMETHODIMP nsDeviceContextSpecWin::Init(nsIPrintSettings* aPrintSettings,
+ bool aIsPrintPreview) {
+ mPrintSettings = aPrintSettings;
+
+ // Get the Printer Name to be used and output format.
+ nsAutoString printerName;
+ if (mPrintSettings) {
+ mOutputFormat = mPrintSettings->GetOutputFormat();
+ mPrintSettings->GetPrinterName(printerName);
+ }
+
+ // If there is no name then use the default printer
+ if (printerName.IsEmpty()) {
+ GetDefaultPrinterName(printerName);
+ }
+
+ // Gather telemetry on the print target type.
+ //
+ // Unfortunately, if we're not using our own internal save-to-pdf codepaths,
+ // there isn't a good way to determine whether a print is going to be to a
+ // physical printer or to a file or some other non-physical output. We do our
+ // best by checking for what seems to be the most common save-to-PDF virtual
+ // printers.
+ //
+ // We use StringBeginsWith below, since printer names are often followed by a
+ // version number or other product differentiating string. (True for doPDF,
+ // novaPDF, PDF-XChange and Soda PDF, for example.)
+ if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) {
+ Telemetry::ScalarAdd(Telemetry::ScalarID::PRINTING_TARGET_TYPE,
+ u"pdf_file"_ns, 1);
+ } else if (StringBeginsWith(printerName, u"Microsoft Print to PDF"_ns) ||
+ StringBeginsWith(printerName, u"Adobe PDF"_ns) ||
+ StringBeginsWith(printerName, u"Bullzip PDF Printer"_ns) ||
+ StringBeginsWith(printerName, u"CutePDF Writer"_ns) ||
+ StringBeginsWith(printerName, u"doPDF"_ns) ||
+ StringBeginsWith(printerName, u"Foxit Reader PDF Printer"_ns) ||
+ StringBeginsWith(printerName, u"Nitro PDF Creator"_ns) ||
+ StringBeginsWith(printerName, u"novaPDF"_ns) ||
+ StringBeginsWith(printerName, u"PDF-XChange"_ns) ||
+ StringBeginsWith(printerName, u"PDF24 PDF"_ns) ||
+ StringBeginsWith(printerName, u"PDFCreator"_ns) ||
+ StringBeginsWith(printerName, u"PrimoPDF"_ns) ||
+ StringBeginsWith(printerName, u"Soda PDF"_ns) ||
+ StringBeginsWith(printerName, u"Solid PDF Creator"_ns) ||
+ StringBeginsWith(printerName,
+ u"Universal Document Converter"_ns)) {
+ Telemetry::ScalarAdd(Telemetry::ScalarID::PRINTING_TARGET_TYPE,
+ u"pdf_file"_ns, 1);
+ } else if (printerName.EqualsLiteral("Microsoft XPS Document Writer")) {
+ Telemetry::ScalarAdd(Telemetry::ScalarID::PRINTING_TARGET_TYPE,
+ u"xps_file"_ns, 1);
+ } else {
+ nsAString::const_iterator start, end;
+ printerName.BeginReading(start);
+ printerName.EndReading(end);
+ if (CaseInsensitiveFindInReadable(u"pdf"_ns, start, end)) {
+ Telemetry::ScalarAdd(Telemetry::ScalarID::PRINTING_TARGET_TYPE,
+ u"pdf_unknown"_ns, 1);
+ } else {
+ Telemetry::ScalarAdd(Telemetry::ScalarID::PRINTING_TARGET_TYPE,
+ u"unknown"_ns, 1);
+ }
+ }
+
+ nsresult rv = NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE;
+ if (aPrintSettings) {
+#ifdef MOZ_ENABLE_SKIA_PDF
+ nsAutoString printViaPdf;
+ Preferences::GetString("print.print_via_pdf_encoder", printViaPdf);
+ if (printViaPdf.EqualsLiteral("skia-pdf")) {
+ mPrintViaSkPDF = true;
+ }
+#endif
+
+ // If we're in the child or we're printing to PDF we only need information
+ // from the print settings.
+ if (XRE_IsContentProcess() ||
+ mOutputFormat == nsIPrintSettings::kOutputFormatPDF) {
+ return NS_OK;
+ }
+
+ nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(aPrintSettings));
+ if (psWin) {
+ nsAutoString deviceName;
+ nsAutoString driverName;
+ psWin->GetDeviceName(deviceName);
+ psWin->GetDriverName(driverName);
+
+ LPDEVMODEW devMode;
+ psWin->GetDevMode(&devMode); // creates new memory (makes a copy)
+
+ if (!deviceName.IsEmpty() && !driverName.IsEmpty() && devMode) {
+ // Scaling is special, it is one of the few
+ // devMode items that we control in layout
+ if (devMode->dmFields & DM_SCALE) {
+ double scale = double(devMode->dmScale) / 100.0f;
+ if (scale != 1.0) {
+ aPrintSettings->SetScaling(scale);
+ devMode->dmScale = 100;
+ }
+ }
+
+ SetDeviceName(deviceName);
+ SetDriverName(driverName);
+ SetDevMode(devMode);
+
+ return NS_OK;
+ } else {
+ PR_PL(
+ ("***** nsDeviceContextSpecWin::Init - "
+ "deviceName/driverName/devMode was NULL!\n"));
+ if (devMode) ::HeapFree(::GetProcessHeap(), 0, devMode);
+ }
+ }
+ } else {
+ PR_PL(("***** nsDeviceContextSpecWin::Init - aPrintSettingswas NULL!\n"));
+ }
+
+ if (printerName.IsEmpty()) {
+ return rv;
+ }
+
+ return GetDataFromPrinter(printerName, mPrintSettings);
+}
+
+//----------------------------------------------------------
+
+already_AddRefed<PrintTarget> nsDeviceContextSpecWin::MakePrintTarget() {
+ NS_ASSERTION(mDevMode || mOutputFormat == nsIPrintSettings::kOutputFormatPDF,
+ "DevMode can't be NULL here unless we're printing to PDF.");
+
+#ifdef MOZ_ENABLE_SKIA_PDF
+ if (mPrintViaSkPDF) {
+ double width, height;
+ mPrintSettings->GetEffectivePageSize(&width, &height);
+ if (width <= 0 || height <= 0) {
+ return nullptr;
+ }
+
+ // convert twips to points
+ width /= TWIPS_PER_POINT_FLOAT;
+ height /= TWIPS_PER_POINT_FLOAT;
+ IntSize size = IntSize::Ceil(width, height);
+
+ if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) {
+ nsString filename;
+ // TODO(dshin):
+ // - Does this handle bug 1659470?
+ // - Should this code path be enabled, we should use temporary files and
+ // then move the file in `EndDocument()`.
+ mPrintSettings->GetToFileName(filename);
+
+ nsAutoCString printFile(NS_ConvertUTF16toUTF8(filename).get());
+ auto skStream = MakeUnique<SkFILEWStream>(printFile.get());
+ return PrintTargetSkPDF::CreateOrNull(std::move(skStream), size);
+ }
+
+ if (mDevMode) {
+ NS_WARNING_ASSERTION(!mDriverName.IsEmpty(), "No driver!");
+ HDC dc =
+ ::CreateDCW(mDriverName.get(), mDeviceName.get(), nullptr, mDevMode);
+ if (!dc) {
+ gfxCriticalError(gfxCriticalError::DefaultOptions(false))
+ << "Failed to create device context in GetSurfaceForPrinter";
+ return nullptr;
+ }
+ return PrintTargetEMF::CreateOrNull(dc, size);
+ }
+ }
+#endif
+
+ if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) {
+ double width, height;
+ mPrintSettings->GetEffectiveSheetSize(&width, &height);
+ if (width <= 0 || height <= 0) {
+ return nullptr;
+ }
+
+ // convert twips to points
+ width /= TWIPS_PER_POINT_FLOAT;
+ height /= TWIPS_PER_POINT_FLOAT;
+
+ auto stream = [&]() -> nsCOMPtr<nsIOutputStream> {
+ if (mPrintSettings->GetOutputDestination() ==
+ nsIPrintSettings::kOutputDestinationStream) {
+ nsCOMPtr<nsIOutputStream> out;
+ mPrintSettings->GetOutputStream(getter_AddRefs(out));
+ return out;
+ }
+
+ // Even if the destination may be a named path, write to a temp file -
+ // this is consistent with behaviour of `PrintTarget` on other platforms.
+ nsCOMPtr<nsIFile> file;
+ nsresult rv = NS_OpenAnonymousTemporaryNsIFile(getter_AddRefs(mTempFile));
+ file = mTempFile;
+
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIFileOutputStream> stream =
+ do_CreateInstance("@mozilla.org/network/file-output-stream;1");
+ if (NS_FAILED(stream->Init(file, -1, -1, 0))) {
+ return nullptr;
+ }
+ return stream;
+ }();
+
+ return PrintTargetPDF::CreateOrNull(stream, IntSize::Ceil(width, height));
+ }
+
+ if (mDevMode) {
+ NS_WARNING_ASSERTION(!mDriverName.IsEmpty(), "No driver!");
+ HDC dc =
+ ::CreateDCW(mDriverName.get(), mDeviceName.get(), nullptr, mDevMode);
+ if (!dc) {
+ gfxCriticalError(gfxCriticalError::DefaultOptions(false))
+ << "Failed to create device context in GetSurfaceForPrinter";
+ return nullptr;
+ }
+
+ // The PrintTargetWindows takes over ownership of this DC
+ return PrintTargetWindows::CreateOrNull(dc);
+ }
+
+ return nullptr;
+}
+
+RefPtr<PrintEndDocumentPromise> nsDeviceContextSpecWin::EndDocument() {
+ if (mPrintSettings->GetOutputDestination() !=
+ nsIPrintSettings::kOutputDestinationFile ||
+ mOutputFormat != nsIPrintSettings::kOutputFormatPDF) {
+ return PrintEndDocumentPromise::CreateAndResolve(true, __func__);
+ }
+
+#ifdef MOZ_ENABLE_SKIA_PDF
+ if (mPrintViaSkPDF) {
+ return PrintEndDocumentPromise::CreateAndResolve(true, __func__);
+ }
+#endif
+
+ MOZ_ASSERT(mTempFile, "No handle to temporary PDF file.");
+
+ nsAutoString targetPath;
+ mPrintSettings->GetToFileName(targetPath);
+
+ if (targetPath.IsEmpty()) {
+ return PrintEndDocumentPromise::CreateAndResolve(true, __func__);
+ }
+
+ // We still need to move the file to its actual destination.
+ nsCOMPtr<nsIFile> destFile;
+ auto rv = NS_NewLocalFile(targetPath, false, getter_AddRefs(destFile));
+ if (NS_FAILED(rv)) {
+ return PrintEndDocumentPromise::CreateAndReject(rv, __func__);
+ }
+
+ return nsIDeviceContextSpec::EndDocumentAsync(
+ __func__,
+ [destFile = std::move(destFile),
+ tempFile = std::move(mTempFile)]() -> nsresult {
+ nsAutoString destLeafName;
+ MOZ_TRY(destFile->GetLeafName(destLeafName));
+
+ nsCOMPtr<nsIFile> destDir;
+ MOZ_TRY(destFile->GetParent(getter_AddRefs(destDir)));
+
+ // This should be fine - Windows API calls usually prevent moving
+ // between different volumes (See Win32 API's `MOVEFILE_COPY_ALLOWED`
+ // flag), but we handle that down this call.
+ MOZ_TRY(tempFile->MoveTo(destDir, destLeafName));
+ return NS_OK;
+ });
+}
+
+//----------------------------------------------------------------------------------
+void nsDeviceContextSpecWin::SetDeviceName(const nsAString& aDeviceName) {
+ mDeviceName = aDeviceName;
+}
+
+//----------------------------------------------------------------------------------
+void nsDeviceContextSpecWin::SetDriverName(const nsAString& aDriverName) {
+ mDriverName = aDriverName;
+}
+
+//----------------------------------------------------------------------------------
+void nsDeviceContextSpecWin::SetDevMode(LPDEVMODEW aDevMode) {
+ if (mDevMode) {
+ ::HeapFree(::GetProcessHeap(), 0, mDevMode);
+ }
+
+ mDevMode = aDevMode;
+}
+
+//------------------------------------------------------------------
+void nsDeviceContextSpecWin::GetDevMode(LPDEVMODEW& aDevMode) {
+ aDevMode = mDevMode;
+}
+
+#define DISPLAY_LAST_ERROR
+
+//----------------------------------------------------------------------------------
+// Setup the object's data member with the selected printer's data
+nsresult nsDeviceContextSpecWin::GetDataFromPrinter(const nsAString& aName,
+ nsIPrintSettings* aPS) {
+ nsresult rv = NS_ERROR_FAILURE;
+
+ nsHPRINTER hPrinter = nullptr;
+ const nsString& flat = PromiseFlatString(aName);
+ wchar_t* name =
+ (wchar_t*)flat.get(); // Windows APIs use non-const name argument
+
+ BOOL status = ::OpenPrinterW(name, &hPrinter, nullptr);
+ if (status) {
+ nsAutoPrinter autoPrinter(hPrinter);
+
+ LPDEVMODEW pDevMode;
+
+ // Allocate a buffer of the correct size.
+ LONG needed =
+ ::DocumentPropertiesW(nullptr, hPrinter, name, nullptr, nullptr, 0);
+ if (needed < 0) {
+ PR_PL(
+ ("**** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't get "
+ "size of DEVMODE using DocumentPropertiesW(pDeviceName = \"%s\"). "
+ "GetLastEror() = %08lx\n",
+ NS_ConvertUTF16toUTF8(aName).get(), GetLastError()));
+ return NS_ERROR_FAILURE;
+ }
+
+ // Some drivers do not return the correct size for their DEVMODE, so we
+ // over-allocate to try and compensate.
+ // (See https://bugzilla.mozilla.org/show_bug.cgi?id=1664530#c5)
+ needed *= 2;
+ pDevMode =
+ (LPDEVMODEW)::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, needed);
+ if (!pDevMode) return NS_ERROR_FAILURE;
+
+ // Get the default DevMode for the printer and modify it for our needs.
+ LONG ret = ::DocumentPropertiesW(nullptr, hPrinter, name, pDevMode, nullptr,
+ DM_OUT_BUFFER);
+
+ if (ret == IDOK && aPS) {
+ nsCOMPtr<nsIPrintSettingsWin> psWin = do_QueryInterface(aPS);
+ MOZ_ASSERT(psWin);
+ psWin->CopyToNative(pDevMode);
+ // Sets back the changes we made to the DevMode into the Printer Driver
+ ret = ::DocumentPropertiesW(nullptr, hPrinter, name, pDevMode, pDevMode,
+ DM_IN_BUFFER | DM_OUT_BUFFER);
+
+ // We need to copy the final DEVMODE settings back to our print settings,
+ // because they may have been set from invalid prefs.
+ if (ret == IDOK) {
+ // We need to get information from the device as well.
+ nsAutoHDC printerDC(::CreateICW(kDriverName, name, nullptr, pDevMode));
+ if (NS_WARN_IF(!printerDC)) {
+ ::HeapFree(::GetProcessHeap(), 0, pDevMode);
+ return NS_ERROR_FAILURE;
+ }
+
+ psWin->CopyFromNative(printerDC, pDevMode);
+ }
+ }
+
+ if (ret != IDOK) {
+ ::HeapFree(::GetProcessHeap(), 0, pDevMode);
+ PR_PL(
+ ("***** nsDeviceContextSpecWin::GetDataFromPrinter - "
+ "DocumentProperties call failed code: %ld/0x%lx\n",
+ ret, ret));
+ DISPLAY_LAST_ERROR
+ return NS_ERROR_FAILURE;
+ }
+
+ SetDevMode(
+ pDevMode); // cache the pointer and takes responsibility for the memory
+
+ SetDeviceName(aName);
+
+ SetDriverName(nsDependentString(kDriverName));
+
+ rv = NS_OK;
+ } else {
+ rv = NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND;
+ PR_PL(
+ ("***** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't open "
+ "printer: [%s]\n",
+ NS_ConvertUTF16toUTF8(aName).get()));
+ DISPLAY_LAST_ERROR
+ }
+ return rv;
+}
+
+//***********************************************************
+// Printer List
+//***********************************************************
+
+nsPrinterListWin::~nsPrinterListWin() = default;
+
+// Helper to get the array of PRINTER_INFO_4 records from the OS into a
+// caller-supplied byte array; returns the number of records present.
+static unsigned GetPrinterInfo4(nsTArray<BYTE>& aBuffer) {
+ const DWORD kLevel = 4;
+ DWORD needed = 0;
+ DWORD count = 0;
+ const DWORD kFlags = PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS;
+ BOOL ok = ::EnumPrintersW(kFlags,
+ nullptr, // Name
+ kLevel, // Level
+ nullptr, // pPrinterEnum
+ 0, // cbBuf (buffer size)
+ &needed, // Bytes needed in buffer
+ &count);
+ if (needed > 0) {
+ if (!aBuffer.SetLength(needed, fallible)) {
+ return 0;
+ }
+ ok = ::EnumPrintersW(kFlags, nullptr, kLevel, aBuffer.Elements(),
+ aBuffer.Length(), &needed, &count);
+ }
+ if (!ok) {
+ return 0;
+ }
+ return count;
+}
+
+nsTArray<nsPrinterListBase::PrinterInfo> nsPrinterListWin::Printers() const {
+ PR_PL(("nsPrinterListWin::Printers\n"));
+
+ AutoTArray<BYTE, 1024> buffer;
+ unsigned count = GetPrinterInfo4(buffer);
+
+ if (!count) {
+ PR_PL(("[No printers found]\n"));
+ return {};
+ }
+
+ const auto* printers =
+ reinterpret_cast<const _PRINTER_INFO_4W*>(buffer.Elements());
+ nsTArray<PrinterInfo> list;
+ for (unsigned i = 0; i < count; i++) {
+ // For LOCAL printers, we check whether OpenPrinter succeeds, and omit
+ // them from the list if not. This avoids presenting printers that the
+ // user cannot actually use (e.g. due to Windows permissions).
+ // For NETWORK printers, this check may block for a long time (waiting for
+ // network timeout), so we skip it; if the user tries to access a printer
+ // that isn't available, we'll have to show an error later.
+ // (We always need to be able to handle an error, anyhow, as the printer
+ // could get disconnected after we've created the list, for example.)
+ bool isAvailable = false;
+ if (printers[i].Attributes & PRINTER_ATTRIBUTE_NETWORK) {
+ isAvailable = true;
+ } else if (printers[i].Attributes & PRINTER_ATTRIBUTE_LOCAL) {
+ HANDLE handle;
+ if (::OpenPrinterW(printers[i].pPrinterName, &handle, nullptr)) {
+ ::ClosePrinter(handle);
+ isAvailable = true;
+ }
+ }
+ if (isAvailable) {
+ list.AppendElement(PrinterInfo{nsString(printers[i].pPrinterName)});
+ PR_PL(("Printer Name: %s\n",
+ NS_ConvertUTF16toUTF8(printers[i].pPrinterName).get()));
+ }
+ }
+
+ if (!count) {
+ PR_PL(("[No usable printers found]\n"));
+ return {};
+ }
+
+ return list;
+}
+
+Maybe<nsPrinterListBase::PrinterInfo> nsPrinterListWin::PrinterByName(
+ nsString aName) const {
+ Maybe<PrinterInfo> rv;
+
+ AutoTArray<BYTE, 1024> buffer;
+ unsigned count = GetPrinterInfo4(buffer);
+
+ const auto* printers =
+ reinterpret_cast<const _PRINTER_INFO_4W*>(buffer.Elements());
+ for (unsigned i = 0; i < count; ++i) {
+ if (aName.Equals(nsString(printers[i].pPrinterName))) {
+ rv.emplace(PrinterInfo{aName});
+ break;
+ }
+ }
+
+ return rv;
+}
+
+Maybe<nsPrinterListBase::PrinterInfo> nsPrinterListWin::PrinterBySystemName(
+ nsString aName) const {
+ return PrinterByName(std::move(aName));
+}
+
+RefPtr<nsIPrinter> nsPrinterListWin::CreatePrinter(PrinterInfo aInfo) const {
+ return nsPrinterWin::Create(mCommonPaperInfo, std::move(aInfo.mName));
+}
+
+nsresult nsPrinterListWin::SystemDefaultPrinterName(nsAString& aName) const {
+ if (!GetDefaultPrinterName(aName)) {
+ NS_WARNING("Uh oh, GetDefaultPrinterName failed");
+ // Indicate failure by leaving aName untouched, i.e. the empty string.
+ }
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+nsPrinterListWin::InitPrintSettingsFromPrinter(
+ const nsAString& aPrinterName, nsIPrintSettings* aPrintSettings) {
+ NS_ENSURE_ARG_POINTER(aPrintSettings);
+
+ if (aPrinterName.IsEmpty()) {
+ return NS_OK;
+ }
+
+ // When printing to PDF on Windows there is no associated printer driver.
+ int16_t outputFormat = aPrintSettings->GetOutputFormat();
+ if (outputFormat == nsIPrintSettings::kOutputFormatPDF) {
+ return NS_OK;
+ }
+
+ RefPtr<nsDeviceContextSpecWin> devSpecWin = new nsDeviceContextSpecWin();
+ if (!devSpecWin) return NS_ERROR_OUT_OF_MEMORY;
+
+ // If the settings have already been initialized from prefs then pass these to
+ // GetDataFromPrinter, so that they are saved to the printer.
+ bool initializedFromPrefs;
+ nsresult rv =
+ aPrintSettings->GetIsInitializedFromPrefs(&initializedFromPrefs);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ return rv;
+ }
+ if (initializedFromPrefs) {
+ // If we pass in print settings to GetDataFromPrinter it already copies
+ // things back to the settings, so we can return here.
+ return devSpecWin->GetDataFromPrinter(aPrinterName, aPrintSettings);
+ }
+
+ devSpecWin->GetDataFromPrinter(aPrinterName);
+
+ LPDEVMODEW devmode;
+ devSpecWin->GetDevMode(devmode);
+ if (NS_WARN_IF(!devmode)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ aPrintSettings->SetPrinterName(aPrinterName);
+
+ // We need to get information from the device as well.
+ const nsString& flat = PromiseFlatString(aPrinterName);
+ char16ptr_t printerName = flat.get();
+ HDC dc = ::CreateICW(kDriverName, printerName, nullptr, devmode);
+ if (NS_WARN_IF(!dc)) {
+ return NS_ERROR_FAILURE;
+ }
+
+ nsCOMPtr<nsIPrintSettingsWin> psWin = do_QueryInterface(aPrintSettings);
+ MOZ_ASSERT(psWin);
+ psWin->CopyFromNative(dc, devmode);
+ ::DeleteDC(dc);
+
+ return NS_OK;
+}