Sync to Wine-0_9_16:
[reactos.git] / reactos / dll / win32 / comdlg32 / printdlg16.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
24 #include <ctype.h>
25 #include <stdlib.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "wine/wingdi16.h"
36 #include "winuser.h"
37 #include "wine/winuser16.h"
38 #include "commdlg.h"
39 #include "dlgs.h"
40 #include "wine/debug.h"
41 #include "cderr.h"
42 #include "winspool.h"
43 #include "winerror.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
46
47 #include "cdlg.h"
48 #include "cdlg16.h"
49 #include "printdlg.h"
50
51 typedef struct
52 {
53 PRINT_PTRA print32;
54 LPPRINTDLG16 lpPrintDlg16;
55 } PRINT_PTRA16;
56
57 /* Internal Functions */
58
59 static BOOL PRINTDLG_CreateDevNames16(HGLOBAL16 *hmem, char* DeviceDriverName,
60 char* DeviceName, char* OutputPort)
61 {
62 long size;
63 char* pDevNamesSpace;
64 char* pTempPtr;
65 LPDEVNAMES lpDevNames;
66 char buf[260];
67 DWORD dwBufLen = sizeof(buf);
68
69 size = strlen(DeviceDriverName) + 1
70 + strlen(DeviceName) + 1
71 + strlen(OutputPort) + 1
72 + sizeof(DEVNAMES);
73
74 if(*hmem)
75 *hmem = GlobalReAlloc16(*hmem, size, GMEM_MOVEABLE);
76 else
77 *hmem = GlobalAlloc16(GMEM_MOVEABLE, size);
78 if (*hmem == 0)
79 return FALSE;
80
81 pDevNamesSpace = GlobalLock16(*hmem);
82 lpDevNames = (LPDEVNAMES) pDevNamesSpace;
83
84 pTempPtr = pDevNamesSpace + sizeof(DEVNAMES);
85 strcpy(pTempPtr, DeviceDriverName);
86 lpDevNames->wDriverOffset = pTempPtr - pDevNamesSpace;
87
88 pTempPtr += strlen(DeviceDriverName) + 1;
89 strcpy(pTempPtr, DeviceName);
90 lpDevNames->wDeviceOffset = pTempPtr - pDevNamesSpace;
91
92 pTempPtr += strlen(DeviceName) + 1;
93 strcpy(pTempPtr, OutputPort);
94 lpDevNames->wOutputOffset = pTempPtr - pDevNamesSpace;
95
96 GetDefaultPrinterA(buf, &dwBufLen);
97 lpDevNames->wDefault = (strcmp(buf, DeviceName) == 0) ? 1 : 0;
98 GlobalUnlock16(*hmem);
99 return TRUE;
100 }
101
102
103 /***********************************************************************
104 * PRINTDLG_WMInitDialog [internal]
105 */
106 static LRESULT PRINTDLG_WMInitDialog16(HWND hDlg, WPARAM wParam, PRINT_PTRA16* ptr16)
107 {
108 PRINT_PTRA *PrintStructures = &ptr16->print32;
109 LPPRINTDLG16 lppd = ptr16->lpPrintDlg16;
110 DEVNAMES *pdn;
111 DEVMODEA *pdm;
112 char *name = NULL;
113 UINT comboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
114
115 /* load Collate ICONs */
116 PrintStructures->hCollateIcon =
117 LoadIconA(COMDLG32_hInstance, "PD32_COLLATE");
118 PrintStructures->hNoCollateIcon =
119 LoadIconA(COMDLG32_hInstance, "PD32_NOCOLLATE");
120 if(PrintStructures->hCollateIcon == 0 ||
121 PrintStructures->hNoCollateIcon == 0) {
122 ERR("no icon in resourcefile\n");
123 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
124 EndDialog(hDlg, FALSE);
125 }
126
127 /* load Paper Orientation ICON */
128 /* FIXME: not implemented yet */
129
130 /*
131 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
132 * must be registered and the Help button must be shown.
133 */
134 if (lppd->Flags & PD_SHOWHELP) {
135 if((PrintStructures->HelpMessageID =
136 RegisterWindowMessageA(HELPMSGSTRINGA)) == 0) {
137 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
138 return FALSE;
139 }
140 } else
141 PrintStructures->HelpMessageID = 0;
142
143 if (!(lppd->Flags & PD_PRINTSETUP)) {
144 /* We have a print quality combo box. What shall we do? */
145 if (GetDlgItem(hDlg,cmb1)) {
146 char buf [20];
147
148 FIXME("Print quality only displaying currently.\n");
149
150 pdm = GlobalLock16(lppd->hDevMode);
151 if(pdm) {
152 switch (pdm->dmPrintQuality) {
153 case DMRES_HIGH : strcpy(buf,"High");break;
154 case DMRES_MEDIUM : strcpy(buf,"Medium");break;
155 case DMRES_LOW : strcpy(buf,"Low");break;
156 case DMRES_DRAFT : strcpy(buf,"Draft");break;
157 case 0 : strcpy(buf,"Default");break;
158 default : sprintf(buf,"%ddpi",pdm->dmPrintQuality);break;
159 }
160 GlobalUnlock16(lppd->hDevMode);
161 } else
162 strcpy(buf,"Default");
163 SendDlgItemMessageA(hDlg,cmb1,CB_ADDSTRING,0,(LPARAM)buf);
164 SendDlgItemMessageA(hDlg,cmb1,CB_SETCURSEL,0,0);
165 EnableWindow(GetDlgItem(hDlg,cmb1),FALSE);
166 }
167 }
168
169 /* FIXME: I allow more freedom than either Win95 or WinNT,
170 * which do not agree to what errors should be thrown or not
171 * in case nToPage or nFromPage is out-of-range.
172 */
173 if (lppd->nMaxPage < lppd->nMinPage)
174 lppd->nMaxPage = lppd->nMinPage;
175 if (lppd->nMinPage == lppd->nMaxPage)
176 lppd->Flags |= PD_NOPAGENUMS;
177 if (lppd->nToPage < lppd->nMinPage)
178 lppd->nToPage = lppd->nMinPage;
179 if (lppd->nToPage > lppd->nMaxPage)
180 lppd->nToPage = lppd->nMaxPage;
181 if (lppd->nFromPage < lppd->nMinPage)
182 lppd->nFromPage = lppd->nMinPage;
183 if (lppd->nFromPage > lppd->nMaxPage)
184 lppd->nFromPage = lppd->nMaxPage;
185
186 /* If the printer combo box is in the dialog, fill it */
187 if (GetDlgItem(hDlg,comboID)) {
188 /* Fill Combobox
189 */
190 pdn = GlobalLock16(lppd->hDevNames);
191 pdm = GlobalLock16(lppd->hDevMode);
192 if(pdn)
193 name = (char*)pdn + pdn->wDeviceOffset;
194 else if(pdm)
195 name = (char*)pdm->dmDeviceName;
196 PRINTDLG_SetUpPrinterListComboA(hDlg, comboID, name);
197 if(pdm) GlobalUnlock16(lppd->hDevMode);
198 if(pdn) GlobalUnlock16(lppd->hDevNames);
199
200 /* Now find selected printer and update rest of dlg */
201 name = HeapAlloc(GetProcessHeap(),0,256);
202 if (GetDlgItemTextA(hDlg, comboID, name, 255))
203 PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
204 } else {
205 /* else just use default printer */
206 char name[200];
207 DWORD dwBufLen = sizeof(name);
208 BOOL ret = GetDefaultPrinterA(name, &dwBufLen);
209
210 if (ret)
211 PRINTDLG_ChangePrinterA(hDlg, name, PrintStructures);
212 else
213 FIXME("No default printer found, expect problems!\n");
214 }
215 HeapFree(GetProcessHeap(),0,name);
216
217 return TRUE;
218 }
219
220 /************************************************************
221 *
222 * PRINTDLG_Get16TemplateFrom32 [Internal]
223 * Generates a 16 bits template from the Wine 32 bits resource
224 *
225 */
226 static HGLOBAL16 PRINTDLG_Get16TemplateFrom32(LPCSTR PrintResourceName)
227 {
228 HRSRC hResInfo;
229 HGLOBAL hDlgTmpl32;
230 LPCVOID template32;
231 DWORD size;
232 HGLOBAL16 hGlobal16;
233 LPVOID template;
234
235 if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
236 PrintResourceName, (LPSTR)RT_DIALOG)))
237 {
238 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
239 return 0;
240 }
241 if (!(hDlgTmpl32 = LoadResource(COMDLG32_hInstance, hResInfo )) ||
242 !(template32 = LockResource( hDlgTmpl32 )))
243 {
244 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
245 return 0;
246 }
247 size = SizeofResource(COMDLG32_hInstance, hResInfo);
248 hGlobal16 = GlobalAlloc16(0, size);
249 if (!hGlobal16)
250 {
251 COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
252 ERR("alloc failure for %ld bytes\n", size);
253 return 0;
254 }
255 template = GlobalLock16(hGlobal16);
256 if (!template)
257 {
258 COMDLG32_SetCommDlgExtendedError(CDERR_MEMLOCKFAILURE);
259 ERR("global lock failure for %x handle\n", hGlobal16);
260 GlobalFree16(hGlobal16);
261 return 0;
262 }
263 ConvertDialog32To16((LPVOID)template32, size, (LPVOID)template);
264 GlobalUnlock16(hGlobal16);
265 return hGlobal16;
266 }
267
268 static BOOL PRINTDLG_CreateDC16(LPPRINTDLG16 lppd)
269 {
270 DEVNAMES *pdn = GlobalLock16(lppd->hDevNames);
271 DEVMODEA *pdm = GlobalLock16(lppd->hDevMode);
272
273 if(lppd->Flags & PD_RETURNDC) {
274 lppd->hDC = HDC_16(CreateDCA((char*)pdn + pdn->wDriverOffset,
275 (char*)pdn + pdn->wDeviceOffset,
276 (char*)pdn + pdn->wOutputOffset,
277 pdm ));
278 } else if(lppd->Flags & PD_RETURNIC) {
279 lppd->hDC = HDC_16(CreateICA((char*)pdn + pdn->wDriverOffset,
280 (char*)pdn + pdn->wDeviceOffset,
281 (char*)pdn + pdn->wOutputOffset,
282 pdm ));
283 }
284 GlobalUnlock16(lppd->hDevNames);
285 GlobalUnlock16(lppd->hDevMode);
286 return lppd->hDC ? TRUE : FALSE;
287 }
288
289 /************************************************************
290 *
291 * PRINTDLG_GetDlgTemplate
292 *
293 */
294 static HGLOBAL16 PRINTDLG_GetDlgTemplate16(PRINTDLG16 *lppd)
295 {
296 HGLOBAL16 hDlgTmpl, hResInfo;
297
298 if (lppd->Flags & PD_PRINTSETUP) {
299 if(lppd->Flags & PD_ENABLESETUPTEMPLATEHANDLE) {
300 hDlgTmpl = lppd->hSetupTemplate;
301 } else if(lppd->Flags & PD_ENABLESETUPTEMPLATE) {
302 hResInfo = FindResource16(lppd->hInstance,
303 MapSL(lppd->lpSetupTemplateName), (LPSTR)RT_DIALOG);
304 hDlgTmpl = LoadResource16(lppd->hInstance, hResInfo);
305 } else {
306 hDlgTmpl = PRINTDLG_Get16TemplateFrom32("PRINT32_SETUP");
307 }
308 } else {
309 if(lppd->Flags & PD_ENABLEPRINTTEMPLATEHANDLE) {
310 hDlgTmpl = lppd->hPrintTemplate;
311 } else if(lppd->Flags & PD_ENABLEPRINTTEMPLATE) {
312 hResInfo = FindResource16(lppd->hInstance,
313 MapSL(lppd->lpPrintTemplateName),
314 (LPSTR)RT_DIALOG);
315 hDlgTmpl = LoadResource16(lppd->hInstance, hResInfo);
316 } else {
317 hDlgTmpl = PRINTDLG_Get16TemplateFrom32("PRINT32");
318 }
319 }
320 return hDlgTmpl;
321 }
322
323 /**********************************************************************
324 *
325 * 16 bit commdlg
326 */
327
328 /***********************************************************************
329 * PrintDlg (COMMDLG.20)
330 *
331 * Displays the the PRINT dialog box, which enables the user to specify
332 * specific properties of the print job.
333 *
334 * RETURNS
335 * nonzero if the user pressed the OK button
336 * zero if the user cancelled the window or an error occurred
337 *
338 * BUGS
339 * * calls up to the 32-bit versions of the Dialogs, which look different
340 * * Customizing is *not* implemented.
341 */
342
343 BOOL16 WINAPI PrintDlg16(
344 LPPRINTDLG16 lppd /* [in/out] ptr to PRINTDLG struct */
345 ) {
346 BOOL bRet = FALSE;
347 LPVOID ptr;
348 HINSTANCE16 hInst = GetWindowLongPtrW( HWND_32(lppd->hwndOwner), GWLP_HINSTANCE );
349
350 if(TRACE_ON(commdlg)) {
351 char flagstr[1000] = "";
352 struct pd_flags *pflag = pd_flags;
353 for( ; pflag->name; pflag++) {
354 if(lppd->Flags & pflag->flag)
355 strcat(flagstr, pflag->name);
356 }
357 TRACE("(%p): hwndOwner = %08x, hDevMode = %08x, hDevNames = %08x\n"
358 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %08x\n"
359 "flags %08lx (%s)\n",
360 lppd, lppd->hwndOwner, lppd->hDevMode, lppd->hDevNames,
361 lppd->nFromPage, lppd->nToPage, lppd->nMinPage, lppd->nMaxPage,
362 lppd->nCopies, lppd->hInstance, lppd->Flags, flagstr);
363 }
364
365 if(lppd->lStructSize != sizeof(PRINTDLG16)) {
366 ERR("structure size %ld\n",lppd->lStructSize);
367 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
368 return FALSE;
369 }
370
371 if(lppd->Flags & PD_RETURNDEFAULT) {
372 PRINTER_INFO_2A *pbuf;
373 DRIVER_INFO_3A *dbuf;
374 HANDLE hprn;
375 DWORD needed;
376
377 if(lppd->hDevMode || lppd->hDevNames) {
378 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
379 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
380 return FALSE;
381 }
382 if(!PRINTDLG_OpenDefaultPrinter(&hprn)) {
383 WARN("Can't find default printer\n");
384 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
385 return FALSE;
386 }
387
388 GetPrinterA(hprn, 2, NULL, 0, &needed);
389 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
390 GetPrinterA(hprn, 2, (LPBYTE)pbuf, needed, &needed);
391 GetPrinterDriverA(hprn, NULL, 3, NULL, 0, &needed);
392 dbuf = HeapAlloc(GetProcessHeap(),0,needed);
393 if (!GetPrinterDriverA(hprn, NULL, 3, (LPBYTE)dbuf, needed, &needed)) {
394 ERR("GetPrinterDriverA failed for %s, le %ld, fix your config!\n",
395 pbuf->pPrinterName,GetLastError());
396 HeapFree(GetProcessHeap(), 0, dbuf);
397 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
398 return FALSE;
399 }
400 ClosePrinter(hprn);
401 PRINTDLG_CreateDevNames16(&(lppd->hDevNames),
402 dbuf->pDriverPath,
403 pbuf->pPrinterName,
404 pbuf->pPortName);
405 lppd->hDevMode = GlobalAlloc16(GMEM_MOVEABLE,pbuf->pDevMode->dmSize+
406 pbuf->pDevMode->dmDriverExtra);
407 ptr = GlobalLock16(lppd->hDevMode);
408 memcpy(ptr, pbuf->pDevMode, pbuf->pDevMode->dmSize +
409 pbuf->pDevMode->dmDriverExtra);
410 GlobalUnlock16(lppd->hDevMode);
411 HeapFree(GetProcessHeap(), 0, pbuf);
412 HeapFree(GetProcessHeap(), 0, dbuf);
413 bRet = TRUE;
414 } else {
415 HGLOBAL16 hDlgTmpl;
416 PRINT_PTRA *PrintStructures;
417 PRINT_PTRA16 *ptr16;
418
419 /* load Dialog resources,
420 * depending on Flags indicates Print32 or Print32_setup dialog
421 */
422 hDlgTmpl = PRINTDLG_GetDlgTemplate16(lppd);
423 if (!hDlgTmpl) {
424 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
425 return FALSE;
426 }
427 ptr16 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(PRINT_PTRA16));
428 ptr16->lpPrintDlg16 = lppd;
429 PrintStructures = &ptr16->print32;
430 PrintStructures->lpPrintDlg = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(PRINTDLGA));
431 #define CVAL(x) PrintStructures->lpPrintDlg->x = lppd->x;
432 #define MVAL(x) PrintStructures->lpPrintDlg->x = MapSL(lppd->x);
433 CVAL(Flags);
434 PrintStructures->lpPrintDlg->hwndOwner = HWND_32(lppd->hwndOwner);
435 PrintStructures->lpPrintDlg->hDC = HDC_32(lppd->hDC);
436 CVAL(nFromPage);CVAL(nToPage);CVAL(nMinPage);CVAL(nMaxPage);
437 CVAL(nCopies);
438 PrintStructures->lpPrintDlg->hInstance = HINSTANCE_32(lppd->hInstance);
439 CVAL(lCustData);
440 MVAL(lpPrintTemplateName);MVAL(lpSetupTemplateName);
441 /* Don't copy rest, it is 16 bit specific */
442 #undef MVAL
443 #undef CVAL
444
445 PrintStructures->lpDevMode = HeapAlloc(GetProcessHeap(),0,sizeof(DEVMODEA));
446
447 /* and create & process the dialog .
448 * -1 is failure, 0 is broken hwnd, everything else is ok.
449 */
450 bRet = (0<DialogBoxIndirectParam16(
451 hInst, hDlgTmpl, lppd->hwndOwner,
452 (DLGPROC16)GetProcAddress16(GetModuleHandle16("COMMDLG"),(LPCSTR)21),
453 (LPARAM)PrintStructures
454 )
455 );
456 if (!PrintStructures->lpPrinterInfo) bRet = FALSE;
457 if(bRet) {
458 DEVMODEA *lpdm = PrintStructures->lpDevMode, *lpdmReturn;
459 PRINTER_INFO_2A *pi = PrintStructures->lpPrinterInfo;
460 DRIVER_INFO_3A *di = PrintStructures->lpDriverInfo;
461
462 if (lppd->hDevMode == 0) {
463 TRACE(" No hDevMode yet... Need to create my own\n");
464 lppd->hDevMode = GlobalAlloc16(GMEM_MOVEABLE,
465 lpdm->dmSize + lpdm->dmDriverExtra);
466 } else {
467 WORD locks;
468 if((locks = (GlobalFlags16(lppd->hDevMode)&GMEM_LOCKCOUNT))) {
469 WARN("hDevMode has %d locks on it. Unlocking it now\n", locks);
470 while(locks--) {
471 GlobalUnlock16(lppd->hDevMode);
472 TRACE("Now got %d locks\n", locks);
473 }
474 }
475 lppd->hDevMode = GlobalReAlloc16(lppd->hDevMode,
476 lpdm->dmSize + lpdm->dmDriverExtra,
477 GMEM_MOVEABLE);
478 }
479 lpdmReturn = GlobalLock16(lppd->hDevMode);
480 memcpy(lpdmReturn, lpdm, lpdm->dmSize + lpdm->dmDriverExtra);
481
482 if (lppd->hDevNames != 0) {
483 WORD locks;
484 if((locks = (GlobalFlags16(lppd->hDevNames)&GMEM_LOCKCOUNT))) {
485 WARN("hDevNames has %d locks on it. Unlocking it now\n", locks);
486 while(locks--)
487 GlobalUnlock16(lppd->hDevNames);
488 }
489 }
490 PRINTDLG_CreateDevNames16(&(lppd->hDevNames),
491 di->pDriverPath,
492 pi->pPrinterName,
493 pi->pPortName
494 );
495 GlobalUnlock16(lppd->hDevMode);
496 /* Copy back the [out] integer parameters */
497 #define CVAL(x) lppd->x = PrintStructures->lpPrintDlg->x;
498 CVAL(Flags);
499 CVAL(nFromPage);
500 CVAL(nToPage);
501 CVAL(nCopies);
502 #undef CVAL
503
504 }
505 if (!(lppd->Flags & (PD_ENABLESETUPTEMPLATEHANDLE | PD_ENABLESETUPTEMPLATE)))
506 GlobalFree16(hDlgTmpl); /* created from the 32 bits resource */
507 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
508 HeapFree(GetProcessHeap(), 0, PrintStructures->lpPrinterInfo);
509 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDriverInfo);
510 HeapFree(GetProcessHeap(), 0, PrintStructures);
511 }
512 if(bRet && (lppd->Flags & PD_RETURNDC || lppd->Flags & PD_RETURNIC))
513 bRet = PRINTDLG_CreateDC16(lppd);
514
515 TRACE("exit! (%d)\n", bRet);
516 return bRet;
517 }
518
519 /***********************************************************************
520 * PrintDlgProc (COMMDLG.21)
521 */
522 BOOL16 CALLBACK PrintDlgProc16(HWND16 hDlg16, UINT16 uMsg, WPARAM16 wParam,
523 LPARAM lParam)
524 {
525 HWND hDlg = HWND_32(hDlg16);
526 PRINT_PTRA16 *PrintStructures;
527 BOOL16 res = FALSE;
528
529 if (uMsg!=WM_INITDIALOG) {
530 PrintStructures = (PRINT_PTRA16*)GetPropA(hDlg,"__WINE_PRINTDLGDATA");
531 if (!PrintStructures)
532 return FALSE;
533 } else {
534 PrintStructures = (PRINT_PTRA16*) lParam;
535 SetPropA(hDlg,"__WINE_PRINTDLGDATA",PrintStructures);
536 res = PRINTDLG_WMInitDialog16(hDlg, wParam, PrintStructures);
537
538 if(PrintStructures->lpPrintDlg16->Flags & PD_ENABLEPRINTHOOK) {
539 res = CallWindowProc16(
540 (WNDPROC16)PrintStructures->lpPrintDlg16->lpfnPrintHook,
541 hDlg16, uMsg, wParam, (LPARAM)PrintStructures->lpPrintDlg16
542 );
543 }
544 return res;
545 }
546
547 if(PrintStructures->lpPrintDlg16->Flags & PD_ENABLEPRINTHOOK) {
548 res = CallWindowProc16(
549 (WNDPROC16)PrintStructures->lpPrintDlg16->lpfnPrintHook,
550 hDlg16,uMsg, wParam, lParam
551 );
552 if(LOWORD(res)) return res;
553 }
554
555 switch (uMsg) {
556 case WM_COMMAND: {
557 /* We need to map those for the 32bit window procedure, compare
558 * with 32Ato16 mapper in winproc.c
559 */
560 return PRINTDLG_WMCommandA(
561 hDlg,
562 MAKEWPARAM(wParam,HIWORD(lParam)),
563 LOWORD(lParam),
564 &PrintStructures->print32
565 );
566 }
567 case WM_DESTROY:
568 DestroyIcon(PrintStructures->print32.hCollateIcon);
569 DestroyIcon(PrintStructures->print32.hNoCollateIcon);
570 /* FIXME: don't forget to delete the paper orientation icons here! */
571
572 return FALSE;
573 }
574 return res;
575 }
576
577 /***********************************************************************
578 * PrintSetupDlgProc (COMMDLG.22)
579 */
580 BOOL16 CALLBACK PrintSetupDlgProc16(HWND16 hWnd16, UINT16 wMsg, WPARAM16 wParam,
581 LPARAM lParam)
582 {
583 HWND hWnd = HWND_32(hWnd16);
584 switch (wMsg)
585 {
586 case WM_INITDIALOG:
587 TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
588 ShowWindow(hWnd, SW_SHOWNORMAL);
589 return (TRUE);
590 case WM_COMMAND:
591 switch (wParam) {
592 case IDOK:
593 EndDialog(hWnd, TRUE);
594 return(TRUE);
595 case IDCANCEL:
596 EndDialog(hWnd, FALSE);
597 return(TRUE);
598 }
599 return(FALSE);
600 }
601 return FALSE;
602 }