The Tor Browser / file comparison

comparison: widget/windows/nsDeviceContextSpecWin.cpp

widget/windows/nsDeviceContextSpecWin.cpp

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:b87f6162f9d7
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "mozilla/ArrayUtils.h"
7
8 #include "nsDeviceContextSpecWin.h"
9 #include "prmem.h"
10
11 #include <winspool.h>
12
13 #include <tchar.h>
14
15 #include "nsAutoPtr.h"
16 #include "nsIWidget.h"
17
18 #include "nsTArray.h"
19 #include "nsIPrintSettingsWin.h"
20
21 #include "nsString.h"
22 #include "nsCRT.h"
23 #include "nsIServiceManager.h"
24 #include "nsReadableUtils.h"
25 #include "nsStringEnumerator.h"
26
27 #include "gfxPDFSurface.h"
28 #include "gfxWindowsSurface.h"
29
30 #include "nsIFileStreams.h"
31 #include "nsIWindowWatcher.h"
32 #include "nsIDOMWindow.h"
33 #include "mozilla/Services.h"
34
35 // For NS_CopyNativeToUnicode
36 #include "nsNativeCharsetUtils.h"
37
38 // File Picker
39 #include "nsIFile.h"
40 #include "nsIFilePicker.h"
41 #include "nsIStringBundle.h"
42 #define NS_ERROR_GFX_PRINTER_BUNDLE_URL "chrome://global/locale/printing.properties"
43
44 #include "prlog.h"
45 #ifdef PR_LOGGING
46 PRLogModuleInfo * kWidgetPrintingLogMod = PR_NewLogModule("printing-widget");
47 #define PR_PL(_p1) PR_LOG(kWidgetPrintingLogMod, PR_LOG_DEBUG, _p1)
48 #else
49 #define PR_PL(_p1)
50 #endif
51
52 using namespace mozilla;
53
54 //----------------------------------------------------------------------------------
55 // The printer data is shared between the PrinterEnumerator and the nsDeviceContextSpecWin
56 // The PrinterEnumerator creates the printer info
57 // but the nsDeviceContextSpecWin cleans it up
58 // If it gets created (via the Page Setup Dialog) but the user never prints anything
59 // then it will never be delete, so this class takes care of that.
60 class GlobalPrinters {
61 public:
62 static GlobalPrinters* GetInstance() { return &mGlobalPrinters; }
63 ~GlobalPrinters() { FreeGlobalPrinters(); }
64
65 void FreeGlobalPrinters();
66
67 bool PrintersAreAllocated() { return mPrinters != nullptr; }
68 LPWSTR GetItemFromList(int32_t aInx) { return mPrinters?mPrinters->ElementAt(aInx):nullptr; }
69 nsresult EnumeratePrinterList();
70 void GetDefaultPrinterName(nsString& aDefaultPrinterName);
71 uint32_t GetNumPrinters() { return mPrinters?mPrinters->Length():0; }
72
73 protected:
74 GlobalPrinters() {}
75 nsresult EnumerateNativePrinters();
76 void ReallocatePrinters();
77
78 static GlobalPrinters mGlobalPrinters;
79 static nsTArray<LPWSTR>* mPrinters;
80 };
81 //---------------
82 // static members
83 GlobalPrinters GlobalPrinters::mGlobalPrinters;
84 nsTArray<LPWSTR>* GlobalPrinters::mPrinters = nullptr;
85
86
87 //******************************************************
88 // Define native paper sizes
89 //******************************************************
90 typedef struct {
91 short mPaperSize; // native enum
92 double mWidth;
93 double mHeight;
94 bool mIsInches;
95 } NativePaperSizes;
96
97 // There are around 40 default print sizes defined by Windows
98 const NativePaperSizes kPaperSizes[] = {
99 {DMPAPER_LETTER, 8.5, 11.0, true},
100 {DMPAPER_LEGAL, 8.5, 14.0, true},
101 {DMPAPER_A4, 210.0, 297.0, false},
102 {DMPAPER_B4, 250.0, 354.0, false},
103 {DMPAPER_B5, 182.0, 257.0, false},
104 {DMPAPER_TABLOID, 11.0, 17.0, true},
105 {DMPAPER_LEDGER, 17.0, 11.0, true},
106 {DMPAPER_STATEMENT, 5.5, 8.5, true},
107 {DMPAPER_EXECUTIVE, 7.25, 10.5, true},
108 {DMPAPER_A3, 297.0, 420.0, false},
109 {DMPAPER_A5, 148.0, 210.0, false},
110 {DMPAPER_CSHEET, 17.0, 22.0, true},
111 {DMPAPER_DSHEET, 22.0, 34.0, true},
112 {DMPAPER_ESHEET, 34.0, 44.0, true},
113 {DMPAPER_LETTERSMALL, 8.5, 11.0, true},
114 {DMPAPER_A4SMALL, 210.0, 297.0, false},
115 {DMPAPER_FOLIO, 8.5, 13.0, true},
116 {DMPAPER_QUARTO, 215.0, 275.0, false},
117 {DMPAPER_10X14, 10.0, 14.0, true},
118 {DMPAPER_11X17, 11.0, 17.0, true},
119 {DMPAPER_NOTE, 8.5, 11.0, true},
120 {DMPAPER_ENV_9, 3.875, 8.875, true},
121 {DMPAPER_ENV_10, 40.125, 9.5, true},
122 {DMPAPER_ENV_11, 4.5, 10.375, true},
123 {DMPAPER_ENV_12, 4.75, 11.0, true},
124 {DMPAPER_ENV_14, 5.0, 11.5, true},
125 {DMPAPER_ENV_DL, 110.0, 220.0, false},
126 {DMPAPER_ENV_C5, 162.0, 229.0, false},
127 {DMPAPER_ENV_C3, 324.0, 458.0, false},
128 {DMPAPER_ENV_C4, 229.0, 324.0, false},
129 {DMPAPER_ENV_C6, 114.0, 162.0, false},
130 {DMPAPER_ENV_C65, 114.0, 229.0, false},
131 {DMPAPER_ENV_B4, 250.0, 353.0, false},
132 {DMPAPER_ENV_B5, 176.0, 250.0, false},
133 {DMPAPER_ENV_B6, 176.0, 125.0, false},
134 {DMPAPER_ENV_ITALY, 110.0, 230.0, false},
135 {DMPAPER_ENV_MONARCH, 3.875, 7.5, true},
136 {DMPAPER_ENV_PERSONAL, 3.625, 6.5, true},
137 {DMPAPER_FANFOLD_US, 14.875, 11.0, true},
138 {DMPAPER_FANFOLD_STD_GERMAN, 8.5, 12.0, true},
139 {DMPAPER_FANFOLD_LGL_GERMAN, 8.5, 13.0, true},
140 };
141 const int32_t kNumPaperSizes = 41;
142
143 //----------------------------------------------------------------------------------
144 nsDeviceContextSpecWin::nsDeviceContextSpecWin()
145 {
146 mDriverName = nullptr;
147 mDeviceName = nullptr;
148 mDevMode = nullptr;
149
150 }
151
152
153 //----------------------------------------------------------------------------------
154
155 NS_IMPL_ISUPPORTS(nsDeviceContextSpecWin, nsIDeviceContextSpec)
156
157 nsDeviceContextSpecWin::~nsDeviceContextSpecWin()
158 {
159 SetDeviceName(nullptr);
160 SetDriverName(nullptr);
161 SetDevMode(nullptr);
162
163 nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(mPrintSettings));
164 if (psWin) {
165 psWin->SetDeviceName(nullptr);
166 psWin->SetDriverName(nullptr);
167 psWin->SetDevMode(nullptr);
168 }
169
170 // Free them, we won't need them for a while
171 GlobalPrinters::GetInstance()->FreeGlobalPrinters();
172 }
173
174
175 //------------------------------------------------------------------
176 // helper
177 static char16_t * GetDefaultPrinterNameFromGlobalPrinters()
178 {
179 nsAutoString printerName;
180 GlobalPrinters::GetInstance()->GetDefaultPrinterName(printerName);
181 return ToNewUnicode(printerName);
182 }
183
184 //----------------------------------------------------------------------------------
185 NS_IMETHODIMP nsDeviceContextSpecWin::Init(nsIWidget* aWidget,
186 nsIPrintSettings* aPrintSettings,
187 bool aIsPrintPreview)
188 {
189 mPrintSettings = aPrintSettings;
190
191 nsresult rv = NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE;
192 if (aPrintSettings) {
193 nsCOMPtr<nsIPrintSettingsWin> psWin(do_QueryInterface(aPrintSettings));
194 if (psWin) {
195 char16_t* deviceName;
196 char16_t* driverName;
197 psWin->GetDeviceName(&deviceName); // creates new memory (makes a copy)
198 psWin->GetDriverName(&driverName); // creates new memory (makes a copy)
199
200 LPDEVMODEW devMode;
201 psWin->GetDevMode(&devMode); // creates new memory (makes a copy)
202
203 if (deviceName && driverName && devMode) {
204 // Scaling is special, it is one of the few
205 // devMode items that we control in layout
206 if (devMode->dmFields & DM_SCALE) {
207 double scale = double(devMode->dmScale) / 100.0f;
208 if (scale != 1.0) {
209 aPrintSettings->SetScaling(scale);
210 devMode->dmScale = 100;
211 }
212 }
213
214 SetDeviceName(deviceName);
215 SetDriverName(driverName);
216 SetDevMode(devMode);
217
218 // clean up
219 free(deviceName);
220 free(driverName);
221
222 return NS_OK;
223 } else {
224 PR_PL(("***** nsDeviceContextSpecWin::Init - deviceName/driverName/devMode was NULL!\n"));
225 if (deviceName) free(deviceName);
226 if (driverName) free(driverName);
227 if (devMode) ::HeapFree(::GetProcessHeap(), 0, devMode);
228 }
229 }
230 } else {
231 PR_PL(("***** nsDeviceContextSpecWin::Init - aPrintSettingswas NULL!\n"));
232 }
233
234 // Get the Print Name to be used
235 char16_t * printerName = nullptr;
236 if (mPrintSettings) {
237 mPrintSettings->GetPrinterName(&printerName);
238 }
239
240 // If there is no name then use the default printer
241 if (!printerName || (printerName && !*printerName)) {
242 printerName = GetDefaultPrinterNameFromGlobalPrinters();
243 }
244
245 NS_ASSERTION(printerName, "We have to have a printer name");
246 if (!printerName || !*printerName) return rv;
247
248 return GetDataFromPrinter(printerName, mPrintSettings);
249 }
250
251 //----------------------------------------------------------
252 // Helper Function - Free and reallocate the string
253 static void CleanAndCopyString(wchar_t*& aStr, const wchar_t* aNewStr)
254 {
255 if (aStr != nullptr) {
256 if (aNewStr != nullptr && wcslen(aStr) > wcslen(aNewStr)) { // reuse it if we can
257 wcscpy(aStr, aNewStr);
258 return;
259 } else {
260 PR_Free(aStr);
261 aStr = nullptr;
262 }
263 }
264
265 if (nullptr != aNewStr) {
266 aStr = (wchar_t *)PR_Malloc(sizeof(wchar_t)*(wcslen(aNewStr) + 1));
267 wcscpy(aStr, aNewStr);
268 }
269 }
270
271 NS_IMETHODIMP nsDeviceContextSpecWin::GetSurfaceForPrinter(gfxASurface **surface)
272 {
273 NS_ASSERTION(mDevMode, "DevMode can't be NULL here");
274
275 nsRefPtr<gfxASurface> newSurface;
276
277 int16_t outputFormat = 0;
278 if (mPrintSettings) {
279 mPrintSettings->GetOutputFormat(&outputFormat);
280 }
281
282 if (outputFormat == nsIPrintSettings::kOutputFormatPDF) {
283 nsXPIDLString filename;
284 mPrintSettings->GetToFileName(getter_Copies(filename));
285
286 double width, height;
287 mPrintSettings->GetEffectivePageSize(&width, &height);
288 // convert twips to points
289 width /= TWIPS_PER_POINT_FLOAT;
290 height /= TWIPS_PER_POINT_FLOAT;
291
292 nsCOMPtr<nsIFile> file = do_CreateInstance("@mozilla.org/file/local;1");
293 nsresult rv = file->InitWithPath(filename);
294 if (NS_FAILED(rv))
295 return rv;
296
297 nsCOMPtr<nsIFileOutputStream> stream = do_CreateInstance("@mozilla.org/network/file-output-stream;1");
298 rv = stream->Init(file, -1, -1, 0);
299 if (NS_FAILED(rv))
300 return rv;
301
302 newSurface = new gfxPDFSurface(stream, gfxSize(width, height));
303 } else {
304 if (mDevMode) {
305 NS_WARN_IF_FALSE(mDriverName, "No driver!");
306 HDC dc = ::CreateDCW(mDriverName, mDeviceName, nullptr, mDevMode);
307
308 // have this surface take over ownership of this DC
309 newSurface = new gfxWindowsSurface(dc, gfxWindowsSurface::FLAG_TAKE_DC | gfxWindowsSurface::FLAG_FOR_PRINTING);
310 }
311 }
312
313 if (newSurface) {
314 *surface = newSurface;
315 NS_ADDREF(*surface);
316 return NS_OK;
317 }
318
319 *surface = nullptr;
320 return NS_ERROR_FAILURE;
321 }
322
323 //----------------------------------------------------------------------------------
324 void nsDeviceContextSpecWin::SetDeviceName(char16ptr_t aDeviceName)
325 {
326 CleanAndCopyString(mDeviceName, aDeviceName);
327 }
328
329 //----------------------------------------------------------------------------------
330 void nsDeviceContextSpecWin::SetDriverName(char16ptr_t aDriverName)
331 {
332 CleanAndCopyString(mDriverName, aDriverName);
333 }
334
335 //----------------------------------------------------------------------------------
336 void nsDeviceContextSpecWin::SetDevMode(LPDEVMODEW aDevMode)
337 {
338 if (mDevMode) {
339 ::HeapFree(::GetProcessHeap(), 0, mDevMode);
340 }
341
342 mDevMode = aDevMode;
343 }
344
345 //------------------------------------------------------------------
346 void
347 nsDeviceContextSpecWin::GetDevMode(LPDEVMODEW &aDevMode)
348 {
349 aDevMode = mDevMode;
350 }
351
352 //----------------------------------------------------------------------------------
353 // Map an incoming size to a Windows Native enum in the DevMode
354 static void
355 MapPaperSizeToNativeEnum(LPDEVMODEW aDevMode,
356 int16_t aType,
357 double aW,
358 double aH)
359 {
360
361 #ifdef DEBUG_rods
362 BOOL doingOrientation = aDevMode->dmFields & DM_ORIENTATION;
363 BOOL doingPaperSize = aDevMode->dmFields & DM_PAPERSIZE;
364 BOOL doingPaperLength = aDevMode->dmFields & DM_PAPERLENGTH;
365 BOOL doingPaperWidth = aDevMode->dmFields & DM_PAPERWIDTH;
366 #endif
367
368 for (int32_t i=0;i<kNumPaperSizes;i++) {
369 if (kPaperSizes[i].mWidth == aW && kPaperSizes[i].mHeight == aH) {
370 aDevMode->dmPaperSize = kPaperSizes[i].mPaperSize;
371 aDevMode->dmFields &= ~DM_PAPERLENGTH;
372 aDevMode->dmFields &= ~DM_PAPERWIDTH;
373 aDevMode->dmFields |= DM_PAPERSIZE;
374 return;
375 }
376 }
377
378 short width = 0;
379 short height = 0;
380 if (aType == nsIPrintSettings::kPaperSizeInches) {
381 width = short(NS_TWIPS_TO_MILLIMETERS(NS_INCHES_TO_TWIPS(float(aW))) / 10);
382 height = short(NS_TWIPS_TO_MILLIMETERS(NS_INCHES_TO_TWIPS(float(aH))) / 10);
383
384 } else if (aType == nsIPrintSettings::kPaperSizeMillimeters) {
385 width = short(aW / 10.0);
386 height = short(aH / 10.0);
387 } else {
388 return; // don't set anything
389 }
390
391 // width and height is in
392 aDevMode->dmPaperSize = 0;
393 aDevMode->dmPaperWidth = width;
394 aDevMode->dmPaperLength = height;
395
396 aDevMode->dmFields |= DM_PAPERSIZE;
397 aDevMode->dmFields |= DM_PAPERLENGTH;
398 aDevMode->dmFields |= DM_PAPERWIDTH;
399 }
400
401 //----------------------------------------------------------------------------------
402 // Setup Paper Size & Orientation options into the DevMode
403 //
404 static void
405 SetupDevModeFromSettings(LPDEVMODEW aDevMode, nsIPrintSettings* aPrintSettings)
406 {
407 // Setup paper size
408 if (aPrintSettings) {
409 int16_t type;
410 aPrintSettings->GetPaperSizeType(&type);
411 if (type == nsIPrintSettings::kPaperSizeNativeData) {
412 int16_t paperEnum;
413 aPrintSettings->GetPaperData(&paperEnum);
414 aDevMode->dmPaperSize = paperEnum;
415 aDevMode->dmFields &= ~DM_PAPERLENGTH;
416 aDevMode->dmFields &= ~DM_PAPERWIDTH;
417 aDevMode->dmFields |= DM_PAPERSIZE;
418 } else {
419 int16_t unit;
420 double width, height;
421 aPrintSettings->GetPaperSizeUnit(&unit);
422 aPrintSettings->GetPaperWidth(&width);
423 aPrintSettings->GetPaperHeight(&height);
424 MapPaperSizeToNativeEnum(aDevMode, unit, width, height);
425 }
426
427 // Setup Orientation
428 int32_t orientation;
429 aPrintSettings->GetOrientation(&orientation);
430 aDevMode->dmOrientation = orientation == nsIPrintSettings::kPortraitOrientation?DMORIENT_PORTRAIT:DMORIENT_LANDSCAPE;
431 aDevMode->dmFields |= DM_ORIENTATION;
432
433 // Setup Number of Copies
434 int32_t copies;
435 aPrintSettings->GetNumCopies(&copies);
436 aDevMode->dmCopies = copies;
437 aDevMode->dmFields |= DM_COPIES;
438 }
439
440 }
441
442 #define DISPLAY_LAST_ERROR
443
444 //----------------------------------------------------------------------------------
445 // Setup the object's data member with the selected printer's data
446 nsresult
447 nsDeviceContextSpecWin::GetDataFromPrinter(char16ptr_t aName, nsIPrintSettings* aPS)
448 {
449 nsresult rv = NS_ERROR_FAILURE;
450
451 if (!GlobalPrinters::GetInstance()->PrintersAreAllocated()) {
452 rv = GlobalPrinters::GetInstance()->EnumeratePrinterList();
453 if (NS_FAILED(rv)) {
454 PR_PL(("***** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't enumerate printers!\n"));
455 DISPLAY_LAST_ERROR
456 }
457 NS_ENSURE_SUCCESS(rv, rv);
458 }
459
460 HANDLE hPrinter = nullptr;
461 wchar_t *name = (wchar_t*)aName; // Windows APIs use non-const name argument
462
463 BOOL status = ::OpenPrinterW(name, &hPrinter, nullptr);
464 if (status) {
465
466 LPDEVMODEW pDevMode;
467 DWORD dwNeeded, dwRet;
468
469 // Allocate a buffer of the correct size.
470 dwNeeded = ::DocumentPropertiesW(nullptr, hPrinter, name, nullptr, nullptr, 0);
471
472 pDevMode = (LPDEVMODEW)::HeapAlloc (::GetProcessHeap(), HEAP_ZERO_MEMORY, dwNeeded);
473 if (!pDevMode) return NS_ERROR_FAILURE;
474
475 // Get the default DevMode for the printer and modify it for our needs.
476 dwRet = DocumentPropertiesW(nullptr, hPrinter, name,
477 pDevMode, nullptr, DM_OUT_BUFFER);
478
479 if (dwRet == IDOK && aPS) {
480 SetupDevModeFromSettings(pDevMode, aPS);
481 // Sets back the changes we made to the DevMode into the Printer Driver
482 dwRet = ::DocumentPropertiesW(nullptr, hPrinter, name,
483 pDevMode, pDevMode,
484 DM_IN_BUFFER | DM_OUT_BUFFER);
485 }
486
487 if (dwRet != IDOK) {
488 ::HeapFree(::GetProcessHeap(), 0, pDevMode);
489 ::ClosePrinter(hPrinter);
490 PR_PL(("***** nsDeviceContextSpecWin::GetDataFromPrinter - DocumentProperties call failed code: %d/0x%x\n", dwRet, dwRet));
491 DISPLAY_LAST_ERROR
492 return NS_ERROR_FAILURE;
493 }
494
495 SetDevMode(pDevMode); // cache the pointer and takes responsibility for the memory
496
497 SetDeviceName(aName);
498
499 SetDriverName(L"WINSPOOL");
500
501 ::ClosePrinter(hPrinter);
502 rv = NS_OK;
503 } else {
504 rv = NS_ERROR_GFX_PRINTER_NAME_NOT_FOUND;
505 PR_PL(("***** nsDeviceContextSpecWin::GetDataFromPrinter - Couldn't open printer: [%s]\n", NS_ConvertUTF16toUTF8(aName).get()));
506 DISPLAY_LAST_ERROR
507 }
508 return rv;
509 }
510
511 //----------------------------------------------------------------------------------
512 // Setup Paper Size options into the DevMode
513 //
514 // When using a data member it may be a HGLOCAL or LPDEVMODE
515 // if it is a HGLOBAL then we need to "lock" it to get the LPDEVMODE
516 // and unlock it when we are done.
517 void
518 nsDeviceContextSpecWin::SetupPaperInfoFromSettings()
519 {
520 LPDEVMODEW devMode;
521
522 GetDevMode(devMode);
523 NS_ASSERTION(devMode, "DevMode can't be NULL here");
524 if (devMode) {
525 SetupDevModeFromSettings(devMode, mPrintSettings);
526 }
527 }
528
529 //----------------------------------------------------------------------------------
530 // Helper Function - Free and reallocate the string
531 nsresult
532 nsDeviceContextSpecWin::SetPrintSettingsFromDevMode(nsIPrintSettings* aPrintSettings,
533 LPDEVMODEW aDevMode)
534 {
535 if (aPrintSettings == nullptr) {
536 return NS_ERROR_FAILURE;
537 }
538 aPrintSettings->SetIsInitializedFromPrinter(true);
539
540 BOOL doingNumCopies = aDevMode->dmFields & DM_COPIES;
541 BOOL doingOrientation = aDevMode->dmFields & DM_ORIENTATION;
542 BOOL doingPaperSize = aDevMode->dmFields & DM_PAPERSIZE;
543 BOOL doingPaperLength = aDevMode->dmFields & DM_PAPERLENGTH;
544 BOOL doingPaperWidth = aDevMode->dmFields & DM_PAPERWIDTH;
545
546 if (doingOrientation) {
547 int32_t orientation = aDevMode->dmOrientation == DMORIENT_PORTRAIT?
548 int32_t(nsIPrintSettings::kPortraitOrientation):nsIPrintSettings::kLandscapeOrientation;
549 aPrintSettings->SetOrientation(orientation);
550 }
551
552 // Setup Number of Copies
553 if (doingNumCopies) {
554 aPrintSettings->SetNumCopies(int32_t(aDevMode->dmCopies));
555 }
556
557 if (aDevMode->dmFields & DM_SCALE) {
558 double scale = double(aDevMode->dmScale) / 100.0f;
559 if (scale != 1.0) {
560 aPrintSettings->SetScaling(scale);
561 aDevMode->dmScale = 100;
562 // To turn this on you must change where the mPrt->mShrinkToFit is being set in the DocumentViewer
563 //aPrintSettings->SetShrinkToFit(false);
564 }
565 }
566
567 if (doingPaperSize) {
568 aPrintSettings->SetPaperSizeType(nsIPrintSettings::kPaperSizeNativeData);
569 aPrintSettings->SetPaperData(aDevMode->dmPaperSize);
570 for (int32_t i=0;i<kNumPaperSizes;i++) {
571 if (kPaperSizes[i].mPaperSize == aDevMode->dmPaperSize) {
572 aPrintSettings->SetPaperSizeUnit(kPaperSizes[i].mIsInches
573 ?int16_t(nsIPrintSettings::kPaperSizeInches):nsIPrintSettings::kPaperSizeMillimeters);
574 break;
575 }
576 }
577
578 } else if (doingPaperLength && doingPaperWidth) {
579 bool found = false;
580 for (int32_t i=0;i<kNumPaperSizes;i++) {
581 if (kPaperSizes[i].mPaperSize == aDevMode->dmPaperSize) {
582 aPrintSettings->SetPaperSizeType(nsIPrintSettings::kPaperSizeDefined);
583 aPrintSettings->SetPaperWidth(kPaperSizes[i].mWidth);
584 aPrintSettings->SetPaperHeight(kPaperSizes[i].mHeight);
585 aPrintSettings->SetPaperSizeUnit(kPaperSizes[i].mIsInches
586 ?int16_t(nsIPrintSettings::kPaperSizeInches):nsIPrintSettings::kPaperSizeMillimeters);
587 found = true;
588 break;
589 }
590 }
591 if (!found) {
592 return NS_ERROR_FAILURE;
593 }
594 } else {
595 return NS_ERROR_FAILURE;
596 }
597 return NS_OK;
598 }
599
600 //***********************************************************
601 // Printer Enumerator
602 //***********************************************************
603 nsPrinterEnumeratorWin::nsPrinterEnumeratorWin()
604 {
605 }
606
607 nsPrinterEnumeratorWin::~nsPrinterEnumeratorWin()
608 {
609 // Do not free printers here
610 // GlobalPrinters::GetInstance()->FreeGlobalPrinters();
611 }
612
613 NS_IMPL_ISUPPORTS(nsPrinterEnumeratorWin, nsIPrinterEnumerator)
614
615 //----------------------------------------------------------------------------------
616 // Return the Default Printer name
617 /* readonly attribute wstring defaultPrinterName; */
618 NS_IMETHODIMP
619 nsPrinterEnumeratorWin::GetDefaultPrinterName(char16_t * *aDefaultPrinterName)
620 {
621 NS_ENSURE_ARG_POINTER(aDefaultPrinterName);
622
623 *aDefaultPrinterName = GetDefaultPrinterNameFromGlobalPrinters(); // helper
624
625 return NS_OK;
626 }
627
628 /* void initPrintSettingsFromPrinter (in wstring aPrinterName, in nsIPrintSettings aPrintSettings); */
629 NS_IMETHODIMP
630 nsPrinterEnumeratorWin::InitPrintSettingsFromPrinter(const char16_t *aPrinterName, nsIPrintSettings *aPrintSettings)
631 {
632 NS_ENSURE_ARG_POINTER(aPrinterName);
633 NS_ENSURE_ARG_POINTER(aPrintSettings);
634
635 if (!*aPrinterName) {
636 return NS_OK;
637 }
638
639 nsRefPtr<nsDeviceContextSpecWin> devSpecWin = new nsDeviceContextSpecWin();
640 if (!devSpecWin) return NS_ERROR_OUT_OF_MEMORY;
641
642 if (NS_FAILED(GlobalPrinters::GetInstance()->EnumeratePrinterList())) {
643 return NS_ERROR_FAILURE;
644 }
645
646 devSpecWin->GetDataFromPrinter(aPrinterName);
647
648 LPDEVMODEW devmode;
649 devSpecWin->GetDevMode(devmode);
650 NS_ASSERTION(devmode, "DevMode can't be NULL here");
651 if (devmode) {
652 aPrintSettings->SetPrinterName(aPrinterName);
653 nsDeviceContextSpecWin::SetPrintSettingsFromDevMode(aPrintSettings, devmode);
654 }
655
656 // Free them, we won't need them for a while
657 GlobalPrinters::GetInstance()->FreeGlobalPrinters();
658 return NS_OK;
659 }
660
661
662 //----------------------------------------------------------------------------------
663 // Enumerate all the Printers from the global array and pass their
664 // names back (usually to script)
665 NS_IMETHODIMP
666 nsPrinterEnumeratorWin::GetPrinterNameList(nsIStringEnumerator **aPrinterNameList)
667 {
668 NS_ENSURE_ARG_POINTER(aPrinterNameList);
669 *aPrinterNameList = nullptr;
670
671 nsresult rv = GlobalPrinters::GetInstance()->EnumeratePrinterList();
672 if (NS_FAILED(rv)) {
673 PR_PL(("***** nsDeviceContextSpecWin::GetPrinterNameList - Couldn't enumerate printers!\n"));
674 return rv;
675 }
676
677 uint32_t numPrinters = GlobalPrinters::GetInstance()->GetNumPrinters();
678 nsTArray<nsString> *printers = new nsTArray<nsString>(numPrinters);
679 if (!printers)
680 return NS_ERROR_OUT_OF_MEMORY;
681
682 uint32_t printerInx = 0;
683 while( printerInx < numPrinters ) {
684 LPWSTR name = GlobalPrinters::GetInstance()->GetItemFromList(printerInx++);
685 printers->AppendElement(nsDependentString(name));
686 }
687
688 return NS_NewAdoptingStringEnumerator(aPrinterNameList, printers);
689 }
690
691 //----------------------------------------------------------------------------------
692 // Display the AdvancedDocumentProperties for the selected Printer
693 NS_IMETHODIMP nsPrinterEnumeratorWin::DisplayPropertiesDlg(const char16_t *aPrinterName, nsIPrintSettings* aPrintSettings)
694 {
695 // Implementation removed because it is unused
696 return NS_OK;
697 }
698
699 //----------------------------------------------------------------------------------
700 //-- Global Printers
701 //----------------------------------------------------------------------------------
702
703 //----------------------------------------------------------------------------------
704 // THe array hold the name and port for each printer
705 void
706 GlobalPrinters::ReallocatePrinters()
707 {
708 if (PrintersAreAllocated()) {
709 FreeGlobalPrinters();
710 }
711 mPrinters = new nsTArray<LPWSTR>();
712 NS_ASSERTION(mPrinters, "Printers Array is NULL!");
713 }
714
715 //----------------------------------------------------------------------------------
716 void
717 GlobalPrinters::FreeGlobalPrinters()
718 {
719 if (mPrinters != nullptr) {
720 for (uint32_t i=0;i<mPrinters->Length();i++) {
721 free(mPrinters->ElementAt(i));
722 }
723 delete mPrinters;
724 mPrinters = nullptr;
725 }
726 }
727
728 //----------------------------------------------------------------------------------
729 nsresult
730 GlobalPrinters::EnumerateNativePrinters()
731 {
732 nsresult rv = NS_ERROR_GFX_PRINTER_NO_PRINTER_AVAILABLE;
733 PR_PL(("-----------------------\n"));
734 PR_PL(("EnumerateNativePrinters\n"));
735
736 WCHAR szDefaultPrinterName[1024];
737 DWORD status = GetProfileStringW(L"devices", 0, L",",
738 szDefaultPrinterName,
739 ArrayLength(szDefaultPrinterName));
740 if (status > 0) {
741 DWORD count = 0;
742 LPWSTR sPtr = szDefaultPrinterName;
743 LPWSTR ePtr = szDefaultPrinterName + status;
744 LPWSTR prvPtr = sPtr;
745 while (sPtr < ePtr) {
746 if (*sPtr == 0) {
747 LPWSTR name = wcsdup(prvPtr);
748 mPrinters->AppendElement(name);
749 PR_PL(("Printer Name: %s\n", prvPtr));
750 prvPtr = sPtr+1;
751 count++;
752 }
753 sPtr++;
754 }
755 rv = NS_OK;
756 }
757 PR_PL(("-----------------------\n"));
758 return rv;
759 }
760
761 //------------------------------------------------------------------
762 // Uses the GetProfileString to get the default printer from the registry
763 void
764 GlobalPrinters::GetDefaultPrinterName(nsString& aDefaultPrinterName)
765 {
766 aDefaultPrinterName.Truncate();
767 WCHAR szDefaultPrinterName[1024];
768 DWORD status = GetProfileStringW(L"windows", L"device", 0,
769 szDefaultPrinterName,
770 ArrayLength(szDefaultPrinterName));
771 if (status > 0) {
772 WCHAR comma = ',';
773 LPWSTR sPtr = szDefaultPrinterName;
774 while (*sPtr != comma && *sPtr != 0)
775 sPtr++;
776 if (*sPtr == comma) {
777 *sPtr = 0;
778 }
779 aDefaultPrinterName = szDefaultPrinterName;
780 } else {
781 aDefaultPrinterName = EmptyString();
782 }
783
784 PR_PL(("DEFAULT PRINTER [%s]\n", aDefaultPrinterName.get()));
785 }
786
787 //----------------------------------------------------------------------------------
788 // This goes and gets the list of available printers and puts
789 // the default printer at the beginning of the list
790 nsresult
791 GlobalPrinters::EnumeratePrinterList()
792 {
793 // reallocate and get a new list each time it is asked for
794 // this deletes the list and re-allocates them
795 ReallocatePrinters();
796
797 // any of these could only fail with an OUT_MEMORY_ERROR
798 // PRINTER_ENUM_LOCAL should get the network printers on Win95
799 nsresult rv = EnumerateNativePrinters();
800 if (NS_FAILED(rv)) return rv;
801
802 // get the name of the default printer
803 nsAutoString defPrinterName;
804 GetDefaultPrinterName(defPrinterName);
805
806 // put the default printer at the beginning of list
807 if (!defPrinterName.IsEmpty()) {
808 for (uint32_t i=0;i<mPrinters->Length();i++) {
809 LPWSTR name = mPrinters->ElementAt(i);
810 if (defPrinterName.Equals(name)) {
811 if (i > 0) {
812 LPWSTR ptr = mPrinters->ElementAt(0);
813 mPrinters->ElementAt(0) = name;
814 mPrinters->ElementAt(i) = ptr;
815 }
816 break;
817 }
818 }
819 }
820
821 // make sure we at least tried to get the printers
822 if (!PrintersAreAllocated()) {
823 PR_PL(("***** nsDeviceContextSpecWin::EnumeratePrinterList - Printers aren`t allocated\n"));
824 return NS_ERROR_FAILURE;
825 }
826
827 return NS_OK;
828 }
829

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial