diff options
Diffstat (limited to 'widget/windows/nsDeviceContextSpecWin.cpp')
| -rw-r--r-- | widget/windows/nsDeviceContextSpecWin.cpp | 680 |
1 files changed, 680 insertions, 0 deletions
diff --git a/widget/windows/nsDeviceContextSpecWin.cpp b/widget/windows/nsDeviceContextSpecWin.cpp new file mode 100644 index 0000000000..ac3bf6f6ed --- /dev/null +++ b/widget/windows/nsDeviceContextSpecWin.cpp @@ -0,0 +1,680 @@ +/* -*- 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 (list.IsEmpty()) { + PR_PL(("[No usable printers found]\n")); + return {}; + } + + list.Sort([](const PrinterInfo& a, const PrinterInfo& b) { + size_t len = std::min(a.mName.Length(), b.mName.Length()); + int result = CaseInsensitiveCompare(a.mName.BeginReading(), + b.mName.BeginReading(), len); + return result ? result : int(a.mName.Length()) - int(b.mName.Length()); + }); + + 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; +} |