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