?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d9: Add a few tests for GetAdapterDisplayModeEx.
[wine/hacks.git] / dlls / comdlg32 / printdlg.c
blob74a06ffa3d5e728ff99b12a05d72671aa83267c6
1 /*
2 * COMMDLG - Print Dialog
3 *
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1996 Albrecht Kleine
6 * Copyright 1999 Klaas van Gend
7 * Copyright 2000 Huw D M Davies
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23 #include <ctype.h>
24 #include <stdlib.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <assert.h>
29
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "winspool.h"
37 #include "winerror.h"
38
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
41
42 #include "commdlg.h"
43 #include "dlgs.h"
44 #include "cderr.h"
45 #include "cdlg.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
48
49 /* Yes these constants are the same, but we're just copying win98 */
50 #define UPDOWN_ID 0x270f
51 #define MAX_COPIES 9999
52
53 /* This PRINTDLGA internal structure stores
54 * pointers to several throughout useful structures.
55 */
56
57 typedef struct
58 {
59 LPDEVMODEA lpDevMode;
60 LPPRINTDLGA lpPrintDlg;
61 LPPRINTER_INFO_2A lpPrinterInfo;
62 LPDRIVER_INFO_3A lpDriverInfo;
63 UINT HelpMessageID;
64 HICON hCollateIcon; /* PrintDlg only */
65 HICON hNoCollateIcon; /* PrintDlg only */
66 HICON hPortraitIcon; /* PrintSetupDlg only */
67 HICON hLandscapeIcon; /* PrintSetupDlg only */
68 HWND hwndUpDown;
69 } PRINT_PTRA;
70
71 typedef struct
72 {
73 LPDEVMODEW lpDevMode;
74 LPPRINTDLGW lpPrintDlg;
75 LPPRINTER_INFO_2W lpPrinterInfo;
76 LPDRIVER_INFO_3W lpDriverInfo;
77 UINT HelpMessageID;
78 HICON hCollateIcon; /* PrintDlg only */
79 HICON hNoCollateIcon; /* PrintDlg only */
80 HICON hPortraitIcon; /* PrintSetupDlg only */
81 HICON hLandscapeIcon; /* PrintSetupDlg only */
82 HWND hwndUpDown;
83 } PRINT_PTRW;
84
85 /* Debugging info */
86 struct pd_flags
87 {
88 DWORD flag;
89 LPCSTR name;
90 };
91
92 static const struct pd_flags psd_flags[] = {
93 {PSD_MINMARGINS,"PSD_MINMARGINS"},
94 {PSD_MARGINS,"PSD_MARGINS"},
95 {PSD_INTHOUSANDTHSOFINCHES,"PSD_INTHOUSANDTHSOFINCHES"},
96 {PSD_INHUNDREDTHSOFMILLIMETERS,"PSD_INHUNDREDTHSOFMILLIMETERS"},
97 {PSD_DISABLEMARGINS,"PSD_DISABLEMARGINS"},
98 {PSD_DISABLEPRINTER,"PSD_DISABLEPRINTER"},
99 {PSD_NOWARNING,"PSD_NOWARNING"},
100 {PSD_DISABLEORIENTATION,"PSD_DISABLEORIENTATION"},
101 {PSD_RETURNDEFAULT,"PSD_RETURNDEFAULT"},
102 {PSD_DISABLEPAPER,"PSD_DISABLEPAPER"},
103 {PSD_SHOWHELP,"PSD_SHOWHELP"},
104 {PSD_ENABLEPAGESETUPHOOK,"PSD_ENABLEPAGESETUPHOOK"},
105 {PSD_ENABLEPAGESETUPTEMPLATE,"PSD_ENABLEPAGESETUPTEMPLATE"},
106 {PSD_ENABLEPAGESETUPTEMPLATEHANDLE,"PSD_ENABLEPAGESETUPTEMPLATEHANDLE"},
107 {PSD_ENABLEPAGEPAINTHOOK,"PSD_ENABLEPAGEPAINTHOOK"},
108 {PSD_DISABLEPAGEPAINTING,"PSD_DISABLEPAGEPAINTING"},
109 {-1, NULL}
110 };
111
112 static const struct pd_flags pd_flags[] = {
113 {PD_SELECTION, "PD_SELECTION "},
114 {PD_PAGENUMS, "PD_PAGENUMS "},
115 {PD_NOSELECTION, "PD_NOSELECTION "},
116 {PD_NOPAGENUMS, "PD_NOPAGENUMS "},
117 {PD_COLLATE, "PD_COLLATE "},
118 {PD_PRINTTOFILE, "PD_PRINTTOFILE "},
119 {PD_PRINTSETUP, "PD_PRINTSETUP "},
120 {PD_NOWARNING, "PD_NOWARNING "},
121 {PD_RETURNDC, "PD_RETURNDC "},
122 {PD_RETURNIC, "PD_RETURNIC "},
123 {PD_RETURNDEFAULT, "PD_RETURNDEFAULT "},
124 {PD_SHOWHELP, "PD_SHOWHELP "},
125 {PD_ENABLEPRINTHOOK, "PD_ENABLEPRINTHOOK "},
126 {PD_ENABLESETUPHOOK, "PD_ENABLESETUPHOOK "},
127 {PD_ENABLEPRINTTEMPLATE, "PD_ENABLEPRINTTEMPLATE "},
128 {PD_ENABLESETUPTEMPLATE, "PD_ENABLESETUPTEMPLATE "},
129 {PD_ENABLEPRINTTEMPLATEHANDLE, "PD_ENABLEPRINTTEMPLATEHANDLE "},
130 {PD_ENABLESETUPTEMPLATEHANDLE, "PD_ENABLESETUPTEMPLATEHANDLE "},
131 {PD_USEDEVMODECOPIES, "PD_USEDEVMODECOPIES[ANDCOLLATE] "},
132 {PD_DISABLEPRINTTOFILE, "PD_DISABLEPRINTTOFILE "},
133 {PD_HIDEPRINTTOFILE, "PD_HIDEPRINTTOFILE "},
134 {PD_NONETWORKBUTTON, "PD_NONETWORKBUTTON "},
135 {-1, NULL}
136 };
137 /* address of wndproc for subclassed Static control */
138 static WNDPROC lpfnStaticWndProc;
139 static WNDPROC edit_wndproc;
140 /* the text of the fake document to render for the Page Setup dialog */
141 static WCHAR wszFakeDocumentText[1024];
142 static const WCHAR pd32_collateW[] = { 'P', 'D', '3', '2', '_', 'C', 'O', 'L', 'L', 'A', 'T', 'E', 0 };
143 static const WCHAR pd32_nocollateW[] = { 'P', 'D', '3', '2', '_', 'N', 'O', 'C', 'O', 'L', 'L', 'A', 'T', 'E', 0 };
144 static const WCHAR pd32_portraitW[] = { 'P', 'D', '3', '2', '_', 'P', 'O', 'R', 'T', 'R', 'A', 'I', 'T', 0 };
145 static const WCHAR pd32_landscapeW[] = { 'P', 'D', '3', '2', '_', 'L', 'A', 'N', 'D', 'S', 'C', 'A', 'P', 'E', 0 };
146 static const WCHAR printdlg_prop[] = {'_','_','W','I','N','E','_','P','R','I','N','T','D','L','G','D','A','T','A',0};
147 static const WCHAR pagesetupdlg_prop[] = { '_', '_', 'W', 'I', 'N', 'E', '_', 'P', 'A', 'G', 'E',
148 'S', 'E', 'T', 'U', 'P', 'D', 'L', 'G', 'D', 'A', 'T', 'A', 0 };
149
150
151 static LPWSTR strdupW(LPCWSTR p)
152 {
153 LPWSTR ret;
154 DWORD len;
155
156 if(!p) return NULL;
157 len = (strlenW(p) + 1) * sizeof(WCHAR);
158 ret = HeapAlloc(GetProcessHeap(), 0, len);
159 memcpy(ret, p, len);
160 return ret;
161 }
162
163 /***********************************************************
164 * convert_to_devmodeA
165 *
166 * Creates an ansi copy of supplied devmode
167 */
168 static DEVMODEA *convert_to_devmodeA(const DEVMODEW *dmW)
169 {
170 DEVMODEA *dmA;
171 DWORD size;
172
173 if (!dmW) return NULL;
174 size = dmW->dmSize - CCHDEVICENAME -
175 ((dmW->dmSize > FIELD_OFFSET(DEVMODEW, dmFormName)) ? CCHFORMNAME : 0);
176
177 dmA = HeapAlloc(GetProcessHeap(), 0, size + dmW->dmDriverExtra);
178 if (!dmA) return NULL;
179
180 WideCharToMultiByte(CP_ACP, 0, dmW->dmDeviceName, -1,
181 (LPSTR)dmA->dmDeviceName, CCHDEVICENAME, NULL, NULL);
182
183 if (FIELD_OFFSET(DEVMODEW, dmFormName) >= dmW->dmSize)
184 {
185 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
186 dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
187 }
188 else
189 {
190 memcpy(&dmA->dmSpecVersion, &dmW->dmSpecVersion,
191 FIELD_OFFSET(DEVMODEW, dmFormName) - FIELD_OFFSET(DEVMODEW, dmSpecVersion));
192 WideCharToMultiByte(CP_ACP, 0, dmW->dmFormName, -1,
193 (LPSTR)dmA->dmFormName, CCHFORMNAME, NULL, NULL);
194
195 memcpy(&dmA->dmLogPixels, &dmW->dmLogPixels, dmW->dmSize - FIELD_OFFSET(DEVMODEW, dmLogPixels));
196 }
197
198 dmA->dmSize = size;
199 memcpy((char *)dmA + dmA->dmSize, (const char *)dmW + dmW->dmSize, dmW->dmDriverExtra);
200 return dmA;
201 }
202
203 /***********************************************************************
204 * PRINTDLG_OpenDefaultPrinter
205 *
206 * Returns a winspool printer handle to the default printer in *hprn
207 * Caller must call ClosePrinter on the handle
208 *
209 * Returns TRUE on success else FALSE
210 */
211 static BOOL PRINTDLG_OpenDefaultPrinter(HANDLE *hprn)
212 {
213 WCHAR buf[260];
214 DWORD dwBufLen = sizeof(buf) / sizeof(buf[0]);
215 BOOL res;
216 if(!GetDefaultPrinterW(buf, &dwBufLen))
217 return FALSE;
218 res = OpenPrinterW(buf, hprn, NULL);
219 if (!res)
220 WARN("Could not open printer %s\n", debugstr_w(buf));
221 return res;
222 }
223
224 /***********************************************************************
225 * PRINTDLG_SetUpPrinterListCombo
226 *
227 * Initializes printer list combox.
228 * hDlg: HWND of dialog
229 * id: Control id of combo
230 * name: Name of printer to select
231 *
232 * Initializes combo with list of available printers. Selects printer 'name'
233 * If name is NULL or does not exist select the default printer.
234 *
235 * Returns number of printers added to list.
236 */
237 static INT PRINTDLG_SetUpPrinterListComboA(HWND hDlg, UINT id, LPCSTR name)
238 {
239 DWORD needed, num;
240 INT i;
241 LPPRINTER_INFO_2A pi;
242 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &needed, &num);
243 pi = HeapAlloc(GetProcessHeap(), 0, needed);
244 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, (LPBYTE)pi, needed, &needed,
245 &num);
246
247 SendDlgItemMessageA(hDlg, id, CB_RESETCONTENT, 0, 0);
248
249 for(i = 0; i < num; i++) {
250 SendDlgItemMessageA(hDlg, id, CB_ADDSTRING, 0,
251 (LPARAM)pi[i].pPrinterName );
252 }
253 HeapFree(GetProcessHeap(), 0, pi);
254 if(!name ||
255 (i = SendDlgItemMessageA(hDlg, id, CB_FINDSTRINGEXACT, -1,
256 (LPARAM)name)) == CB_ERR) {
257
258 char buf[260];
259 DWORD dwBufLen = sizeof(buf);
260 if (name != NULL)
261 WARN("Can't find %s in printer list so trying to find default\n",
262 debugstr_a(name));
263 if(!GetDefaultPrinterA(buf, &dwBufLen))
264 return num;
265 i = SendDlgItemMessageA(hDlg, id, CB_FINDSTRINGEXACT, -1, (LPARAM)buf);
266 if(i == CB_ERR)
267 FIXME("Can't find default printer in printer list\n");
268 }
269 SendDlgItemMessageA(hDlg, id, CB_SETCURSEL, i, 0);
270 return num;
271 }
272
273 static INT PRINTDLG_SetUpPrinterListComboW(HWND hDlg, UINT id, LPCWSTR name)
274 {
275 DWORD needed, num;
276 INT i;
277 LPPRINTER_INFO_2W pi;
278 EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &needed, &num);
279 pi = HeapAlloc(GetProcessHeap(), 0, needed);
280 EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 2, (LPBYTE)pi, needed, &needed,
281 &num);
282
283 for(i = 0; i < num; i++) {
284 SendDlgItemMessageW(hDlg, id, CB_ADDSTRING, 0,
285 (LPARAM)pi[i].pPrinterName );
286 }
287 HeapFree(GetProcessHeap(), 0, pi);
288 if(!name ||
289 (i = SendDlgItemMessageW(hDlg, id, CB_FINDSTRINGEXACT, -1,
290 (LPARAM)name)) == CB_ERR) {
291 WCHAR buf[260];
292 DWORD dwBufLen = sizeof(buf)/sizeof(buf[0]);
293 if (name != NULL)
294 WARN("Can't find %s in printer list so trying to find default\n",
295 debugstr_w(name));
296 if(!GetDefaultPrinterW(buf, &dwBufLen))
297 return num;
298 i = SendDlgItemMessageW(hDlg, id, CB_FINDSTRINGEXACT, -1, (LPARAM)buf);
299 if(i == CB_ERR)
300 TRACE("Can't find default printer in printer list\n");
301 }
302 SendDlgItemMessageW(hDlg, id, CB_SETCURSEL, i, 0);
303 return num;
304 }
305
306 /***********************************************************************
307 * PRINTDLG_CreateDevNames [internal]
308 *
309 *
310 * creates a DevNames structure.
311 *
312 * (NB. when we handle unicode the offsets will be in wchars).
313 */
314 static BOOL PRINTDLG_CreateDevNames(HGLOBAL *hmem, const char* DeviceDriverName,
315 const char* DeviceName, const char* OutputPort)
316 {
317 long size;
318 char* pDevNamesSpace;
319 char* pTempPtr;
320 LPDEVNAMES lpDevNames;
321 char buf[260];
322 DWORD dwBufLen = sizeof(buf);
323
324 size = strlen(DeviceDriverName) + 1
325 + strlen(DeviceName) + 1
326 + strlen(OutputPort) + 1
327 + sizeof(DEVNAMES);
328
329 if(*hmem)
330 *hmem = GlobalReAlloc(*hmem, size, GMEM_MOVEABLE);
331 else
332 *hmem = GlobalAlloc(GMEM_MOVEABLE, size);
333 if (*hmem == 0)
334 return FALSE;
335
336 pDevNamesSpace = GlobalLock(*hmem);
337 lpDevNames = (LPDEVNAMES) pDevNamesSpace;
338
339 pTempPtr = pDevNamesSpace + sizeof(DEVNAMES);
340 strcpy(pTempPtr, DeviceDriverName);
341 lpDevNames->wDriverOffset = pTempPtr - pDevNamesSpace;
342
343 pTempPtr += strlen(DeviceDriverName) + 1;
344 strcpy(pTempPtr, DeviceName);
345 lpDevNames->wDeviceOffset = pTempPtr - pDevNamesSpace;
346
347 pTempPtr += strlen(DeviceName) + 1;
348 strcpy(pTempPtr, OutputPort);
349 lpDevNames->wOutputOffset = pTempPtr - pDevNamesSpace;
350
351 GetDefaultPrinterA(buf, &dwBufLen);
352 lpDevNames->wDefault = (strcmp(buf, DeviceName) == 0) ? 1 : 0;
353 GlobalUnlock(*hmem);
354 return TRUE;
355 }
356
357 static BOOL PRINTDLG_CreateDevNamesW(HGLOBAL *hmem, LPCWSTR DeviceDriverName,
358 LPCWSTR DeviceName, LPCWSTR OutputPort)
359 {
360 long size;
361 LPWSTR pDevNamesSpace;
362 LPWSTR pTempPtr;
363 LPDEVNAMES lpDevNames;
364 WCHAR bufW[260];
365 DWORD dwBufLen = sizeof(bufW) / sizeof(WCHAR);
366
367 size = sizeof(WCHAR)*lstrlenW(DeviceDriverName) + 2
368 + sizeof(WCHAR)*lstrlenW(DeviceName) + 2
369 + sizeof(WCHAR)*lstrlenW(OutputPort) + 2
370 + sizeof(DEVNAMES);
371
372 if(*hmem)
373 *hmem = GlobalReAlloc(*hmem, size, GMEM_MOVEABLE);
374 else
375 *hmem = GlobalAlloc(GMEM_MOVEABLE, size);
376 if (*hmem == 0)
377 return FALSE;
378
379 pDevNamesSpace = GlobalLock(*hmem);
380 lpDevNames = (LPDEVNAMES) pDevNamesSpace;
381
382 pTempPtr = (LPWSTR)((LPDEVNAMES)pDevNamesSpace + 1);
383 lstrcpyW(pTempPtr, DeviceDriverName);
384 lpDevNames->wDriverOffset = pTempPtr - pDevNamesSpace;
385
386 pTempPtr += lstrlenW(DeviceDriverName) + 1;
387 lstrcpyW(pTempPtr, DeviceName);
388 lpDevNames->wDeviceOffset = pTempPtr - pDevNamesSpace;
389
390 pTempPtr += lstrlenW(DeviceName) + 1;
391 lstrcpyW(pTempPtr, OutputPort);
392 lpDevNames->wOutputOffset = pTempPtr - pDevNamesSpace;
393
394 GetDefaultPrinterW(bufW, &dwBufLen);
395 lpDevNames->wDefault = (lstrcmpW(bufW, DeviceName) == 0) ? 1 : 0;
396 GlobalUnlock(*hmem);
397 return TRUE;
398 }
399
400 /***********************************************************************
401 * PRINTDLG_UpdatePrintDlg [internal]
402 *
403 *
404 * updates the PrintDlg structure for return values.
405 *
406 * RETURNS
407 * FALSE if user is not allowed to close (i.e. wrong nTo or nFrom values)
408 * TRUE if successful.
409 */
410 static BOOL PRINTDLG_UpdatePrintDlgA(HWND hDlg,
411 PRINT_PTRA* PrintStructures)
412 {
413 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
414 PDEVMODEA lpdm = PrintStructures->lpDevMode;
415 LPPRINTER_INFO_2A pi = PrintStructures->lpPrinterInfo;
416
417
418 if(!lpdm) {
419 FIXME("No lpdm ptr?\n");
420 return FALSE;
421 }
422
423
424 if(!(lppd->Flags & PD_PRINTSETUP)) {
425 /* check whether nFromPage and nToPage are within range defined by
426 * nMinPage and nMaxPage
427 */
428 if (IsDlgButtonChecked(hDlg, rad3) == BST_CHECKED) { /* Pages */
429 WORD nToPage;
430 WORD nFromPage;
431 BOOL translated;
432 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
433 nToPage = GetDlgItemInt(hDlg, edt2, &translated, FALSE);
434
435 /* if no ToPage value is entered, use the FromPage value */
436 if(!translated) nToPage = nFromPage;
437
438 if (nFromPage < lppd->nMinPage || nFromPage > lppd->nMaxPage ||
439 nToPage < lppd->nMinPage || nToPage > lppd->nMaxPage) {
440 WCHAR resourcestr[256];
441 WCHAR resultstr[256];
442 LoadStringW(COMDLG32_hInstance, PD32_INVALID_PAGE_RANGE, resourcestr, 255);
443 wsprintfW(resultstr,resourcestr, lppd->nMinPage, lppd->nMaxPage);
444 LoadStringW(COMDLG32_hInstance, PD32_PRINT_TITLE, resourcestr, 255);
445 MessageBoxW(hDlg, resultstr, resourcestr, MB_OK | MB_ICONWARNING);
446 return FALSE;
447 }
448 lppd->nFromPage = nFromPage;
449 lppd->nToPage = nToPage;
450 lppd->Flags |= PD_PAGENUMS;
451 }
452 else
453 lppd->Flags &= ~PD_PAGENUMS;
454
455 if (IsDlgButtonChecked(hDlg, rad2) == BST_CHECKED) /* Selection */
456 lppd->Flags |= PD_SELECTION;
457 else
458 lppd->Flags &= ~PD_SELECTION;
459
460 if (IsDlgButtonChecked(hDlg, chx1) == BST_CHECKED) {/* Print to file */
461 static char file[] = "FILE:";
462 lppd->Flags |= PD_PRINTTOFILE;
463 pi->pPortName = file;
464 }
465
466 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED) { /* Collate */
467 FIXME("Collate lppd not yet implemented as output\n");
468 }
469
470 /* set PD_Collate and nCopies */
471 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
472 /* The application doesn't support multiple copies or collate...
473 */
474 lppd->Flags &= ~PD_COLLATE;
475 lppd->nCopies = 1;
476 /* if the printer driver supports it... store info there
477 * otherwise no collate & multiple copies !
478 */
479 if (lpdm->dmFields & DM_COLLATE)
480 lpdm->dmCollate =
481 (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED);
482 if (lpdm->dmFields & DM_COPIES)
483 lpdm->u1.s1.dmCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
484 } else {
485 /* Application is responsible for multiple copies */
486 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
487 lppd->Flags |= PD_COLLATE;
488 else
489 lppd->Flags &= ~PD_COLLATE;
490 lppd->nCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
491 /* multiple copies already included in the document. Driver must print only one copy */
492 lpdm->u1.s1.dmCopies = 1;
493 }
494
495 /* Print quality, PrintDlg16 */
496 if(GetDlgItem(hDlg, cmb1))
497 {
498 HWND hQuality = GetDlgItem(hDlg, cmb1);
499 int Sel = SendMessageA(hQuality, CB_GETCURSEL, 0, 0);
500
501 if(Sel != CB_ERR)
502 {
503 LONG dpi = SendMessageA(hQuality, CB_GETITEMDATA, Sel, 0);
504 lpdm->dmFields |= DM_PRINTQUALITY | DM_YRESOLUTION;
505 lpdm->u1.s1.dmPrintQuality = LOWORD(dpi);
506 lpdm->dmYResolution = HIWORD(dpi);
507 }
508 }
509 }
510 return TRUE;
511 }
512
513 static BOOL PRINTDLG_UpdatePrintDlgW(HWND hDlg,
514 PRINT_PTRW* PrintStructures)
515 {
516 LPPRINTDLGW lppd = PrintStructures->lpPrintDlg;
517 PDEVMODEW lpdm = PrintStructures->lpDevMode;
518 LPPRINTER_INFO_2W pi = PrintStructures->lpPrinterInfo;
519
520
521 if(!lpdm) {
522 FIXME("No lpdm ptr?\n");
523 return FALSE;
524 }
525
526
527 if(!(lppd->Flags & PD_PRINTSETUP)) {
528 /* check whether nFromPage and nToPage are within range defined by
529 * nMinPage and nMaxPage
530 */
531 if (IsDlgButtonChecked(hDlg, rad3) == BST_CHECKED) { /* Pages */
532 WORD nToPage;
533 WORD nFromPage;
534 BOOL translated;
535 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
536 nToPage = GetDlgItemInt(hDlg, edt2, &translated, FALSE);
537
538 /* if no ToPage value is entered, use the FromPage value */
539 if(!translated) nToPage = nFromPage;
540
541 if (nFromPage < lppd->nMinPage || nFromPage > lppd->nMaxPage ||
542 nToPage < lppd->nMinPage || nToPage > lppd->nMaxPage) {
543 WCHAR resourcestr[256];
544 WCHAR resultstr[256];
545 LoadStringW(COMDLG32_hInstance, PD32_INVALID_PAGE_RANGE,
546 resourcestr, 255);
547 wsprintfW(resultstr,resourcestr, lppd->nMinPage, lppd->nMaxPage);
548 LoadStringW(COMDLG32_hInstance, PD32_PRINT_TITLE,
549 resourcestr, 255);
550 MessageBoxW(hDlg, resultstr, resourcestr,
551 MB_OK | MB_ICONWARNING);
552 return FALSE;
553 }
554 lppd->nFromPage = nFromPage;
555 lppd->nToPage = nToPage;
556 lppd->Flags |= PD_PAGENUMS;
557 }
558 else
559 lppd->Flags &= ~PD_PAGENUMS;
560
561 if (IsDlgButtonChecked(hDlg, rad2) == BST_CHECKED) /* Selection */
562 lppd->Flags |= PD_SELECTION;
563 else
564 lppd->Flags &= ~PD_SELECTION;
565
566 if (IsDlgButtonChecked(hDlg, chx1) == BST_CHECKED) {/* Print to file */
567 static WCHAR file[] = {'F','I','L','E',':',0};
568 lppd->Flags |= PD_PRINTTOFILE;
569 pi->pPortName = file;
570 }
571
572 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED) { /* Collate */
573 FIXME("Collate lppd not yet implemented as output\n");
574 }
575
576 /* set PD_Collate and nCopies */
577 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
578 /* The application doesn't support multiple copies or collate...
579 */
580 lppd->Flags &= ~PD_COLLATE;
581 lppd->nCopies = 1;
582 /* if the printer driver supports it... store info there
583 * otherwise no collate & multiple copies !
584 */
585 if (lpdm->dmFields & DM_COLLATE)
586 lpdm->dmCollate =
587 (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED);
588 if (lpdm->dmFields & DM_COPIES)
589 lpdm->u1.s1.dmCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
590 } else {
591 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
592 lppd->Flags |= PD_COLLATE;
593 else
594 lppd->Flags &= ~PD_COLLATE;
595 lppd->nCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
596 }
597 }
598 return TRUE;
599 }
600
601 /************************************************************************
602 * PRINTDLG_SetUpPaperComboBox
603 *
604 * Initialize either the papersize or inputslot combos of the Printer Setup
605 * dialog. We store the associated word (eg DMPAPER_A4) as the item data.
606 * We also try to re-select the old selection.
607 */
608 static BOOL PRINTDLG_SetUpPaperComboBoxA(HWND hDlg,
609 int nIDComboBox,
610 char* PrinterName,
611 char* PortName,
612 LPDEVMODEA dm)
613 {
614 int i;
615 int NrOfEntries;
616 char* Names;
617 WORD* Words;
618 DWORD Sel;
619 WORD oldWord = 0;
620 int NamesSize;
621 int fwCapability_Names;
622 int fwCapability_Words;
623
624 TRACE(" Printer: %s, Port: %s, ComboID: %d\n",PrinterName,PortName,nIDComboBox);
625
626 /* query the dialog box for the current selected value */
627 Sel = SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETCURSEL, 0, 0);
628 if(Sel != CB_ERR) {
629 /* we enter here only if a different printer is selected after
630 * the Print Setup dialog is opened. The current settings are
631 * stored into the newly selected printer.
632 */
633 oldWord = SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETITEMDATA,
634 Sel, 0);
635 if (dm) {
636 if (nIDComboBox == cmb2)
637 dm->u1.s1.dmPaperSize = oldWord;
638 else
639 dm->u1.s1.dmDefaultSource = oldWord;
640 }
641 }
642 else {
643 /* we enter here only when the Print setup dialog is initially
644 * opened. In this case the settings are restored from when
645 * the dialog was last closed.
646 */
647 if (dm) {
648 if (nIDComboBox == cmb2)
649 oldWord = dm->u1.s1.dmPaperSize;
650 else
651 oldWord = dm->u1.s1.dmDefaultSource;
652 }
653 }
654
655 if (nIDComboBox == cmb2) {
656 NamesSize = 64;
657 fwCapability_Names = DC_PAPERNAMES;
658 fwCapability_Words = DC_PAPERS;
659 } else {
660 nIDComboBox = cmb3;
661 NamesSize = 24;
662 fwCapability_Names = DC_BINNAMES;
663 fwCapability_Words = DC_BINS;
664 }
665
666 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
667 fwCapability_Names, NULL, dm);
668 if (NrOfEntries == 0)
669 WARN("no Name Entries found!\n");
670 else if (NrOfEntries < 0)
671 return FALSE;
672
673 if(DeviceCapabilitiesA(PrinterName, PortName, fwCapability_Words, NULL, dm)
674 != NrOfEntries) {
675 ERR("Number of caps is different\n");
676 NrOfEntries = 0;
677 }
678
679 Names = HeapAlloc(GetProcessHeap(),0, NrOfEntries*sizeof(char)*NamesSize);
680 Words = HeapAlloc(GetProcessHeap(),0, NrOfEntries*sizeof(WORD));
681 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
682 fwCapability_Names, Names, dm);
683 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
684 fwCapability_Words, (LPSTR)Words, dm);
685
686 /* reset any current content in the combobox */
687 SendDlgItemMessageA(hDlg, nIDComboBox, CB_RESETCONTENT, 0, 0);
688
689 /* store new content */
690 for (i = 0; i < NrOfEntries; i++) {
691 DWORD pos = SendDlgItemMessageA(hDlg, nIDComboBox, CB_ADDSTRING, 0,
692 (LPARAM)(&Names[i*NamesSize]) );
693 SendDlgItemMessageA(hDlg, nIDComboBox, CB_SETITEMDATA, pos,
694 Words[i]);
695 }
696
697 /* Look for old selection - can't do this is previous loop since
698 item order will change as more items are added */
699 Sel = 0;
700 for (i = 0; i < NrOfEntries; i++) {
701 if(SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETITEMDATA, i, 0) ==
702 oldWord) {
703 Sel = i;
704 break;
705 }
706 }
707 SendDlgItemMessageA(hDlg, nIDComboBox, CB_SETCURSEL, Sel, 0);
708
709 HeapFree(GetProcessHeap(),0,Words);
710 HeapFree(GetProcessHeap(),0,Names);
711 return TRUE;
712 }
713
714 static BOOL PRINTDLG_SetUpPaperComboBoxW(HWND hDlg,
715 int nIDComboBox,
716 const WCHAR* PrinterName,
717 const WCHAR* PortName,
718 LPDEVMODEW dm)
719 {
720 int i;
721 int NrOfEntries;
722 WCHAR* Names;
723 WORD* Words;
724 DWORD Sel;
725 WORD oldWord = 0;
726 int NamesSize;
727 int fwCapability_Names;
728 int fwCapability_Words;
729
730 TRACE(" Printer: %s, Port: %s, ComboID: %d\n",debugstr_w(PrinterName),debugstr_w(PortName),nIDComboBox);
731
732 /* query the dialog box for the current selected value */
733 Sel = SendDlgItemMessageW(hDlg, nIDComboBox, CB_GETCURSEL, 0, 0);
734 if(Sel != CB_ERR) {
735 /* we enter here only if a different printer is selected after
736 * the Print Setup dialog is opened. The current settings are
737 * stored into the newly selected printer.
738 */
739 oldWord = SendDlgItemMessageW(hDlg, nIDComboBox, CB_GETITEMDATA,
740 Sel, 0);
741 if (dm) {
742 if (nIDComboBox == cmb2)
743 dm->u1.s1.dmPaperSize = oldWord;
744 else
745 dm->u1.s1.dmDefaultSource = oldWord;
746 }
747 }
748 else {
749 /* we enter here only when the Print setup dialog is initially
750 * opened. In this case the settings are restored from when
751 * the dialog was last closed.
752 */
753 if (dm) {
754 if (nIDComboBox == cmb2)
755 oldWord = dm->u1.s1.dmPaperSize;
756 else
757 oldWord = dm->u1.s1.dmDefaultSource;
758 }
759 }
760
761 if (nIDComboBox == cmb2) {
762 NamesSize = 64;
763 fwCapability_Names = DC_PAPERNAMES;
764 fwCapability_Words = DC_PAPERS;
765 } else {
766 nIDComboBox = cmb3;
767 NamesSize = 24;
768 fwCapability_Names = DC_BINNAMES;
769 fwCapability_Words = DC_BINS;
770 }
771
772 NrOfEntries = DeviceCapabilitiesW(PrinterName, PortName,
773 fwCapability_Names, NULL, dm);
774 if (NrOfEntries == 0)
775 WARN("no Name Entries found!\n");
776 else if (NrOfEntries < 0)
777 return FALSE;
778
779 if(DeviceCapabilitiesW(PrinterName, PortName, fwCapability_Words, NULL, dm)
780 != NrOfEntries) {
781 ERR("Number of caps is different\n");
782 NrOfEntries = 0;
783 }
784
785 Names = HeapAlloc(GetProcessHeap(),0, NrOfEntries*sizeof(WCHAR)*NamesSize);
786 Words = HeapAlloc(GetProcessHeap(),0, NrOfEntries*sizeof(WORD));
787 NrOfEntries = DeviceCapabilitiesW(PrinterName, PortName,
788 fwCapability_Names, Names, dm);
789 NrOfEntries = DeviceCapabilitiesW(PrinterName, PortName,
790 fwCapability_Words, Words, dm);
791
792 /* reset any current content in the combobox */
793 SendDlgItemMessageW(hDlg, nIDComboBox, CB_RESETCONTENT, 0, 0);
794
795 /* store new content */
796 for (i = 0; i < NrOfEntries; i++) {
797 DWORD pos = SendDlgItemMessageW(hDlg, nIDComboBox, CB_ADDSTRING, 0,
798 (LPARAM)(&Names[i*NamesSize]) );
799 SendDlgItemMessageW(hDlg, nIDComboBox, CB_SETITEMDATA, pos,
800 Words[i]);
801 }
802
803 /* Look for old selection - can't do this is previous loop since
804 item order will change as more items are added */
805 Sel = 0;
806 for (i = 0; i < NrOfEntries; i++) {
807 if(SendDlgItemMessageW(hDlg, nIDComboBox, CB_GETITEMDATA, i, 0) ==
808 oldWord) {
809 Sel = i;
810 break;
811 }
812 }
813 SendDlgItemMessageW(hDlg, nIDComboBox, CB_SETCURSEL, Sel, 0);
814
815 HeapFree(GetProcessHeap(),0,Words);
816 HeapFree(GetProcessHeap(),0,Names);
817 return TRUE;
818 }
819
820
821 /***********************************************************************
822 * PRINTDLG_UpdatePrinterInfoTexts [internal]
823 */
824 static void PRINTDLG_UpdatePrinterInfoTextsA(HWND hDlg, const PRINTER_INFO_2A *pi)
825 {
826 char StatusMsg[256];
827 char ResourceString[256];
828 int i;
829
830 /* Status Message */
831 StatusMsg[0]='\0';
832
833 /* add all status messages */
834 for (i = 0; i < 25; i++) {
835 if (pi->Status & (1<<i)) {
836 LoadStringA(COMDLG32_hInstance, PD32_PRINTER_STATUS_PAUSED+i,
837 ResourceString, 255);
838 strcat(StatusMsg,ResourceString);
839 }
840 }
841 /* append "ready" */
842 /* FIXME: status==ready must only be appended if really so.
843 but how to detect? */
844 LoadStringA(COMDLG32_hInstance, PD32_PRINTER_STATUS_READY,
845 ResourceString, 255);
846 strcat(StatusMsg,ResourceString);
847 SetDlgItemTextA(hDlg, stc12, StatusMsg);
848
849 /* set all other printer info texts */
850 SetDlgItemTextA(hDlg, stc11, pi->pDriverName);
851
852 if (pi->pLocation != NULL && pi->pLocation[0] != '\0')
853 SetDlgItemTextA(hDlg, stc14, pi->pLocation);
854 else
855 SetDlgItemTextA(hDlg, stc14, pi->pPortName);
856 SetDlgItemTextA(hDlg, stc13, pi->pComment ? pi->pComment : "");
857 return;
858 }
859
860 static void PRINTDLG_UpdatePrinterInfoTextsW(HWND hDlg, const PRINTER_INFO_2W *pi)
861 {
862 WCHAR StatusMsg[256];
863 WCHAR ResourceString[256];
864 static const WCHAR emptyW[] = {0};
865 int i;
866
867 /* Status Message */
868 StatusMsg[0]='\0';
869
870 /* add all status messages */
871 for (i = 0; i < 25; i++) {
872 if (pi->Status & (1<<i)) {
873 LoadStringW(COMDLG32_hInstance, PD32_PRINTER_STATUS_PAUSED+i,
874 ResourceString, 255);
875 lstrcatW(StatusMsg,ResourceString);
876 }
877 }
878 /* append "ready" */
879 /* FIXME: status==ready must only be appended if really so.
880 but how to detect? */
881 LoadStringW(COMDLG32_hInstance, PD32_PRINTER_STATUS_READY,
882 ResourceString, 255);
883 lstrcatW(StatusMsg,ResourceString);
884 SetDlgItemTextW(hDlg, stc12, StatusMsg);
885
886 /* set all other printer info texts */
887 SetDlgItemTextW(hDlg, stc11, pi->pDriverName);
888 if (pi->pLocation != NULL && pi->pLocation[0] != '\0')
889 SetDlgItemTextW(hDlg, stc14, pi->pLocation);
890 else
891 SetDlgItemTextW(hDlg, stc14, pi->pPortName);
892 SetDlgItemTextW(hDlg, stc13, pi->pComment ? pi->pComment : emptyW);
893 }
894
895
896 /*******************************************************************
897 *
898 * PRINTDLG_ChangePrinter
899 *
900 */
901 static BOOL PRINTDLG_ChangePrinterA(HWND hDlg, char *name, PRINT_PTRA *PrintStructures)
902 {
903 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
904 LPDEVMODEA lpdm = NULL;
905 LONG dmSize;
906 DWORD needed;
907 HANDLE hprn;
908
909 HeapFree(GetProcessHeap(),0, PrintStructures->lpPrinterInfo);
910 HeapFree(GetProcessHeap(),0, PrintStructures->lpDriverInfo);
911 if(!OpenPrinterA(name, &hprn, NULL)) {
912 ERR("Can't open printer %s\n", name);
913 return FALSE;
914 }
915 GetPrinterA(hprn, 2, NULL, 0, &needed);
916 PrintStructures->lpPrinterInfo = HeapAlloc(GetProcessHeap(),0,needed);
917 GetPrinterA(hprn, 2, (LPBYTE)PrintStructures->lpPrinterInfo, needed,
918 &needed);
919 GetPrinterDriverA(hprn, NULL, 3, NULL, 0, &needed);
920 PrintStructures->lpDriverInfo = HeapAlloc(GetProcessHeap(),0,needed);
921 if (!GetPrinterDriverA(hprn, NULL, 3, (LPBYTE)PrintStructures->lpDriverInfo,
922 needed, &needed)) {
923 ERR("GetPrinterDriverA failed for %s, fix your config!\n",PrintStructures->lpPrinterInfo->pPrinterName);
924 return FALSE;
925 }
926 ClosePrinter(hprn);
927
928 PRINTDLG_UpdatePrinterInfoTextsA(hDlg, PrintStructures->lpPrinterInfo);
929
930 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
931 PrintStructures->lpDevMode = NULL;
932
933 dmSize = DocumentPropertiesA(0, 0, name, NULL, NULL, 0);
934 if(dmSize == -1) {
935 ERR("DocumentProperties fails on %s\n", debugstr_a(name));
936 return FALSE;
937 }
938 PrintStructures->lpDevMode = HeapAlloc(GetProcessHeap(), 0, dmSize);
939 dmSize = DocumentPropertiesA(0, 0, name, PrintStructures->lpDevMode, NULL,
940 DM_OUT_BUFFER);
941 if(lppd->hDevMode && (lpdm = GlobalLock(lppd->hDevMode)) &&
942 !lstrcmpA( (LPSTR) lpdm->dmDeviceName,
943 (LPSTR) PrintStructures->lpDevMode->dmDeviceName)) {
944 /* Supplied devicemode matches current printer so try to use it */
945 DocumentPropertiesA(0, 0, name, PrintStructures->lpDevMode, lpdm,
946 DM_OUT_BUFFER | DM_IN_BUFFER);
947 }
948 if(lpdm)
949 GlobalUnlock(lppd->hDevMode);
950
951 lpdm = PrintStructures->lpDevMode; /* use this as a shortcut */
952
953 if(!(lppd->Flags & PD_PRINTSETUP)) {
954 /* Print range (All/Range/Selection) */
955 if(lppd->nFromPage != 0xffff)
956 SetDlgItemInt(hDlg, edt1, lppd->nFromPage, FALSE);
957 if(lppd->nToPage != 0xffff)
958 SetDlgItemInt(hDlg, edt2, lppd->nToPage, FALSE);
959
960 CheckRadioButton(hDlg, rad1, rad3, rad1); /* default */
961 if (lppd->Flags & PD_NOSELECTION)
962 EnableWindow(GetDlgItem(hDlg, rad2), FALSE);
963 else
964 if (lppd->Flags & PD_SELECTION)
965 CheckRadioButton(hDlg, rad1, rad3, rad2);
966 if (lppd->Flags & PD_NOPAGENUMS) {
967 EnableWindow(GetDlgItem(hDlg, rad3), FALSE);
968 EnableWindow(GetDlgItem(hDlg, stc2),FALSE);
969 EnableWindow(GetDlgItem(hDlg, edt1), FALSE);
970 EnableWindow(GetDlgItem(hDlg, stc3),FALSE);
971 EnableWindow(GetDlgItem(hDlg, edt2), FALSE);
972 } else {
973 if (lppd->Flags & PD_PAGENUMS)
974 CheckRadioButton(hDlg, rad1, rad3, rad3);
975 }
976
977 /* Collate pages
978 *
979 * FIXME: The ico3 is not displayed for some reason. I don't know why.
980 */
981 if (lppd->Flags & PD_COLLATE) {
982 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
983 (LPARAM)PrintStructures->hCollateIcon);
984 CheckDlgButton(hDlg, chx2, 1);
985 } else {
986 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
987 (LPARAM)PrintStructures->hNoCollateIcon);
988 CheckDlgButton(hDlg, chx2, 0);
989 }
990
991 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
992 /* if printer doesn't support it: no Collate */
993 if (!(lpdm->dmFields & DM_COLLATE)) {
994 EnableWindow(GetDlgItem(hDlg, chx2), FALSE);
995 EnableWindow(GetDlgItem(hDlg, ico3), FALSE);
996 }
997 }
998
999 /* nCopies */
1000 {
1001 INT copies;
1002 if (lppd->hDevMode == 0)
1003 copies = lppd->nCopies;
1004 else
1005 copies = lpdm->u1.s1.dmCopies;
1006 if(copies == 0) copies = 1;
1007 else if(copies < 0) copies = MAX_COPIES;
1008 SetDlgItemInt(hDlg, edt3, copies, FALSE);
1009 }
1010
1011 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
1012 /* if printer doesn't support it: no nCopies */
1013 if (!(lpdm->dmFields & DM_COPIES)) {
1014 EnableWindow(GetDlgItem(hDlg, edt3), FALSE);
1015 EnableWindow(GetDlgItem(hDlg, stc5), FALSE);
1016 }
1017 }
1018
1019 /* print to file */
1020 CheckDlgButton(hDlg, chx1, (lppd->Flags & PD_PRINTTOFILE) ? 1 : 0);
1021 if (lppd->Flags & PD_DISABLEPRINTTOFILE)
1022 EnableWindow(GetDlgItem(hDlg, chx1), FALSE);
1023 if (lppd->Flags & PD_HIDEPRINTTOFILE)
1024 ShowWindow(GetDlgItem(hDlg, chx1), SW_HIDE);
1025
1026 /* Fill print quality combo, PrintDlg16 */
1027 if(GetDlgItem(hDlg, cmb1))
1028 {
1029 DWORD numResolutions = DeviceCapabilitiesA(PrintStructures->lpPrinterInfo->pPrinterName,
1030 PrintStructures->lpPrinterInfo->pPortName,
1031 DC_ENUMRESOLUTIONS, NULL, lpdm);
1032
1033 if(numResolutions != -1)
1034 {
1035 HWND hQuality = GetDlgItem(hDlg, cmb1);
1036 LONG* Resolutions;
1037 char buf[255];
1038 DWORD i;
1039 int dpiX, dpiY;
1040 HDC hPrinterDC = CreateDCA(PrintStructures->lpPrinterInfo->pDriverName,
1041 PrintStructures->lpPrinterInfo->pPrinterName,
1042 0, lpdm);
1043
1044 Resolutions = HeapAlloc(GetProcessHeap(), 0, numResolutions*sizeof(LONG)*2);
1045 DeviceCapabilitiesA(PrintStructures->lpPrinterInfo->pPrinterName,
1046 PrintStructures->lpPrinterInfo->pPortName,
1047 DC_ENUMRESOLUTIONS, (LPSTR)Resolutions, lpdm);
1048
1049 dpiX = GetDeviceCaps(hPrinterDC, LOGPIXELSX);
1050 dpiY = GetDeviceCaps(hPrinterDC, LOGPIXELSY);
1051 DeleteDC(hPrinterDC);
1052
1053 SendMessageA(hQuality, CB_RESETCONTENT, 0, 0);
1054 for(i = 0; i < (numResolutions * 2); i += 2)
1055 {
1056 BOOL IsDefault = FALSE;
1057 LRESULT Index;
1058
1059 if(Resolutions[i] == Resolutions[i+1])
1060 {
1061 if(dpiX == Resolutions[i])
1062 IsDefault = TRUE;
1063 sprintf(buf, "%d dpi", Resolutions[i]);
1064 } else
1065 {
1066 if(dpiX == Resolutions[i] && dpiY == Resolutions[i+1])
1067 IsDefault = TRUE;
1068 sprintf(buf, "%d dpi x %d dpi", Resolutions[i], Resolutions[i+1]);
1069 }
1070
1071 Index = SendMessageA(hQuality, CB_ADDSTRING, 0, (LPARAM)buf);
1072
1073 if(IsDefault)
1074 SendMessageA(hQuality, CB_SETCURSEL, Index, 0);
1075
1076 SendMessageA(hQuality, CB_SETITEMDATA, Index, MAKELONG(dpiX,dpiY));
1077 }
1078 HeapFree(GetProcessHeap(), 0, Resolutions);
1079 }
1080 }
1081 } else { /* PD_PRINTSETUP */
1082 BOOL bPortrait = (lpdm->u1.s1.dmOrientation == DMORIENT_PORTRAIT);
1083
1084 PRINTDLG_SetUpPaperComboBoxA(hDlg, cmb2,
1085 PrintStructures->lpPrinterInfo->pPrinterName,
1086 PrintStructures->lpPrinterInfo->pPortName,
1087 lpdm);
1088 PRINTDLG_SetUpPaperComboBoxA(hDlg, cmb3,
1089 PrintStructures->lpPrinterInfo->pPrinterName,
1090 PrintStructures->lpPrinterInfo->pPortName,
1091 lpdm);
1092 CheckRadioButton(hDlg, rad1, rad2, bPortrait ? rad1: rad2);
1093 SendDlgItemMessageA(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1094 (LPARAM)(bPortrait ? PrintStructures->hPortraitIcon :
1095 PrintStructures->hLandscapeIcon));
1096
1097 }
1098
1099 /* help button */
1100 if ((lppd->Flags & PD_SHOWHELP)==0) {
1101 /* hide if PD_SHOWHELP not specified */
1102 ShowWindow(GetDlgItem(hDlg, pshHelp), SW_HIDE);
1103 }
1104 return TRUE;
1105 }
1106
1107 static BOOL PRINTDLG_ChangePrinterW(HWND hDlg, WCHAR *name,
1108 PRINT_PTRW *PrintStructures)
1109 {
1110 LPPRINTDLGW lppd = PrintStructures->lpPrintDlg;
1111 LPDEVMODEW lpdm = NULL;
1112 LONG dmSize;
1113 DWORD needed;
1114 HANDLE hprn;
1115
1116 HeapFree(GetProcessHeap(),0, PrintStructures->lpPrinterInfo);
1117 HeapFree(GetProcessHeap(),0, PrintStructures->lpDriverInfo);
1118 if(!OpenPrinterW(name, &hprn, NULL)) {
1119 ERR("Can't open printer %s\n", debugstr_w(name));
1120 return FALSE;
1121 }
1122 GetPrinterW(hprn, 2, NULL, 0, &needed);
1123 PrintStructures->lpPrinterInfo = HeapAlloc(GetProcessHeap(),0,needed);
1124 GetPrinterW(hprn, 2, (LPBYTE)PrintStructures->lpPrinterInfo, needed,
1125 &needed);
1126 GetPrinterDriverW(hprn, NULL, 3, NULL, 0, &needed);
1127 PrintStructures->lpDriverInfo = HeapAlloc(GetProcessHeap(),0,needed);
1128 if (!GetPrinterDriverW(hprn, NULL, 3, (LPBYTE)PrintStructures->lpDriverInfo,
1129 needed, &needed)) {
1130 ERR("GetPrinterDriverA failed for %s, fix your config!\n",debugstr_w(PrintStructures->lpPrinterInfo->pPrinterName));
1131 return FALSE;
1132 }
1133 ClosePrinter(hprn);
1134
1135 PRINTDLG_UpdatePrinterInfoTextsW(hDlg, PrintStructures->lpPrinterInfo);
1136
1137 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
1138 PrintStructures->lpDevMode = NULL;
1139
1140 dmSize = DocumentPropertiesW(0, 0, name, NULL, NULL, 0);
1141 if(dmSize == -1) {
1142 ERR("DocumentProperties fails on %s\n", debugstr_w(name));
1143 return FALSE;
1144 }
1145 PrintStructures->lpDevMode = HeapAlloc(GetProcessHeap(), 0, dmSize);
1146 dmSize = DocumentPropertiesW(0, 0, name, PrintStructures->lpDevMode, NULL,
1147 DM_OUT_BUFFER);
1148 if(lppd->hDevMode && (lpdm = GlobalLock(lppd->hDevMode)) &&
1149 !lstrcmpW(lpdm->dmDeviceName,
1150 PrintStructures->lpDevMode->dmDeviceName)) {
1151 /* Supplied devicemode matches current printer so try to use it */
1152 DocumentPropertiesW(0, 0, name, PrintStructures->lpDevMode, lpdm,
1153 DM_OUT_BUFFER | DM_IN_BUFFER);
1154 }
1155 if(lpdm)
1156 GlobalUnlock(lppd->hDevMode);
1157
1158 lpdm = PrintStructures->lpDevMode; /* use this as a shortcut */
1159
1160 if(!(lppd->Flags & PD_PRINTSETUP)) {
1161 /* Print range (All/Range/Selection) */
1162 if(lppd->nFromPage != 0xffff)
1163 SetDlgItemInt(hDlg, edt1, lppd->nFromPage, FALSE);
1164 if(lppd->nToPage != 0xffff)
1165 SetDlgItemInt(hDlg, edt2, lppd->nToPage, FALSE);
1166
1167 CheckRadioButton(hDlg, rad1, rad3, rad1); /* default */
1168 if (lppd->Flags & PD_NOSELECTION)
1169 EnableWindow(GetDlgItem(hDlg, rad2), FALSE);
1170 else
1171 if (lppd->Flags & PD_SELECTION)
1172 CheckRadioButton(hDlg, rad1, rad3, rad2);
1173 if (lppd->Flags & PD_NOPAGENUMS) {
1174 EnableWindow(GetDlgItem(hDlg, rad3), FALSE);
1175 EnableWindow(GetDlgItem(hDlg, stc2),FALSE);
1176 EnableWindow(GetDlgItem(hDlg, edt1), FALSE);
1177 EnableWindow(GetDlgItem(hDlg, stc3),FALSE);
1178 EnableWindow(GetDlgItem(hDlg, edt2), FALSE);
1179 } else {
1180 if (lppd->Flags & PD_PAGENUMS)
1181 CheckRadioButton(hDlg, rad1, rad3, rad3);
1182 }
1183
1184 /* Collate pages
1185 *
1186 * FIXME: The ico3 is not displayed for some reason. I don't know why.
1187 */
1188 if (lppd->Flags & PD_COLLATE) {
1189 SendDlgItemMessageW(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1190 (LPARAM)PrintStructures->hCollateIcon);
1191 CheckDlgButton(hDlg, chx2, 1);
1192 } else {
1193 SendDlgItemMessageW(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1194 (LPARAM)PrintStructures->hNoCollateIcon);
1195 CheckDlgButton(hDlg, chx2, 0);
1196 }
1197
1198 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
1199 /* if printer doesn't support it: no Collate */
1200 if (!(lpdm->dmFields & DM_COLLATE)) {
1201 EnableWindow(GetDlgItem(hDlg, chx2), FALSE);
1202 EnableWindow(GetDlgItem(hDlg, ico3), FALSE);
1203 }
1204 }
1205
1206 /* nCopies */
1207 {
1208 INT copies;
1209 if (lppd->hDevMode == 0)
1210 copies = lppd->nCopies;
1211 else
1212 copies = lpdm->u1.s1.dmCopies;
1213 if(copies == 0) copies = 1;
1214 else if(copies < 0) copies = MAX_COPIES;
1215 SetDlgItemInt(hDlg, edt3, copies, FALSE);
1216 }
1217
1218 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
1219 /* if printer doesn't support it: no nCopies */
1220 if (!(lpdm->dmFields & DM_COPIES)) {
1221 EnableWindow(GetDlgItem(hDlg, edt3), FALSE);
1222 EnableWindow(GetDlgItem(hDlg, stc5), FALSE);
1223 }
1224 }
1225
1226 /* print to file */
1227 CheckDlgButton(hDlg, chx1, (lppd->Flags & PD_PRINTTOFILE) ? 1 : 0);
1228 if (lppd->Flags & PD_DISABLEPRINTTOFILE)
1229 EnableWindow(GetDlgItem(hDlg, chx1), FALSE);
1230 if (lppd->Flags & PD_HIDEPRINTTOFILE)
1231 ShowWindow(GetDlgItem(hDlg, chx1), SW_HIDE);
1232
1233 } else { /* PD_PRINTSETUP */
1234 BOOL bPortrait = (lpdm->u1.s1.dmOrientation == DMORIENT_PORTRAIT);
1235
1236 PRINTDLG_SetUpPaperComboBoxW(hDlg, cmb2,
1237 PrintStructures->lpPrinterInfo->pPrinterName,
1238 PrintStructures->lpPrinterInfo->pPortName,
1239 lpdm);
1240 PRINTDLG_SetUpPaperComboBoxW(hDlg, cmb3,
1241 PrintStructures->lpPrinterInfo->pPrinterName,
1242 PrintStructures->lpPrinterInfo->pPortName,
1243 lpdm);
1244 CheckRadioButton(hDlg, rad1, rad2, bPortrait ? rad1: rad2);
1245 SendDlgItemMessageW(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1246 (LPARAM)(bPortrait ? PrintStructures->hPortraitIcon :
1247 PrintStructures->hLandscapeIcon));
1248
1249 }
1250
1251 /* help button */
1252 if ((lppd->Flags & PD_SHOWHELP)==0) {
1253 /* hide if PD_SHOWHELP not specified */
1254 ShowWindow(GetDlgItem(hDlg, pshHelp), SW_HIDE);
1255 }
1256 return TRUE;
1257 }
1258
1259 /***********************************************************************
1260 * check_printer_setup [internal]
1261 */
1262 static LRESULT check_printer_setup(HWND hDlg)
1263 {
1264 DWORD needed,num;
1265 WCHAR resourcestr[256],resultstr[256];
1266
1267 EnumPrintersW(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &needed, &num);
1268 if(needed == 0)
1269 {
1270 EnumPrintersW(PRINTER_ENUM_CONNECTIONS, NULL, 2, NULL, 0, &needed, &num);
1271 }
1272 if(needed > 0)
1273 return TRUE;
1274 else
1275 {
1276 LoadStringW(COMDLG32_hInstance, PD32_NO_DEVICES,resultstr, 255);
1277 LoadStringW(COMDLG32_hInstance, PD32_PRINT_TITLE,resourcestr, 255);
1278 MessageBoxW(hDlg, resultstr, resourcestr,MB_OK | MB_ICONWARNING);
1279 return FALSE;
1280 }
1281 }
1282
1283 /***********************************************************************
1284 * PRINTDLG_WMInitDialog [internal]
1285 */
1286 static LRESULT PRINTDLG_WMInitDialog(HWND hDlg,
1287 PRINT_PTRA* PrintStructures)
1288 {
1289 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
1290 DEVNAMES *pdn;
1291 DEVMODEA *pdm;
1292 char *name = NULL;
1293 UINT comboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
1294
1295 /* load Collate ICONs */
1296 /* We load these with LoadImage because they are not a standard
1297 size and we don't want them rescaled */
1298 PrintStructures->hCollateIcon =
1299 LoadImageA(COMDLG32_hInstance, "PD32_COLLATE", IMAGE_ICON, 0, 0, 0);
1300 PrintStructures->hNoCollateIcon =
1301 LoadImageA(COMDLG32_hInstance, "PD32_NOCOLLATE", IMAGE_ICON, 0, 0, 0);
1302
1303 /* These can be done with LoadIcon */
1304 PrintStructures->hPortraitIcon =
1305 LoadIconA(COMDLG32_hInstance, "PD32_PORTRAIT");
1306 PrintStructures->hLandscapeIcon =
1307 LoadIconA(COMDLG32_hInstance, "PD32_LANDSCAPE");
1308
1309 /* display the collate/no_collate icon */
1310 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1311 (LPARAM)PrintStructures->hNoCollateIcon);
1312
1313 if(PrintStructures->hCollateIcon == 0 ||
1314 PrintStructures->hNoCollateIcon == 0 ||
1315 PrintStructures->hPortraitIcon == 0 ||
1316 PrintStructures->hLandscapeIcon == 0) {
1317 ERR("no icon in resourcefile\n");
1318 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
1319 EndDialog(hDlg, FALSE);
1320 }
1321
1322 /*
1323 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
1324 * must be registered and the Help button must be shown.
1325 */
1326 if (lppd->Flags & PD_SHOWHELP) {
1327 if((PrintStructures->HelpMessageID =
1328 RegisterWindowMessageA(HELPMSGSTRINGA)) == 0) {
1329 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
1330 return FALSE;
1331 }
1332 } else
1333 PrintStructures->HelpMessageID = 0;
1334
1335 if(!(lppd->Flags &PD_PRINTSETUP)) {
1336 PrintStructures->hwndUpDown =
1337 CreateUpDownControl(WS_CHILD | WS_VISIBLE | WS_BORDER |
1338 UDS_NOTHOUSANDS | UDS_ARROWKEYS |
1339 UDS_ALIGNRIGHT | UDS_SETBUDDYINT, 0, 0, 0, 0,
1340 hDlg, UPDOWN_ID, COMDLG32_hInstance,
1341 GetDlgItem(hDlg, edt3), MAX_COPIES, 1, 1);
1342 }
1343
1344 /* FIXME: I allow more freedom than either Win95 or WinNT,
1345 * which do not agree to what errors should be thrown or not
1346 * in case nToPage or nFromPage is out-of-range.
1347 */
1348 if (lppd->nMaxPage < lppd->nMinPage)
1349 lppd->nMaxPage = lppd->nMinPage;
1350 if (lppd->nMinPage == lppd->nMaxPage)
1351 lppd->Flags |= PD_NOPAGENUMS;
1352 if (lppd->nToPage < lppd->nMinPage)
1353 lppd->nToPage = lppd->nMinPage;
1354 if (lppd->nToPage > lppd->nMaxPage)
1355 lppd->nToPage = lppd->nMaxPage;
1356 if (lppd->nFromPage < lppd->nMinPage)
1357 lppd->nFromPage = lppd->nMinPage;
1358 if (lppd->nFromPage > lppd->nMaxPage)
1359 lppd->nFromPage = lppd->nMaxPage;
1360
1361 /* if we have the combo box, fill it */
1362 if (GetDlgItem(hDlg,comboID)) {
1363 /* Fill Combobox
1364 */
1365 pdn = GlobalLock(lppd->hDevNames);
1366 pdm = GlobalLock(lppd->hDevMode);
1367 if(pdn)
1368 name = (char*)pdn + pdn->wDeviceOffset;
1369 else if(pdm)
1370 name = (char*)pdm->dmDeviceName;
1371 PRINTDLG_SetUpPrinterListComboA(hDlg, comboID, name);
1372 if(pdm) GlobalUnlock(lppd->hDevMode);
1373 if(pdn) GlobalUnlock(lppd->hDevNames);
1374
1375 /* Now find selected printer and update rest of dlg */
1376 name = HeapAlloc(GetProcessHeap(),0,256);
1377 if (GetDlgItemTextA(hDlg, comboID, name, 255))
1378 PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
1379 HeapFree(GetProcessHeap(),0,name);
1380 } else {
1381 /* else use default printer */
1382 char name[200];
1383 DWORD dwBufLen = sizeof(name);
1384 BOOL ret = GetDefaultPrinterA(name, &dwBufLen);
1385
1386 if (ret)
1387 PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
1388 else
1389 FIXME("No default printer found, expect problems!\n");
1390 }
1391 return TRUE;
1392 }
1393
1394 static LRESULT PRINTDLG_WMInitDialogW(HWND hDlg,
1395 PRINT_PTRW* PrintStructures)
1396 {
1397 LPPRINTDLGW lppd = PrintStructures->lpPrintDlg;
1398 DEVNAMES *pdn;
1399 DEVMODEW *pdm;
1400 WCHAR *name = NULL;
1401 UINT comboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
1402
1403 /* load Collate ICONs */
1404 /* We load these with LoadImage because they are not a standard
1405 size and we don't want them rescaled */
1406 PrintStructures->hCollateIcon =
1407 LoadImageW(COMDLG32_hInstance, pd32_collateW, IMAGE_ICON, 0, 0, 0);
1408 PrintStructures->hNoCollateIcon =
1409 LoadImageW(COMDLG32_hInstance, pd32_nocollateW, IMAGE_ICON, 0, 0, 0);
1410
1411 /* These can be done with LoadIcon */
1412 PrintStructures->hPortraitIcon =
1413 LoadIconW(COMDLG32_hInstance, pd32_portraitW);
1414 PrintStructures->hLandscapeIcon =
1415 LoadIconW(COMDLG32_hInstance, pd32_landscapeW);
1416
1417 /* display the collate/no_collate icon */
1418 SendDlgItemMessageW(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1419 (LPARAM)PrintStructures->hNoCollateIcon);
1420
1421 if(PrintStructures->hCollateIcon == 0 ||
1422 PrintStructures->hNoCollateIcon == 0 ||
1423 PrintStructures->hPortraitIcon == 0 ||
1424 PrintStructures->hLandscapeIcon == 0) {
1425 ERR("no icon in resourcefile\n");
1426 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
1427 EndDialog(hDlg, FALSE);
1428 }
1429
1430 /*
1431 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
1432 * must be registered and the Help button must be shown.
1433 */
1434 if (lppd->Flags & PD_SHOWHELP) {
1435 if((PrintStructures->HelpMessageID =
1436 RegisterWindowMessageW(HELPMSGSTRINGW)) == 0) {
1437 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
1438 return FALSE;
1439 }
1440 } else
1441 PrintStructures->HelpMessageID = 0;
1442
1443 if(!(lppd->Flags &PD_PRINTSETUP)) {
1444 PrintStructures->hwndUpDown =
1445 CreateUpDownControl(WS_CHILD | WS_VISIBLE | WS_BORDER |
1446 UDS_NOTHOUSANDS | UDS_ARROWKEYS |
1447 UDS_ALIGNRIGHT | UDS_SETBUDDYINT, 0, 0, 0, 0,
1448 hDlg, UPDOWN_ID, COMDLG32_hInstance,
1449 GetDlgItem(hDlg, edt3), MAX_COPIES, 1, 1);
1450 }
1451
1452 /* FIXME: I allow more freedom than either Win95 or WinNT,
1453 * which do not agree to what errors should be thrown or not
1454 * in case nToPage or nFromPage is out-of-range.
1455 */
1456 if (lppd->nMaxPage < lppd->nMinPage)
1457 lppd->nMaxPage = lppd->nMinPage;
1458 if (lppd->nMinPage == lppd->nMaxPage)
1459 lppd->Flags |= PD_NOPAGENUMS;
1460 if (lppd->nToPage < lppd->nMinPage)
1461 lppd->nToPage = lppd->nMinPage;
1462 if (lppd->nToPage > lppd->nMaxPage)
1463 lppd->nToPage = lppd->nMaxPage;
1464 if (lppd->nFromPage < lppd->nMinPage)
1465 lppd->nFromPage = lppd->nMinPage;
1466 if (lppd->nFromPage > lppd->nMaxPage)
1467 lppd->nFromPage = lppd->nMaxPage;
1468
1469 /* if we have the combo box, fill it */
1470 if (GetDlgItem(hDlg,comboID)) {
1471 /* Fill Combobox
1472 */
1473 pdn = GlobalLock(lppd->hDevNames);
1474 pdm = GlobalLock(lppd->hDevMode);
1475 if(pdn)
1476 name = (WCHAR*)pdn + pdn->wDeviceOffset;
1477 else if(pdm)
1478 name = pdm->dmDeviceName;
1479 PRINTDLG_SetUpPrinterListComboW(hDlg, comboID, name);
1480 if(pdm) GlobalUnlock(lppd->hDevMode);
1481 if(pdn) GlobalUnlock(lppd->hDevNames);
1482
1483 /* Now find selected printer and update rest of dlg */
1484 /* ansi is ok here */
1485 name = HeapAlloc(GetProcessHeap(),0,256*sizeof(WCHAR));
1486 if (GetDlgItemTextW(hDlg, comboID, name, 255))
1487 PRINTDLG_ChangePrinterW(hDlg, name, PrintStructures);
1488 HeapFree(GetProcessHeap(),0,name);
1489 } else {
1490 /* else use default printer */
1491 WCHAR name[200];
1492 DWORD dwBufLen = sizeof(name) / sizeof(WCHAR);
1493 BOOL ret = GetDefaultPrinterW(name, &dwBufLen);
1494
1495 if (ret)
1496 PRINTDLG_ChangePrinterW(hDlg, name, PrintStructures);
1497 else
1498 FIXME("No default printer found, expect problems!\n");
1499 }
1500 return TRUE;
1501 }
1502
1503 /***********************************************************************
1504 * PRINTDLG_WMCommand [internal]
1505 */
1506 static LRESULT PRINTDLG_WMCommandA(HWND hDlg, WPARAM wParam,
1507 PRINT_PTRA* PrintStructures)
1508 {
1509 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
1510 UINT PrinterComboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
1511 LPDEVMODEA lpdm = PrintStructures->lpDevMode;
1512
1513 switch (LOWORD(wParam)) {
1514 case IDOK:
1515 TRACE(" OK button was hit\n");
1516 if (!PRINTDLG_UpdatePrintDlgA(hDlg, PrintStructures)) {
1517 FIXME("Update printdlg was not successful!\n");
1518 return(FALSE);
1519 }
1520 EndDialog(hDlg, TRUE);
1521 return(TRUE);
1522
1523 case IDCANCEL:
1524 TRACE(" CANCEL button was hit\n");
1525 EndDialog(hDlg, FALSE);
1526 return(FALSE);
1527
1528 case pshHelp:
1529 TRACE(" HELP button was hit\n");
1530 SendMessageA(lppd->hwndOwner, PrintStructures->HelpMessageID,
1531 (WPARAM) hDlg, (LPARAM) lppd);
1532 break;
1533
1534 case chx2: /* collate pages checkbox */
1535 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
1536 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1537 (LPARAM)PrintStructures->hCollateIcon);
1538 else
1539 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1540 (LPARAM)PrintStructures->hNoCollateIcon);
1541 break;
1542 case edt1: /* from page nr editbox */
1543 case edt2: /* to page nr editbox */
1544 if (HIWORD(wParam)==EN_CHANGE) {
1545 WORD nToPage;
1546 WORD nFromPage;
1547 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
1548 nToPage = GetDlgItemInt(hDlg, edt2, NULL, FALSE);
1549 if (nFromPage != lppd->nFromPage || nToPage != lppd->nToPage)
1550 CheckRadioButton(hDlg, rad1, rad3, rad3);
1551 }
1552 break;
1553
1554 case edt3:
1555 if(HIWORD(wParam) == EN_CHANGE) {
1556 INT copies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
1557 if(copies <= 1)
1558 EnableWindow(GetDlgItem(hDlg, chx2), FALSE);
1559 else
1560 EnableWindow(GetDlgItem(hDlg, chx2), TRUE);
1561 }
1562 break;
1563
1564 case psh2: /* Properties button */
1565 {
1566 HANDLE hPrinter;
1567 char PrinterName[256];
1568
1569 GetDlgItemTextA(hDlg, PrinterComboID, PrinterName, 255);
1570 if (!OpenPrinterA(PrinterName, &hPrinter, NULL)) {
1571 FIXME(" Call to OpenPrinter did not succeed!\n");
1572 break;
1573 }
1574 DocumentPropertiesA(hDlg, hPrinter, PrinterName,
1575 PrintStructures->lpDevMode,
1576 PrintStructures->lpDevMode,
1577 DM_IN_BUFFER | DM_OUT_BUFFER | DM_IN_PROMPT);
1578 ClosePrinter(hPrinter);
1579 break;
1580 }
1581
1582 case rad1: /* Paperorientation */
1583 if (lppd->Flags & PD_PRINTSETUP)
1584 {
1585 lpdm->u1.s1.dmOrientation = DMORIENT_PORTRAIT;
1586 SendDlgItemMessageA(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1587 (LPARAM)(PrintStructures->hPortraitIcon));
1588 }
1589 break;
1590
1591 case rad2: /* Paperorientation */
1592 if (lppd->Flags & PD_PRINTSETUP)
1593 {
1594 lpdm->u1.s1.dmOrientation = DMORIENT_LANDSCAPE;
1595 SendDlgItemMessageA(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1596 (LPARAM)(PrintStructures->hLandscapeIcon));
1597 }
1598 break;
1599
1600 case cmb1: /* Printer Combobox in PRINT SETUP, quality combobox in PRINT16 */
1601 if (PrinterComboID != LOWORD(wParam)) {
1602 break;
1603 }
1604 /* FALLTHROUGH */
1605 case cmb4: /* Printer combobox */
1606 if (HIWORD(wParam)==CBN_SELCHANGE) {
1607 char PrinterName[256];
1608 GetDlgItemTextA(hDlg, LOWORD(wParam), PrinterName, 255);
1609 PRINTDLG_ChangePrinterA(hDlg, PrinterName, PrintStructures);
1610 }
1611 break;
1612
1613 case cmb2: /* Papersize */
1614 {
1615 DWORD Sel = SendDlgItemMessageA(hDlg, cmb2, CB_GETCURSEL, 0, 0);
1616 if(Sel != CB_ERR)
1617 lpdm->u1.s1.dmPaperSize = SendDlgItemMessageA(hDlg, cmb2,
1618 CB_GETITEMDATA,
1619 Sel, 0);
1620 }
1621 break;
1622
1623 case cmb3: /* Bin */
1624 {
1625 DWORD Sel = SendDlgItemMessageA(hDlg, cmb3, CB_GETCURSEL, 0, 0);
1626 if(Sel != CB_ERR)
1627 lpdm->u1.s1.dmDefaultSource = SendDlgItemMessageA(hDlg, cmb3,
1628 CB_GETITEMDATA, Sel,
1629 0);
1630 }
1631 break;
1632 }
1633 if(lppd->Flags & PD_PRINTSETUP) {
1634 switch (LOWORD(wParam)) {
1635 case rad1: /* orientation */
1636 case rad2:
1637 if (IsDlgButtonChecked(hDlg, rad1) == BST_CHECKED) {
1638 if(lpdm->u1.s1.dmOrientation != DMORIENT_PORTRAIT) {
1639 lpdm->u1.s1.dmOrientation = DMORIENT_PORTRAIT;
1640 SendDlgItemMessageA(hDlg, stc10, STM_SETIMAGE, IMAGE_ICON,
1641 (LPARAM)PrintStructures->hPortraitIcon);
1642 SendDlgItemMessageA(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1643 (LPARAM)PrintStructures->hPortraitIcon);
1644 }
1645 } else {
1646 if(lpdm->u1.s1.dmOrientation != DMORIENT_LANDSCAPE) {
1647 lpdm->u1.s1.dmOrientation = DMORIENT_LANDSCAPE;
1648 SendDlgItemMessageA(hDlg, stc10, STM_SETIMAGE, IMAGE_ICON,
1649 (LPARAM)PrintStructures->hLandscapeIcon);
1650 SendDlgItemMessageA(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1651 (LPARAM)PrintStructures->hLandscapeIcon);
1652 }
1653 }
1654 break;
1655 }
1656 }
1657 return FALSE;
1658 }
1659
1660 static LRESULT PRINTDLG_WMCommandW(HWND hDlg, WPARAM wParam,
1661 PRINT_PTRW* PrintStructures)
1662 {
1663 LPPRINTDLGW lppd = PrintStructures->lpPrintDlg;
1664 UINT PrinterComboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
1665 LPDEVMODEW lpdm = PrintStructures->lpDevMode;
1666
1667 switch (LOWORD(wParam)) {
1668 case IDOK:
1669 TRACE(" OK button was hit\n");
1670 if (!PRINTDLG_UpdatePrintDlgW(hDlg, PrintStructures)) {
1671 FIXME("Update printdlg was not successful!\n");
1672 return(FALSE);
1673 }
1674 EndDialog(hDlg, TRUE);
1675 return(TRUE);
1676
1677 case IDCANCEL:
1678 TRACE(" CANCEL button was hit\n");
1679 EndDialog(hDlg, FALSE);
1680 return(FALSE);
1681
1682 case pshHelp:
1683 TRACE(" HELP button was hit\n");
1684 SendMessageW(lppd->hwndOwner, PrintStructures->HelpMessageID,
1685 (WPARAM) hDlg, (LPARAM) lppd);
1686 break;
1687
1688 case chx2: /* collate pages checkbox */
1689 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
1690 SendDlgItemMessageW(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1691 (LPARAM)PrintStructures->hCollateIcon);
1692 else
1693 SendDlgItemMessageW(hDlg, ico3, STM_SETIMAGE, IMAGE_ICON,
1694 (LPARAM)PrintStructures->hNoCollateIcon);
1695 break;
1696 case edt1: /* from page nr editbox */
1697 case edt2: /* to page nr editbox */
1698 if (HIWORD(wParam)==EN_CHANGE) {
1699 WORD nToPage;
1700 WORD nFromPage;
1701 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
1702 nToPage = GetDlgItemInt(hDlg, edt2, NULL, FALSE);
1703 if (nFromPage != lppd->nFromPage || nToPage != lppd->nToPage)
1704 CheckRadioButton(hDlg, rad1, rad3, rad3);
1705 }
1706 break;
1707
1708 case edt3:
1709 if(HIWORD(wParam) == EN_CHANGE) {
1710 INT copies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
1711 if(copies <= 1)
1712 EnableWindow(GetDlgItem(hDlg, chx2), FALSE);
1713 else
1714 EnableWindow(GetDlgItem(hDlg, chx2), TRUE);
1715 }
1716 break;
1717
1718 case psh2: /* Properties button */
1719 {
1720 HANDLE hPrinter;
1721 WCHAR PrinterName[256];
1722
1723 if (!GetDlgItemTextW(hDlg, PrinterComboID, PrinterName, 255)) break;
1724 if (!OpenPrinterW(PrinterName, &hPrinter, NULL)) {
1725 FIXME(" Call to OpenPrinter did not succeed!\n");
1726 break;
1727 }
1728 DocumentPropertiesW(hDlg, hPrinter, PrinterName,
1729 PrintStructures->lpDevMode,
1730 PrintStructures->lpDevMode,
1731 DM_IN_BUFFER | DM_OUT_BUFFER | DM_IN_PROMPT);
1732 ClosePrinter(hPrinter);
1733 break;
1734 }
1735
1736 case rad1: /* Paperorientation */
1737 if (lppd->Flags & PD_PRINTSETUP)
1738 {
1739 lpdm->u1.s1.dmOrientation = DMORIENT_PORTRAIT;
1740 SendDlgItemMessageW(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1741 (LPARAM)(PrintStructures->hPortraitIcon));
1742 }
1743 break;
1744
1745 case rad2: /* Paperorientation */
1746 if (lppd->Flags & PD_PRINTSETUP)
1747 {
1748 lpdm->u1.s1.dmOrientation = DMORIENT_LANDSCAPE;
1749 SendDlgItemMessageW(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1750 (LPARAM)(PrintStructures->hLandscapeIcon));
1751 }
1752 break;
1753
1754 case cmb1: /* Printer Combobox in PRINT SETUP */
1755 /* FALLTHROUGH */
1756 case cmb4: /* Printer combobox */
1757 if (HIWORD(wParam)==CBN_SELCHANGE) {
1758 WCHAR PrinterName[256];
1759 GetDlgItemTextW(hDlg, LOWORD(wParam), PrinterName, 255);
1760 PRINTDLG_ChangePrinterW(hDlg, PrinterName, PrintStructures);
1761 }
1762 break;
1763
1764 case cmb2: /* Papersize */
1765 {
1766 DWORD Sel = SendDlgItemMessageW(hDlg, cmb2, CB_GETCURSEL, 0, 0);
1767 if(Sel != CB_ERR)
1768 lpdm->u1.s1.dmPaperSize = SendDlgItemMessageW(hDlg, cmb2,
1769 CB_GETITEMDATA,
1770 Sel, 0);
1771 }
1772 break;
1773
1774 case cmb3: /* Bin */
1775 {
1776 DWORD Sel = SendDlgItemMessageW(hDlg, cmb3, CB_GETCURSEL, 0, 0);
1777 if(Sel != CB_ERR)
1778 lpdm->u1.s1.dmDefaultSource = SendDlgItemMessageW(hDlg, cmb3,
1779 CB_GETITEMDATA, Sel,
1780 0);
1781 }
1782 break;
1783 }
1784 if(lppd->Flags & PD_PRINTSETUP) {
1785 switch (LOWORD(wParam)) {
1786 case rad1: /* orientation */
1787 case rad2:
1788 if (IsDlgButtonChecked(hDlg, rad1) == BST_CHECKED) {
1789 if(lpdm->u1.s1.dmOrientation != DMORIENT_PORTRAIT) {
1790 lpdm->u1.s1.dmOrientation = DMORIENT_PORTRAIT;
1791 SendDlgItemMessageW(hDlg, stc10, STM_SETIMAGE, IMAGE_ICON,
1792 (LPARAM)PrintStructures->hPortraitIcon);
1793 SendDlgItemMessageW(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1794 (LPARAM)PrintStructures->hPortraitIcon);
1795 }
1796 } else {
1797 if(lpdm->u1.s1.dmOrientation != DMORIENT_LANDSCAPE) {
1798 lpdm->u1.s1.dmOrientation = DMORIENT_LANDSCAPE;
1799 SendDlgItemMessageW(hDlg, stc10, STM_SETIMAGE, IMAGE_ICON,
1800 (LPARAM)PrintStructures->hLandscapeIcon);
1801 SendDlgItemMessageW(hDlg, ico1, STM_SETIMAGE, IMAGE_ICON,
1802 (LPARAM)PrintStructures->hLandscapeIcon);
1803 }
1804 }
1805 break;
1806 }
1807 }
1808 return FALSE;
1809 }
1810
1811 /***********************************************************************
1812 * PrintDlgProcA [internal]
1813 */
1814 static INT_PTR CALLBACK PrintDlgProcA(HWND hDlg, UINT uMsg, WPARAM wParam,
1815 LPARAM lParam)
1816 {
1817 PRINT_PTRA* PrintStructures;
1818 INT_PTR res = FALSE;
1819
1820 if (uMsg!=WM_INITDIALOG) {
1821 PrintStructures = GetPropW(hDlg, printdlg_prop);
1822 if (!PrintStructures)
1823 return FALSE;
1824 } else {
1825 PrintStructures = (PRINT_PTRA*) lParam;
1826 SetPropW(hDlg, printdlg_prop, PrintStructures);
1827 if(!check_printer_setup(hDlg))
1828 {
1829 EndDialog(hDlg,FALSE);
1830 return FALSE;
1831 }
1832 res = PRINTDLG_WMInitDialog(hDlg, PrintStructures);
1833
1834 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK)
1835 res = PrintStructures->lpPrintDlg->lpfnPrintHook(
1836 hDlg, uMsg, wParam, (LPARAM)PrintStructures->lpPrintDlg
1837 );
1838 return res;
1839 }
1840
1841 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK) {
1842 res = PrintStructures->lpPrintDlg->lpfnPrintHook(hDlg,uMsg,wParam,
1843 lParam);
1844 if(res) return res;
1845 }
1846
1847 switch (uMsg) {
1848 case WM_COMMAND:
1849 return PRINTDLG_WMCommandA(hDlg, wParam, PrintStructures);
1850
1851 case WM_DESTROY:
1852 DestroyIcon(PrintStructures->hCollateIcon);
1853 DestroyIcon(PrintStructures->hNoCollateIcon);
1854 DestroyIcon(PrintStructures->hPortraitIcon);
1855 DestroyIcon(PrintStructures->hLandscapeIcon);
1856 if(PrintStructures->hwndUpDown)
1857 DestroyWindow(PrintStructures->hwndUpDown);
1858 return FALSE;
1859 }
1860 return res;
1861 }
1862
1863 static INT_PTR CALLBACK PrintDlgProcW(HWND hDlg, UINT uMsg, WPARAM wParam,
1864 LPARAM lParam)
1865 {
1866 PRINT_PTRW* PrintStructures;
1867 INT_PTR res = FALSE;
1868
1869 if (uMsg!=WM_INITDIALOG) {
1870 PrintStructures = GetPropW(hDlg, printdlg_prop);
1871 if (!PrintStructures)
1872 return FALSE;
1873 } else {
1874 PrintStructures = (PRINT_PTRW*) lParam;
1875 SetPropW(hDlg, printdlg_prop, PrintStructures);
1876 if(!check_printer_setup(hDlg))
1877 {
1878 EndDialog(hDlg,FALSE);
1879 return FALSE;
1880 }
1881 res = PRINTDLG_WMInitDialogW(hDlg, PrintStructures);
1882
1883 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK)
1884 res = PrintStructures->lpPrintDlg->lpfnPrintHook(hDlg, uMsg, wParam, (LPARAM)PrintStructures->lpPrintDlg);
1885 return res;
1886 }
1887
1888 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK) {
1889 res = PrintStructures->lpPrintDlg->lpfnPrintHook(hDlg,uMsg,wParam, lParam);
1890 if(res) return res;
1891 }
1892
1893 switch (uMsg) {
1894 case WM_COMMAND:
1895 return PRINTDLG_WMCommandW(hDlg, wParam, PrintStructures);
1896
1897 case WM_DESTROY:
1898 DestroyIcon(PrintStructures->hCollateIcon);
1899 DestroyIcon(PrintStructures->hNoCollateIcon);
1900 DestroyIcon(PrintStructures->hPortraitIcon);
1901 DestroyIcon(PrintStructures->hLandscapeIcon);
1902 if(PrintStructures->hwndUpDown)
1903 DestroyWindow(PrintStructures->hwndUpDown);
1904 return FALSE;
1905 }
1906 return res;
1907 }
1908
1909 /************************************************************
1910 *
1911 * PRINTDLG_GetDlgTemplate
1912 *
1913 */
1914 static HGLOBAL PRINTDLG_GetDlgTemplateA(const PRINTDLGA *lppd)
1915 {
1916 HRSRC hResInfo;
1917 HGLOBAL hDlgTmpl;
1918
1919 if (lppd->Flags & PD_PRINTSETUP) {
1920 if(lppd->Flags & PD_ENABLESETUPTEMPLATEHANDLE) {
1921 hDlgTmpl = lppd->hSetupTemplate;
1922 } else if(lppd->Flags & PD_ENABLESETUPTEMPLATE) {
1923 hResInfo = FindResourceA(lppd->hInstance,
1924 lppd->lpSetupTemplateName, (LPSTR)RT_DIALOG);
1925 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
1926 } else {
1927 hResInfo = FindResourceA(COMDLG32_hInstance, "PRINT32_SETUP",
1928 (LPSTR)RT_DIALOG);
1929 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
1930 }
1931 } else {
1932 if(lppd->Flags & PD_ENABLEPRINTTEMPLATEHANDLE) {
1933 hDlgTmpl = lppd->hPrintTemplate;
1934 } else if(lppd->Flags & PD_ENABLEPRINTTEMPLATE) {
1935 hResInfo = FindResourceA(lppd->hInstance,
1936 lppd->lpPrintTemplateName,
1937 (LPSTR)RT_DIALOG);
1938 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
1939 } else {
1940 hResInfo = FindResourceA(COMDLG32_hInstance, "PRINT32",
1941 (LPSTR)RT_DIALOG);
1942 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
1943 }
1944 }
1945 return hDlgTmpl;
1946 }
1947
1948 static HGLOBAL PRINTDLG_GetDlgTemplateW(const PRINTDLGW *lppd)
1949 {
1950 HRSRC hResInfo;
1951 HGLOBAL hDlgTmpl;
1952 static const WCHAR xpsetup[] = { 'P','R','I','N','T','3','2','_','S','E','T','U','P',0};
1953 static const WCHAR xprint[] = { 'P','R','I','N','T','3','2',0};
1954
1955 if (lppd->Flags & PD_PRINTSETUP) {
1956 if(lppd->Flags & PD_ENABLESETUPTEMPLATEHANDLE) {
1957 hDlgTmpl = lppd->hSetupTemplate;
1958 } else if(lppd->Flags & PD_ENABLESETUPTEMPLATE) {
1959 hResInfo = FindResourceW(lppd->hInstance,
1960 lppd->lpSetupTemplateName, (LPWSTR)RT_DIALOG);
1961 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
1962 } else {
1963 hResInfo = FindResourceW(COMDLG32_hInstance, xpsetup, (LPWSTR)RT_DIALOG);
1964 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
1965 }
1966 } else {
1967 if(lppd->Flags & PD_ENABLEPRINTTEMPLATEHANDLE) {
1968 hDlgTmpl = lppd->hPrintTemplate;
1969 } else if(lppd->Flags & PD_ENABLEPRINTTEMPLATE) {
1970 hResInfo = FindResourceW(lppd->hInstance,
1971 lppd->lpPrintTemplateName,
1972 (LPWSTR)RT_DIALOG);
1973 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
1974 } else {
1975 hResInfo = FindResourceW(COMDLG32_hInstance, xprint, (LPWSTR)RT_DIALOG);
1976 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
1977 }
1978 }
1979 return hDlgTmpl;
1980 }
1981
1982 /***********************************************************************
1983 *
1984 * PRINTDLG_CreateDC
1985 *
1986 */
1987 static BOOL PRINTDLG_CreateDCA(LPPRINTDLGA lppd)
1988 {
1989 DEVNAMES *pdn = GlobalLock(lppd->hDevNames);
1990 DEVMODEA *pdm = GlobalLock(lppd->hDevMode);
1991
1992 if(lppd->Flags & PD_RETURNDC) {
1993 lppd->hDC = CreateDCA((char*)pdn + pdn->wDriverOffset,
1994 (char*)pdn + pdn->wDeviceOffset,
1995 (char*)pdn + pdn->wOutputOffset,
1996 pdm );
1997 } else if(lppd->Flags & PD_RETURNIC) {
1998 lppd->hDC = CreateICA((char*)pdn + pdn->wDriverOffset,
1999 (char*)pdn + pdn->wDeviceOffset,
2000 (char*)pdn + pdn->wOutputOffset,
2001 pdm );
2002 }
2003 GlobalUnlock(lppd->hDevNames);
2004 GlobalUnlock(lppd->hDevMode);
2005 return lppd->hDC ? TRUE : FALSE;
2006 }
2007
2008 static BOOL PRINTDLG_CreateDCW(LPPRINTDLGW lppd)
2009 {
2010 DEVNAMES *pdn = GlobalLock(lppd->hDevNames);
2011 DEVMODEW *pdm = GlobalLock(lppd->hDevMode);
2012
2013 if(lppd->Flags & PD_RETURNDC) {
2014 lppd->hDC = CreateDCW((WCHAR*)pdn + pdn->wDriverOffset,
2015 (WCHAR*)pdn + pdn->wDeviceOffset,
2016 (WCHAR*)pdn + pdn->wOutputOffset,
2017 pdm );
2018 } else if(lppd->Flags & PD_RETURNIC) {
2019 lppd->hDC = CreateICW((WCHAR*)pdn + pdn->wDriverOffset,
2020 (WCHAR*)pdn + pdn->wDeviceOffset,
2021 (WCHAR*)pdn + pdn->wOutputOffset,
2022 pdm );
2023 }
2024 GlobalUnlock(lppd->hDevNames);
2025 GlobalUnlock(lppd->hDevMode);
2026 return lppd->hDC ? TRUE : FALSE;
2027 }
2028
2029 /***********************************************************************
2030 * PrintDlgA (COMDLG32.@)
2031 *
2032 * Displays the PRINT dialog box, which enables the user to specify
2033 * specific properties of the print job.
2034 *
2035 * PARAMS
2036 * lppd [IO] ptr to PRINTDLG32 struct
2037 *
2038 * RETURNS
2039 * nonzero if the user pressed the OK button
2040 * zero if the user cancelled the window or an error occurred
2041 *
2042 * BUGS
2043 * PrintDlg:
2044 * * The Collate Icons do not display, even though they are in the code.
2045 * * The Properties Button(s) should call DocumentPropertiesA().
2046 */
2047
2048 BOOL WINAPI PrintDlgA(LPPRINTDLGA lppd)
2049 {
2050 BOOL bRet = FALSE;
2051 LPVOID ptr;
2052 HINSTANCE hInst;
2053
2054 if (!lppd)
2055 {
2056 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION);
2057 return FALSE;
2058 }
2059
2060 if(TRACE_ON(commdlg)) {
2061 char flagstr[1000] = "";
2062 const struct pd_flags *pflag = pd_flags;
2063 for( ; pflag->name; pflag++) {
2064 if(lppd->Flags & pflag->flag)
2065 strcat(flagstr, pflag->name);
2066 }
2067 TRACE("(%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
2068 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %p\n"
2069 "flags %08x (%s)\n",
2070 lppd, lppd->hwndOwner, lppd->hDevMode, lppd->hDevNames,
2071 lppd->nFromPage, lppd->nToPage, lppd->nMinPage, lppd->nMaxPage,
2072 lppd->nCopies, lppd->hInstance, lppd->Flags, flagstr);
2073 }
2074
2075 if(lppd->lStructSize != sizeof(PRINTDLGA)) {
2076 WARN("structure size failure !!!\n");
2077 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
2078 return FALSE;
2079 }
2080
2081 if(lppd->Flags & PD_RETURNDEFAULT) {
2082 PRINTER_INFO_2A *pbuf;
2083 DRIVER_INFO_3A *dbuf;
2084 HANDLE hprn;
2085 DWORD needed;
2086
2087 if(lppd->hDevMode || lppd->hDevNames) {
2088 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
2089 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
2090 return FALSE;
2091 }
2092 if(!PRINTDLG_OpenDefaultPrinter(&hprn)) {
2093 WARN("Can't find default printer\n");
2094 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
2095 return FALSE;
2096 }
2097
2098 GetPrinterA(hprn, 2, NULL, 0, &needed);
2099 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
2100 GetPrinterA(hprn, 2, (LPBYTE)pbuf, needed, &needed);
2101
2102 GetPrinterDriverA(hprn, NULL, 3, NULL, 0, &needed);
2103 dbuf = HeapAlloc(GetProcessHeap(),0,needed);
2104 if (!GetPrinterDriverA(hprn, NULL, 3, (LPBYTE)dbuf, needed, &needed)) {
2105 ERR("GetPrinterDriverA failed, le %d, fix your config for printer %s!\n",
2106 GetLastError(),pbuf->pPrinterName);
2107 HeapFree(GetProcessHeap(), 0, dbuf);
2108 HeapFree(GetProcessHeap(), 0, pbuf);
2109 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
2110 return FALSE;
2111 }
2112 ClosePrinter(hprn);
2113
2114 PRINTDLG_CreateDevNames(&(lppd->hDevNames),
2115 dbuf->pDriverPath,
2116 pbuf->pPrinterName,
2117 pbuf->pPortName);
2118 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, pbuf->pDevMode->dmSize +
2119 pbuf->pDevMode->dmDriverExtra);
2120 ptr = GlobalLock(lppd->hDevMode);
2121 memcpy(ptr, pbuf->pDevMode, pbuf->pDevMode->dmSize +
2122 pbuf->pDevMode->dmDriverExtra);
2123 GlobalUnlock(lppd->hDevMode);
2124 HeapFree(GetProcessHeap(), 0, pbuf);
2125 HeapFree(GetProcessHeap(), 0, dbuf);
2126 bRet = TRUE;
2127 } else {
2128 HGLOBAL hDlgTmpl;
2129 PRINT_PTRA *PrintStructures;
2130
2131 /* load Dialog resources,
2132 * depending on Flags indicates Print32 or Print32_setup dialog
2133 */
2134 hDlgTmpl = PRINTDLG_GetDlgTemplateA(lppd);
2135 if (!hDlgTmpl) {
2136 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
2137 return FALSE;
2138 }
2139 ptr = LockResource( hDlgTmpl );
2140 if (!ptr) {
2141 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
2142 return FALSE;
2143 }
2144
2145 PrintStructures = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2146 sizeof(PRINT_PTRA));
2147 PrintStructures->lpPrintDlg = lppd;
2148
2149 /* and create & process the dialog .
2150 * -1 is failure, 0 is broken hwnd, everything else is ok.
2151 */
2152 hInst = COMDLG32_hInstance;
2153 if (lppd->Flags & (PD_ENABLESETUPTEMPLATE | PD_ENABLEPRINTTEMPLATE)) hInst = lppd->hInstance;
2154 bRet = (0<DialogBoxIndirectParamA(hInst, ptr, lppd->hwndOwner,
2155 PrintDlgProcA,
2156 (LPARAM)PrintStructures));
2157
2158 if(bRet) {
2159 DEVMODEA *lpdm = PrintStructures->lpDevMode, *lpdmReturn;
2160 PRINTER_INFO_2A *pi = PrintStructures->lpPrinterInfo;
2161 DRIVER_INFO_3A *di = PrintStructures->lpDriverInfo;
2162
2163 if (lppd->hDevMode == 0) {
2164 TRACE(" No hDevMode yet... Need to create my own\n");
2165 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE,
2166 lpdm->dmSize + lpdm->dmDriverExtra);
2167 } else {
2168 lppd->hDevMode = GlobalReAlloc(lppd->hDevMode,
2169 lpdm->dmSize + lpdm->dmDriverExtra,
2170 GMEM_MOVEABLE);
2171 }
2172 lpdmReturn = GlobalLock(lppd->hDevMode);
2173 memcpy(lpdmReturn, lpdm, lpdm->dmSize + lpdm->dmDriverExtra);
2174
2175 PRINTDLG_CreateDevNames(&(lppd->hDevNames),
2176 di->pDriverPath,
2177 pi->pPrinterName,
2178 pi->pPortName
2179 );
2180 GlobalUnlock(lppd->hDevMode);
2181 }
2182 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
2183 HeapFree(GetProcessHeap(), 0, PrintStructures->lpPrinterInfo);
2184 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDriverInfo);
2185 HeapFree(GetProcessHeap(), 0, PrintStructures);
2186 }
2187 if(bRet && (lppd->Flags & PD_RETURNDC || lppd->Flags & PD_RETURNIC))
2188 bRet = PRINTDLG_CreateDCA(lppd);
2189
2190 TRACE("exit! (%d)\n", bRet);
2191 return bRet;
2192 }
2193
2194 /***********************************************************************
2195 * PrintDlgW (COMDLG32.@)
2196 *
2197 * See PrintDlgA.
2198 */
2199 BOOL WINAPI PrintDlgW(LPPRINTDLGW lppd)
2200 {
2201 BOOL bRet = FALSE;
2202 LPVOID ptr;
2203 HINSTANCE hInst;
2204
2205 if (!lppd)
2206 {
2207 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION);
2208 return FALSE;
2209 }
2210
2211 if(TRACE_ON(commdlg)) {
2212 char flagstr[1000] = "";
2213 const struct pd_flags *pflag = pd_flags;
2214 for( ; pflag->name; pflag++) {
2215 if(lppd->Flags & pflag->flag)
2216 strcat(flagstr, pflag->name);
2217 }
2218 TRACE("(%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
2219 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %p\n"
2220 "flags %08x (%s)\n",
2221 lppd, lppd->hwndOwner, lppd->hDevMode, lppd->hDevNames,
2222 lppd->nFromPage, lppd->nToPage, lppd->nMinPage, lppd->nMaxPage,
2223 lppd->nCopies, lppd->hInstance, lppd->Flags, flagstr);
2224 }
2225
2226 if(lppd->lStructSize != sizeof(PRINTDLGW)) {
2227 WARN("structure size failure !!!\n");
2228 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
2229 return FALSE;
2230 }
2231
2232 if(lppd->Flags & PD_RETURNDEFAULT) {
2233 PRINTER_INFO_2W *pbuf;
2234 DRIVER_INFO_3W *dbuf;
2235 HANDLE hprn;
2236 DWORD needed;
2237
2238 if(lppd->hDevMode || lppd->hDevNames) {
2239 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
2240 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
2241 return FALSE;
2242 }
2243 if(!PRINTDLG_OpenDefaultPrinter(&hprn)) {
2244 WARN("Can't find default printer\n");
2245 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
2246 return FALSE;
2247 }
2248
2249 GetPrinterW(hprn, 2, NULL, 0, &needed);
2250 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
2251 GetPrinterW(hprn, 2, (LPBYTE)pbuf, needed, &needed);
2252
2253 GetPrinterDriverW(hprn, NULL, 3, NULL, 0, &needed);
2254 dbuf = HeapAlloc(GetProcessHeap(),0,needed);
2255 if (!GetPrinterDriverW(hprn, NULL, 3, (LPBYTE)dbuf, needed, &needed)) {
2256 ERR("GetPrinterDriverA failed, le %d, fix your config for printer %s!\n",
2257 GetLastError(),debugstr_w(pbuf->pPrinterName));
2258 HeapFree(GetProcessHeap(), 0, dbuf);
2259 HeapFree(GetProcessHeap(), 0, pbuf);
2260 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
2261 return FALSE;
2262 }
2263 ClosePrinter(hprn);
2264
2265 PRINTDLG_CreateDevNamesW(&(lppd->hDevNames),
2266 dbuf->pDriverPath,
2267 pbuf->pPrinterName,
2268 pbuf->pPortName);
2269 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, pbuf->pDevMode->dmSize +
2270 pbuf->pDevMode->dmDriverExtra);
2271 ptr = GlobalLock(lppd->hDevMode);
2272 memcpy(ptr, pbuf->pDevMode, pbuf->pDevMode->dmSize +
2273 pbuf->pDevMode->dmDriverExtra);
2274 GlobalUnlock(lppd->hDevMode);
2275 HeapFree(GetProcessHeap(), 0, pbuf);
2276 HeapFree(GetProcessHeap(), 0, dbuf);
2277 bRet = TRUE;
2278 } else {
2279 HGLOBAL hDlgTmpl;
2280 PRINT_PTRW *PrintStructures;
2281
2282 /* load Dialog resources,
2283 * depending on Flags indicates Print32 or Print32_setup dialog
2284 */
2285 hDlgTmpl = PRINTDLG_GetDlgTemplateW(lppd);
2286 if (!hDlgTmpl) {
2287 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
2288 return FALSE;
2289 }
2290 ptr = LockResource( hDlgTmpl );
2291 if (!ptr) {
2292 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
2293 return FALSE;
2294 }
2295
2296 PrintStructures = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2297 sizeof(PRINT_PTRW));
2298 PrintStructures->lpPrintDlg = lppd;
2299
2300 /* and create & process the dialog .
2301 * -1 is failure, 0 is broken hwnd, everything else is ok.
2302 */
2303 hInst = COMDLG32_hInstance;
2304 if (lppd->Flags & (PD_ENABLESETUPTEMPLATE | PD_ENABLEPRINTTEMPLATE)) hInst = lppd->hInstance;
2305 bRet = (0<DialogBoxIndirectParamW(hInst, ptr, lppd->hwndOwner,
2306 PrintDlgProcW,
2307 (LPARAM)PrintStructures));
2308
2309 if(bRet) {
2310 DEVMODEW *lpdm = PrintStructures->lpDevMode, *lpdmReturn;
2311 PRINTER_INFO_2W *pi = PrintStructures->lpPrinterInfo;
2312 DRIVER_INFO_3W *di = PrintStructures->lpDriverInfo;
2313
2314 if (lppd->hDevMode == 0) {
2315 TRACE(" No hDevMode yet... Need to create my own\n");
2316 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE,
2317 lpdm->dmSize + lpdm->dmDriverExtra);
2318 } else {
2319 WORD locks;
2320 if((locks = (GlobalFlags(lppd->hDevMode) & GMEM_LOCKCOUNT))) {
2321 WARN("hDevMode has %d locks on it. Unlocking it now\n", locks);
2322 while(locks--) {
2323 GlobalUnlock(lppd->hDevMode);
2324 TRACE("Now got %d locks\n", locks);
2325 }
2326 }
2327 lppd->hDevMode = GlobalReAlloc(lppd->hDevMode,
2328 lpdm->dmSize + lpdm->dmDriverExtra,
2329 GMEM_MOVEABLE);
2330 }
2331 lpdmReturn = GlobalLock(lppd->hDevMode);
2332 memcpy(lpdmReturn, lpdm, lpdm->dmSize + lpdm->dmDriverExtra);
2333
2334 if (lppd->hDevNames != 0) {
2335 WORD locks;
2336 if((locks = (GlobalFlags(lppd->hDevNames) & GMEM_LOCKCOUNT))) {
2337 WARN("hDevNames has %d locks on it. Unlocking it now\n", locks);
2338 while(locks--)
2339 GlobalUnlock(lppd->hDevNames);
2340 }
2341 }
2342 PRINTDLG_CreateDevNamesW(&(lppd->hDevNames),
2343 di->pDriverPath,
2344 pi->pPrinterName,
2345 pi->pPortName
2346 );
2347 GlobalUnlock(lppd->hDevMode);
2348 }
2349 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
2350 HeapFree(GetProcessHeap(), 0, PrintStructures->lpPrinterInfo);
2351 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDriverInfo);
2352 HeapFree(GetProcessHeap(), 0, PrintStructures);
2353 }
2354 if(bRet && (lppd->Flags & PD_RETURNDC || lppd->Flags & PD_RETURNIC))
2355 bRet = PRINTDLG_CreateDCW(lppd);
2356
2357 TRACE("exit! (%d)\n", bRet);
2358 return bRet;
2359 }
2360
2361 /***********************************************************************
2362 *
2363 * PageSetupDlg
2364 * rad1 - portrait
2365 * rad2 - landscape
2366 * cmb1 - printer select (not in standard dialog template)
2367 * cmb2 - paper size
2368 * cmb3 - source (tray?)
2369 * edt4 - border left
2370 * edt5 - border top
2371 * edt6 - border right
2372 * edt7 - border bottom
2373 * psh3 - "Printer..."
2374 */
2375
2376 typedef struct
2377 {
2378 BOOL unicode;
2379 union
2380 {
2381 LPPAGESETUPDLGA dlga;
2382 LPPAGESETUPDLGW dlgw;
2383 } u;
2384 HWND hDlg; /* Page Setup dialog handle */
2385 RECT rtDrawRect; /* Drawing rect for page */
2386 } pagesetup_data;
2387
2388 static inline DWORD pagesetup_get_flags(const pagesetup_data *data)
2389 {
2390 return data->u.dlgw->Flags;
2391 }
2392
2393 static inline BOOL is_metric(const pagesetup_data *data)
2394 {
2395 return pagesetup_get_flags(data) & PSD_INHUNDREDTHSOFMILLIMETERS;
2396 }
2397
2398 static inline LONG tenths_mm_to_size(const pagesetup_data *data, LONG size)
2399 {
2400 if (is_metric(data))
2401 return 10 * size;
2402 else
2403 return 10 * size * 100 / 254;
2404 }
2405
2406 static inline LONG thousandths_inch_to_size(const pagesetup_data *data, LONG size)
2407 {
2408 if (is_metric(data))
2409 return size * 254 / 100;
2410 else
2411 return size;
2412 }
2413
2414 static WCHAR get_decimal_sep(void)
2415 {
2416 static WCHAR sep;
2417
2418 if(!sep)
2419 {
2420 WCHAR buf[2] = {'.',0};
2421 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buf, sizeof(buf) / sizeof(buf[0]));
2422 sep = buf[0];
2423 }
2424 return sep;
2425 }
2426
2427 static void size2str(const pagesetup_data *data, DWORD size, LPWSTR strout)
2428 {
2429 WCHAR integer_fmt[] = {'%','d',0};
2430 WCHAR hundredths_fmt[] = {'%','d','%','c','%','0','2','d',0};
2431 WCHAR thousandths_fmt[] = {'%','d','%','c','%','0','3','d',0};
2432
2433 /* FIXME use LOCALE_SDECIMAL when the edit parsing code can cope */
2434
2435 if (is_metric(data))
2436 {
2437 if(size % 100)
2438 wsprintfW(strout, hundredths_fmt, size / 100, get_decimal_sep(), size % 100);
2439 else
2440 wsprintfW(strout, integer_fmt, size / 100);
2441 }
2442 else
2443 {
2444 if(size % 1000)
2445 wsprintfW(strout, thousandths_fmt, size / 1000, get_decimal_sep(), size % 1000);
2446 else
2447 wsprintfW(strout, integer_fmt, size / 1000);
2448
2449 }
2450 }
2451
2452 static inline BOOL is_default_metric(void)
2453 {
2454 DWORD system;
2455 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IMEASURE | LOCALE_RETURN_NUMBER,
2456 (LPWSTR)&system, sizeof(system));
2457 return system == 0;
2458 }
2459
2460 /**********************************************
2461 * rotate_rect
2462 * Cyclically permute the four members of rc
2463 * If sense is TRUE l -> t -> r -> b
2464 * otherwise l <- t <- r <- b
2465 */
2466 static inline void rotate_rect(RECT *rc, BOOL sense)
2467 {
2468 INT tmp;
2469 if(sense)
2470 {
2471 tmp = rc->bottom;
2472 rc->bottom = rc->right;
2473 rc->right = rc->top;
2474 rc->top = rc->left;
2475 rc->left = tmp;
2476 }
2477 else
2478 {
2479 tmp = rc->left;
2480 rc->left = rc->top;
2481 rc->top = rc->right;
2482 rc->right = rc->bottom;
2483 rc->bottom = tmp;
2484 }
2485 }
2486
2487 static void pagesetup_set_orientation(pagesetup_data *data, WORD orient)
2488 {
2489 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2490
2491 assert(orient == DMORIENT_PORTRAIT || orient == DMORIENT_LANDSCAPE);
2492
2493 if(data->unicode)
2494 dm->u1.s1.dmOrientation = orient;
2495 else
2496 {
2497 DEVMODEA *dmA = (DEVMODEA *)dm;
2498 dmA->u1.s1.dmOrientation = orient;
2499 }
2500 GlobalUnlock(data->u.dlgw->hDevMode);
2501 }
2502
2503 static WORD pagesetup_get_orientation(const pagesetup_data *data)
2504 {
2505 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2506 WORD orient;
2507
2508 if(data->unicode)
2509 orient = dm->u1.s1.dmOrientation;
2510 else
2511 {
2512 DEVMODEA *dmA = (DEVMODEA *)dm;
2513 orient = dmA->u1.s1.dmOrientation;
2514 }
2515 GlobalUnlock(data->u.dlgw->hDevMode);
2516 return orient;
2517 }
2518
2519 static void pagesetup_set_papersize(pagesetup_data *data, WORD paper)
2520 {
2521 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2522
2523 if(data->unicode)
2524 dm->u1.s1.dmPaperSize = paper;
2525 else
2526 {
2527 DEVMODEA *dmA = (DEVMODEA *)dm;
2528 dmA->u1.s1.dmPaperSize = paper;
2529 }
2530 GlobalUnlock(data->u.dlgw->hDevMode);
2531 }
2532
2533 static WORD pagesetup_get_papersize(const pagesetup_data *data)
2534 {
2535 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2536 WORD paper;
2537
2538 if(data->unicode)
2539 paper = dm->u1.s1.dmPaperSize;
2540 else
2541 {
2542 DEVMODEA *dmA = (DEVMODEA *)dm;
2543 paper = dmA->u1.s1.dmPaperSize;
2544 }
2545 GlobalUnlock(data->u.dlgw->hDevMode);
2546 return paper;
2547 }
2548
2549 static void pagesetup_set_defaultsource(pagesetup_data *data, WORD source)
2550 {
2551 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2552
2553 if(data->unicode)
2554 dm->u1.s1.dmDefaultSource = source;
2555 else
2556 {
2557 DEVMODEA *dmA = (DEVMODEA *)dm;
2558 dmA->u1.s1.dmDefaultSource = source;
2559 }
2560 GlobalUnlock(data->u.dlgw->hDevMode);
2561 }
2562
2563 typedef enum
2564 {
2565 devnames_driver_name,
2566 devnames_device_name,
2567 devnames_output_name
2568 } devnames_name;
2569
2570
2571 static inline WORD get_devname_offset(const DEVNAMES *dn, devnames_name which)
2572 {
2573 switch(which)
2574 {
2575 case devnames_driver_name: return dn->wDriverOffset;
2576 case devnames_device_name: return dn->wDeviceOffset;
2577 case devnames_output_name: return dn->wOutputOffset;
2578 }
2579 ERR("Souldn't be here\n");
2580 return 0;
2581 }
2582
2583 static WCHAR *pagesetup_get_a_devname(const pagesetup_data *data, devnames_name which)
2584 {
2585 DEVNAMES *dn;
2586 WCHAR *name;
2587
2588 dn = GlobalLock(data->u.dlgw->hDevNames);
2589 if(data->unicode)
2590 name = strdupW((WCHAR *)dn + get_devname_offset(dn, which));
2591 else
2592 {
2593 int len = MultiByteToWideChar(CP_ACP, 0, (char*)dn + get_devname_offset(dn, which), -1, NULL, 0);
2594 name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2595 MultiByteToWideChar(CP_ACP, 0, (char*)dn + get_devname_offset(dn, which), -1, name, len);
2596 }
2597 GlobalUnlock(data->u.dlgw->hDevNames);
2598 return name;
2599 }
2600
2601 static WCHAR *pagesetup_get_drvname(const pagesetup_data *data)
2602 {
2603 return pagesetup_get_a_devname(data, devnames_driver_name);
2604 }
2605
2606 static WCHAR *pagesetup_get_devname(const pagesetup_data *data)
2607 {
2608 return pagesetup_get_a_devname(data, devnames_device_name);
2609 }
2610
2611 static WCHAR *pagesetup_get_portname(const pagesetup_data *data)
2612 {
2613 return pagesetup_get_a_devname(data, devnames_output_name);
2614 }
2615
2616 static void pagesetup_release_a_devname(const pagesetup_data *data, WCHAR *name)
2617 {
2618 HeapFree(GetProcessHeap(), 0, name);
2619 }
2620
2621 static void pagesetup_set_devnames(pagesetup_data *data, LPCWSTR drv, LPCWSTR devname, LPCWSTR port)
2622 {
2623 DEVNAMES *dn;
2624 WCHAR def[256];
2625 DWORD len = sizeof(DEVNAMES), drv_len, dev_len, port_len;
2626
2627 if(data->unicode)
2628 {
2629 drv_len = (strlenW(drv) + 1) * sizeof(WCHAR);
2630 dev_len = (strlenW(devname) + 1) * sizeof(WCHAR);
2631 port_len = (strlenW(port) + 1) * sizeof(WCHAR);
2632 }
2633 else
2634 {
2635 drv_len = WideCharToMultiByte(CP_ACP, 0, drv, -1, NULL, 0, NULL, NULL);
2636 dev_len = WideCharToMultiByte(CP_ACP, 0, devname, -1, NULL, 0, NULL, NULL);
2637 port_len = WideCharToMultiByte(CP_ACP, 0, port, -1, NULL, 0, NULL, NULL);
2638 }
2639 len += drv_len + dev_len + port_len;
2640
2641 if(data->u.dlgw->hDevNames)
2642 data->u.dlgw->hDevNames = GlobalReAlloc(data->u.dlgw->hDevNames, len, GMEM_MOVEABLE);
2643 else
2644 data->u.dlgw->hDevNames = GlobalAlloc(GMEM_MOVEABLE, len);
2645
2646 dn = GlobalLock(data->u.dlgw->hDevNames);
2647
2648 if(data->unicode)
2649 {
2650 WCHAR *ptr = (WCHAR *)(dn + 1);
2651 len = sizeof(DEVNAMES) / sizeof(WCHAR);
2652 dn->wDriverOffset = len;
2653 strcpyW(ptr, drv);
2654 ptr += drv_len / sizeof(WCHAR);
2655 len += drv_len / sizeof(WCHAR);
2656 dn->wDeviceOffset = len;
2657 strcpyW(ptr, devname);
2658 ptr += dev_len / sizeof(WCHAR);
2659 len += dev_len / sizeof(WCHAR);
2660 dn->wOutputOffset = len;
2661 strcpyW(ptr, port);
2662 }
2663 else
2664 {
2665 char *ptr = (char *)(dn + 1);
2666 len = sizeof(DEVNAMES);
2667 dn->wDriverOffset = len;
2668 WideCharToMultiByte(CP_ACP, 0, drv, -1, ptr, drv_len, NULL, NULL);
2669 ptr += drv_len;
2670 len += drv_len;
2671 dn->wDeviceOffset = len;
2672 WideCharToMultiByte(CP_ACP, 0, devname, -1, ptr, dev_len, NULL, NULL);
2673 ptr += dev_len;
2674 len += dev_len;
2675 dn->wOutputOffset = len;
2676 WideCharToMultiByte(CP_ACP, 0, port, -1, ptr, port_len, NULL, NULL);
2677 }
2678
2679 dn->wDefault = 0;
2680 len = sizeof(def) / sizeof(def[0]);
2681 GetDefaultPrinterW(def, &len);
2682 if(!lstrcmpW(def, devname))
2683 dn->wDefault = 1;
2684
2685 GlobalUnlock(data->u.dlgw->hDevNames);
2686 }
2687
2688 static DEVMODEW *pagesetup_get_devmode(const pagesetup_data *data)
2689 {
2690 DEVMODEW *dm = GlobalLock(data->u.dlgw->hDevMode);
2691 DEVMODEW *ret;
2692
2693 if(data->unicode)
2694 {
2695 /* We make a copy even in the unicode case because the ptr
2696 may get passed back to us in pagesetup_set_devmode. */
2697 ret = HeapAlloc(GetProcessHeap(), 0, dm->dmSize + dm->dmDriverExtra);
2698 memcpy(ret, dm, dm->dmSize + dm->dmDriverExtra);
2699 }
2700 else
2701 ret = GdiConvertToDevmodeW((DEVMODEA *)dm);
2702
2703 GlobalUnlock(data->u.dlgw->hDevMode);
2704 return ret;
2705 }
2706
2707 static void pagesetup_release_devmode(const pagesetup_data *data, DEVMODEW *dm)
2708 {
2709 HeapFree(GetProcessHeap(), 0, dm);
2710 }
2711
2712 static void pagesetup_set_devmode(pagesetup_data *data, DEVMODEW *dm)
2713 {
2714 DEVMODEA *dmA = NULL;
2715 void *src, *dst;
2716 DWORD size;
2717
2718 if(data->unicode)
2719 {
2720 size = dm->dmSize + dm->dmDriverExtra;
2721 src = dm;
2722 }
2723 else
2724 {
2725 dmA = convert_to_devmodeA(dm);
2726 size = dmA->dmSize + dmA->dmDriverExtra;
2727 src = dmA;
2728 }
2729
2730 if(data->u.dlgw->hDevMode)
2731 data->u.dlgw->hDevMode = GlobalReAlloc(data->u.dlgw->hDevMode, size,
2732 GMEM_MOVEABLE);
2733 else
2734 data->u.dlgw->hDevMode = GlobalAlloc(GMEM_MOVEABLE, size);
2735
2736 dst = GlobalLock(data->u.dlgw->hDevMode);
2737 memcpy(dst, src, size);
2738 GlobalUnlock(data->u.dlgw->hDevMode);
2739 HeapFree(GetProcessHeap(), 0, dmA);
2740 }
2741
2742 static inline POINT *pagesetup_get_papersize_pt(const pagesetup_data *data)
2743 {
2744 return &data->u.dlgw->ptPaperSize;
2745 }
2746
2747 static inline RECT *pagesetup_get_margin_rect(const pagesetup_data *data)
2748 {
2749 return &data->u.dlgw->rtMargin;
2750 }
2751
2752 typedef enum
2753 {
2754 page_setup_hook,
2755 page_paint_hook
2756 } hook_type;
2757
2758 static inline LPPAGESETUPHOOK pagesetup_get_hook(const pagesetup_data *data, hook_type which)
2759 {
2760 switch(which)
2761 {
2762 case page_setup_hook: return data->u.dlgw->lpfnPageSetupHook;
2763 case page_paint_hook: return data->u.dlgw->lpfnPagePaintHook;
2764 }
2765 return NULL;
2766 }
2767
2768 /* This should only be used in calls to hook procs so we return the ptr
2769 already cast to LPARAM */
2770 static inline LPARAM pagesetup_get_dlg_struct(const pagesetup_data *data)
2771 {
2772 return (LPARAM)data->u.dlgw;
2773 }
2774
2775 static inline void swap_point(POINT *pt)
2776 {
2777 LONG tmp = pt->x;
2778 pt->x = pt->y;
2779 pt->y = tmp;
2780 }
2781
2782 static BOOL pagesetup_update_papersize(pagesetup_data *data)
2783 {
2784 DEVMODEW *dm;
2785 LPWSTR devname, portname;
2786 int i, num;
2787 WORD *words = NULL, paperword;
2788 POINT *points = NULL;
2789 BOOL retval = FALSE;
2790
2791 dm = pagesetup_get_devmode(data);
2792 devname = pagesetup_get_devname(data);
2793 portname = pagesetup_get_portname(data);
2794
2795 num = DeviceCapabilitiesW(devname, portname, DC_PAPERS, NULL, dm);
2796 if (num <= 0)
2797 {
2798 FIXME("No papernames found for %s/%s\n", debugstr_w(devname), debugstr_w(portname));
2799 goto end;
2800 }
2801
2802 words = HeapAlloc(GetProcessHeap(), 0, num * sizeof(WORD));
2803 points = HeapAlloc(GetProcessHeap(), 0, num * sizeof(POINT));
2804
2805 if (num != DeviceCapabilitiesW(devname, portname, DC_PAPERS, (LPWSTR)words, dm))
2806 {
2807 FIXME("Number of returned words is not %d\n", num);
2808 goto end;
2809 }
2810
2811 if (num != DeviceCapabilitiesW(devname, portname, DC_PAPERSIZE, (LPWSTR)points, dm))
2812 {
2813 FIXME("Number of returned sizes is not %d\n", num);
2814 goto end;
2815 }
2816
2817 paperword = pagesetup_get_papersize(data);
2818
2819 for (i = 0; i < num; i++)
2820 if (words[i] == paperword)
2821 break;
2822
2823 if (i == num)
2824 {
2825 FIXME("Papersize %d not found in list?\n", paperword);
2826 goto end;
2827 }
2828
2829 /* this is _10ths_ of a millimeter */
2830 pagesetup_get_papersize_pt(data)->x = tenths_mm_to_size(data, points[i].x);
2831 pagesetup_get_papersize_pt(data)->y = tenths_mm_to_size(data, points[i].y);
2832
2833 if(pagesetup_get_orientation(data) == DMORIENT_LANDSCAPE)
2834 swap_point(pagesetup_get_papersize_pt(data));
2835
2836 retval = TRUE;
2837
2838 end:
2839 HeapFree(GetProcessHeap(), 0, words);
2840 HeapFree(GetProcessHeap(), 0, points);
2841 pagesetup_release_a_devname(data, portname);
2842 pagesetup_release_a_devname(data, devname);
2843 pagesetup_release_devmode(data, dm);
2844
2845 return retval;
2846 }
2847
2848 /**********************************************************************************************
2849 * pagesetup_change_printer
2850 *
2851 * Redefines hDevMode and hDevNames HANDLES and initialises it.
2852 *
2853 */
2854 static BOOL pagesetup_change_printer(LPWSTR name, pagesetup_data *data)
2855 {
2856 HANDLE hprn;
2857 DWORD needed;
2858 PRINTER_INFO_2W *prn_info = NULL;
2859 DRIVER_INFO_3W *drv_info = NULL;
2860 DEVMODEW *dm = NULL;
2861 BOOL retval = FALSE;
2862
2863 if(!OpenPrinterW(name, &hprn, NULL))
2864 {
2865 ERR("Can't open printer %s\n", debugstr_w(name));
2866 goto end;
2867 }
2868
2869 GetPrinterW(hprn, 2, NULL, 0, &needed);
2870 prn_info = HeapAlloc(GetProcessHeap(), 0, needed);
2871 GetPrinterW(hprn, 2, (LPBYTE)prn_info, needed, &needed);
2872 GetPrinterDriverW(hprn, NULL, 3, NULL, 0, &needed);
2873 drv_info = HeapAlloc(GetProcessHeap(), 0, needed);
2874 if(!GetPrinterDriverW(hprn, NULL, 3, (LPBYTE)drv_info, needed, &needed))
2875 {
2876 ERR("GetPrinterDriverA failed for %s, fix your config!\n", debugstr_w(prn_info->pPrinterName));
2877 goto end;
2878 }
2879 ClosePrinter(hprn);
2880
2881 needed = DocumentPropertiesW(0, 0, name, NULL, NULL, 0);
2882 if(needed == -1)
2883 {
2884 ERR("DocumentProperties fails on %s\n", debugstr_w(name));
2885 goto end;
2886 }
2887
2888 dm = HeapAlloc(GetProcessHeap(), 0, needed);
2889 DocumentPropertiesW(0, 0, name, dm, NULL, DM_OUT_BUFFER);
2890
2891 pagesetup_set_devmode(data, dm);
2892 pagesetup_set_devnames(data, drv_info->pDriverPath, prn_info->pPrinterName,
2893 prn_info->pPortName);
2894
2895 retval = TRUE;
2896 end:
2897 HeapFree(GetProcessHeap(), 0, dm);
2898 HeapFree(GetProcessHeap(), 0, prn_info);
2899 HeapFree(GetProcessHeap(), 0, drv_info);
2900 return retval;
2901 }
2902
2903 /****************************************************************************************
2904 * pagesetup_init_combos
2905 *
2906 * Fills Printers, Paper and Source combos
2907 *
2908 */
2909 static void pagesetup_init_combos(HWND hDlg, pagesetup_data *data)
2910 {
2911 DEVMODEW *dm;
2912 LPWSTR devname, portname;
2913
2914 dm = pagesetup_get_devmode(data);
2915 devname = pagesetup_get_devname(data);
2916 portname = pagesetup_get_portname(data);
2917
2918 PRINTDLG_SetUpPrinterListComboW(hDlg, cmb1, devname);
2919 PRINTDLG_SetUpPaperComboBoxW(hDlg, cmb2, devname, portname, dm);
2920 PRINTDLG_SetUpPaperComboBoxW(hDlg, cmb3, devname, portname, dm);
2921
2922 pagesetup_release_a_devname(data, portname);
2923 pagesetup_release_a_devname(data, devname);
2924 pagesetup_release_devmode(data, dm);
2925 }
2926
2927
2928 /****************************************************************************************
2929 * pagesetup_change_printer_dialog
2930 *
2931 * Pops up another dialog that lets the user pick another printer.
2932 *
2933 * For now we display the PrintDlg, this should display a striped down version of it.
2934 */
2935 static void pagesetup_change_printer_dialog(HWND hDlg, pagesetup_data *data)
2936 {
2937 PRINTDLGW prnt;
2938 LPWSTR drvname, devname, portname;
2939 DEVMODEW *tmp_dm, *dm;
2940
2941 memset(&prnt, 0, sizeof(prnt));
2942 prnt.lStructSize = sizeof(prnt);
2943 prnt.Flags = 0;
2944 prnt.hwndOwner = hDlg;
2945
2946 drvname = pagesetup_get_drvname(data);
2947 devname = pagesetup_get_devname(data);
2948 portname = pagesetup_get_portname(data);
2949 prnt.hDevNames = 0;
2950 PRINTDLG_CreateDevNamesW(&prnt.hDevNames, drvname, devname, portname);
2951 pagesetup_release_a_devname(data, portname);
2952 pagesetup_release_a_devname(data, devname);
2953 pagesetup_release_a_devname(data, drvname);
2954
2955 tmp_dm = pagesetup_get_devmode(data);
2956 prnt.hDevMode = GlobalAlloc(GMEM_MOVEABLE, tmp_dm->dmSize + tmp_dm->dmDriverExtra);
2957 dm = GlobalLock(prnt.hDevMode);
2958 memcpy(dm, tmp_dm, tmp_dm->dmSize + tmp_dm->dmDriverExtra);
2959 GlobalUnlock(prnt.hDevMode);
2960 pagesetup_release_devmode(data, tmp_dm);
2961
2962 if (PrintDlgW(&prnt))
2963 {
2964 DEVMODEW *dm = GlobalLock(prnt.hDevMode);
2965 DEVNAMES *dn = GlobalLock(prnt.hDevNames);
2966
2967 pagesetup_set_devnames(data, (WCHAR*)dn + dn->wDriverOffset,
2968 (WCHAR*)dn + dn->wDeviceOffset, (WCHAR *)dn + dn->wOutputOffset);
2969 pagesetup_set_devmode(data, dm);
2970 GlobalUnlock(prnt.hDevNames);
2971 GlobalUnlock(prnt.hDevMode);
2972 pagesetup_init_combos(hDlg, data);
2973 }
2974
2975 GlobalFree(prnt.hDevMode);
2976 GlobalFree(prnt.hDevNames);
2977
2978 }
2979
2980 /******************************************************************************************
2981 * pagesetup_change_preview
2982 *
2983 * Changes paper preview size / position
2984 *
2985 */
2986 static void pagesetup_change_preview(const pagesetup_data *data)
2987 {
2988 LONG width, height, x, y;
2989 RECT tmp;
2990 const int shadow = 4;
2991
2992 if(pagesetup_get_orientation(data) == DMORIENT_LANDSCAPE)
2993 {
2994 width = data->rtDrawRect.right - data->rtDrawRect.left;
2995 height = pagesetup_get_papersize_pt(data)->y * width / pagesetup_get_papersize_pt(data)->x;
2996 }
2997 else
2998 {
2999 height = data->rtDrawRect.bottom - data->rtDrawRect.top;
3000 width = pagesetup_get_papersize_pt(data)->x * height / pagesetup_get_papersize_pt(data)->y;
3001 }
3002 x = (data->rtDrawRect.right + data->rtDrawRect.left - width) / 2;
3003 y = (data->rtDrawRect.bottom + data->rtDrawRect.top - height) / 2;
3004 TRACE("draw rect %s x=%d, y=%d, w=%d, h=%d\n",
3005 wine_dbgstr_rect(&data->rtDrawRect), x, y, width, height);
3006
3007 MoveWindow(GetDlgItem(data->hDlg, rct2), x + width, y + shadow, shadow, height, FALSE);
3008 MoveWindow(GetDlgItem(data->hDlg, rct3), x + shadow, y + height, width, shadow, FALSE);
3009 MoveWindow(GetDlgItem(data->hDlg, rct1), x, y, width, height, FALSE);
3010
3011 tmp = data->rtDrawRect;
3012 tmp.right += shadow;
3013 tmp.bottom += shadow;
3014 InvalidateRect(data->hDlg, &tmp, TRUE);
3015 }
3016
3017 static inline LONG *element_from_margin_id(RECT *rc, WORD id)
3018 {
3019 switch(id)
3020 {
3021 case edt4: return &rc->left;
3022 case edt5: return &rc->top;
3023 case edt6: return &rc->right;
3024 case edt7: return &rc->bottom;
3025 }
3026 return NULL;
3027 }
3028
3029 static void update_margin_edits(HWND hDlg, const pagesetup_data *data, WORD id)
3030 {
3031 WCHAR str[100];
3032 WORD idx;
3033
3034 for(idx = edt4; idx <= edt7; idx++)
3035 {
3036 if(id == 0 || id == idx)
3037 {
3038 size2str(data, *element_from_margin_id(pagesetup_get_margin_rect(data), idx), str);
3039 SetDlgItemTextW(hDlg, idx, str);
3040 }
3041 }
3042 }
3043
3044 static void margin_edit_notification(HWND hDlg, const pagesetup_data *data, WORD msg, WORD id)
3045 {
3046 switch (msg)
3047 {
3048 case EN_CHANGE:
3049 {
3050 WCHAR buf[10];
3051 LONG val = 0;
3052 LONG *value = element_from_margin_id(pagesetup_get_margin_rect(data), id);
3053
3054 if (GetDlgItemTextW(hDlg, id, buf, sizeof(buf) / sizeof(buf[0])) != 0)
3055 {
3056 WCHAR *end;
3057 WCHAR decimal = get_decimal_sep();
3058
3059 val = strtolW(buf, &end, 10);
3060 if(end != buf || *end == decimal)
3061 {
3062 int mult = is_metric(data) ? 100 : 1000;
3063 val *= mult;
3064 if(*end == decimal)
3065 {
3066 while(mult > 1)
3067 {
3068 end++;
3069 mult /= 10;
3070 if(isdigitW(*end))
3071 val += (*end - '0') * mult;
3072 else
3073 break;
3074 }
3075 }
3076 }
3077 }
3078 *value = val;
3079 return;
3080 }
3081
3082 case EN_KILLFOCUS:
3083 update_margin_edits(hDlg, data, id);
3084 return;
3085 }
3086 }
3087
3088 static void set_margin_groupbox_title(HWND hDlg, const pagesetup_data *data)
3089 {
3090 WCHAR title[256];
3091
3092 if(LoadStringW(COMDLG32_hInstance, is_metric(data) ? PD32_MARGINS_IN_MILLIMETERS : PD32_MARGINS_IN_INCHES,
3093 title, sizeof(title)/sizeof(title[0])))
3094 SetDlgItemTextW(hDlg, grp4, title);
3095 }
3096
3097 static void pagesetup_update_orientation_buttons(HWND hDlg, const pagesetup_data *data)
3098 {
3099 if (pagesetup_get_orientation(data) == DMORIENT_LANDSCAPE)
3100 CheckRadioButton(hDlg, rad1, rad2, rad2);
3101 else
3102 CheckRadioButton(hDlg, rad1, rad2, rad1);
3103 }
3104
3105 /****************************************************************************************
3106 * pagesetup_printer_properties
3107 *
3108 * Handle invocation of the 'Properties' button (not present in the default template).
3109 */
3110 static void pagesetup_printer_properties(HWND hDlg, pagesetup_data *data)
3111 {
3112 HANDLE hprn;
3113 LPWSTR devname;
3114 DEVMODEW *dm;
3115 LRESULT count;
3116 int i;
3117
3118 devname = pagesetup_get_devname(data);
3119
3120 if (!OpenPrinterW(devname, &hprn, NULL))
3121 {
3122 FIXME("Call to OpenPrinter did not succeed!\n");
3123 pagesetup_release_a_devname(data, devname);
3124 return;
3125 }
3126
3127 dm = pagesetup_get_devmode(data);
3128 DocumentPropertiesW(hDlg, hprn, devname, dm, dm, DM_IN_BUFFER | DM_OUT_BUFFER | DM_IN_PROMPT);
3129 pagesetup_set_devmode(data, dm);
3130 pagesetup_release_devmode(data, dm);
3131 pagesetup_release_a_devname(data, devname);
3132 ClosePrinter(hprn);
3133
3134 /* Changing paper */
3135 pagesetup_update_papersize(data);
3136 pagesetup_update_orientation_buttons(hDlg, data);
3137
3138 /* Changing paper preview */
3139 pagesetup_change_preview(data);
3140
3141 /* Selecting paper in combo */
3142 count = SendDlgItemMessageW(hDlg, cmb2, CB_GETCOUNT, 0, 0);
3143 if(count != CB_ERR)
3144 {
3145 WORD paperword = pagesetup_get_papersize(data);
3146 for(i = 0; i < count; i++)
3147 {
3148 if(SendDlgItemMessageW(hDlg, cmb2, CB_GETITEMDATA, i, 0) == paperword) {
3149 SendDlgItemMessageW(hDlg, cmb2, CB_SETCURSEL, i, 0);
3150 break;
3151 }
3152 }
3153 }
3154 }
3155
3156 /********************************************************************************
3157 * pagesetup_wm_command
3158 * process WM_COMMAND message for PageSetupDlg
3159 *
3160 * PARAMS
3161 * hDlg [in] Main dialog HANDLE
3162 * wParam [in] WM_COMMAND wParam
3163 * lParam [in] WM_COMMAND lParam
3164 * pda [in/out] ptr to PageSetupDataA
3165 */
3166
3167 static BOOL pagesetup_wm_command(HWND hDlg, WPARAM wParam, LPARAM lParam, pagesetup_data *data)
3168 {
3169 WORD msg = HIWORD(wParam);
3170 WORD id = LOWORD(wParam);
3171
3172 TRACE("loword (lparam) %d, wparam 0x%lx, lparam %08lx\n",
3173 LOWORD(lParam),wParam,lParam);
3174 switch (id) {
3175 case IDOK:
3176 EndDialog(hDlg, TRUE);
3177 return TRUE ;
3178
3179 case IDCANCEL:
3180 EndDialog(hDlg, FALSE);
3181 return FALSE ;
3182
3183 case psh3: /* Printer... */
3184 pagesetup_change_printer_dialog(hDlg, data);
3185 return TRUE;
3186
3187 case rad1: /* Portrait */
3188 case rad2: /* Landscape */
3189 if((id == rad1 && pagesetup_get_orientation(data) == DMORIENT_LANDSCAPE) ||
3190 (id == rad2 && pagesetup_get_orientation(data) == DMORIENT_PORTRAIT))
3191 {
3192 pagesetup_set_orientation(data, (id == rad1) ? DMORIENT_PORTRAIT : DMORIENT_LANDSCAPE);
3193 pagesetup_update_papersize(data);
3194 rotate_rect(pagesetup_get_margin_rect(data), (id == rad2));
3195 update_margin_edits(hDlg, data, 0);
3196 pagesetup_change_preview(data);
3197 }
3198 break;
3199 case cmb1: /* Printer combo */
3200 if(msg == CBN_SELCHANGE)
3201 {
3202 WCHAR name[256];
3203 GetDlgItemTextW(hDlg, id, name, sizeof(name) / sizeof(name[0]));
3204 pagesetup_change_printer(name, data);
3205 pagesetup_init_combos(hDlg, data);
3206 }
3207 break;
3208 case cmb2: /* Paper combo */
3209 if(msg == CBN_SELCHANGE)
3210 {
3211 DWORD paperword = SendDlgItemMessageW(hDlg, cmb2, CB_GETITEMDATA,
3212 SendDlgItemMessageW(hDlg, cmb2, CB_GETCURSEL, 0, 0), 0);
3213 if (paperword != CB_ERR)
3214 {
3215 pagesetup_set_papersize(data, paperword);
3216 pagesetup_update_papersize(data);
3217 pagesetup_change_preview(data);
3218 } else
3219 FIXME("could not get dialog text for papersize cmbbox?\n");
3220 }
3221 break;
3222 case cmb3: /* Paper Source */
3223 if(msg == CBN_SELCHANGE)
3224 {
3225 WORD source = SendDlgItemMessageW(hDlg, cmb3, CB_GETITEMDATA,
3226 SendDlgItemMessageW(hDlg, cmb3, CB_GETCURSEL, 0, 0), 0);
3227 pagesetup_set_defaultsource(data, source);
3228 }
3229 break;
3230 case psh2: /* Printer Properties button */
3231 pagesetup_printer_properties(hDlg, data);
3232 break;
3233 case edt4:
3234 case edt5:
3235 case edt6:
3236 case edt7:
3237 margin_edit_notification(hDlg, data, msg, id);
3238 break;
3239 }
3240 InvalidateRect(GetDlgItem(hDlg, rct1), NULL, TRUE);
3241 return FALSE;
3242 }
3243
3244 /***********************************************************************
3245 * default_page_paint_hook
3246 * Default hook paint procedure that receives WM_PSD_* messages from the dialog box
3247 * whenever the sample page is redrawn.
3248 */
3249 static UINT_PTR default_page_paint_hook(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam,
3250 const pagesetup_data *data)
3251 {
3252 LPRECT lprc = (LPRECT) lParam;
3253 HDC hdc = (HDC) wParam;
3254 HPEN hpen, holdpen;
3255 LOGFONTW lf;
3256 HFONT hfont, holdfont;
3257 INT oldbkmode;
3258 TRACE("uMsg: WM_USER+%d\n",uMsg-WM_USER);
3259 /* Call user paint hook if enable */
3260 if (pagesetup_get_flags(data) & PSD_ENABLEPAGEPAINTHOOK)
3261 if (pagesetup_get_hook(data, page_paint_hook)(hwndDlg, uMsg, wParam, lParam))
3262 return TRUE;
3263
3264 switch (uMsg) {
3265 /* LPPAGESETUPDLG in lParam */
3266 case WM_PSD_PAGESETUPDLG:
3267 /* Inform about the sample page rectangle */
3268 case WM_PSD_FULLPAGERECT:
3269 /* Inform about the margin rectangle */
3270 case WM_PSD_MINMARGINRECT:
3271 return FALSE;
3272
3273 /* Draw dashed rectangle showing margins */
3274 case WM_PSD_MARGINRECT:
3275 hpen = CreatePen(PS_DASH, 1, GetSysColor(COLOR_3DSHADOW));
3276 holdpen = SelectObject(hdc, hpen);
3277 Rectangle(hdc, lprc->left, lprc->top, lprc->right, lprc->bottom);
3278 DeleteObject(SelectObject(hdc, holdpen));
3279 return TRUE;
3280 /* Draw the fake document */
3281 case WM_PSD_GREEKTEXTRECT:
3282 /* select a nice scalable font, because we want the text really small */
3283 SystemParametersInfoW(SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0);
3284 lf.lfHeight = 6; /* value chosen based on visual effect */
3285 hfont = CreateFontIndirectW(&lf);
3286 holdfont = SelectObject(hdc, hfont);
3287
3288 /* if text not loaded, then do so now */
3289 if (wszFakeDocumentText[0] == '\0')
3290 LoadStringW(COMDLG32_hInstance,
3291 IDS_FAKEDOCTEXT,
3292 wszFakeDocumentText,
3293 sizeof(wszFakeDocumentText)/sizeof(wszFakeDocumentText[0]));
3294
3295 oldbkmode = SetBkMode(hdc, TRANSPARENT);
3296 DrawTextW(hdc, wszFakeDocumentText, -1, lprc, DT_TOP|DT_LEFT|DT_NOPREFIX|DT_WORDBREAK);
3297 SetBkMode(hdc, oldbkmode);
3298
3299 DeleteObject(SelectObject(hdc, holdfont));
3300 return TRUE;
3301
3302 /* Envelope stamp */
3303 case WM_PSD_ENVSTAMPRECT:
3304 /* Return address */
3305 case WM_PSD_YAFULLPAGERECT:
3306 FIXME("envelope/stamp is not implemented\n");
3307 return FALSE;
3308 default:
3309 FIXME("Unknown message %x\n",uMsg);
3310 return FALSE;
3311 }
3312 return TRUE;
3313 }
3314
3315 /***********************************************************************
3316 * PagePaintProc
3317 * The main paint procedure for the PageSetupDlg function.
3318 * The Page Setup dialog box includes an image of a sample page that shows how
3319 * the user's selections affect the appearance of the printed output.
3320 * The image consists of a rectangle that represents the selected paper
3321 * or envelope type, with a dotted-line rectangle representing
3322 * the current margins, and partial (Greek text) characters
3323 * to show how text looks on the printed page.
3324 *
3325 * The following messages in the order sends to user hook procedure:
3326 * WM_PSD_PAGESETUPDLG Draw the contents of the sample page
3327 * WM_PSD_FULLPAGERECT Inform about the bounding rectangle
3328 * WM_PSD_MINMARGINRECT Inform about the margin rectangle (min margin?)
3329 * WM_PSD_MARGINRECT Draw the margin rectangle
3330 * WM_PSD_GREEKTEXTRECT Draw the Greek text inside the margin rectangle
3331 * If any of first three messages returns TRUE, painting done.
3332 *
3333 * PARAMS:
3334 * hWnd [in] Handle to the Page Setup dialog box
3335 * uMsg [in] Received message
3336 *
3337 * TODO:
3338 * WM_PSD_ENVSTAMPRECT Draw in the envelope-stamp rectangle (for envelopes only)
3339 * WM_PSD_YAFULLPAGERECT Draw the return address portion (for envelopes and other paper sizes)
3340 *
3341 * RETURNS:
3342 * FALSE if all done correctly
3343 *
3344 */
3345
3346
3347 static LRESULT CALLBACK
3348 PRINTDLG_PagePaintProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3349 {
3350 PAINTSTRUCT ps;
3351 RECT rcClient, rcMargin;
3352 HPEN hpen, holdpen;
3353 HDC hdc;
3354 HBRUSH hbrush, holdbrush;
3355 pagesetup_data *data;
3356 int papersize=0, orientation=0; /* FIXME: set this values for user paint hook */
3357 double scalx, scaly;
3358
3359 if (uMsg != WM_PAINT)
3360 return CallWindowProcA(lpfnStaticWndProc, hWnd, uMsg, wParam, lParam);
3361
3362 /* Processing WM_PAINT message */
3363 data = GetPropW(hWnd, pagesetupdlg_prop);
3364 if (!data) {
3365 WARN("__WINE_PAGESETUPDLGDATA prop not set?\n");
3366 return FALSE;
3367 }
3368 if (default_page_paint_hook(hWnd, WM_PSD_PAGESETUPDLG, MAKELONG(papersize, orientation),
3369 pagesetup_get_dlg_struct(data), data))
3370 return FALSE;
3371
3372 hdc = BeginPaint(hWnd, &ps);
3373 GetClientRect(hWnd, &rcClient);
3374
3375 scalx = rcClient.right / (double)pagesetup_get_papersize_pt(data)->x;
3376 scaly = rcClient.bottom / (double)pagesetup_get_papersize_pt(data)->y;
3377 rcMargin = rcClient;
3378
3379 rcMargin.left += pagesetup_get_margin_rect(data)->left * scalx;
3380 rcMargin.top += pagesetup_get_margin_rect(data)->top * scaly;
3381 rcMargin.right -= pagesetup_get_margin_rect(data)->right * scalx;
3382 rcMargin.bottom -= pagesetup_get_margin_rect(data)->bottom * scaly;
3383
3384 /* if the space is too small then we make sure to not draw anything */
3385 rcMargin.left = min(rcMargin.left, rcMargin.right);
3386 rcMargin.top = min(rcMargin.top, rcMargin.bottom);
3387
3388 if (!default_page_paint_hook(hWnd, WM_PSD_FULLPAGERECT, (WPARAM)hdc, (LPARAM)&rcClient, data) &&
3389 !default_page_paint_hook(hWnd, WM_PSD_MINMARGINRECT, (WPARAM)hdc, (LPARAM)&rcMargin, data) )
3390 {
3391 /* fill background */
3392 hbrush = GetSysColorBrush(COLOR_3DHIGHLIGHT);
3393 FillRect(hdc, &rcClient, hbrush);
3394 holdbrush = SelectObject(hdc, hbrush);
3395
3396 hpen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DSHADOW));
3397 holdpen = SelectObject(hdc, hpen);
3398
3399 /* paint left edge */
3400 MoveToEx(hdc, rcClient.left, rcClient.top, NULL);
3401 LineTo(hdc, rcClient.left, rcClient.bottom-1);
3402
3403 /* paint top edge */
3404 MoveToEx(hdc, rcClient.left, rcClient.top, NULL);
3405 LineTo(hdc, rcClient.right, rcClient.top);
3406
3407 hpen = CreatePen(PS_SOLID, 1, GetSysColor(COLOR_3DDKSHADOW));
3408 DeleteObject(SelectObject(hdc, hpen));
3409
3410 /* paint right edge */
3411 MoveToEx(hdc, rcClient.right-1, rcClient.top, NULL);
3412 LineTo(hdc, rcClient.right-1, rcClient.bottom);
3413
3414 /* paint bottom edge */
3415 MoveToEx(hdc, rcClient.left, rcClient.bottom-1, NULL);
3416 LineTo(hdc, rcClient.right, rcClient.bottom-1);
3417
3418 DeleteObject(SelectObject(hdc, holdpen));
3419 DeleteObject(SelectObject(hdc, holdbrush));
3420
3421 default_page_paint_hook(hWnd, WM_PSD_MARGINRECT, (WPARAM)hdc, (LPARAM)&rcMargin, data);
3422
3423 /* give text a bit of a space from the frame */
3424 rcMargin.left += 2;
3425 rcMargin.top += 2;
3426 rcMargin.right -= 2;
3427 rcMargin.bottom -= 2;
3428
3429 /* if the space is too small then we make sure to not draw anything */
3430 rcMargin.left = min(rcMargin.left, rcMargin.right);
3431 rcMargin.top = min(rcMargin.top, rcMargin.bottom);
3432
3433 default_page_paint_hook(hWnd, WM_PSD_GREEKTEXTRECT, (WPARAM)hdc, (LPARAM)&rcMargin, data);
3434 }
3435
3436 EndPaint(hWnd, &ps);
3437 return FALSE;
3438 }
3439
3440 /*******************************************************
3441 * The margin edit controls are subclassed to filter
3442 * anything other than numbers and the decimal separator.
3443 */
3444 static LRESULT CALLBACK pagesetup_margin_editproc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
3445 {
3446 if (msg == WM_CHAR)
3447 {
3448 WCHAR decimal = get_decimal_sep();
3449 WCHAR wc = (WCHAR)wparam;
3450 if(!isdigitW(wc) && wc != decimal && wc != VK_BACK) return 0;
3451 }
3452 return CallWindowProcW(edit_wndproc, hwnd, msg, wparam, lparam);
3453 }
3454
3455 static void subclass_margin_edits(HWND hDlg)
3456 {
3457 int id;
3458 WNDPROC old_proc;
3459
3460 for(id = edt4; id <= edt7; id++)
3461 {
3462 old_proc = (WNDPROC)SetWindowLongPtrW(GetDlgItem(hDlg, id),
3463 GWLP_WNDPROC,
3464 (ULONG_PTR)pagesetup_margin_editproc);
3465 InterlockedCompareExchangePointer((void**)&edit_wndproc, old_proc, NULL);
3466 }
3467 }
3468
3469 /***********************************************************************
3470 * pagesetup_dlg_proc
3471 *
3472 * Message handler for PageSetupDlg
3473 */
3474 static INT_PTR CALLBACK pagesetup_dlg_proc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
3475 {
3476 pagesetup_data *data;
3477 INT_PTR res = FALSE;
3478 HWND hDrawWnd;
3479
3480 if (uMsg == WM_INITDIALOG) { /*Init dialog*/
3481 data = (pagesetup_data *)lParam;
3482 data->hDlg = hDlg;
3483
3484 hDrawWnd = GetDlgItem(hDlg, rct1);
3485 TRACE("set property to %p\n", data);
3486 SetPropW(hDlg, pagesetupdlg_prop, data);
3487 SetPropW(hDrawWnd, pagesetupdlg_prop, data);
3488 GetWindowRect(hDrawWnd, &data->rtDrawRect); /* Calculating rect in client coordinates where paper draws */
3489 ScreenToClient(hDlg, (LPPOINT)&data->rtDrawRect);
3490 ScreenToClient(hDlg, (LPPOINT)(&data->rtDrawRect.right));
3491 lpfnStaticWndProc = (WNDPROC)SetWindowLongPtrW(
3492 hDrawWnd,
3493 GWLP_WNDPROC,
3494 (ULONG_PTR)PRINTDLG_PagePaintProc);
3495
3496 /* FIXME: Paint hook. Must it be at begin of initialization or at end? */
3497 res = TRUE;
3498 if (pagesetup_get_flags(data) & PSD_ENABLEPAGESETUPHOOK)
3499 {
3500 if (!pagesetup_get_hook(data, page_setup_hook)(hDlg, uMsg, wParam,
3501 pagesetup_get_dlg_struct(data)))
3502 FIXME("Setup page hook failed?\n");
3503 }
3504
3505 /* if printer button disabled */
3506 if (pagesetup_get_flags(data) & PSD_DISABLEPRINTER)
3507 EnableWindow(GetDlgItem(hDlg, psh3), FALSE);
3508 /* if margin edit boxes disabled */
3509 if (pagesetup_get_flags(data) & PSD_DISABLEMARGINS)
3510 {
3511 EnableWindow(GetDlgItem(hDlg, edt4), FALSE);
3512 EnableWindow(GetDlgItem(hDlg, edt5), FALSE);
3513 EnableWindow(GetDlgItem(hDlg, edt6), FALSE);
3514 EnableWindow(GetDlgItem(hDlg, edt7), FALSE);
3515 }
3516
3517 /* Set orientation radiobuttons properly */
3518 pagesetup_update_orientation_buttons(hDlg, data);
3519
3520 /* if orientation disabled */
3521 if (pagesetup_get_flags(data) & PSD_DISABLEORIENTATION)
3522 {
3523 EnableWindow(GetDlgItem(hDlg,rad1),FALSE);
3524 EnableWindow(GetDlgItem(hDlg,rad2),FALSE);
3525 }
3526
3527 /* We fill them out enabled or not */
3528 if (!(pagesetup_get_flags(data) & PSD_MARGINS))
3529 {
3530 /* default is 1 inch */
3531 LONG size = thousandths_inch_to_size(data, 1000);
3532 SetRect(pagesetup_get_margin_rect(data), size, size, size, size);
3533 }
3534 update_margin_edits(hDlg, data, 0);
3535 subclass_margin_edits(hDlg);
3536 set_margin_groupbox_title(hDlg, data);
3537
3538 /* if paper disabled */
3539 if (pagesetup_get_flags(data) & PSD_DISABLEPAPER)
3540 {
3541 EnableWindow(GetDlgItem(hDlg,cmb2),FALSE);
3542 EnableWindow(GetDlgItem(hDlg,cmb3),FALSE);
3543 }
3544
3545 /* filling combos: printer, paper, source. selecting current printer (from DEVMODEA) */
3546 pagesetup_init_combos(hDlg, data);
3547 pagesetup_update_papersize(data);
3548 pagesetup_set_defaultsource(data, DMBIN_FORMSOURCE); /* FIXME: This is the auto select bin. Is this correct? */
3549
3550 /* Drawing paper prev */
3551 pagesetup_change_preview(data);
3552 return TRUE;
3553 } else {
3554 data = GetPropW(hDlg, pagesetupdlg_prop);
3555 if (!data)
3556 {
3557 WARN("__WINE_PAGESETUPDLGDATA prop not set?\n");
3558 return FALSE;
3559 }
3560 if (pagesetup_get_flags(data) & PSD_ENABLEPAGESETUPHOOK)
3561 {
3562 res = pagesetup_get_hook(data, page_setup_hook)(hDlg, uMsg, wParam, lParam);
3563 if (res) return res;
3564 }
3565 }
3566 switch (uMsg) {
3567 case WM_COMMAND:
3568 return pagesetup_wm_command(hDlg, wParam, lParam, data);
3569 }
3570 return FALSE;
3571 }
3572
3573 static WCHAR *get_default_printer(void)
3574 {
3575 WCHAR *name = NULL;
3576 DWORD len = 0;
3577
3578 GetDefaultPrinterW(NULL, &len);
3579 if(len)
3580 {
3581 name = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
3582 GetDefaultPrinterW(name, &len);
3583 }
3584 return name;
3585 }
3586
3587 static void pagesetup_dump_dlg_struct(pagesetup_data *data)
3588 {
3589 if(TRACE_ON(commdlg))
3590 {
3591 char flagstr[1000] = "";
3592 const struct pd_flags *pflag = psd_flags;
3593 for( ; pflag->name; pflag++)
3594 {
3595 if(pagesetup_get_flags(data) & pflag->flag)
3596 {
3597 strcat(flagstr, pflag->name);
3598 strcat(flagstr, "|");
3599 }
3600 }
3601 TRACE("%s: (%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
3602 "hinst %p, flags %08x (%s)\n",
3603 data->unicode ? "unicode" : "ansi",
3604 data->u.dlgw, data->u.dlgw->hwndOwner, data->u.dlgw->hDevMode,
3605 data->u.dlgw->hDevNames, data->u.dlgw->hInstance,
3606 pagesetup_get_flags(data), flagstr);
3607 }
3608 }
3609
3610 static void *pagesetup_get_template(pagesetup_data *data)
3611 {
3612 HRSRC res;
3613 HGLOBAL tmpl_handle;
3614
3615 if(pagesetup_get_flags(data) & PSD_ENABLEPAGESETUPTEMPLATEHANDLE)
3616 {
3617 tmpl_handle = data->u.dlgw->hPageSetupTemplate;
3618 }
3619 else if(pagesetup_get_flags(data) & PSD_ENABLEPAGESETUPTEMPLATE)
3620 {
3621 if(data->unicode)
3622 res = FindResourceW(data->u.dlgw->hInstance,
3623 data->u.dlgw->lpPageSetupTemplateName, MAKEINTRESOURCEW(RT_DIALOG));
3624 else
3625 res = FindResourceA(data->u.dlga->hInstance,
3626 data->u.dlga->lpPageSetupTemplateName, MAKEINTRESOURCEA(RT_DIALOG));
3627 tmpl_handle = LoadResource(data->u.dlgw->hInstance, res);
3628 }
3629 else
3630 {
3631 res = FindResourceW(COMDLG32_hInstance, MAKEINTRESOURCEW(PAGESETUPDLGORD),
3632 MAKEINTRESOURCEW(RT_DIALOG));
3633 tmpl_handle = LoadResource(COMDLG32_hInstance, res);
3634 }
3635 return LockResource(tmpl_handle);
3636 }
3637
3638 static BOOL pagesetup_common(pagesetup_data *data)
3639 {
3640 BOOL ret;
3641 void *tmpl;
3642
3643 if(!pagesetup_get_dlg_struct(data))
3644 {
3645 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION);
3646 return FALSE;
3647 }
3648
3649 pagesetup_dump_dlg_struct(data);
3650
3651 if(data->u.dlgw->lStructSize != sizeof(PAGESETUPDLGW))
3652 {
3653 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
3654 return FALSE;
3655 }
3656
3657 if ((pagesetup_get_flags(data) & PSD_ENABLEPAGEPAINTHOOK) &&
3658 (pagesetup_get_hook(data, page_paint_hook) == NULL))
3659 {
3660 COMDLG32_SetCommDlgExtendedError(CDERR_NOHOOK);
3661 return FALSE;
3662 }
3663
3664 if(!(pagesetup_get_flags(data) & (PSD_INTHOUSANDTHSOFINCHES | PSD_INHUNDREDTHSOFMILLIMETERS)))
3665 data->u.dlgw->Flags |= is_default_metric() ?
3666 PSD_INHUNDREDTHSOFMILLIMETERS : PSD_INTHOUSANDTHSOFINCHES;
3667
3668 if (!data->u.dlgw->hDevMode || !data->u.dlgw->hDevNames)
3669 {
3670 WCHAR *def = get_default_printer();
3671 if(!def)
3672 {
3673 if (!(pagesetup_get_flags(data) & PSD_NOWARNING))
3674 {
3675 WCHAR errstr[256];
3676 LoadStringW(COMDLG32_hInstance, PD32_NO_DEFAULT_PRINTER, errstr, 255);
3677 MessageBoxW(data->u.dlgw->hwndOwner, errstr, 0, MB_OK | MB_ICONERROR);
3678 }
3679 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
3680 return FALSE;
3681 }
3682 pagesetup_change_printer(def, data);
3683 HeapFree(GetProcessHeap(), 0, def);
3684 }
3685
3686 if (pagesetup_get_flags(data) & PSD_RETURNDEFAULT)
3687 {
3688 pagesetup_update_papersize(data);
3689 return TRUE;
3690 }
3691
3692 tmpl = pagesetup_get_template(data);
3693
3694 ret = DialogBoxIndirectParamW(data->u.dlgw->hInstance, tmpl,
3695 data->u.dlgw->hwndOwner,
3696 pagesetup_dlg_proc, (LPARAM)data) > 0;
3697 return ret;
3698 }
3699
3700 /***********************************************************************
3701 * PageSetupDlgA (COMDLG32.@)
3702 *
3703 * Displays the PAGE SETUP dialog box, which enables the user to specify
3704 * specific properties of a printed page such as
3705 * size, source, orientation and the width of the page margins.
3706 *
3707 * PARAMS
3708 * setupdlg [IO] PAGESETUPDLGA struct
3709 *
3710 * RETURNS
3711 * TRUE if the user pressed the OK button
3712 * FALSE if the user cancelled the window or an error occurred
3713 *
3714 * NOTES
3715 * The values of hDevMode and hDevNames are filled on output and can be
3716 * changed in PAGESETUPDLG when they are passed in PageSetupDlg.
3717 *
3718 */
3719 BOOL WINAPI PageSetupDlgA(LPPAGESETUPDLGA setupdlg)
3720 {
3721 pagesetup_data data;
3722
3723 data.unicode = FALSE;
3724 data.u.dlga = setupdlg;
3725
3726 return pagesetup_common(&data);
3727 }
3728
3729 /***********************************************************************
3730 * PageSetupDlgW (COMDLG32.@)
3731 *
3732 * See PageSetupDlgA.
3733 */
3734 BOOL WINAPI PageSetupDlgW(LPPAGESETUPDLGW setupdlg)
3735 {
3736 pagesetup_data data;
3737
3738 data.unicode = TRUE;
3739 data.u.dlgw = setupdlg;
3740
3741 return pagesetup_common(&data);
3742 }
3743
3744 /***********************************************************************
3745 * PrintDlgExA (COMDLG32.@)
3746 *
3747 * See PrintDlgExW.
3748 *
3749 * BUGS
3750 * Only a Stub
3751 *
3752 */
3753 HRESULT WINAPI PrintDlgExA(LPPRINTDLGEXA lppd)
3754 {
3755
3756 FIXME("(%p) stub\n", lppd);
3757 if ((lppd == NULL) || (lppd->lStructSize != sizeof(PRINTDLGEXA))) {
3758 return E_INVALIDARG;
3759 }
3760
3761 if (!IsWindow(lppd->hwndOwner)) {
3762 return E_HANDLE;
3763 }
3764
3765 return E_NOTIMPL;
3766 }
3767
3768 /***********************************************************************
3769 * PrintDlgExW (COMDLG32.@)
3770 *
3771 * Display the property sheet style PRINT dialog box
3772 *
3773 * PARAMS
3774 * lppd [IO] ptr to PRINTDLGEX struct
3775 *
3776 * RETURNS
3777 * Success: S_OK
3778 * Failure: One of the following COM error codes:
3779 * E_OUTOFMEMORY Insufficient memory.
3780 * E_INVALIDARG One or more arguments are invalid.
3781 * E_POINTER Invalid pointer.
3782 * E_HANDLE Invalid handle.
3783 * E_FAIL Unspecified error.
3784 *
3785 * NOTES
3786 * This Dialog enables the user to specify specific properties of the print job.
3787 * The property sheet can also have additional application-specific and
3788 * driver-specific property pages.
3789 *
3790 * BUGS
3791 * Not fully implemented
3792 *
3793 */
3794 HRESULT WINAPI PrintDlgExW(LPPRINTDLGEXW lppd)
3795 {
3796 DWORD ret = E_FAIL;
3797 LPVOID ptr;
3798
3799 FIXME("(%p) not fully implemented\n", lppd);
3800
3801 if ((lppd == NULL) || (lppd->lStructSize != sizeof(PRINTDLGEXW))) {
3802 return E_INVALIDARG;
3803 }
3804
3805 if (!IsWindow(lppd->hwndOwner)) {
3806 return E_HANDLE;
3807 }
3808
3809 if (lppd->Flags & PD_RETURNDEFAULT) {
3810 PRINTER_INFO_2W *pbuf;
3811 DRIVER_INFO_2W *dbuf;
3812 HANDLE hprn;
3813 DWORD needed = 1024;
3814 BOOL bRet;
3815
3816 if (lppd->hDevMode || lppd->hDevNames) {
3817 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
3818 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
3819 return E_INVALIDARG;
3820 }
3821 if (!PRINTDLG_OpenDefaultPrinter(&hprn)) {
3822 WARN("Can't find default printer\n");
3823 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
3824 return E_FAIL;
3825 }
3826
3827 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
3828 bRet = GetPrinterW(hprn, 2, (LPBYTE)pbuf, needed, &needed);
3829 if (!bRet && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
3830 HeapFree(GetProcessHeap(), 0, pbuf);
3831 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
3832 bRet = GetPrinterW(hprn, 2, (LPBYTE)pbuf, needed, &needed);
3833 }
3834 if (!bRet) {
3835 HeapFree(GetProcessHeap(), 0, pbuf);
3836 ClosePrinter(hprn);
3837 return E_FAIL;
3838 }
3839
3840 needed = 1024;
3841 dbuf = HeapAlloc(GetProcessHeap(), 0, needed);
3842 bRet = GetPrinterDriverW(hprn, NULL, 3, (LPBYTE)dbuf, needed, &needed);
3843 if (!bRet && (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
3844 HeapFree(GetProcessHeap(), 0, dbuf);
3845 dbuf = HeapAlloc(GetProcessHeap(), 0, needed);
3846 bRet = GetPrinterDriverW(hprn, NULL, 3, (LPBYTE)dbuf, needed, &needed);
3847 }
3848 if (!bRet) {
3849 ERR("GetPrinterDriverW failed, last error %d, fix your config for printer %s!\n",
3850 GetLastError(), debugstr_w(pbuf->pPrinterName));
3851 HeapFree(GetProcessHeap(), 0, dbuf);
3852 HeapFree(GetProcessHeap(), 0, pbuf);
3853 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
3854 ClosePrinter(hprn);
3855 return E_FAIL;
3856 }
3857 ClosePrinter(hprn);
3858
3859 PRINTDLG_CreateDevNamesW(&(lppd->hDevNames),
3860 dbuf->pDriverPath,
3861 pbuf->pPrinterName,
3862 pbuf->pPortName);
3863 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, pbuf->pDevMode->dmSize +
3864 pbuf->pDevMode->dmDriverExtra);
3865 if (lppd->hDevMode) {
3866 ptr = GlobalLock(lppd->hDevMode);
3867 if (ptr) {
3868 memcpy(ptr, pbuf->pDevMode, pbuf->pDevMode->dmSize +
3869 pbuf->pDevMode->dmDriverExtra);
3870 GlobalUnlock(lppd->hDevMode);
3871 ret = S_OK;
3872 }
3873 }
3874 HeapFree(GetProcessHeap(), 0, pbuf);
3875 HeapFree(GetProcessHeap(), 0, dbuf);
3876
3877 return ret;
3878 }
3879
3880 return E_NOTIMPL;
3881 }
useful hacks and other patches not (yet) suitable for mainline