Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 4; 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 "nsPrinterWin.h"
#include <algorithm>
#include <windows.h>
#include <winspool.h>
#include "mozilla/Array.h"
#include "mozilla/dom/Promise.h"
#include "nsPaper.h"
#include "nsPrintSettingsImpl.h"
#include "nsPrintSettingsWin.h"
#include "nsWindowsHelpers.h"
#include "PrintBackgroundTask.h"
#include "WinUtils.h"
using namespace mozilla;
using namespace mozilla::gfx;
using namespace mozilla::widget;
using mozilla::PrintSettingsInitializer;
using mozilla::dom::Promise;
static const double kPointsPerTenthMM = 72.0 / 254.0;
static const double kPointsPerInch = 72.0;
nsPrinterWin::nsPrinterWin(const CommonPaperInfoArray* aArray,
const nsAString& aName)
: nsPrinterBase(aArray),
mName(aName),
mDefaultDevmodeWStorage("nsPrinterWin::mDefaultDevmodeWStorage") {}
// static
already_AddRefed<nsPrinterWin> nsPrinterWin::Create(
const CommonPaperInfoArray* aArray, const nsAString& aName) {
return do_AddRef(new nsPrinterWin(aArray, aName));
}
template <class T>
static nsTArray<T> GetDeviceCapabilityArray(const LPWSTR aPrinterName,
WORD aCapabilityID,
mozilla::Mutex& aDriverMutex,
int& aCount) {
MOZ_ASSERT(aCount >= 0, "Possibly passed aCount from previous error case.");
nsTArray<T> caps;
// We only want to access printer drivers in the parent process.
if (!XRE_IsParentProcess()) {
return caps;
}
// Both the call to get the size and the call to actually populate the array
// are relatively expensive, so as sometimes the lengths of the arrays that we
// retrieve depend on each other we allow a count to be passed in to save the
// first call. As we allocate double the count anyway this should allay any
// safety worries.
if (!aCount) {
// Passing nullptr as the port here seems to work. Given that we would have
// to OpenPrinter with just the name anyway to get the port that makes
// sense. Also, the printer set-up seems to stop you from having two
// printers with the same name. Note: this (and the call below) are blocking
// calls, which could be slow.
MutexAutoLock autoLock(aDriverMutex);
aCount = ::DeviceCapabilitiesW(aPrinterName, nullptr, aCapabilityID,
nullptr, nullptr);
if (aCount <= 0) {
return caps;
}
}
// As DeviceCapabilitiesW doesn't take a size, there is a greater risk of the
// buffer being overflowed, so we over-allocate for safety.
caps.SetLength(aCount * 2);
MutexAutoLock autoLock(aDriverMutex);
int count =
::DeviceCapabilitiesW(aPrinterName, nullptr, aCapabilityID,
reinterpret_cast<LPWSTR>(caps.Elements()), nullptr);
if (count <= 0) {
caps.Clear();
return caps;
}
// We know from bug 1673708 that sometimes the final array returned is smaller
// than the required array count. Assert here to see if this is reproduced on
// test servers.
MOZ_ASSERT(count == aCount, "Different array count returned than expected.");
// Note that TruncateLength will crash if count > caps.Length().
caps.TruncateLength(count);
return caps;
}
static void DevmodeToSettingsInitializer(
const nsString& aPrinterName, const DEVMODEW* aDevmode,
mozilla::Mutex& aDriverMutex,
PrintSettingsInitializer& aSettingsInitializer) {
aSettingsInitializer.mPrinter.Assign(aPrinterName);
HDC dc;
{
MutexAutoLock autoLock(aDriverMutex);
dc = ::CreateICW(nullptr, aPrinterName.get(), nullptr, aDevmode);
}
nsAutoHDC printerDc(dc);
MOZ_ASSERT(printerDc, "CreateICW failed");
if (!printerDc) {
return;
}
if (aDevmode->dmFields & DM_PAPERSIZE) {
aSettingsInitializer.mPaperInfo.mId.Truncate();
aSettingsInitializer.mPaperInfo.mId.AppendInt(aDevmode->dmPaperSize);
// If it is not a paper size we know about, the unit will remain unchanged.
nsPrintSettingsWin::PaperSizeUnitFromDmPaperSize(
aDevmode->dmPaperSize, aSettingsInitializer.mPaperSizeUnit);
}
int pixelsPerInchY = ::GetDeviceCaps(printerDc, LOGPIXELSY);
int physicalHeight = ::GetDeviceCaps(printerDc, PHYSICALHEIGHT);
double heightInInches = double(physicalHeight) / pixelsPerInchY;
int pixelsPerInchX = ::GetDeviceCaps(printerDc, LOGPIXELSX);
int physicalWidth = ::GetDeviceCaps(printerDc, PHYSICALWIDTH);
double widthInches = double(physicalWidth) / pixelsPerInchX;
if (aDevmode->dmFields & DM_ORIENTATION &&
aDevmode->dmOrientation == DMORIENT_LANDSCAPE) {
std::swap(widthInches, heightInInches);
}
aSettingsInitializer.mPaperInfo.mSize.SizeTo(widthInches * kPointsPerInch,
heightInInches * kPointsPerInch);
gfx::MarginDouble margin =
WinUtils::GetUnwriteableMarginsForDeviceInInches(printerDc);
aSettingsInitializer.mPaperInfo.mUnwriteableMargin = Some(MarginDouble{
margin.top * kPointsPerInch, margin.right * kPointsPerInch,
margin.bottom * kPointsPerInch, margin.left * kPointsPerInch});
// Using Y to match existing code for print scaling calculations.
aSettingsInitializer.mResolution = pixelsPerInchY;
if (aDevmode->dmFields & DM_COLOR) {
// See comment for PrintSettingsInitializer.mPrintInColor
aSettingsInitializer.mPrintInColor =
aDevmode->dmColor != DMCOLOR_MONOCHROME;
}
if (aDevmode->dmFields & DM_ORIENTATION) {
aSettingsInitializer.mSheetOrientation =
int32_t(aDevmode->dmOrientation == DMORIENT_PORTRAIT
? nsPrintSettings::kPortraitOrientation
: nsPrintSettings::kLandscapeOrientation);
}
if (aDevmode->dmFields & DM_COPIES) {
aSettingsInitializer.mNumCopies = aDevmode->dmCopies;
}
if (aDevmode->dmFields & DM_DUPLEX) {
switch (aDevmode->dmDuplex) {
default:
MOZ_FALLTHROUGH_ASSERT("bad value for dmDuplex field");
case DMDUP_SIMPLEX:
aSettingsInitializer.mDuplex = nsPrintSettings::kDuplexNone;
break;
case DMDUP_VERTICAL:
aSettingsInitializer.mDuplex = nsPrintSettings::kDuplexFlipOnLongEdge;
break;
case DMDUP_HORIZONTAL:
aSettingsInitializer.mDuplex = nsPrintSettings::kDuplexFlipOnShortEdge;
break;
}
}
}
NS_IMETHODIMP
nsPrinterWin::GetName(nsAString& aName) {
aName.Assign(mName);
return NS_OK;
}
NS_IMETHODIMP
nsPrinterWin::GetSystemName(nsAString& aName) {
aName.Assign(mName);
return NS_OK;
}
namespace mozilla {
template <>
void ResolveOrReject(Promise& aPromise, nsPrinterWin& aPrinter,
const PrintSettingsInitializer& aResult) {
aPromise.MaybeResolve(
RefPtr<nsIPrintSettings>(CreatePlatformPrintSettings(aResult)));
}
} // namespace mozilla
NS_IMETHODIMP nsPrinterWin::CopyFromWithValidation(
nsIPrintSettings* aSettingsToCopyFrom, JSContext* aCx,
Promise** aResultPromise) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aResultPromise);
PrintSettingsInitializer settingsInitializer =
aSettingsToCopyFrom->GetSettingsInitializer();
return PrintBackgroundTaskPromise(
*this, aCx, aResultPromise, "CopyFromWithValidation"_ns,
&nsPrinterWin::GetValidatedSettings, settingsInitializer);
}
bool nsPrinterWin::SupportsDuplex() const {
MutexAutoLock autoLock(mDriverMutex);
return ::DeviceCapabilitiesW(mName.get(), nullptr, DC_DUPLEX, nullptr,
nullptr) == 1;
}
bool nsPrinterWin::SupportsColor() const {
MutexAutoLock autoLock(mDriverMutex);
return ::DeviceCapabilitiesW(mName.get(), nullptr, DC_COLORDEVICE, nullptr,
nullptr) == 1;
}
bool nsPrinterWin::SupportsMonochrome() const {
if (!SupportsColor()) {
return true;
}
nsHPRINTER hPrinter = nullptr;
if (NS_WARN_IF(!::OpenPrinterW(mName.get(), &hPrinter, nullptr))) {
return false;
}
nsAutoPrinter autoPrinter(hPrinter);
nsTArray<uint8_t> devmodeWStorage = CopyDefaultDevmodeW();
if (devmodeWStorage.IsEmpty()) {
return false;
}
auto* devmode = reinterpret_cast<DEVMODEW*>(devmodeWStorage.Elements());
devmode->dmFields |= DM_COLOR;
devmode->dmColor = DMCOLOR_MONOCHROME;
// Try to modify the devmode settings and see if the setting sticks.
//
// This has been the only reliable way to detect it that we've found.
MutexAutoLock autoLock(mDriverMutex);
LONG ret =
::DocumentPropertiesW(nullptr, autoPrinter.get(), mName.get(), devmode,
devmode, DM_IN_BUFFER | DM_OUT_BUFFER);
if (ret != IDOK) {
return false;
}
return !(devmode->dmFields & DM_COLOR) ||
devmode->dmColor == DMCOLOR_MONOCHROME;
}
bool nsPrinterWin::SupportsCollation() const {
MutexAutoLock autoLock(mDriverMutex);
return ::DeviceCapabilitiesW(mName.get(), nullptr, DC_COLLATE, nullptr,
nullptr) == 1;
}
nsPrinterBase::PrinterInfo nsPrinterWin::CreatePrinterInfo() const {
return PrinterInfo{PaperList(), DefaultSettings()};
}
mozilla::gfx::MarginDouble nsPrinterWin::GetMarginsForPaper(
nsString aPaperId) const {
gfx::MarginDouble margin;
nsTArray<uint8_t> devmodeWStorage = CopyDefaultDevmodeW();
if (devmodeWStorage.IsEmpty()) {
return margin;
}
auto* devmode = reinterpret_cast<DEVMODEW*>(devmodeWStorage.Elements());
devmode->dmFields = DM_PAPERSIZE;
devmode->dmPaperSize = _wtoi((const wchar_t*)aPaperId.BeginReading());
HDC dc;
{
MutexAutoLock autoLock(mDriverMutex);
dc = ::CreateICW(nullptr, mName.get(), nullptr, devmode);
}
nsAutoHDC printerDc(dc);
MOZ_ASSERT(printerDc, "CreateICW failed");
if (!printerDc) {
return margin;
}
margin = WinUtils::GetUnwriteableMarginsForDeviceInInches(printerDc);
margin.top *= kPointsPerInch;
margin.right *= kPointsPerInch;
margin.bottom *= kPointsPerInch;
margin.left *= kPointsPerInch;
return margin;
}
nsTArray<uint8_t> nsPrinterWin::CopyDefaultDevmodeW() const {
nsTArray<uint8_t> devmodeStorageW;
auto devmodeStorageWLock = mDefaultDevmodeWStorage.Lock();
if (devmodeStorageWLock->IsEmpty()) {
nsHPRINTER hPrinter = nullptr;
// OpenPrinter could fail if, for example, the printer has been removed
// or otherwise become inaccessible since it was selected.
if (NS_WARN_IF(!::OpenPrinterW(mName.get(), &hPrinter, nullptr))) {
return devmodeStorageW;
}
nsAutoPrinter autoPrinter(hPrinter);
// Allocate devmode storage of the correct size.
MutexAutoLock autoLock(mDriverMutex);
LONG bytesNeeded = ::DocumentPropertiesW(nullptr, autoPrinter.get(),
mName.get(), nullptr, nullptr, 0);
// Note that we must cast the sizeof() to a signed type so that comparison
// with the signed, potentially-negative bytesNeeded will work!
MOZ_ASSERT(bytesNeeded >= LONG(sizeof(DEVMODEW)),
"DocumentPropertiesW failed to get valid size");
if (bytesNeeded < LONG(sizeof(DEVMODEW))) {
return devmodeStorageW;
}
// Allocate extra space in case of bad drivers that return a too-small
// result from DocumentProperties.
devmodeStorageWLock->SetLength(bytesNeeded * 2);
auto* devmode =
reinterpret_cast<DEVMODEW*>(devmodeStorageWLock->Elements());
LONG ret = ::DocumentPropertiesW(nullptr, autoPrinter.get(), mName.get(),
devmode, nullptr, DM_OUT_BUFFER);
MOZ_ASSERT(ret == IDOK, "DocumentPropertiesW failed");
if (ret != IDOK) {
return devmodeStorageW;
}
}
devmodeStorageW.Assign(devmodeStorageWLock.ref());
return devmodeStorageW;
}
nsTArray<mozilla::PaperInfo> nsPrinterWin::PaperList() const {
// Paper IDs are returned as WORDs.
int requiredArrayCount = 0;
auto paperIds = GetDeviceCapabilityArray<WORD>(
mName.get(), DC_PAPERS, mDriverMutex, requiredArrayCount);
if (!paperIds.Length()) {
return {};
}
// Paper names are returned in 64 long character buffers.
auto paperNames = GetDeviceCapabilityArray<Array<wchar_t, 64>>(
mName.get(), DC_PAPERNAMES, mDriverMutex, requiredArrayCount);
// Check that we have the same number of names as IDs.
if (paperNames.Length() != paperIds.Length()) {
return {};
}
// Paper sizes are returned as POINT structs with a tenth of a millimeter as
// the unit.
auto paperSizes = GetDeviceCapabilityArray<POINT>(
mName.get(), DC_PAPERSIZE, mDriverMutex, requiredArrayCount);
// Check that we have the same number of sizes as IDs.
if (paperSizes.Length() != paperIds.Length()) {
return {};
}
nsTArray<mozilla::PaperInfo> paperList;
paperList.SetCapacity(paperNames.Length());
for (size_t i = 0; i < paperNames.Length(); ++i) {
// Paper names are null terminated unless they are 64 characters long.
auto firstNull =
std::find(paperNames[i].cbegin(), paperNames[i].cend(), L'\0');
auto nameLength = firstNull - paperNames[i].cbegin();
double width = paperSizes[i].x * kPointsPerTenthMM;
double height = paperSizes[i].y * kPointsPerTenthMM;
// Skip if no name or invalid size.
if (!nameLength || width <= 0 || height <= 0) {
continue;
}
// Windows paper IDs are 16-bit integers; we stringify them to store in the
// PaperInfo.mId field.
nsString paperIdString;
paperIdString.AppendInt(paperIds[i]);
// We don't resolve the margins eagerly because they're really expensive (on
// the order of seconds for some drivers).
nsDependentSubstring name(paperNames[i].cbegin(), nameLength);
paperList.AppendElement(mozilla::PaperInfo(paperIdString, nsString(name),
{width, height}, Nothing()));
}
return paperList;
}
PrintSettingsInitializer nsPrinterWin::DefaultSettings() const {
nsTArray<uint8_t> devmodeWStorage = CopyDefaultDevmodeW();
if (devmodeWStorage.IsEmpty()) {
return {};
}
const auto* devmode =
reinterpret_cast<const DEVMODEW*>(devmodeWStorage.Elements());
PrintSettingsInitializer settingsInitializer;
DevmodeToSettingsInitializer(mName, devmode, mDriverMutex,
settingsInitializer);
settingsInitializer.mDevmodeWStorage = std::move(devmodeWStorage);
return settingsInitializer;
}
PrintSettingsInitializer nsPrinterWin::GetValidatedSettings(
PrintSettingsInitializer aSettingsToValidate) const {
// This function validates the settings by relying on the printer driver
// rejecting any invalid settings and resetting them to valid values.
// Create a copy of the default DEVMODE for this printer.
nsTArray<uint8_t> devmodeWStorage = CopyDefaultDevmodeW();
if (devmodeWStorage.IsEmpty()) {
return aSettingsToValidate;
}
nsHPRINTER hPrinter = nullptr;
if (NS_WARN_IF(!::OpenPrinterW(mName.get(), &hPrinter, nullptr))) {
return aSettingsToValidate;
}
nsAutoPrinter autoPrinter(hPrinter);
// Copy the settings from aSettingsToValidate into our DEVMODE.
DEVMODEW* devmode = reinterpret_cast<DEVMODEW*>(devmodeWStorage.Elements());
if (!aSettingsToValidate.mPaperInfo.mId.IsEmpty()) {
devmode->dmPaperSize = _wtoi(
(const wchar_t*)aSettingsToValidate.mPaperInfo.mId.BeginReading());
devmode->dmFields |= DM_PAPERSIZE;
} else {
devmode->dmPaperSize = 0;
devmode->dmFields &= ~DM_PAPERSIZE;
}
devmode->dmFields |= DM_COLOR;
devmode->dmColor =
aSettingsToValidate.mPrintInColor ? DMCOLOR_COLOR : DMCOLOR_MONOCHROME;
// Note: small page sizes can be required here for sticker, label and slide
// printers etc. see bug 1271900.
if (aSettingsToValidate.mPaperInfo.mSize.height > 0) {
devmode->dmPaperLength = std::round(
aSettingsToValidate.mPaperInfo.mSize.height / kPointsPerTenthMM);
devmode->dmFields |= DM_PAPERLENGTH;
} else {
devmode->dmPaperLength = 0;
devmode->dmFields &= ~DM_PAPERLENGTH;
}
if (aSettingsToValidate.mPaperInfo.mSize.width > 0) {
devmode->dmPaperWidth = std::round(
aSettingsToValidate.mPaperInfo.mSize.width / kPointsPerTenthMM);
devmode->dmFields |= DM_PAPERWIDTH;
} else {
devmode->dmPaperWidth = 0;
devmode->dmFields &= ~DM_PAPERWIDTH;
}
// Setup Orientation
devmode->dmOrientation = aSettingsToValidate.mSheetOrientation ==
nsPrintSettings::kPortraitOrientation
? DMORIENT_PORTRAIT
: DMORIENT_LANDSCAPE;
devmode->dmFields |= DM_ORIENTATION;
// Setup Number of Copies
devmode->dmCopies = aSettingsToValidate.mNumCopies;
devmode->dmFields |= DM_COPIES;
// Setup Simplex/Duplex mode
devmode->dmFields |= DM_DUPLEX;
switch (aSettingsToValidate.mDuplex) {
case nsPrintSettings::kDuplexNone:
devmode->dmDuplex = DMDUP_SIMPLEX;
break;
case nsPrintSettings::kDuplexFlipOnLongEdge:
devmode->dmDuplex = DMDUP_VERTICAL;
break;
case nsPrintSettings::kDuplexFlipOnShortEdge:
devmode->dmDuplex = DMDUP_HORIZONTAL;
break;
default:
MOZ_ASSERT_UNREACHABLE("bad value for duplex option");
break;
}
// Apply the settings in the DEVMODE to the printer and retrieve the updated
// DEVMODE back into the same structure.
LONG ret;
{
MutexAutoLock autoLock(mDriverMutex);
ret = ::DocumentPropertiesW(nullptr, autoPrinter.get(), mName.get(),
devmode, devmode, DM_IN_BUFFER | DM_OUT_BUFFER);
}
if (ret != IDOK) {
return aSettingsToValidate;
}
// Copy the settings back from the DEVMODE into aSettingsToValidate and
// return.
DevmodeToSettingsInitializer(mName, devmode, mDriverMutex,
aSettingsToValidate);
aSettingsToValidate.mDevmodeWStorage = std::move(devmodeWStorage);
return aSettingsToValidate;
}