diff options
Diffstat (limited to 'widget/windows/nsDeviceContextSpecWin.cpp')
| -rw-r--r-- | widget/windows/nsDeviceContextSpecWin.cpp | 669 |
1 files changed, 669 insertions, 0 deletions
diff --git a/widget/windows/nsDeviceContextSpecWin.cpp b/widget/windows/nsDeviceContextSpecWin.cpp new file mode 100644 index 000000000..b7750be58 --- /dev/null +++ b/widget/windows/nsDeviceContextSpecWin.cpp @@ -0,0 +1,669 @@ +/* -*- 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/PrintTargetPDF.h" +#include "mozilla/gfx/PrintTargetWindows.h" +#include "mozilla/Logging.h" +#include "mozilla/Preferences.h" +#include "mozilla/RefPtr.h" + +#include "prmem.h" + +#include <winspool.h> + +#include "nsIWidget.h" + +#include "nsTArray.h" +#include "nsIPrintSettingsWin.h" + +#include "nsString.h" +#include "nsIServiceManager.h" +#include "nsReadableUtils.h" +#include "nsStringEnumerator.h" + +#include "gfxWindowsSurface.h" + +#include "nsIFileStreams.h" +#include "nsIWindowWatcher.h" +#include "nsIDOMWindow.h" +#include "mozilla/Services.h" +#include "nsWindowsHelpers.h" + +#include "mozilla/gfx/Logging.h" + +#include "mozilla/Logging.h" +static mozilla::LazyLogModule kWidgetPrintingLogMod("printing-widget"); +#define PR_PL(_p1) MOZ_LOG(kWidgetPrintingLogMod, mozilla::LogLevel::Debug, _p1) + +using namespace mozilla; +using namespace mozilla::gfx; + +static const wchar_t kDriverName[] = L"WINSPOOL"; + +//---------------------------------------------------------------------------------- +// The printer data is shared between the PrinterEnumerator and the nsDeviceContextSpecWin +// The PrinterEnumerator creates the printer info +// but the nsDeviceContextSpecWin cleans it up +// If it gets created (via the Page Setup Dialog) but the user never prints anything +// then it will never be delete, so this class takes care of that. +class GlobalPrinters { +public: + static GlobalPrinters* GetInstance() { return &mGlobalPrinters; } + ~GlobalPrinters() { FreeGlobalPrinters(); } + + void FreeGlobalPrinters(); + + bool PrintersAreAllocated() { return mPrinters != nullptr; } + LPWSTR GetItemFromList(int32_t aInx) { return mPrinters?mPrinters->ElementAt(aInx):nullptr; } + nsresult EnumeratePrinterList(); + void GetDefaultPrinterName(nsString& aDefaultPrinterName); + uint32_t GetNumPrinters() { return mPrinters?mPrinters->Length():0; } + +protected: + GlobalPrinters() {} + nsresult EnumerateNativePrinters(); + void ReallocatePrinters(); + + static GlobalPrinters mGlobalPrinters; + static nsTArray<LPWSTR>* mPrinters; +}; +//--------------- +// static members +GlobalPrinters GlobalPrinters::mGlobalPrinters; +nsTArray<LPWSTR>* GlobalPrinters::mPrinters = nullptr; + +struct AutoFreeGlobalPrinters +{ + ~AutoFreeGlobalPrinters() { + GlobalPrinters::GetInstance()->FreeGlobalPrinters(); + } +}; + +//---------------------------------------------------------------------------------- +nsDeviceContextSpecWin::nsDeviceContextSpecWin() +{ + mDriverName = nullptr; + mDeviceName = nullptr; + mDevMode = nullptr; + +} + + +//---------------------------------------------------------------------------------- + +NS_IMPL_ISUPPORTS(nsDeviceContextSpecWin, nsIDeviceContextSpec) + +nsDeviceContextSpecWin::~nsDeviceContextSpecWin() +{ + SetDeviceName(nullptr); + SetDriverName(nullptr); + SetDevMode(nullptr); + + nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(mPrintSettings)); + if (psWin) { + psWin->SetDeviceName(nullptr); + psWin->SetDriverName(nullptr); + psWin->SetDevMode(nullptr); + } + + // Free them, we won't need them for a while + GlobalPrinters::GetInstance()->FreeGlobalPrinters(); +} + + +//------------------------------------------------------------------ +// helper +static char16_t * GetDefaultPrinterNameFromGlobalPrinters() +{ + nsAutoString printerName; + GlobalPrinters::GetInstance()->GetDefaultPrinterName(printerName); + return ToNewUnicode(printerName); +} + +//---------------------------------------------------------------------------------- +NS_IMETHODIMP nsDeviceContextSpecWin::Init(nsIWidget* aWidget, + nsIPrintSettings* aPrintSettings, + bool aIsPrintPreview) +{ + mPrintSettings = aPrintSettings; + + nsresult rv = NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE; + if (aPrintSettings) { + // If we're in the child and printing via the parent or we're printing to + // PDF we only need information from the print settings. + mPrintSettings->GetOutputFormat(&mOutputFormat); + if ((XRE_IsContentProcess() && + Preferences::GetBool("print.print_via_parent")) || + mOutputFormat == nsIPrintSettings::kOutputFormatPDF) { + return NS_OK; + } + + nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(aPrintSettings)); + if (psWin) { + char16_t* deviceName; + char16_t* driverName; + psWin->GetDeviceName(&deviceName); // creates new memory (makes a copy) + psWin->GetDriverName(&driverName); // creates new memory (makes a copy) + + LPDEVMODEW devMode; + psWin->GetDevMode(&devMode); // creates new memory (makes a copy) + + if (deviceName && driverName && 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); + + // clean up + free(deviceName); + free(driverName); + + return NS_OK; + } else { + PR_PL(("***** nsDeviceContextSpecWin::Init - deviceName/driverName/devMode was NULL!\n")); + if (deviceName) free(deviceName); + if (driverName) free(driverName); + if (devMode) ::HeapFree(::GetProcessHeap(), 0, devMode); + } + } + } else { + PR_PL(("***** nsDeviceContextSpecWin::Init - aPrintSettingswas NULL!\n")); + } + + // Get the Printer Name to be used and output format. + char16_t * printerName = nullptr; + if (mPrintSettings) { + mPrintSettings->GetPrinterName(&printerName); + } + + // If there is no name then use the default printer + if (!printerName || (printerName && !*printerName)) { + printerName = GetDefaultPrinterNameFromGlobalPrinters(); + } + + NS_ASSERTION(printerName, "We have to have a printer name"); + if (!printerName || !*printerName) return rv; + + return GetDataFromPrinter(printerName, mPrintSettings); +} + +//---------------------------------------------------------- +// Helper Function - Free and reallocate the string +static void CleanAndCopyString(wchar_t*& aStr, const wchar_t* aNewStr) +{ + if (aStr != nullptr) { + if (aNewStr != nullptr && wcslen(aStr) > wcslen(aNewStr)) { // reuse it if we can + wcscpy(aStr, aNewStr); + return; + } else { + PR_Free(aStr); + aStr = nullptr; + } + } + + if (nullptr != aNewStr) { + aStr = (wchar_t *)PR_Malloc(sizeof(wchar_t)*(wcslen(aNewStr) + 1)); + wcscpy(aStr, aNewStr); + } +} + +already_AddRefed<PrintTarget> nsDeviceContextSpecWin::MakePrintTarget() +{ + NS_ASSERTION(mDevMode, "DevMode can't be NULL here"); + + if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) { + nsXPIDLString filename; + mPrintSettings->GetToFileName(getter_Copies(filename)); + + 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; + + nsCOMPtr<nsIFile> file = do_CreateInstance("@mozilla.org/file/local;1"); + nsresult rv = file->InitWithPath(filename); + if (NS_FAILED(rv)) { + return nullptr; + } + + nsCOMPtr<nsIFileOutputStream> stream = do_CreateInstance("@mozilla.org/network/file-output-stream;1"); + rv = stream->Init(file, -1, -1, 0); + if (NS_FAILED(rv)) { + return nullptr; + } + + return PrintTargetPDF::CreateOrNull(stream, IntSize::Truncate(width, height)); + } + + if (mDevMode) { + NS_WARNING_ASSERTION(mDriverName, "No driver!"); + HDC dc = ::CreateDCW(mDriverName, mDeviceName, 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; +} + +float +nsDeviceContextSpecWin::GetDPI() +{ + // To match the previous printing code we need to return 72 when printing to + // PDF and 144 when printing to a Windows surface. + return mOutputFormat == nsIPrintSettings::kOutputFormatPDF ? 72.0f : 144.0f; +} + +float +nsDeviceContextSpecWin::GetPrintingScale() +{ + MOZ_ASSERT(mPrintSettings); + + // To match the previous printing code there is no scaling for PDF. + if (mOutputFormat == nsIPrintSettings::kOutputFormatPDF) { + return 1.0f; + } + + // The print settings will have the resolution stored from the real device. + int32_t resolution; + mPrintSettings->GetResolution(&resolution); + return float(resolution) / GetDPI(); +} + +//---------------------------------------------------------------------------------- +void nsDeviceContextSpecWin::SetDeviceName(char16ptr_t aDeviceName) +{ + CleanAndCopyString(mDeviceName, aDeviceName); +} + +//---------------------------------------------------------------------------------- +void nsDeviceContextSpecWin::SetDriverName(char16ptr_t aDriverName) +{ + CleanAndCopyString(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(char16ptr_t aName, nsIPrintSettings* aPS) +{ + nsresult rv = NS_ERROR_FAILURE; + + if (!GlobalPrinters::GetInstance()->PrintersAreAllocated()) { + rv = GlobalPrinters::GetInstance()->EnumeratePrinterList(); + if (NS_FAILED(rv)) { + PR_PL(("***** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't enumerate printers!\n")); + DISPLAY_LAST_ERROR + } + NS_ENSURE_SUCCESS(rv, rv); + } + + nsHPRINTER hPrinter = nullptr; + wchar_t *name = (wchar_t*)aName; // 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() = %08x\n", + aName ? NS_ConvertUTF16toUTF8(aName).get() : "", GetLastError())); + return NS_ERROR_FAILURE; + } + + 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, aName, 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: %d/0x%x\n", ret, ret)); + DISPLAY_LAST_ERROR + return NS_ERROR_FAILURE; + } + + SetDevMode(pDevMode); // cache the pointer and takes responsibility for the memory + + SetDeviceName(aName); + + SetDriverName(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 Enumerator +//*********************************************************** +nsPrinterEnumeratorWin::nsPrinterEnumeratorWin() +{ +} + +nsPrinterEnumeratorWin::~nsPrinterEnumeratorWin() +{ + // Do not free printers here + // GlobalPrinters::GetInstance()->FreeGlobalPrinters(); +} + +NS_IMPL_ISUPPORTS(nsPrinterEnumeratorWin, nsIPrinterEnumerator) + +//---------------------------------------------------------------------------------- +// Return the Default Printer name +NS_IMETHODIMP +nsPrinterEnumeratorWin::GetDefaultPrinterName(char16_t * *aDefaultPrinterName) +{ + NS_ENSURE_ARG_POINTER(aDefaultPrinterName); + + *aDefaultPrinterName = GetDefaultPrinterNameFromGlobalPrinters(); // helper + + return NS_OK; +} + +NS_IMETHODIMP +nsPrinterEnumeratorWin::InitPrintSettingsFromPrinter(const char16_t *aPrinterName, nsIPrintSettings *aPrintSettings) +{ + NS_ENSURE_ARG_POINTER(aPrinterName); + NS_ENSURE_ARG_POINTER(aPrintSettings); + + if (!*aPrinterName) { + return NS_OK; + } + + // When printing to PDF on Windows there is no associated printer driver. + int16_t outputFormat; + aPrintSettings->GetOutputFormat(&outputFormat); + if (outputFormat == nsIPrintSettings::kOutputFormatPDF) { + return NS_OK; + } + + RefPtr<nsDeviceContextSpecWin> devSpecWin = new nsDeviceContextSpecWin(); + if (!devSpecWin) return NS_ERROR_OUT_OF_MEMORY; + + if (NS_FAILED(GlobalPrinters::GetInstance()->EnumeratePrinterList())) { + return NS_ERROR_FAILURE; + } + + AutoFreeGlobalPrinters autoFreeGlobalPrinters; + + // 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. + char16ptr_t printerName = aPrinterName; + 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; +} + + +//---------------------------------------------------------------------------------- +// Enumerate all the Printers from the global array and pass their +// names back (usually to script) +NS_IMETHODIMP +nsPrinterEnumeratorWin::GetPrinterNameList(nsIStringEnumerator **aPrinterNameList) +{ + NS_ENSURE_ARG_POINTER(aPrinterNameList); + *aPrinterNameList = nullptr; + + nsresult rv = GlobalPrinters::GetInstance()->EnumeratePrinterList(); + if (NS_FAILED(rv)) { + PR_PL(("***** nsDeviceContextSpecWin::GetPrinterNameList - Couldn't enumerate printers!\n")); + return rv; + } + + uint32_t numPrinters = GlobalPrinters::GetInstance()->GetNumPrinters(); + nsTArray<nsString> *printers = new nsTArray<nsString>(numPrinters); + if (!printers) + return NS_ERROR_OUT_OF_MEMORY; + + nsString* names = printers->AppendElements(numPrinters); + for (uint32_t printerInx = 0; printerInx < numPrinters; ++printerInx) { + LPWSTR name = GlobalPrinters::GetInstance()->GetItemFromList(printerInx); + names[printerInx].Assign(name); + } + + return NS_NewAdoptingStringEnumerator(aPrinterNameList, printers); +} + +//---------------------------------------------------------------------------------- +//-- Global Printers +//---------------------------------------------------------------------------------- + +//---------------------------------------------------------------------------------- +// THe array hold the name and port for each printer +void +GlobalPrinters::ReallocatePrinters() +{ + if (PrintersAreAllocated()) { + FreeGlobalPrinters(); + } + mPrinters = new nsTArray<LPWSTR>(); + NS_ASSERTION(mPrinters, "Printers Array is NULL!"); +} + +//---------------------------------------------------------------------------------- +void +GlobalPrinters::FreeGlobalPrinters() +{ + if (mPrinters != nullptr) { + for (uint32_t i=0;i<mPrinters->Length();i++) { + free(mPrinters->ElementAt(i)); + } + delete mPrinters; + mPrinters = nullptr; + } +} + +//---------------------------------------------------------------------------------- +nsresult +GlobalPrinters::EnumerateNativePrinters() +{ + nsresult rv = NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE; + PR_PL(("-----------------------\n")); + PR_PL(("EnumerateNativePrinters\n")); + + WCHAR szDefaultPrinterName[1024]; + DWORD status = GetProfileStringW(L"devices", 0, L",", + szDefaultPrinterName, + ArrayLength(szDefaultPrinterName)); + if (status > 0) { + DWORD count = 0; + LPWSTR sPtr = szDefaultPrinterName; + LPWSTR ePtr = szDefaultPrinterName + status; + LPWSTR prvPtr = sPtr; + while (sPtr < ePtr) { + if (*sPtr == 0) { + LPWSTR name = wcsdup(prvPtr); + mPrinters->AppendElement(name); + PR_PL(("Printer Name: %s\n", prvPtr)); + prvPtr = sPtr+1; + count++; + } + sPtr++; + } + rv = NS_OK; + } + PR_PL(("-----------------------\n")); + return rv; +} + +//------------------------------------------------------------------ +// Uses the GetProfileString to get the default printer from the registry +void +GlobalPrinters::GetDefaultPrinterName(nsString& aDefaultPrinterName) +{ + aDefaultPrinterName.Truncate(); + WCHAR szDefaultPrinterName[1024]; + DWORD status = GetProfileStringW(L"windows", L"device", 0, + szDefaultPrinterName, + ArrayLength(szDefaultPrinterName)); + if (status > 0) { + WCHAR comma = ','; + LPWSTR sPtr = szDefaultPrinterName; + while (*sPtr != comma && *sPtr != 0) + sPtr++; + if (*sPtr == comma) { + *sPtr = 0; + } + aDefaultPrinterName = szDefaultPrinterName; + } else { + aDefaultPrinterName = EmptyString(); + } + + PR_PL(("DEFAULT PRINTER [%s]\n", aDefaultPrinterName.get())); +} + +//---------------------------------------------------------------------------------- +// This goes and gets the list of available printers and puts +// the default printer at the beginning of the list +nsresult +GlobalPrinters::EnumeratePrinterList() +{ + // reallocate and get a new list each time it is asked for + // this deletes the list and re-allocates them + ReallocatePrinters(); + + // any of these could only fail with an OUT_MEMORY_ERROR + // PRINTER_ENUM_LOCAL should get the network printers on Win95 + nsresult rv = EnumerateNativePrinters(); + if (NS_FAILED(rv)) return rv; + + // get the name of the default printer + nsAutoString defPrinterName; + GetDefaultPrinterName(defPrinterName); + + // put the default printer at the beginning of list + if (!defPrinterName.IsEmpty()) { + for (uint32_t i=0;i<mPrinters->Length();i++) { + LPWSTR name = mPrinters->ElementAt(i); + if (defPrinterName.Equals(name)) { + if (i > 0) { + LPWSTR ptr = mPrinters->ElementAt(0); + mPrinters->ElementAt(0) = name; + mPrinters->ElementAt(i) = ptr; + } + break; + } + } + } + + // make sure we at least tried to get the printers + if (!PrintersAreAllocated()) { + PR_PL(("***** nsDeviceContextSpecWin::EnumeratePrinterList - Printers aren`t allocated\n")); + return NS_ERROR_FAILURE; + } + + return NS_OK; +} + |