Add m-esr52 at 52.6.0

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;
+}
+