?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented _ultow() and export [Nt/Zw]QueryVolumeInformationFile().
[wine/dcerpc.git] / dlls / commdlg / printdlg.c
blobc321854b44b7b50cf3a72ee8e9f2d8f976cb2e34
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 #include <ctype.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include "windef.h"
14 #include "winbase.h"
15 #include "wingdi.h"
16 #include "wine/wingdi16.h"
17 #include "winuser.h"
18 #include "wine/winuser16.h"
19 #include "commdlg.h"
20 #include "dlgs.h"
21 #include "debugtools.h"
22 #include "cderr.h"
23 #include "winspool.h"
24 #include "winerror.h"
25
26 DEFAULT_DEBUG_CHANNEL(commdlg);
27
28 #include "cdlg.h"
29
30
31 /* This PRINTDLGA internal structure stores
32 * pointers to several throughout useful structures.
33 *
34 */
35 typedef struct
36 {
37 LPDEVMODEA lpDevMode;
38 LPPRINTDLGA lpPrintDlg;
39 LPPRINTER_INFO_2A lpPrinterInfo;
40 UINT HelpMessageID;
41 HICON hCollateIcon; /* PrintDlg only */
42 HICON hNoCollateIcon; /* PrintDlg only */
43 HICON hPortraitIcon; /* PrintSetupDlg only */
44 HICON hLandscapeIcon; /* PrintSetupDlg only */
45 } PRINT_PTRA;
46
47 /* Debugiging info */
48 static struct pd_flags {
49 DWORD flag;
50 LPSTR name;
51 } pd_flags[] = {
52 {PD_SELECTION, "PD_SELECTION "},
53 {PD_PAGENUMS, "PD_PAGENUMS "},
54 {PD_NOSELECTION, "PD_NOSELECTION "},
55 {PD_NOPAGENUMS, "PD_NOPAGENUMS "},
56 {PD_COLLATE, "PD_COLLATE "},
57 {PD_PRINTTOFILE, "PD_PRINTTOFILE "},
58 {PD_PRINTSETUP, "PD_PRINTSETUP "},
59 {PD_NOWARNING, "PD_NOWARNING "},
60 {PD_RETURNDC, "PD_RETURNDC "},
61 {PD_RETURNIC, "PD_RETURNIC "},
62 {PD_RETURNDEFAULT, "PD_RETURNDEFAULT "},
63 {PD_SHOWHELP, "PD_SHOWHELP "},
64 {PD_ENABLEPRINTHOOK, "PD_ENABLEPRINTHOOK "},
65 {PD_ENABLESETUPHOOK, "PD_ENABLESETUPHOOK "},
66 {PD_ENABLEPRINTTEMPLATE, "PD_ENABLEPRINTTEMPLATE "},
67 {PD_ENABLESETUPTEMPLATE, "PD_ENABLESETUPTEMPLATE "},
68 {PD_ENABLEPRINTTEMPLATEHANDLE, "PD_ENABLEPRINTTEMPLATEHANDLE "},
69 {PD_ENABLESETUPTEMPLATEHANDLE, "PD_ENABLESETUPTEMPLATEHANDLE "},
70 {PD_USEDEVMODECOPIES, "PD_USEDEVMODECOPIES[ANDCOLLATE] "},
71 {PD_DISABLEPRINTTOFILE, "PD_DISABLEPRINTTOFILE "},
72 {PD_HIDEPRINTTOFILE, "PD_HIDEPRINTTOFILE "},
73 {PD_NONETWORKBUTTON, "PD_NONETWORKBUTTON "},
74 {-1, NULL}
75 };
76
77
78 /***********************************************************************
79 * PRINTDLG_GetDefaultPrinterName
80 *
81 * Returns the default printer name in buf.
82 * Even under WinNT/2000 default printer is retrieved via GetProfileString -
83 * these entries are mapped somewhere in the registry rather than win.ini.
84 *
85 * Returns TRUE on success else FALSE
86 */
87 static BOOL PRINTDLG_GetDefaultPrinterName(LPSTR buf, DWORD len)
88 {
89 char *ptr;
90
91 if(!GetProfileStringA("windows", "device", "", buf, len))
92 return FALSE;
93 if((ptr = strchr(buf, ',')) == NULL)
94 return FALSE;
95 *ptr = '\0';
96 return TRUE;
97 }
98
99 /***********************************************************************
100 * PRINTDLG_OpenDefaultPrinter
101 *
102 * Returns a winspool printer handle to the default printer in *hprn
103 * Caller must call ClosePrinter on the handle
104 *
105 * Returns TRUE on success else FALSE
106 */
107 static BOOL PRINTDLG_OpenDefaultPrinter(HANDLE *hprn)
108 {
109 char buf[260];
110 if(!PRINTDLG_GetDefaultPrinterName(buf, sizeof(buf)))
111 return FALSE;
112 return OpenPrinterA(buf, hprn, NULL);
113 }
114
115 /***********************************************************************
116 * PRINTDLG_SetUpPrinterListCombo
117 *
118 * Initializes printer list combox.
119 * hDlg: HWND of dialog
120 * id: Control id of combo
121 * name: Name of printer to select
122 *
123 * Initializes combo with list of available printers. Selects printer 'name'
124 * If name is NULL or does not exist select the default printer.
125 *
126 * Returns number of printers added to list.
127 */
128 static INT PRINTDLG_SetUpPrinterListCombo(HWND hDlg, UINT id, LPCSTR name)
129 {
130 DWORD needed, num;
131 INT i;
132 LPPRINTER_INFO_2A pi;
133 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, NULL, 0, &needed, &num);
134 pi = HeapAlloc(GetProcessHeap(), 0, needed);
135 EnumPrintersA(PRINTER_ENUM_LOCAL, NULL, 2, (LPBYTE)pi, needed, &needed,
136 &num);
137
138 for(i = 0; i < num; i++) {
139 SendDlgItemMessageA(hDlg, id, CB_ADDSTRING, 0,
140 (LPARAM)pi[i].pPrinterName );
141 }
142 HeapFree(GetProcessHeap(), 0, pi);
143 if(!name ||
144 (i = SendDlgItemMessageA(hDlg, id, CB_FINDSTRINGEXACT, -1,
145 (LPARAM)name)) == CB_ERR) {
146
147 char buf[260];
148 TRACE("Can't find '%s' in printer list so trying to find default\n",
149 name);
150 if(!PRINTDLG_GetDefaultPrinterName(buf, sizeof(buf)))
151 return num;
152 i = SendDlgItemMessageA(hDlg, id, CB_FINDSTRINGEXACT, -1, (LPARAM)buf);
153 if(i == CB_ERR)
154 TRACE("Can't find default printer in printer list\n");
155 }
156 SendDlgItemMessageA(hDlg, id, CB_SETCURSEL, i, 0);
157 return num;
158 }
159
160 /***********************************************************************
161 * PRINTDLG_CreateDevNames [internal]
162 *
163 *
164 * creates a DevNames structure.
165 *
166 * (NB. when we handle unicode the offsets will be in wchars).
167 */
168 static BOOL PRINTDLG_CreateDevNames(HGLOBAL *hmem, char* DeviceDriverName,
169 char* DeviceName, char* OutputPort)
170 {
171 long size;
172 char* pDevNamesSpace;
173 char* pTempPtr;
174 LPDEVNAMES lpDevNames;
175 char buf[260];
176
177 size = strlen(DeviceDriverName) + 1
178 + strlen(DeviceName) + 1
179 + strlen(OutputPort) + 1
180 + sizeof(DEVNAMES);
181
182 if(*hmem)
183 *hmem = GlobalReAlloc(*hmem, size, GMEM_MOVEABLE);
184 else
185 *hmem = GlobalAlloc(GMEM_MOVEABLE, size);
186 if (*hmem == 0)
187 return FALSE;
188
189 pDevNamesSpace = GlobalLock(*hmem);
190 lpDevNames = (LPDEVNAMES) pDevNamesSpace;
191
192 pTempPtr = pDevNamesSpace + sizeof(DEVNAMES);
193 strcpy(pTempPtr, DeviceDriverName);
194 lpDevNames->wDriverOffset = pTempPtr - pDevNamesSpace;
195
196 pTempPtr += strlen(DeviceDriverName) + 1;
197 strcpy(pTempPtr, DeviceName);
198 lpDevNames->wDeviceOffset = pTempPtr - pDevNamesSpace;
199
200 pTempPtr += strlen(DeviceName) + 1;
201 strcpy(pTempPtr, OutputPort);
202 lpDevNames->wOutputOffset = pTempPtr - pDevNamesSpace;
203
204 PRINTDLG_GetDefaultPrinterName(buf, sizeof(buf));
205 lpDevNames->wDefault = (strcmp(buf, DeviceName) == 0) ? 1 : 0;
206 GlobalUnlock(*hmem);
207 return TRUE;
208 }
209
210 /***********************************************************************
211 * PRINTDLG_UpdatePrintDlg [internal]
212 *
213 *
214 * updates the PrintDlg structure for returnvalues.
215 *
216 * RETURNS
217 * FALSE if user is not allowed to close (i.e. wrong nTo or nFrom values)
218 * TRUE if succesful.
219 */
220 static BOOL PRINTDLG_UpdatePrintDlg(HWND hDlg,
221 PRINT_PTRA* PrintStructures)
222 {
223 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
224 PDEVMODEA lpdm = PrintStructures->lpDevMode;
225 LPPRINTER_INFO_2A pi = PrintStructures->lpPrinterInfo;
226
227
228 if(!lpdm) return FALSE;
229
230
231 if(!(lppd->Flags & PD_PRINTSETUP)) {
232 /* check whether nFromPage and nToPage are within range defined by
233 * nMinPage and nMaxPage
234 */
235 if (IsDlgButtonChecked(hDlg, rad3) == BST_CHECKED) { /* Pages */
236 WORD nToPage;
237 WORD nFromPage;
238 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
239 nToPage = GetDlgItemInt(hDlg, edt2, NULL, FALSE);
240 if (nFromPage < lppd->nMinPage || nFromPage > lppd->nMaxPage ||
241 nToPage < lppd->nMinPage || nToPage > lppd->nMaxPage) {
242 char resourcestr[256];
243 char resultstr[256];
244 LoadStringA(COMDLG32_hInstance, PD32_INVALID_PAGE_RANGE,
245 resourcestr, 255);
246 sprintf(resultstr,resourcestr, lppd->nMinPage, lppd->nMaxPage);
247 LoadStringA(COMDLG32_hInstance, PD32_PRINT_TITLE,
248 resourcestr, 255);
249 MessageBoxA(hDlg, resultstr, resourcestr,
250 MB_OK | MB_ICONWARNING);
251 return FALSE;
252 }
253 lppd->nFromPage = nFromPage;
254 lppd->nToPage = nToPage;
255 }
256
257 if (IsDlgButtonChecked(hDlg, chx1) == BST_CHECKED) {/* Print to file */
258 lppd->Flags |= PD_PRINTTOFILE;
259 pi->pPortName = "FILE:";
260 }
261
262 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED) { /* Collate */
263 FIXME("Collate lppd not yet implemented as output\n");
264 }
265
266 /* set PD_Collate and nCopies */
267 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
268 /* The application doesn't support multiple copies or collate...
269 */
270 lppd->Flags &= ~PD_COLLATE;
271 lppd->nCopies = 1;
272 /* if the printer driver supports it... store info there
273 * otherwise no collate & multiple copies !
274 */
275 if (lpdm->dmFields & DM_COLLATE)
276 lpdm->dmCollate =
277 (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED);
278 if (lpdm->dmFields & DM_COPIES)
279 lpdm->dmCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
280 } else {
281 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
282 lppd->Flags |= PD_COLLATE;
283 else
284 lppd->Flags &= ~PD_COLLATE;
285 lppd->nCopies = GetDlgItemInt(hDlg, edt3, NULL, FALSE);
286 }
287 }
288 return TRUE;
289 }
290
291
292 /************************************************************************
293 * PRINTDLG_SetUpPaperComboBox
294 *
295 * Initialize either the papersize or inputslot combos of the Printer Setup
296 * dialog. We store the associated word (eg DMPAPER_A4) as the item data.
297 * We also try to re-select the old selection.
298 */
299 static BOOL PRINTDLG_SetUpPaperComboBox(HWND hDlg,
300 int nIDComboBox,
301 char* PrinterName,
302 char* PortName,
303 LPDEVMODEA dm)
304 {
305 int i;
306 DWORD NrOfEntries;
307 char* Names;
308 WORD* Words;
309 DWORD Sel;
310 WORD oldWord = 0;
311 int NamesSize;
312 int fwCapability_Names;
313 int fwCapability_Words;
314
315 TRACE(" Printer: %s, ComboID: %d\n",PrinterName,nIDComboBox);
316
317 /* query the dialog box for the current selected value */
318 Sel = SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETCURSEL, 0, 0);
319 if(Sel != CB_ERR) {
320 oldWord = SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETITEMDATA, Sel,
321 0);
322 }
323
324 if (nIDComboBox == cmb2) {
325 NamesSize = 64;
326 fwCapability_Names = DC_PAPERNAMES;
327 fwCapability_Words = DC_PAPERS;
328 } else {
329 nIDComboBox = cmb3;
330 NamesSize = 24;
331 fwCapability_Names = DC_BINNAMES;
332 fwCapability_Words = DC_BINS;
333 }
334
335 /* for some printer drivers, DeviceCapabilities calls a VXD to obtain the
336 * paper settings. As Wine doesn't allow VXDs, this results in a crash.
337 */
338 WARN(" if your printer driver uses VXDs, expect a crash now!\n");
339 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
340 fwCapability_Names, NULL, dm);
341 if (NrOfEntries == 0)
342 WARN("no Name Entries found!\n");
343
344 if(DeviceCapabilitiesA(PrinterName, PortName, fwCapability_Words, NULL, dm)
345 != NrOfEntries) {
346 ERR("Number of caps is different\n");
347 NrOfEntries = 0;
348 }
349
350 Names = HeapAlloc(GetProcessHeap(),0, NrOfEntries*NamesSize);
351 Words = HeapAlloc(GetProcessHeap(),0, NrOfEntries*sizeof(WORD));
352 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
353 fwCapability_Names, Names, dm);
354 NrOfEntries = DeviceCapabilitiesA(PrinterName, PortName,
355 fwCapability_Words, (LPSTR)Words, dm);
356
357 /* reset any current content in the combobox */
358 SendDlgItemMessageA(hDlg, nIDComboBox, CB_RESETCONTENT, 0, 0);
359
360 /* store new content */
361 for (i = 0; i < NrOfEntries; i++) {
362 DWORD pos = SendDlgItemMessageA(hDlg, nIDComboBox, CB_ADDSTRING, 0,
363 (LPARAM)(&Names[i*NamesSize]) );
364 SendDlgItemMessageA(hDlg, nIDComboBox, CB_SETITEMDATA, pos,
365 Words[i]);
366 }
367
368 /* Look for old selection - can't do this is previous loop since
369 item order will change as more items are added */
370 Sel = 0;
371 for (i = 0; i < NrOfEntries; i++) {
372 if(SendDlgItemMessageA(hDlg, nIDComboBox, CB_GETITEMDATA, i, 0) ==
373 oldWord) {
374 Sel = i;
375 break;
376 }
377 }
378 SendDlgItemMessageA(hDlg, nIDComboBox, CB_SETCURSEL, Sel, 0);
379
380 HeapFree(GetProcessHeap(),0,Words);
381 HeapFree(GetProcessHeap(),0,Names);
382 return TRUE;
383 }
384
385 /***********************************************************************
386 * PRINTDLG_UpdatePrinterInfoTexts [internal]
387 */
388 static void PRINTDLG_UpdatePrinterInfoTexts(HWND hDlg, LPPRINTER_INFO_2A pi)
389 {
390 char StatusMsg[256];
391 char ResourceString[256];
392 int i;
393
394 /* Status Message */
395 StatusMsg[0]='\0';
396
397 /* add all status messages */
398 for (i = 0; i < 25; i++) {
399 if (pi->Status & (1<<i)) {
400 LoadStringA(COMDLG32_hInstance, PD32_PRINTER_STATUS_PAUSED+i,
401 ResourceString, 255);
402 strcat(StatusMsg,ResourceString);
403 }
404 }
405 /* append "ready" */
406 /* FIXME: status==ready must only be appended if really so.
407 but how to detect? */
408 LoadStringA(COMDLG32_hInstance, PD32_PRINTER_STATUS_READY,
409 ResourceString, 255);
410 strcat(StatusMsg,ResourceString);
411
412 SendDlgItemMessageA(hDlg, stc12, WM_SETTEXT, 0, (LPARAM)StatusMsg);
413
414 /* set all other printer info texts */
415 SendDlgItemMessageA(hDlg, stc11, WM_SETTEXT, 0, (LPARAM)pi->pDriverName);
416 if (pi->pLocation != NULL && pi->pLocation[0] != '\0')
417 SendDlgItemMessageA(hDlg, stc14, WM_SETTEXT, 0,(LPARAM)pi->pLocation);
418 else
419 SendDlgItemMessageA(hDlg, stc14, WM_SETTEXT, 0,(LPARAM)pi->pPortName);
420 SendDlgItemMessageA(hDlg, stc13, WM_SETTEXT, 0, (LPARAM)pi->pComment);
421 return;
422 }
423
424
425 /*******************************************************************
426 *
427 * PRINTDLG_ChangePrinter
428 *
429 */
430 static BOOL PRINTDLG_ChangePrinter(HWND hDlg, char *name,
431 PRINT_PTRA *PrintStructures)
432 {
433 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
434 LPDEVMODEA lpdm = NULL;
435 LONG dmSize;
436 DWORD needed;
437 HANDLE hprn;
438
439 if(PrintStructures->lpPrinterInfo)
440 HeapFree(GetProcessHeap(),0, PrintStructures->lpPrinterInfo);
441 if(!OpenPrinterA(name, &hprn, NULL)) {
442 ERR("Can't open printer %s\n", name);
443 return FALSE;
444 }
445 GetPrinterA(hprn, 2, NULL, 0, &needed);
446 PrintStructures->lpPrinterInfo = HeapAlloc(GetProcessHeap(),0,needed);
447 GetPrinterA(hprn, 2, (LPBYTE)PrintStructures->lpPrinterInfo, needed,
448 &needed);
449 ClosePrinter(hprn);
450
451 PRINTDLG_UpdatePrinterInfoTexts(hDlg, PrintStructures->lpPrinterInfo);
452
453 if(PrintStructures->lpDevMode) {
454 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
455 PrintStructures->lpDevMode = NULL;
456 }
457
458 dmSize = DocumentPropertiesA(0, 0, name, NULL, NULL, 0);
459 if(dmSize == -1) {
460 ERR("DocumentProperties fails on %s\n", debugstr_a(name));
461 return FALSE;
462 }
463 PrintStructures->lpDevMode = HeapAlloc(GetProcessHeap(), 0, dmSize);
464 dmSize = DocumentPropertiesA(0, 0, name, PrintStructures->lpDevMode, NULL,
465 DM_OUT_BUFFER);
466 if(lppd->hDevMode && (lpdm = GlobalLock(lppd->hDevMode)) &&
467 !strcmp(lpdm->dmDeviceName,
468 PrintStructures->lpDevMode->dmDeviceName)) {
469 /* Supplied devicemode matches current printer so try to use it */
470 DocumentPropertiesA(0, 0, name, PrintStructures->lpDevMode, lpdm,
471 DM_OUT_BUFFER | DM_IN_BUFFER);
472 }
473 if(lpdm)
474 GlobalUnlock(lppd->hDevMode);
475
476 lpdm = PrintStructures->lpDevMode; /* use this as a shortcut */
477
478 if(!(lppd->Flags & PD_PRINTSETUP)) {
479 /* Print range (All/Range/Selection) */
480 SetDlgItemInt(hDlg, edt1, lppd->nFromPage, FALSE);
481 SetDlgItemInt(hDlg, edt2, lppd->nToPage, FALSE);
482 CheckRadioButton(hDlg, rad1, rad3, rad1); /* default */
483 if (lppd->Flags & PD_NOSELECTION)
484 EnableWindow(GetDlgItem(hDlg, rad2), FALSE);
485 else
486 if (lppd->Flags & PD_SELECTION)
487 CheckRadioButton(hDlg, rad1, rad3, rad2);
488 if (lppd->Flags & PD_NOPAGENUMS) {
489 EnableWindow(GetDlgItem(hDlg, rad3), FALSE);
490 EnableWindow(GetDlgItem(hDlg, stc2),FALSE);
491 EnableWindow(GetDlgItem(hDlg, edt1), FALSE);
492 EnableWindow(GetDlgItem(hDlg, stc3),FALSE);
493 EnableWindow(GetDlgItem(hDlg, edt2), FALSE);
494 } else {
495 if (lppd->Flags & PD_PAGENUMS)
496 CheckRadioButton(hDlg, rad1, rad3, rad3);
497 }
498 /* "All xxx pages"... */
499 {
500 char resourcestr[64];
501 char result[64];
502 LoadStringA(COMDLG32_hInstance, PD32_PRINT_ALL_X_PAGES,
503 resourcestr, 49);
504 sprintf(result,resourcestr,lppd->nMaxPage - lppd->nMinPage + 1);
505 SendDlgItemMessageA(hDlg, rad1, WM_SETTEXT, 0, (LPARAM) result);
506 }
507
508 /* Collate pages
509 *
510 * FIXME: The ico3 is not displayed for some reason. I don't know why.
511 */
512 if (lppd->Flags & PD_COLLATE) {
513 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, (WPARAM) IMAGE_ICON,
514 (LPARAM)PrintStructures->hCollateIcon);
515 CheckDlgButton(hDlg, chx2, 1);
516 } else {
517 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, (WPARAM) IMAGE_ICON,
518 (LPARAM)PrintStructures->hNoCollateIcon);
519 CheckDlgButton(hDlg, chx2, 0);
520 }
521
522 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
523 /* if printer doesn't support it: no Collate */
524 if (!(lpdm->dmFields & DM_COLLATE)) {
525 EnableWindow(GetDlgItem(hDlg, chx2), FALSE);
526 EnableWindow(GetDlgItem(hDlg, ico3), FALSE);
527 }
528 }
529
530 /* nCopies */
531 if (lppd->hDevMode == 0)
532 SetDlgItemInt(hDlg, edt3, lppd->nCopies, FALSE);
533 else
534 SetDlgItemInt(hDlg, edt3, lpdm->dmCopies, FALSE);
535
536 if (lppd->Flags & PD_USEDEVMODECOPIESANDCOLLATE) {
537 /* if printer doesn't support it: no nCopies */
538 if (!(lpdm->dmFields & DM_COPIES)) {
539 EnableWindow(GetDlgItem(hDlg, edt3), FALSE);
540 EnableWindow(GetDlgItem(hDlg, stc5), FALSE);
541 }
542 }
543
544 /* print to file */
545 CheckDlgButton(hDlg, chx1, (lppd->Flags & PD_PRINTTOFILE) ? 1 : 0);
546 if (lppd->Flags & PD_DISABLEPRINTTOFILE)
547 EnableWindow(GetDlgItem(hDlg, chx1), FALSE);
548 if (lppd->Flags & PD_HIDEPRINTTOFILE)
549 ShowWindow(GetDlgItem(hDlg, chx1), SW_HIDE);
550
551 } else { /* PD_PRINTSETUP */
552 PRINTDLG_SetUpPaperComboBox(hDlg, cmb2,
553 PrintStructures->lpPrinterInfo->pPrinterName,
554 PrintStructures->lpPrinterInfo->pPortName,
555 lpdm);
556 PRINTDLG_SetUpPaperComboBox(hDlg, cmb3,
557 PrintStructures->lpPrinterInfo->pPrinterName,
558 PrintStructures->lpPrinterInfo->pPortName,
559 lpdm);
560 CheckRadioButton(hDlg, rad1, rad2,
561 (lpdm->u1.s1.dmOrientation == DMORIENT_PORTRAIT) ?
562 rad1: rad2);
563 }
564
565 /* help button */
566 if ((lppd->Flags & PD_SHOWHELP)==0) {
567 /* hide if PD_SHOWHELP not specified */
568 ShowWindow(GetDlgItem(hDlg, pshHelp), SW_HIDE);
569 }
570
571 return TRUE;
572 }
573
574 /***********************************************************************
575 * PRINTDLG_WMInitDialog [internal]
576 */
577 static LRESULT PRINTDLG_WMInitDialog(HWND hDlg, WPARAM wParam,
578 PRINT_PTRA* PrintStructures)
579 {
580 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
581 DEVNAMES *pdn;
582 DEVMODEA *pdm;
583 char *name = NULL;
584 UINT comboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
585
586 /* load Collate ICONs */
587 PrintStructures->hCollateIcon =
588 LoadIconA(COMDLG32_hInstance, "PD32_COLLATE");
589 PrintStructures->hNoCollateIcon =
590 LoadIconA(COMDLG32_hInstance, "PD32_NOCOLLATE");
591 if(PrintStructures->hCollateIcon == 0 ||
592 PrintStructures->hNoCollateIcon == 0) {
593 ERR("no icon in resourcefile\n");
594 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
595 EndDialog(hDlg, FALSE);
596 }
597
598 /* load Paper Orientation ICON */
599 /* FIXME: not implemented yet */
600
601 /*
602 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
603 * must be registered and the Help button must be shown.
604 */
605 if (lppd->Flags & PD_SHOWHELP) {
606 if((PrintStructures->HelpMessageID =
607 RegisterWindowMessageA(HELPMSGSTRING)) == 0) {
608 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
609 return FALSE;
610 }
611 } else
612 PrintStructures->HelpMessageID = 0;
613
614 /* FIXME: I allow more freedom than either Win95 or WinNT,
615 * which do not agree to what errors should be thrown or not
616 * in case nToPage or nFromPage is out-of-range.
617 */
618 if (lppd->nMaxPage < lppd->nMinPage)
619 lppd->nMaxPage = lppd->nMinPage;
620 if (lppd->nMinPage == lppd->nMaxPage)
621 lppd->Flags |= PD_NOPAGENUMS;
622 if (lppd->nToPage < lppd->nMinPage)
623 lppd->nToPage = lppd->nMinPage;
624 if (lppd->nToPage > lppd->nMaxPage)
625 lppd->nToPage = lppd->nMaxPage;
626 if (lppd->nFromPage < lppd->nMinPage)
627 lppd->nFromPage = lppd->nMinPage;
628 if (lppd->nFromPage > lppd->nMaxPage)
629 lppd->nFromPage = lppd->nMaxPage;
630
631 /* Fill Combobox
632 */
633 pdn = GlobalLock(lppd->hDevNames);
634 pdm = GlobalLock(lppd->hDevMode);
635 if(pdn)
636 name = (char*)pdn + pdn->wDeviceOffset;
637 else if(pdm)
638 name = pdm->dmDeviceName;
639 PRINTDLG_SetUpPrinterListCombo(hDlg, comboID, name);
640 if(pdm) GlobalUnlock(lppd->hDevMode);
641 if(pdn) GlobalUnlock(lppd->hDevNames);
642
643 /* Now find selected printer and update rest of dlg */
644 name = HeapAlloc(GetProcessHeap(),0,256);
645 GetDlgItemTextA(hDlg, comboID, name, 255);
646 PRINTDLG_ChangePrinter(hDlg, name, PrintStructures);
647 HeapFree(GetProcessHeap(),0,name);
648
649 return TRUE;
650 }
651
652 /***********************************************************************
653 * PRINTDLG_WMCommand [internal]
654 */
655 static LRESULT PRINTDLG_WMCommand(HWND hDlg, WPARAM wParam,
656 LPARAM lParam, PRINT_PTRA* PrintStructures)
657 {
658 LPPRINTDLGA lppd = PrintStructures->lpPrintDlg;
659 UINT PrinterComboID = (lppd->Flags & PD_PRINTSETUP) ? cmb1 : cmb4;
660 LPDEVMODEA lpdm = PrintStructures->lpDevMode;
661
662 switch (LOWORD(wParam)) {
663 case IDOK:
664 TRACE(" OK button was hit\n");
665 if (PRINTDLG_UpdatePrintDlg(hDlg, PrintStructures)!=TRUE)
666 return(FALSE);
667 EndDialog(hDlg, TRUE);
668 return(TRUE);
669
670 case IDCANCEL:
671 TRACE(" CANCEL button was hit\n");
672 EndDialog(hDlg, FALSE);
673 return(FALSE);
674
675 case pshHelp:
676 TRACE(" HELP button was hit\n");
677 SendMessageA(lppd->hwndOwner, PrintStructures->HelpMessageID,
678 (WPARAM) hDlg, (LPARAM) lppd);
679 break;
680
681 case chx2: /* collate pages checkbox */
682 if (IsDlgButtonChecked(hDlg, chx2) == BST_CHECKED)
683 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, (WPARAM) IMAGE_ICON,
684 (LPARAM)PrintStructures->hCollateIcon);
685 else
686 SendDlgItemMessageA(hDlg, ico3, STM_SETIMAGE, (WPARAM) IMAGE_ICON,
687 (LPARAM)PrintStructures->hNoCollateIcon);
688 break;
689 case edt1: /* from page nr editbox */
690 case edt2: /* to page nr editbox */
691 if (HIWORD(wParam)==EN_CHANGE) {
692 WORD nToPage;
693 WORD nFromPage;
694 nFromPage = GetDlgItemInt(hDlg, edt1, NULL, FALSE);
695 nToPage = GetDlgItemInt(hDlg, edt2, NULL, FALSE);
696 if (nFromPage != lppd->nFromPage || nToPage != lppd->nToPage)
697 CheckRadioButton(hDlg, rad1, rad3, rad3);
698 }
699 break;
700 case psh2: /* Properties button */
701 {
702 HANDLE hPrinter;
703 char PrinterName[256];
704
705 GetDlgItemTextA(hDlg, PrinterComboID, PrinterName, 255);
706 if (!OpenPrinterA(PrinterName, &hPrinter, NULL)) {
707 WARN(" Call to OpenPrinter did not succeed!\n");
708 break;
709 }
710 DocumentPropertiesA(hDlg, hPrinter, PrinterName,
711 PrintStructures->lpDevMode,
712 PrintStructures->lpDevMode,
713 DM_IN_BUFFER | DM_OUT_BUFFER | DM_IN_PROMPT);
714 ClosePrinter(hPrinter);
715 break;
716 }
717
718 case cmb1:
719 case cmb4: /* Printer combobox */
720 if (HIWORD(wParam)==CBN_SELCHANGE) {
721 char PrinterName[256];
722 GetDlgItemTextA(hDlg, LOWORD(wParam), PrinterName, 255);
723 PRINTDLG_ChangePrinter(hDlg, PrinterName, PrintStructures);
724 }
725 break;
726
727 case cmb2: /* Papersize */
728 {
729 DWORD Sel = SendDlgItemMessageA(hDlg, cmb2, CB_GETCURSEL, 0, 0);
730 if(Sel != CB_ERR)
731 lpdm->u1.s1.dmPaperSize = SendDlgItemMessageA(hDlg, cmb2,
732 CB_GETITEMDATA,
733 Sel, 0);
734 }
735 break;
736
737 case cmb3: /* Bin */
738 {
739 DWORD Sel = SendDlgItemMessageA(hDlg, cmb3, CB_GETCURSEL, 0, 0);
740 if(Sel != CB_ERR)
741 lpdm->dmDefaultSource = SendDlgItemMessageA(hDlg, cmb3,
742 CB_GETITEMDATA, Sel,
743 0);
744 }
745 break;
746 }
747 return FALSE;
748 }
749
750 /***********************************************************************
751 * PrintDlgProcA [internal]
752 */
753 BOOL WINAPI PrintDlgProcA(HWND hDlg, UINT uMsg, WPARAM wParam,
754 LPARAM lParam)
755 {
756 PRINT_PTRA* PrintStructures;
757 LRESULT res=FALSE;
758
759 if (uMsg!=WM_INITDIALOG) {
760 PrintStructures = (PRINT_PTRA*) GetWindowLongA(hDlg, DWL_USER);
761 if (!PrintStructures)
762 return FALSE;
763 } else {
764 PrintStructures = (PRINT_PTRA*) lParam;
765 SetWindowLongA(hDlg, DWL_USER, lParam);
766 res = PRINTDLG_WMInitDialog(hDlg, wParam, PrintStructures);
767
768 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK) {
769 res = PrintStructures->lpPrintDlg->lpfnPrintHook(hDlg, uMsg,
770 wParam,
771 (LPARAM)PrintStructures->lpPrintDlg);
772 }
773 return res;
774 }
775
776 if(PrintStructures->lpPrintDlg->Flags & PD_ENABLEPRINTHOOK) {
777 res = PrintStructures->lpPrintDlg->lpfnPrintHook(hDlg, uMsg, wParam,
778 lParam);
779 if(res) return res;
780 }
781
782 switch (uMsg) {
783 case WM_COMMAND:
784 return PRINTDLG_WMCommand(hDlg, wParam, lParam, PrintStructures);
785
786 case WM_DESTROY:
787 DestroyIcon(PrintStructures->hCollateIcon);
788 DestroyIcon(PrintStructures->hNoCollateIcon);
789 /* FIXME: don't forget to delete the paper orientation icons here! */
790
791 return FALSE;
792 }
793 return res;
794 }
795
796 /************************************************************
797 *
798 * PRINTDLG_GetDlgTemplate
799 *
800 */
801 static HGLOBAL PRINTDLG_GetDlgTemplate(PRINTDLGA *lppd)
802 {
803 HGLOBAL hDlgTmpl, hResInfo;
804
805 if (lppd->Flags & PD_PRINTSETUP) {
806 if(lppd->Flags & PD_ENABLESETUPTEMPLATEHANDLE) {
807 hDlgTmpl = lppd->hSetupTemplate;
808 } else if(lppd->Flags & PD_ENABLESETUPTEMPLATE) {
809 hResInfo = FindResourceA(lppd->hInstance,
810 lppd->lpSetupTemplateName, RT_DIALOGA);
811 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
812 } else {
813 hResInfo = FindResourceA(COMDLG32_hInstance, "PRINT32_SETUP",
814 RT_DIALOGA);
815 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
816 }
817 } else {
818 if(lppd->Flags & PD_ENABLEPRINTTEMPLATEHANDLE) {
819 hDlgTmpl = lppd->hPrintTemplate;
820 } else if(lppd->Flags & PD_ENABLEPRINTTEMPLATE) {
821 hResInfo = FindResourceA(lppd->hInstance,
822 lppd->lpPrintTemplateName,
823 RT_DIALOGA);
824 hDlgTmpl = LoadResource(lppd->hInstance, hResInfo);
825 } else {
826 hResInfo = FindResourceA(COMDLG32_hInstance, "PRINT32",
827 RT_DIALOGA);
828 hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo);
829 }
830 }
831 return hDlgTmpl;
832 }
833
834 /***********************************************************************
835 *
836 * PRINTDLG_CreateDC
837 *
838 */
839 static BOOL PRINTDLG_CreateDC(LPPRINTDLGA lppd)
840 {
841 DEVNAMES *pdn = GlobalLock(lppd->hDevNames);
842 DEVMODEA *pdm = GlobalLock(lppd->hDevMode);
843
844 if(lppd->Flags & PD_RETURNDC) {
845 lppd->hDC = CreateDCA((char*)pdn + pdn->wDriverOffset,
846 (char*)pdn + pdn->wDeviceOffset,
847 (char*)pdn + pdn->wOutputOffset,
848 pdm );
849 } else if(lppd->Flags & PD_RETURNIC) {
850 lppd->hDC = CreateICA((char*)pdn + pdn->wDriverOffset,
851 (char*)pdn + pdn->wDeviceOffset,
852 (char*)pdn + pdn->wOutputOffset,
853 pdm );
854 }
855 GlobalUnlock(lppd->hDevNames);
856 GlobalUnlock(lppd->hDevMode);
857 return lppd->hDC ? TRUE : FALSE;
858 }
859
860 /***********************************************************************
861 * PrintDlgA (COMDLG32.17)
862 *
863 * Displays the the PRINT dialog box, which enables the user to specify
864 * specific properties of the print job.
865 *
866 * RETURNS
867 * nonzero if the user pressed the OK button
868 * zero if the user cancelled the window or an error occurred
869 *
870 * BUGS
871 * PrintDlg:
872 * * The Collate Icons do not display, even though they are in the code.
873 * * The Properties Button(s) should call DocumentPropertiesA().
874 * PrintSetupDlg:
875 * * The Paper Orientation Icons are not implemented yet.
876 * * The Properties Button(s) should call DocumentPropertiesA().
877 * * Settings are not yet taken from a provided DevMode or
878 * default printer settings.
879 */
880 BOOL WINAPI PrintDlgA(
881 LPPRINTDLGA lppd /* [in/out] ptr to PRINTDLG32 struct */
882 )
883 {
884 BOOL bRet = FALSE;
885 LPVOID ptr;
886 HINSTANCE hInst = GetWindowLongA( lppd->hwndOwner, GWL_HINSTANCE );
887
888 if(TRACE_ON(commdlg)) {
889 char flagstr[1000] = "";
890 struct pd_flags *pflag = pd_flags;
891 for( ; pflag->name; pflag++) {
892 if(lppd->Flags & pflag->flag)
893 strcat(flagstr, pflag->name);
894 }
895 TRACE("(%p): hwndOwner = %08x, hDevMode = %08x, hDevNames = %08x\n"
896 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %08x\n"
897 "flags %08lx (%s)\n",
898 lppd, lppd->hwndOwner, lppd->hDevMode, lppd->hDevNames,
899 lppd->nFromPage, lppd->nToPage, lppd->nMinPage, lppd->nMaxPage,
900 lppd->nCopies, lppd->hInstance, lppd->Flags, flagstr);
901 }
902
903 if(lppd->lStructSize != sizeof(PRINTDLGA)) {
904 WARN("structure size failure !!!\n");
905 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
906 return FALSE;
907 }
908
909 if(lppd->Flags & PD_RETURNDEFAULT) {
910 PRINTER_INFO_2A *pbuf;
911 HANDLE hprn;
912 DWORD needed;
913
914 if(lppd->hDevMode || lppd->hDevNames) {
915 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
916 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE);
917 return FALSE;
918 }
919 if(!PRINTDLG_OpenDefaultPrinter(&hprn)) {
920 WARN("Can't find default printer\n");
921 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN);
922 return FALSE;
923 }
924
925 GetPrinterA(hprn, 2, NULL, 0, &needed);
926 pbuf = HeapAlloc(GetProcessHeap(), 0, needed);
927 GetPrinterA(hprn, 2, (LPBYTE)pbuf, needed, &needed);
928 ClosePrinter(hprn);
929 PRINTDLG_CreateDevNames(&(lppd->hDevNames), "winspool",
930 pbuf->pDevMode->dmDeviceName,
931 pbuf->pPortName);
932 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE, pbuf->pDevMode->dmSize +
933 pbuf->pDevMode->dmDriverExtra);
934 ptr = GlobalLock(lppd->hDevMode);
935 memcpy(ptr, pbuf->pDevMode, pbuf->pDevMode->dmSize +
936 pbuf->pDevMode->dmDriverExtra);
937 GlobalUnlock(lppd->hDevMode);
938 HeapFree(GetProcessHeap(), 0, pbuf);
939 bRet = TRUE;
940 } else {
941 HGLOBAL hDlgTmpl;
942 PRINT_PTRA *PrintStructures;
943
944 /* load Dialog resources,
945 * depending on Flags indicates Print32 or Print32_setup dialog
946 */
947 hDlgTmpl = PRINTDLG_GetDlgTemplate(lppd);
948 if (!(hDlgTmpl) || !(ptr = LockResource( hDlgTmpl ))) {
949 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
950 return FALSE;
951 }
952 PrintStructures = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
953 sizeof(PRINT_PTRA));
954 PrintStructures->lpPrintDlg = lppd;
955
956 /* and create & process the dialog .
957 * -1 is failure, 0 is broken hwnd, everything else is ok.
958 */
959 bRet = (0<DialogBoxIndirectParamA(hInst, ptr, lppd->hwndOwner,
960 PrintDlgProcA,
961 (LPARAM)PrintStructures));
962
963 if(bRet) {
964 DEVMODEA *lpdm = PrintStructures->lpDevMode, *lpdmReturn;
965 PRINTER_INFO_2A *pi = PrintStructures->lpPrinterInfo;
966
967 if (lppd->hDevMode == 0) {
968 TRACE(" No hDevMode yet... Need to create my own\n");
969 lppd->hDevMode = GlobalAlloc(GMEM_MOVEABLE,
970 lpdm->dmSize + lpdm->dmDriverExtra);
971 } else {
972 WORD locks;
973 if((locks = (GlobalFlags(lppd->hDevMode) & GMEM_LOCKCOUNT))) {
974 WARN("hDevMode has %d locks on it. Unlocking it now\n", locks);
975 while(locks--) {
976 GlobalUnlock(lppd->hDevMode);
977 TRACE("Now got %d locks\n", locks);
978 }
979 }
980 lppd->hDevMode = GlobalReAlloc(lppd->hDevMode,
981 lpdm->dmSize + lpdm->dmDriverExtra,
982 GMEM_MOVEABLE);
983 }
984 lpdmReturn = GlobalLock(lppd->hDevMode);
985 memcpy(lpdmReturn, lpdm, lpdm->dmSize + lpdm->dmDriverExtra);
986
987 if (lppd->hDevNames != 0) {
988 WORD locks;
989 if((locks = (GlobalFlags(lppd->hDevNames) & GMEM_LOCKCOUNT))) {
990 WARN("hDevNames has %d locks on it. Unlocking it now\n", locks);
991 while(locks--)
992 GlobalUnlock(lppd->hDevNames);
993 }
994 }
995 PRINTDLG_CreateDevNames(&(lppd->hDevNames), "winspool",
996 lpdmReturn->dmDeviceName, pi->pPortName);
997 GlobalUnlock(lppd->hDevMode);
998 }
999 HeapFree(GetProcessHeap(), 0, PrintStructures->lpDevMode);
1000 HeapFree(GetProcessHeap(), 0, PrintStructures->lpPrinterInfo);
1001 HeapFree(GetProcessHeap(), 0, PrintStructures);
1002 }
1003 if(bRet && (lppd->Flags & PD_RETURNDC || lppd->Flags & PD_RETURNIC))
1004 bRet = PRINTDLG_CreateDC(lppd);
1005
1006 TRACE("exit! (%d)\n", bRet);
1007 return bRet;
1008 }
1009
1010
1011
1012 /***********************************************************************
1013 * PrintDlgW (COMDLG32.18)
1014 */
1015 BOOL WINAPI PrintDlgW( LPPRINTDLGW printdlg )
1016 {
1017 FIXME("A really empty stub\n" );
1018 return FALSE;
1019 }
1020
1021 /***********************************************************************
1022 *
1023 * PageSetupDlg
1024 */
1025
1026 /***********************************************************************
1027 * PageSetupDlgA (COMDLG32.15)
1028 */
1029 BOOL WINAPI PageSetupDlgA(LPPAGESETUPDLGA setupdlg) {
1030 FIXME("(%p), stub!\n",setupdlg);
1031 return FALSE;
1032 }
1033 /***********************************************************************
1034 * PageSetupDlgW (COMDLG32.16)
1035 */
1036 BOOL WINAPI PageSetupDlgW(LPPAGESETUPDLGW setupdlg) {
1037 FIXME("(%p), stub!\n",setupdlg);
1038 return FALSE;
1039 }
1040
1041 /**********************************************************************
1042 *
1043 * 16 bit commdlg
1044 */
1045
1046 /***********************************************************************
1047 * PrintDlgProc16 (COMMDLG.21)
1048 */
1049 LRESULT WINAPI PrintDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1050 LPARAM lParam)
1051 {
1052 switch (wMsg)
1053 {
1054 case WM_INITDIALOG:
1055 TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
1056 ShowWindow(hWnd, SW_SHOWNORMAL);
1057 return (TRUE);
1058 case WM_COMMAND:
1059 switch (wParam)
1060 {
1061 case IDOK:
1062 EndDialog(hWnd, TRUE);
1063 return(TRUE);
1064 case IDCANCEL:
1065 EndDialog(hWnd, FALSE);
1066 return(TRUE);
1067 }
1068 return(FALSE);
1069 }
1070 return FALSE;
1071 }
1072
1073
1074 /***********************************************************************
1075 * PrintSetupDlgProc16 (COMMDLG.22)
1076 */
1077 LRESULT WINAPI PrintSetupDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1078 LPARAM lParam)
1079 {
1080 switch (wMsg)
1081 {
1082 case WM_INITDIALOG:
1083 TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
1084 ShowWindow(hWnd, SW_SHOWNORMAL);
1085 return (TRUE);
1086 case WM_COMMAND:
1087 switch (wParam) {
1088 case IDOK:
1089 EndDialog(hWnd, TRUE);
1090 return(TRUE);
1091 case IDCANCEL:
1092 EndDialog(hWnd, FALSE);
1093 return(TRUE);
1094 }
1095 return(FALSE);
1096 }
1097 return FALSE;
1098 }
1099
1100
1101 /***********************************************************************
1102 * PrintDlg16 (COMMDLG.20)
1103 *
1104 * Displays the the PRINT dialog box, which enables the user to specify
1105 * specific properties of the print job.
1106 *
1107 * RETURNS
1108 * nonzero if the user pressed the OK button
1109 * zero if the user cancelled the window or an error occurred
1110 *
1111 * BUGS
1112 * * calls up to the 32-bit versions of the Dialogs, which look different
1113 * * Customizing is *not* implemented.
1114 */
1115 BOOL16 WINAPI PrintDlg16( LPPRINTDLG16 lpPrint )
1116 {
1117 PRINTDLGA Print32;
1118 BOOL16 ret;
1119 char *ptr, *ptr16;
1120 DWORD size;
1121
1122 memset(&Print32, 0, sizeof(Print32));
1123 Print32.lStructSize = sizeof(Print32);
1124 Print32.hwndOwner = lpPrint->hwndOwner;
1125 if(lpPrint->hDevMode) {
1126 size = GlobalSize16(lpPrint->hDevMode);
1127 Print32.hDevMode = GlobalAlloc(GMEM_MOVEABLE, size);
1128 ptr = GlobalLock(Print32.hDevMode);
1129 ptr16 = GlobalLock16(lpPrint->hDevMode);
1130 memcpy(ptr, ptr16, size);
1131 GlobalFree16(lpPrint->hDevMode);
1132 GlobalUnlock(Print32.hDevMode);
1133 } else
1134 Print32.hDevMode = 0;
1135 if(lpPrint->hDevNames) {
1136 size = GlobalSize16(lpPrint->hDevNames);
1137 Print32.hDevNames = GlobalAlloc(GMEM_MOVEABLE, size);
1138 ptr = GlobalLock(Print32.hDevNames);
1139 ptr16 = GlobalLock16(lpPrint->hDevNames);
1140 memcpy(ptr, ptr16, size);
1141 GlobalFree16(lpPrint->hDevNames);
1142 GlobalUnlock(Print32.hDevNames);
1143 } else
1144 Print32.hDevNames = 0;
1145 Print32.Flags = lpPrint->Flags;
1146 Print32.nFromPage = lpPrint->nFromPage;
1147 Print32.nToPage = lpPrint->nToPage;
1148 Print32.nMinPage = lpPrint->nMinPage;
1149 Print32.nMaxPage = lpPrint->nMaxPage;
1150 Print32.nCopies = lpPrint->nCopies;
1151 Print32.hInstance = lpPrint->hInstance;
1152 Print32.lCustData = lpPrint->lCustData;
1153 if(lpPrint->lpfnPrintHook) {
1154 FIXME("Need to allocate thunk\n");
1155 /* Print32.lpfnPrintHook = lpPrint->lpfnPrintHook;*/
1156 }
1157 if(lpPrint->lpfnSetupHook) {
1158 FIXME("Need to allocate thunk\n");
1159 /* Print32.lpfnSetupHook = lpPrint->lpfnSetupHook;*/
1160 }
1161 Print32.lpPrintTemplateName = MapSL(lpPrint->lpPrintTemplateName);
1162 Print32.lpSetupTemplateName = MapSL(lpPrint->lpSetupTemplateName);
1163 Print32.hPrintTemplate = lpPrint->hPrintTemplate;
1164 Print32.hSetupTemplate = lpPrint->hSetupTemplate;
1165
1166 ret = PrintDlgA(&Print32);
1167
1168 if(Print32.hDevMode) {
1169 size = GlobalSize(Print32.hDevMode);
1170 lpPrint->hDevMode = GlobalAlloc16(GMEM_MOVEABLE, size);
1171 ptr16 = GlobalLock16(lpPrint->hDevMode);
1172 ptr = GlobalLock(Print32.hDevMode);
1173 memcpy(ptr16, ptr, size);
1174 GlobalFree(Print32.hDevMode);
1175 GlobalUnlock16(lpPrint->hDevMode);
1176 } else
1177 lpPrint->hDevMode = 0;
1178 if(Print32.hDevNames) {
1179 size = GlobalSize(Print32.hDevNames);
1180 lpPrint->hDevNames = GlobalAlloc16(GMEM_MOVEABLE, size);
1181 ptr16 = GlobalLock16(lpPrint->hDevNames);
1182 ptr = GlobalLock(Print32.hDevNames);
1183 memcpy(ptr16, ptr, size);
1184 GlobalFree(Print32.hDevNames);
1185 GlobalUnlock16(lpPrint->hDevNames);
1186 } else
1187 lpPrint->hDevNames = 0;
1188 lpPrint->hDC = Print32.hDC;
1189 lpPrint->Flags = Print32.Flags;
1190 lpPrint->nFromPage = Print32.nFromPage;
1191 lpPrint->nToPage = Print32.nToPage;
1192 lpPrint->nCopies = Print32.nCopies;
1193
1194 return ret;
1195 }
1196
1197 /***********************************************************************
1198 * PrintDlgExA
1199 */
1200 HRESULT WINAPI PrintDlgExA(LPVOID lpPrintDlgExA) /* [???] FIXME: LPPRINTDLGEXA */
1201 {
1202 FIXME("stub\n");
1203 return E_NOTIMPL;
1204 }
1205 /***********************************************************************
1206 * PrintDlgExW
1207 */
1208 HRESULT WINAPI PrintDlgExW(LPVOID lpPrintDlgExW) /* [???] FIXME: LPPRINTDLGEXW */
1209 {
1210 FIXME("stub\n");
1211 return E_NOTIMPL;
1212 }
widl and rpcrt4 development