2 * COMMDLG - Print Dialog
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1996 Albrecht Kleine
6 * Copyright 1999 Klaas van Gend
7 * Copyright 2000 Huw D M Davies
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.
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.
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
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
39 #include "wine/unicode.h"
40 #include "wine/debug.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(commdlg
);
49 /* Yes these constants are the same, but we're just copying win98 */
50 #define UPDOWN_ID 0x270f
51 #define MAX_COPIES 9999
53 /* This PRINTDLGA internal structure stores
54 * pointers to several throughout useful structures.
60 LPPRINTDLGA lpPrintDlg
;
61 LPPRINTER_INFO_2A lpPrinterInfo
;
62 LPDRIVER_INFO_3A lpDriverInfo
;
64 HICON hCollateIcon
; /* PrintDlg only */
65 HICON hNoCollateIcon
; /* PrintDlg only */
66 HICON hPortraitIcon
; /* PrintSetupDlg only */
67 HICON hLandscapeIcon
; /* PrintSetupDlg only */
74 LPPRINTDLGW lpPrintDlg
;
75 LPPRINTER_INFO_2W lpPrinterInfo
;
76 LPDRIVER_INFO_3W lpDriverInfo
;
78 HICON hCollateIcon
; /* PrintDlg only */
79 HICON hNoCollateIcon
; /* PrintDlg only */
80 HICON hPortraitIcon
; /* PrintSetupDlg only */
81 HICON hLandscapeIcon
; /* PrintSetupDlg only */
92 static const struct pd_flags psd_flags
[] = {
93 {PSD_MINMARGINS
,"PSD_MINMARGINS"},
94 {PSD_MARGINS
,"PSD_MARGINS"},
95 {PSD_INTHOUSANDTHSOFINCHES
,"PSD_INTHOUSANDTHSOFINCHES"},
96 {PSD_INHUNDREDTHSOFMILLIMETERS
,"PSD_INHUNDREDTHSOFMILLIMETERS"},
97 {PSD_DISABLEMARGINS
,"PSD_DISABLEMARGINS"},
98 {PSD_DISABLEPRINTER
,"PSD_DISABLEPRINTER"},
99 {PSD_NOWARNING
,"PSD_NOWARNING"},
100 {PSD_DISABLEORIENTATION
,"PSD_DISABLEORIENTATION"},
101 {PSD_RETURNDEFAULT
,"PSD_RETURNDEFAULT"},
102 {PSD_DISABLEPAPER
,"PSD_DISABLEPAPER"},
103 {PSD_SHOWHELP
,"PSD_SHOWHELP"},
104 {PSD_ENABLEPAGESETUPHOOK
,"PSD_ENABLEPAGESETUPHOOK"},
105 {PSD_ENABLEPAGESETUPTEMPLATE
,"PSD_ENABLEPAGESETUPTEMPLATE"},
106 {PSD_ENABLEPAGESETUPTEMPLATEHANDLE
,"PSD_ENABLEPAGESETUPTEMPLATEHANDLE"},
107 {PSD_ENABLEPAGEPAINTHOOK
,"PSD_ENABLEPAGEPAINTHOOK"},
108 {PSD_DISABLEPAGEPAINTING
,"PSD_DISABLEPAGEPAINTING"},
112 static const struct pd_flags pd_flags
[] = {
113 {PD_SELECTION
, "PD_SELECTION "},
114 {PD_PAGENUMS
, "PD_PAGENUMS "},
115 {PD_NOSELECTION
, "PD_NOSELECTION "},
116 {PD_NOPAGENUMS
, "PD_NOPAGENUMS "},
117 {PD_COLLATE
, "PD_COLLATE "},
118 {PD_PRINTTOFILE
, "PD_PRINTTOFILE "},
119 {PD_PRINTSETUP
, "PD_PRINTSETUP "},
120 {PD_NOWARNING
, "PD_NOWARNING "},
121 {PD_RETURNDC
, "PD_RETURNDC "},
122 {PD_RETURNIC
, "PD_RETURNIC "},
123 {PD_RETURNDEFAULT
, "PD_RETURNDEFAULT "},
124 {PD_SHOWHELP
, "PD_SHOWHELP "},
125 {PD_ENABLEPRINTHOOK
, "PD_ENABLEPRINTHOOK "},
126 {PD_ENABLESETUPHOOK
, "PD_ENABLESETUPHOOK "},
127 {PD_ENABLEPRINTTEMPLATE
, "PD_ENABLEPRINTTEMPLATE "},
128 {PD_ENABLESETUPTEMPLATE
, "PD_ENABLESETUPTEMPLATE "},
129 {PD_ENABLEPRINTTEMPLATEHANDLE
, "PD_ENABLEPRINTTEMPLATEHANDLE "},
130 {PD_ENABLESETUPTEMPLATEHANDLE
, "PD_ENABLESETUPTEMPLATEHANDLE "},
131 {PD_USEDEVMODECOPIES
, "PD_USEDEVMODECOPIES[ANDCOLLATE] "},
132 {PD_DISABLEPRINTTOFILE
, "PD_DISABLEPRINTTOFILE "},
133 {PD_HIDEPRINTTOFILE
, "PD_HIDEPRINTTOFILE "},
134 {PD_NONETWORKBUTTON
, "PD_NONETWORKBUTTON "},
137 /* address of wndproc for subclassed Static control */
138 static WNDPROC lpfnStaticWndProc
;
139 static WNDPROC edit_wndproc
;
140 /* the text of the fake document to render for the Page Setup dialog */
141 static WCHAR wszFakeDocumentText
[1024];
142 static const WCHAR pd32_collateW
[] = { 'P', 'D', '3', '2', '_', 'C', 'O', 'L', 'L', 'A', 'T', 'E', 0 };
143 static const WCHAR pd32_nocollateW
[] = { 'P', 'D', '3', '2', '_', 'N', 'O', 'C', 'O', 'L', 'L', 'A', 'T', 'E', 0 };
144 static const WCHAR pd32_portraitW
[] = { 'P', 'D', '3', '2', '_', 'P', 'O', 'R', 'T', 'R', 'A', 'I', 'T', 0 };
145 static const WCHAR pd32_landscapeW
[] = { 'P', 'D', '3', '2', '_', 'L', 'A', 'N', 'D', 'S', 'C', 'A', 'P', 'E', 0 };
146 static const WCHAR printdlg_prop
[] = {'_','_','W','I','N','E','_','P','R','I','N','T','D','L','G','D','A','T','A',0};
147 static const WCHAR pagesetupdlg_prop
[] = { '_', '_', 'W', 'I', 'N', 'E', '_', 'P', 'A', 'G', 'E',
148 'S', 'E', 'T', 'U', 'P', 'D', 'L', 'G', 'D', 'A', 'T', 'A', 0 };
151 static LPWSTR
strdupW(LPCWSTR p
)
157 len
= (strlenW(p
) + 1) * sizeof(WCHAR
);
158 ret
= HeapAlloc(GetProcessHeap(), 0, len
);
163 /***********************************************************
164 * convert_to_devmodeA
166 * Creates an ansi copy of supplied devmode
168 static DEVMODEA
*convert_to_devmodeA(const DEVMODEW
*dmW
)
173 if (!dmW
) return NULL
;
174 size
= dmW
->dmSize
- CCHDEVICENAME
-
175 ((dmW
->dmSize
> FIELD_OFFSET(DEVMODEW
, dmFormName
)) ? CCHFORMNAME
: 0);
177 dmA
= HeapAlloc(GetProcessHeap(), 0, size
+ dmW
->dmDriverExtra
);
178 if (!dmA
) return NULL
;
180 WideCharToMultiByte(CP_ACP
, 0, dmW
->dmDeviceName
, -1,
181 (LPSTR
)dmA
->dmDeviceName
, CCHDEVICENAME
, NULL
, NULL
);
183 if (FIELD_OFFSET(DEVMODEW
, dmFormName
) >= dmW
->dmSize
)
185 memcpy(&dmA
->dmSpecVersion
, &dmW
->dmSpecVersion
,
186 dmW
->dmSize
- FIELD_OFFSET(DEVMODEW
, dmSpecVersion
));
190 memcpy(&dmA
->dmSpecVersion
, &dmW
->dmSpecVersion
,
191 FIELD_OFFSET(DEVMODEW
, dmFormName
) - FIELD_OFFSET(DEVMODEW
, dmSpecVersion
));
192 WideCharToMultiByte(CP_ACP
, 0, dmW
->dmFormName
, -1,
193 (LPSTR
)dmA
->dmFormName
, CCHFORMNAME
, NULL
, NULL
);
195 memcpy(&dmA
->dmLogPixels
, &dmW
->dmLogPixels
, dmW
->dmSize
- FIELD_OFFSET(DEVMODEW
, dmLogPixels
));
199 memcpy((char *)dmA
+ dmA
->dmSize
, (const char *)dmW
+ dmW
->dmSize
, dmW
->dmDriverExtra
);
203 /***********************************************************************
204 * PRINTDLG_OpenDefaultPrinter
206 * Returns a winspool printer handle to the default printer in *hprn
207 * Caller must call ClosePrinter on the handle
209 * Returns TRUE on success else FALSE
211 static BOOL
PRINTDLG_OpenDefaultPrinter(HANDLE
*hprn
)
214 DWORD dwBufLen
= sizeof(buf
) / sizeof(buf
[0]);
216 if(!GetDefaultPrinterW(buf
, &dwBufLen
))
218 res
= OpenPrinterW(buf
, hprn
, NULL
);
220 WARN("Could not open printer %s\n", debugstr_w(buf
));
224 /***********************************************************************
225 * PRINTDLG_SetUpPrinterListCombo
227 * Initializes printer list combox.
228 * hDlg: HWND of dialog
229 * id: Control id of combo
230 * name: Name of printer to select
232 * Initializes combo with list of available printers. Selects printer 'name'
233 * If name is NULL or does not exist select the default printer.
235 * Returns number of printers added to list.
237 static INT
PRINTDLG_SetUpPrinterListComboA(HWND hDlg
, UINT id
, LPCSTR name
)
241 LPPRINTER_INFO_2A pi
;
242 EnumPrintersA(PRINTER_ENUM_LOCAL
, NULL
, 2, NULL
, 0, &needed
, &num
);
243 pi
= HeapAlloc(GetProcessHeap(), 0, needed
);
244 EnumPrintersA(PRINTER_ENUM_LOCAL
, NULL
, 2, (LPBYTE
)pi
, needed
, &needed
,
247 SendDlgItemMessageA(hDlg
, id
, CB_RESETCONTENT
, 0, 0);
249 for(i
= 0; i
< num
; i
++) {
250 SendDlgItemMessageA(hDlg
, id
, CB_ADDSTRING
, 0,
251 (LPARAM
)pi
[i
].pPrinterName
);
253 HeapFree(GetProcessHeap(), 0, pi
);
255 (i
= SendDlgItemMessageA(hDlg
, id
, CB_FINDSTRINGEXACT
, -1,
256 (LPARAM
)name
)) == CB_ERR
) {
259 DWORD dwBufLen
= sizeof(buf
);
261 WARN("Can't find %s in printer list so trying to find default\n",
263 if(!GetDefaultPrinterA(buf
, &dwBufLen
))
265 i
= SendDlgItemMessageA(hDlg
, id
, CB_FINDSTRINGEXACT
, -1, (LPARAM
)buf
);
267 FIXME("Can't find default printer in printer list\n");
269 SendDlgItemMessageA(hDlg
, id
, CB_SETCURSEL
, i
, 0);
273 static INT
PRINTDLG_SetUpPrinterListComboW(HWND hDlg
, UINT id
, LPCWSTR name
)
277 LPPRINTER_INFO_2W pi
;
278 EnumPrintersW(PRINTER_ENUM_LOCAL
, NULL
, 2, NULL
, 0, &needed
, &num
);
279 pi
= HeapAlloc(GetProcessHeap(), 0, needed
);
280 EnumPrintersW(PRINTER_ENUM_LOCAL
, NULL
, 2, (LPBYTE
)pi
, needed
, &needed
,
283 for(i
= 0; i
< num
; i
++) {
284 SendDlgItemMessageW(hDlg
, id
, CB_ADDSTRING
, 0,
285 (LPARAM
)pi
[i
].pPrinterName
);
287 HeapFree(GetProcessHeap(), 0, pi
);
289 (i
= SendDlgItemMessageW(hDlg
, id
, CB_FINDSTRINGEXACT
, -1,
290 (LPARAM
)name
)) == CB_ERR
) {
292 DWORD dwBufLen
= sizeof(buf
)/sizeof(buf
[0]);
294 WARN("Can't find %s in printer list so trying to find default\n",
296 if(!GetDefaultPrinterW(buf
, &dwBufLen
))
298 i
= SendDlgItemMessageW(hDlg
, id
, CB_FINDSTRINGEXACT
, -1, (LPARAM
)buf
);
300 TRACE("Can't find default printer in printer list\n");
302 SendDlgItemMessageW(hDlg
, id
, CB_SETCURSEL
, i
, 0);
306 /***********************************************************************
307 * PRINTDLG_CreateDevNames [internal]
310 * creates a DevNames structure.
312 * (NB. when we handle unicode the offsets will be in wchars).
314 static BOOL
PRINTDLG_CreateDevNames(HGLOBAL
*hmem
, const char* DeviceDriverName
,
315 const char* DeviceName
, const char* OutputPort
)
318 char* pDevNamesSpace
;
320 LPDEVNAMES lpDevNames
;
322 DWORD dwBufLen
= sizeof(buf
);
324 size
= strlen(DeviceDriverName
) + 1
325 + strlen(DeviceName
) + 1
326 + strlen(OutputPort
) + 1
330 *hmem
= GlobalReAlloc(*hmem
, size
, GMEM_MOVEABLE
);
332 *hmem
= GlobalAlloc(GMEM_MOVEABLE
, size
);
336 pDevNamesSpace
= GlobalLock(*hmem
);
337 lpDevNames
= (LPDEVNAMES
) pDevNamesSpace
;
339 pTempPtr
= pDevNamesSpace
+ sizeof(DEVNAMES
);
340 strcpy(pTempPtr
, DeviceDriverName
);
341 lpDevNames
->wDriverOffset
= pTempPtr
- pDevNamesSpace
;
343 pTempPtr
+= strlen(DeviceDriverName
) + 1;
344 strcpy(pTempPtr
, DeviceName
);
345 lpDevNames
->wDeviceOffset
= pTempPtr
- pDevNamesSpace
;
347 pTempPtr
+= strlen(DeviceName
) + 1;
348 strcpy(pTempPtr
, OutputPort
);
349 lpDevNames
->wOutputOffset
= pTempPtr
- pDevNamesSpace
;
351 GetDefaultPrinterA(buf
, &dwBufLen
);
352 lpDevNames
->wDefault
= (strcmp(buf
, DeviceName
) == 0) ? 1 : 0;
357 static BOOL
PRINTDLG_CreateDevNamesW(HGLOBAL
*hmem
, LPCWSTR DeviceDriverName
,
358 LPCWSTR DeviceName
, LPCWSTR OutputPort
)
361 LPWSTR pDevNamesSpace
;
363 LPDEVNAMES lpDevNames
;
365 DWORD dwBufLen
= sizeof(bufW
) / sizeof(WCHAR
);
367 size
= sizeof(WCHAR
)*lstrlenW(DeviceDriverName
) + 2
368 + sizeof(WCHAR
)*lstrlenW(DeviceName
) + 2
369 + sizeof(WCHAR
)*lstrlenW(OutputPort
) + 2
373 *hmem
= GlobalReAlloc(*hmem
, size
, GMEM_MOVEABLE
);
375 *hmem
= GlobalAlloc(GMEM_MOVEABLE
, size
);
379 pDevNamesSpace
= GlobalLock(*hmem
);
380 lpDevNames
= (LPDEVNAMES
) pDevNamesSpace
;
382 pTempPtr
= (LPWSTR
)((LPDEVNAMES
)pDevNamesSpace
+ 1);
383 lstrcpyW(pTempPtr
, DeviceDriverName
);
384 lpDevNames
->wDriverOffset
= pTempPtr
- pDevNamesSpace
;
386 pTempPtr
+= lstrlenW(DeviceDriverName
) + 1;
387 lstrcpyW(pTempPtr
, DeviceName
);
388 lpDevNames
->wDeviceOffset
= pTempPtr
- pDevNamesSpace
;
390 pTempPtr
+= lstrlenW(DeviceName
) + 1;
391 lstrcpyW(pTempPtr
, OutputPort
);
392 lpDevNames
->wOutputOffset
= pTempPtr
- pDevNamesSpace
;
394 GetDefaultPrinterW(bufW
, &dwBufLen
);
395 lpDevNames
->wDefault
= (lstrcmpW(bufW
, DeviceName
) == 0) ? 1 : 0;
400 /***********************************************************************
401 * PRINTDLG_UpdatePrintDlg [internal]
404 * updates the PrintDlg structure for return values.
407 * FALSE if user is not allowed to close (i.e. wrong nTo or nFrom values)
408 * TRUE if successful.
410 static BOOL
PRINTDLG_UpdatePrintDlgA(HWND hDlg
,
411 PRINT_PTRA
* PrintStructures
)
413 LPPRINTDLGA lppd
= PrintStructures
->lpPrintDlg
;
414 PDEVMODEA lpdm
= PrintStructures
->lpDevMode
;
415 LPPRINTER_INFO_2A pi
= PrintStructures
->lpPrinterInfo
;
419 FIXME("No lpdm ptr?\n");
424 if(!(lppd
->Flags
& PD_PRINTSETUP
)) {
425 /* check whether nFromPage and nToPage are within range defined by
426 * nMinPage and nMaxPage
428 if (IsDlgButtonChecked(hDlg
, rad3
) == BST_CHECKED
) { /* Pages */
432 nFromPage
= GetDlgItemInt(hDlg
, edt1
, NULL
, FALSE
);
433 nToPage
= GetDlgItemInt(hDlg
, edt2
, &translated
, FALSE
);
435 /* if no ToPage value is entered, use the FromPage value */
436 if(!translated
) nToPage
= nFromPage
;
438 if (nFromPage
< lppd
->nMinPage
|| nFromPage
> lppd
->nMaxPage
||
439 nToPage
< lppd
->nMinPage
|| nToPage
> lppd
->nMaxPage
) {
440 WCHAR resourcestr
[256];
441 WCHAR resultstr
[256];
442 LoadStringW(COMDLG32_hInstance
, PD32_INVALID_PAGE_RANGE
, resourcestr
, 255);
443 wsprintfW(resultstr
,resourcestr
, lppd
->nMinPage
, lppd
->nMaxPage
);
444 LoadStringW(COMDLG32_hInstance
, PD32_PRINT_TITLE
, resourcestr
, 255);
445 MessageBoxW(hDlg
, resultstr
, resourcestr
, MB_OK
| MB_ICONWARNING
);
448 lppd
->nFromPage
= nFromPage
;
449 lppd
->nToPage
= nToPage
;
450 lppd
->Flags
|= PD_PAGENUMS
;
453 lppd
->Flags
&= ~PD_PAGENUMS
;
455 if (IsDlgButtonChecked(hDlg
, rad2
) == BST_CHECKED
) /* Selection */
456 lppd
->Flags
|= PD_SELECTION
;
458 lppd
->Flags
&= ~PD_SELECTION
;
460 if (IsDlgButtonChecked(hDlg
, chx1
) == BST_CHECKED
) {/* Print to file */
461 static char file
[] = "FILE:";
462 lppd
->Flags
|= PD_PRINTTOFILE
;
463 pi
->pPortName
= file
;
466 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
) { /* Collate */
467 FIXME("Collate lppd not yet implemented as output\n");
470 /* set PD_Collate and nCopies */
471 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
472 /* The application doesn't support multiple copies or collate...
474 lppd
->Flags
&= ~PD_COLLATE
;
476 /* if the printer driver supports it... store info there
477 * otherwise no collate & multiple copies !
479 if (lpdm
->dmFields
& DM_COLLATE
)
481 (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
);
482 if (lpdm
->dmFields
& DM_COPIES
)
483 lpdm
->u1
.s1
.dmCopies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
485 /* Application is responsible for multiple copies */
486 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
)
487 lppd
->Flags
|= PD_COLLATE
;
489 lppd
->Flags
&= ~PD_COLLATE
;
490 lppd
->nCopies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
491 /* multiple copies already included in the document. Driver must print only one copy */
492 lpdm
->u1
.s1
.dmCopies
= 1;
495 /* Print quality, PrintDlg16 */
496 if(GetDlgItem(hDlg
, cmb1
))
498 HWND hQuality
= GetDlgItem(hDlg
, cmb1
);
499 int Sel
= SendMessageA(hQuality
, CB_GETCURSEL
, 0, 0);
503 LONG dpi
= SendMessageA(hQuality
, CB_GETITEMDATA
, Sel
, 0);
504 lpdm
->dmFields
|= DM_PRINTQUALITY
| DM_YRESOLUTION
;
505 lpdm
->u1
.s1
.dmPrintQuality
= LOWORD(dpi
);
506 lpdm
->dmYResolution
= HIWORD(dpi
);
513 static BOOL
PRINTDLG_UpdatePrintDlgW(HWND hDlg
,
514 PRINT_PTRW
* PrintStructures
)
516 LPPRINTDLGW lppd
= PrintStructures
->lpPrintDlg
;
517 PDEVMODEW lpdm
= PrintStructures
->lpDevMode
;
518 LPPRINTER_INFO_2W pi
= PrintStructures
->lpPrinterInfo
;
522 FIXME("No lpdm ptr?\n");
527 if(!(lppd
->Flags
& PD_PRINTSETUP
)) {
528 /* check whether nFromPage and nToPage are within range defined by
529 * nMinPage and nMaxPage
531 if (IsDlgButtonChecked(hDlg
, rad3
) == BST_CHECKED
) { /* Pages */
535 nFromPage
= GetDlgItemInt(hDlg
, edt1
, NULL
, FALSE
);
536 nToPage
= GetDlgItemInt(hDlg
, edt2
, &translated
, FALSE
);
538 /* if no ToPage value is entered, use the FromPage value */
539 if(!translated
) nToPage
= nFromPage
;
541 if (nFromPage
< lppd
->nMinPage
|| nFromPage
> lppd
->nMaxPage
||
542 nToPage
< lppd
->nMinPage
|| nToPage
> lppd
->nMaxPage
) {
543 WCHAR resourcestr
[256];
544 WCHAR resultstr
[256];
545 LoadStringW(COMDLG32_hInstance
, PD32_INVALID_PAGE_RANGE
,
547 wsprintfW(resultstr
,resourcestr
, lppd
->nMinPage
, lppd
->nMaxPage
);
548 LoadStringW(COMDLG32_hInstance
, PD32_PRINT_TITLE
,
550 MessageBoxW(hDlg
, resultstr
, resourcestr
,
551 MB_OK
| MB_ICONWARNING
);
554 lppd
->nFromPage
= nFromPage
;
555 lppd
->nToPage
= nToPage
;
556 lppd
->Flags
|= PD_PAGENUMS
;
559 lppd
->Flags
&= ~PD_PAGENUMS
;
561 if (IsDlgButtonChecked(hDlg
, rad2
) == BST_CHECKED
) /* Selection */
562 lppd
->Flags
|= PD_SELECTION
;
564 lppd
->Flags
&= ~PD_SELECTION
;
566 if (IsDlgButtonChecked(hDlg
, chx1
) == BST_CHECKED
) {/* Print to file */
567 static WCHAR file
[] = {'F','I','L','E',':',0};
568 lppd
->Flags
|= PD_PRINTTOFILE
;
569 pi
->pPortName
= file
;
572 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
) { /* Collate */
573 FIXME("Collate lppd not yet implemented as output\n");
576 /* set PD_Collate and nCopies */
577 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
578 /* The application doesn't support multiple copies or collate...
580 lppd
->Flags
&= ~PD_COLLATE
;
582 /* if the printer driver supports it... store info there
583 * otherwise no collate & multiple copies !
585 if (lpdm
->dmFields
& DM_COLLATE
)
587 (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
);
588 if (lpdm
->dmFields
& DM_COPIES
)
589 lpdm
->u1
.s1
.dmCopies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
591 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
)
592 lppd
->Flags
|= PD_COLLATE
;
594 lppd
->Flags
&= ~PD_COLLATE
;
595 lppd
->nCopies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
601 /************************************************************************
602 * PRINTDLG_SetUpPaperComboBox
604 * Initialize either the papersize or inputslot combos of the Printer Setup
605 * dialog. We store the associated word (eg DMPAPER_A4) as the item data.
606 * We also try to re-select the old selection.
608 static BOOL
PRINTDLG_SetUpPaperComboBoxA(HWND hDlg
,
621 int fwCapability_Names
;
622 int fwCapability_Words
;
624 TRACE(" Printer: %s, Port: %s, ComboID: %d\n",PrinterName
,PortName
,nIDComboBox
);
626 /* query the dialog box for the current selected value */
627 Sel
= SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_GETCURSEL
, 0, 0);
629 /* we enter here only if a different printer is selected after
630 * the Print Setup dialog is opened. The current settings are
631 * stored into the newly selected printer.
633 oldWord
= SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_GETITEMDATA
,
636 if (nIDComboBox
== cmb2
)
637 dm
->u1
.s1
.dmPaperSize
= oldWord
;
639 dm
->u1
.s1
.dmDefaultSource
= oldWord
;
643 /* we enter here only when the Print setup dialog is initially
644 * opened. In this case the settings are restored from when
645 * the dialog was last closed.
648 if (nIDComboBox
== cmb2
)
649 oldWord
= dm
->u1
.s1
.dmPaperSize
;
651 oldWord
= dm
->u1
.s1
.dmDefaultSource
;
655 if (nIDComboBox
== cmb2
) {
657 fwCapability_Names
= DC_PAPERNAMES
;
658 fwCapability_Words
= DC_PAPERS
;
662 fwCapability_Names
= DC_BINNAMES
;
663 fwCapability_Words
= DC_BINS
;
666 NrOfEntries
= DeviceCapabilitiesA(PrinterName
, PortName
,
667 fwCapability_Names
, NULL
, dm
);
668 if (NrOfEntries
== 0)
669 WARN("no Name Entries found!\n");
670 else if (NrOfEntries
< 0)
673 if(DeviceCapabilitiesA(PrinterName
, PortName
, fwCapability_Words
, NULL
, dm
)
675 ERR("Number of caps is different\n");
679 Names
= HeapAlloc(GetProcessHeap(),0, NrOfEntries
*sizeof(char)*NamesSize
);
680 Words
= HeapAlloc(GetProcessHeap(),0, NrOfEntries
*sizeof(WORD
));
681 NrOfEntries
= DeviceCapabilitiesA(PrinterName
, PortName
,
682 fwCapability_Names
, Names
, dm
);
683 NrOfEntries
= DeviceCapabilitiesA(PrinterName
, PortName
,
684 fwCapability_Words
, (LPSTR
)Words
, dm
);
686 /* reset any current content in the combobox */
687 SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_RESETCONTENT
, 0, 0);
689 /* store new content */
690 for (i
= 0; i
< NrOfEntries
; i
++) {
691 DWORD pos
= SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_ADDSTRING
, 0,
692 (LPARAM
)(&Names
[i
*NamesSize
]) );
693 SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_SETITEMDATA
, pos
,
697 /* Look for old selection - can't do this is previous loop since
698 item order will change as more items are added */
700 for (i
= 0; i
< NrOfEntries
; i
++) {
701 if(SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_GETITEMDATA
, i
, 0) ==
707 SendDlgItemMessageA(hDlg
, nIDComboBox
, CB_SETCURSEL
, Sel
, 0);
709 HeapFree(GetProcessHeap(),0,Words
);
710 HeapFree(GetProcessHeap(),0,Names
);
714 static BOOL
PRINTDLG_SetUpPaperComboBoxW(HWND hDlg
,
716 const WCHAR
* PrinterName
,
717 const WCHAR
* PortName
,
727 int fwCapability_Names
;
728 int fwCapability_Words
;
730 TRACE(" Printer: %s, Port: %s, ComboID: %d\n",debugstr_w(PrinterName
),debugstr_w(PortName
),nIDComboBox
);
732 /* query the dialog box for the current selected value */
733 Sel
= SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_GETCURSEL
, 0, 0);
735 /* we enter here only if a different printer is selected after
736 * the Print Setup dialog is opened. The current settings are
737 * stored into the newly selected printer.
739 oldWord
= SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_GETITEMDATA
,
742 if (nIDComboBox
== cmb2
)
743 dm
->u1
.s1
.dmPaperSize
= oldWord
;
745 dm
->u1
.s1
.dmDefaultSource
= oldWord
;
749 /* we enter here only when the Print setup dialog is initially
750 * opened. In this case the settings are restored from when
751 * the dialog was last closed.
754 if (nIDComboBox
== cmb2
)
755 oldWord
= dm
->u1
.s1
.dmPaperSize
;
757 oldWord
= dm
->u1
.s1
.dmDefaultSource
;
761 if (nIDComboBox
== cmb2
) {
763 fwCapability_Names
= DC_PAPERNAMES
;
764 fwCapability_Words
= DC_PAPERS
;
768 fwCapability_Names
= DC_BINNAMES
;
769 fwCapability_Words
= DC_BINS
;
772 NrOfEntries
= DeviceCapabilitiesW(PrinterName
, PortName
,
773 fwCapability_Names
, NULL
, dm
);
774 if (NrOfEntries
== 0)
775 WARN("no Name Entries found!\n");
776 else if (NrOfEntries
< 0)
779 if(DeviceCapabilitiesW(PrinterName
, PortName
, fwCapability_Words
, NULL
, dm
)
781 ERR("Number of caps is different\n");
785 Names
= HeapAlloc(GetProcessHeap(),0, NrOfEntries
*sizeof(WCHAR
)*NamesSize
);
786 Words
= HeapAlloc(GetProcessHeap(),0, NrOfEntries
*sizeof(WORD
));
787 NrOfEntries
= DeviceCapabilitiesW(PrinterName
, PortName
,
788 fwCapability_Names
, Names
, dm
);
789 NrOfEntries
= DeviceCapabilitiesW(PrinterName
, PortName
,
790 fwCapability_Words
, Words
, dm
);
792 /* reset any current content in the combobox */
793 SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_RESETCONTENT
, 0, 0);
795 /* store new content */
796 for (i
= 0; i
< NrOfEntries
; i
++) {
797 DWORD pos
= SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_ADDSTRING
, 0,
798 (LPARAM
)(&Names
[i
*NamesSize
]) );
799 SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_SETITEMDATA
, pos
,
803 /* Look for old selection - can't do this is previous loop since
804 item order will change as more items are added */
806 for (i
= 0; i
< NrOfEntries
; i
++) {
807 if(SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_GETITEMDATA
, i
, 0) ==
813 SendDlgItemMessageW(hDlg
, nIDComboBox
, CB_SETCURSEL
, Sel
, 0);
815 HeapFree(GetProcessHeap(),0,Words
);
816 HeapFree(GetProcessHeap(),0,Names
);
821 /***********************************************************************
822 * PRINTDLG_UpdatePrinterInfoTexts [internal]
824 static void PRINTDLG_UpdatePrinterInfoTextsA(HWND hDlg
, const PRINTER_INFO_2A
*pi
)
827 char ResourceString
[256];
833 /* add all status messages */
834 for (i
= 0; i
< 25; i
++) {
835 if (pi
->Status
& (1<<i
)) {
836 LoadStringA(COMDLG32_hInstance
, PD32_PRINTER_STATUS_PAUSED
+i
,
837 ResourceString
, 255);
838 strcat(StatusMsg
,ResourceString
);
842 /* FIXME: status==ready must only be appended if really so.
843 but how to detect? */
844 LoadStringA(COMDLG32_hInstance
, PD32_PRINTER_STATUS_READY
,
845 ResourceString
, 255);
846 strcat(StatusMsg
,ResourceString
);
847 SetDlgItemTextA(hDlg
, stc12
, StatusMsg
);
849 /* set all other printer info texts */
850 SetDlgItemTextA(hDlg
, stc11
, pi
->pDriverName
);
852 if (pi
->pLocation
!= NULL
&& pi
->pLocation
[0] != '\0')
853 SetDlgItemTextA(hDlg
, stc14
, pi
->pLocation
);
855 SetDlgItemTextA(hDlg
, stc14
, pi
->pPortName
);
856 SetDlgItemTextA(hDlg
, stc13
, pi
->pComment
? pi
->pComment
: "");
860 static void PRINTDLG_UpdatePrinterInfoTextsW(HWND hDlg
, const PRINTER_INFO_2W
*pi
)
862 WCHAR StatusMsg
[256];
863 WCHAR ResourceString
[256];
864 static const WCHAR emptyW
[] = {0};
870 /* add all status messages */
871 for (i
= 0; i
< 25; i
++) {
872 if (pi
->Status
& (1<<i
)) {
873 LoadStringW(COMDLG32_hInstance
, PD32_PRINTER_STATUS_PAUSED
+i
,
874 ResourceString
, 255);
875 lstrcatW(StatusMsg
,ResourceString
);
879 /* FIXME: status==ready must only be appended if really so.
880 but how to detect? */
881 LoadStringW(COMDLG32_hInstance
, PD32_PRINTER_STATUS_READY
,
882 ResourceString
, 255);
883 lstrcatW(StatusMsg
,ResourceString
);
884 SetDlgItemTextW(hDlg
, stc12
, StatusMsg
);
886 /* set all other printer info texts */
887 SetDlgItemTextW(hDlg
, stc11
, pi
->pDriverName
);
888 if (pi
->pLocation
!= NULL
&& pi
->pLocation
[0] != '\0')
889 SetDlgItemTextW(hDlg
, stc14
, pi
->pLocation
);
891 SetDlgItemTextW(hDlg
, stc14
, pi
->pPortName
);
892 SetDlgItemTextW(hDlg
, stc13
, pi
->pComment
? pi
->pComment
: emptyW
);
896 /*******************************************************************
898 * PRINTDLG_ChangePrinter
901 static BOOL
PRINTDLG_ChangePrinterA(HWND hDlg
, char *name
, PRINT_PTRA
*PrintStructures
)
903 LPPRINTDLGA lppd
= PrintStructures
->lpPrintDlg
;
904 LPDEVMODEA lpdm
= NULL
;
909 HeapFree(GetProcessHeap(),0, PrintStructures
->lpPrinterInfo
);
910 HeapFree(GetProcessHeap(),0, PrintStructures
->lpDriverInfo
);
911 if(!OpenPrinterA(name
, &hprn
, NULL
)) {
912 ERR("Can't open printer %s\n", name
);
915 GetPrinterA(hprn
, 2, NULL
, 0, &needed
);
916 PrintStructures
->lpPrinterInfo
= HeapAlloc(GetProcessHeap(),0,needed
);
917 GetPrinterA(hprn
, 2, (LPBYTE
)PrintStructures
->lpPrinterInfo
, needed
,
919 GetPrinterDriverA(hprn
, NULL
, 3, NULL
, 0, &needed
);
920 PrintStructures
->lpDriverInfo
= HeapAlloc(GetProcessHeap(),0,needed
);
921 if (!GetPrinterDriverA(hprn
, NULL
, 3, (LPBYTE
)PrintStructures
->lpDriverInfo
,
923 ERR("GetPrinterDriverA failed for %s, fix your config!\n",PrintStructures
->lpPrinterInfo
->pPrinterName
);
928 PRINTDLG_UpdatePrinterInfoTextsA(hDlg
, PrintStructures
->lpPrinterInfo
);
930 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDevMode
);
931 PrintStructures
->lpDevMode
= NULL
;
933 dmSize
= DocumentPropertiesA(0, 0, name
, NULL
, NULL
, 0);
935 ERR("DocumentProperties fails on %s\n", debugstr_a(name
));
938 PrintStructures
->lpDevMode
= HeapAlloc(GetProcessHeap(), 0, dmSize
);
939 dmSize
= DocumentPropertiesA(0, 0, name
, PrintStructures
->lpDevMode
, NULL
,
941 if(lppd
->hDevMode
&& (lpdm
= GlobalLock(lppd
->hDevMode
)) &&
942 !lstrcmpA( (LPSTR
) lpdm
->dmDeviceName
,
943 (LPSTR
) PrintStructures
->lpDevMode
->dmDeviceName
)) {
944 /* Supplied devicemode matches current printer so try to use it */
945 DocumentPropertiesA(0, 0, name
, PrintStructures
->lpDevMode
, lpdm
,
946 DM_OUT_BUFFER
| DM_IN_BUFFER
);
949 GlobalUnlock(lppd
->hDevMode
);
951 lpdm
= PrintStructures
->lpDevMode
; /* use this as a shortcut */
953 if(!(lppd
->Flags
& PD_PRINTSETUP
)) {
954 /* Print range (All/Range/Selection) */
955 if(lppd
->nFromPage
!= 0xffff)
956 SetDlgItemInt(hDlg
, edt1
, lppd
->nFromPage
, FALSE
);
957 if(lppd
->nToPage
!= 0xffff)
958 SetDlgItemInt(hDlg
, edt2
, lppd
->nToPage
, FALSE
);
960 CheckRadioButton(hDlg
, rad1
, rad3
, rad1
); /* default */
961 if (lppd
->Flags
& PD_NOSELECTION
)
962 EnableWindow(GetDlgItem(hDlg
, rad2
), FALSE
);
964 if (lppd
->Flags
& PD_SELECTION
)
965 CheckRadioButton(hDlg
, rad1
, rad3
, rad2
);
966 if (lppd
->Flags
& PD_NOPAGENUMS
) {
967 EnableWindow(GetDlgItem(hDlg
, rad3
), FALSE
);
968 EnableWindow(GetDlgItem(hDlg
, stc2
),FALSE
);
969 EnableWindow(GetDlgItem(hDlg
, edt1
), FALSE
);
970 EnableWindow(GetDlgItem(hDlg
, stc3
),FALSE
);
971 EnableWindow(GetDlgItem(hDlg
, edt2
), FALSE
);
973 if (lppd
->Flags
& PD_PAGENUMS
)
974 CheckRadioButton(hDlg
, rad1
, rad3
, rad3
);
979 * FIXME: The ico3 is not displayed for some reason. I don't know why.
981 if (lppd
->Flags
& PD_COLLATE
) {
982 SendDlgItemMessageA(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
983 (LPARAM
)PrintStructures
->hCollateIcon
);
984 CheckDlgButton(hDlg
, chx2
, 1);
986 SendDlgItemMessageA(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
987 (LPARAM
)PrintStructures
->hNoCollateIcon
);
988 CheckDlgButton(hDlg
, chx2
, 0);
991 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
992 /* if printer doesn't support it: no Collate */
993 if (!(lpdm
->dmFields
& DM_COLLATE
)) {
994 EnableWindow(GetDlgItem(hDlg
, chx2
), FALSE
);
995 EnableWindow(GetDlgItem(hDlg
, ico3
), FALSE
);
1002 if (lppd
->hDevMode
== 0)
1003 copies
= lppd
->nCopies
;
1005 copies
= lpdm
->u1
.s1
.dmCopies
;
1006 if(copies
== 0) copies
= 1;
1007 else if(copies
< 0) copies
= MAX_COPIES
;
1008 SetDlgItemInt(hDlg
, edt3
, copies
, FALSE
);
1011 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
1012 /* if printer doesn't support it: no nCopies */
1013 if (!(lpdm
->dmFields
& DM_COPIES
)) {
1014 EnableWindow(GetDlgItem(hDlg
, edt3
), FALSE
);
1015 EnableWindow(GetDlgItem(hDlg
, stc5
), FALSE
);
1020 CheckDlgButton(hDlg
, chx1
, (lppd
->Flags
& PD_PRINTTOFILE
) ? 1 : 0);
1021 if (lppd
->Flags
& PD_DISABLEPRINTTOFILE
)
1022 EnableWindow(GetDlgItem(hDlg
, chx1
), FALSE
);
1023 if (lppd
->Flags
& PD_HIDEPRINTTOFILE
)
1024 ShowWindow(GetDlgItem(hDlg
, chx1
), SW_HIDE
);
1026 /* Fill print quality combo, PrintDlg16 */
1027 if(GetDlgItem(hDlg
, cmb1
))
1029 DWORD numResolutions
= DeviceCapabilitiesA(PrintStructures
->lpPrinterInfo
->pPrinterName
,
1030 PrintStructures
->lpPrinterInfo
->pPortName
,
1031 DC_ENUMRESOLUTIONS
, NULL
, lpdm
);
1033 if(numResolutions
!= -1)
1035 HWND hQuality
= GetDlgItem(hDlg
, cmb1
);
1040 HDC hPrinterDC
= CreateDCA(PrintStructures
->lpPrinterInfo
->pDriverName
,
1041 PrintStructures
->lpPrinterInfo
->pPrinterName
,
1044 Resolutions
= HeapAlloc(GetProcessHeap(), 0, numResolutions
*sizeof(LONG
)*2);
1045 DeviceCapabilitiesA(PrintStructures
->lpPrinterInfo
->pPrinterName
,
1046 PrintStructures
->lpPrinterInfo
->pPortName
,
1047 DC_ENUMRESOLUTIONS
, (LPSTR
)Resolutions
, lpdm
);
1049 dpiX
= GetDeviceCaps(hPrinterDC
, LOGPIXELSX
);
1050 dpiY
= GetDeviceCaps(hPrinterDC
, LOGPIXELSY
);
1051 DeleteDC(hPrinterDC
);
1053 SendMessageA(hQuality
, CB_RESETCONTENT
, 0, 0);
1054 for(i
= 0; i
< (numResolutions
* 2); i
+= 2)
1056 BOOL IsDefault
= FALSE
;
1059 if(Resolutions
[i
] == Resolutions
[i
+1])
1061 if(dpiX
== Resolutions
[i
])
1063 sprintf(buf
, "%d dpi", Resolutions
[i
]);
1066 if(dpiX
== Resolutions
[i
] && dpiY
== Resolutions
[i
+1])
1068 sprintf(buf
, "%d dpi x %d dpi", Resolutions
[i
], Resolutions
[i
+1]);
1071 Index
= SendMessageA(hQuality
, CB_ADDSTRING
, 0, (LPARAM
)buf
);
1074 SendMessageA(hQuality
, CB_SETCURSEL
, Index
, 0);
1076 SendMessageA(hQuality
, CB_SETITEMDATA
, Index
, MAKELONG(dpiX
,dpiY
));
1078 HeapFree(GetProcessHeap(), 0, Resolutions
);
1081 } else { /* PD_PRINTSETUP */
1082 BOOL bPortrait
= (lpdm
->u1
.s1
.dmOrientation
== DMORIENT_PORTRAIT
);
1084 PRINTDLG_SetUpPaperComboBoxA(hDlg
, cmb2
,
1085 PrintStructures
->lpPrinterInfo
->pPrinterName
,
1086 PrintStructures
->lpPrinterInfo
->pPortName
,
1088 PRINTDLG_SetUpPaperComboBoxA(hDlg
, cmb3
,
1089 PrintStructures
->lpPrinterInfo
->pPrinterName
,
1090 PrintStructures
->lpPrinterInfo
->pPortName
,
1092 CheckRadioButton(hDlg
, rad1
, rad2
, bPortrait
? rad1
: rad2
);
1093 SendDlgItemMessageA(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1094 (LPARAM
)(bPortrait
? PrintStructures
->hPortraitIcon
:
1095 PrintStructures
->hLandscapeIcon
));
1100 if ((lppd
->Flags
& PD_SHOWHELP
)==0) {
1101 /* hide if PD_SHOWHELP not specified */
1102 ShowWindow(GetDlgItem(hDlg
, pshHelp
), SW_HIDE
);
1107 static BOOL
PRINTDLG_ChangePrinterW(HWND hDlg
, WCHAR
*name
,
1108 PRINT_PTRW
*PrintStructures
)
1110 LPPRINTDLGW lppd
= PrintStructures
->lpPrintDlg
;
1111 LPDEVMODEW lpdm
= NULL
;
1116 HeapFree(GetProcessHeap(),0, PrintStructures
->lpPrinterInfo
);
1117 HeapFree(GetProcessHeap(),0, PrintStructures
->lpDriverInfo
);
1118 if(!OpenPrinterW(name
, &hprn
, NULL
)) {
1119 ERR("Can't open printer %s\n", debugstr_w(name
));
1122 GetPrinterW(hprn
, 2, NULL
, 0, &needed
);
1123 PrintStructures
->lpPrinterInfo
= HeapAlloc(GetProcessHeap(),0,needed
);
1124 GetPrinterW(hprn
, 2, (LPBYTE
)PrintStructures
->lpPrinterInfo
, needed
,
1126 GetPrinterDriverW(hprn
, NULL
, 3, NULL
, 0, &needed
);
1127 PrintStructures
->lpDriverInfo
= HeapAlloc(GetProcessHeap(),0,needed
);
1128 if (!GetPrinterDriverW(hprn
, NULL
, 3, (LPBYTE
)PrintStructures
->lpDriverInfo
,
1130 ERR("GetPrinterDriverA failed for %s, fix your config!\n",debugstr_w(PrintStructures
->lpPrinterInfo
->pPrinterName
));
1135 PRINTDLG_UpdatePrinterInfoTextsW(hDlg
, PrintStructures
->lpPrinterInfo
);
1137 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDevMode
);
1138 PrintStructures
->lpDevMode
= NULL
;
1140 dmSize
= DocumentPropertiesW(0, 0, name
, NULL
, NULL
, 0);
1142 ERR("DocumentProperties fails on %s\n", debugstr_w(name
));
1145 PrintStructures
->lpDevMode
= HeapAlloc(GetProcessHeap(), 0, dmSize
);
1146 dmSize
= DocumentPropertiesW(0, 0, name
, PrintStructures
->lpDevMode
, NULL
,
1148 if(lppd
->hDevMode
&& (lpdm
= GlobalLock(lppd
->hDevMode
)) &&
1149 !lstrcmpW(lpdm
->dmDeviceName
,
1150 PrintStructures
->lpDevMode
->dmDeviceName
)) {
1151 /* Supplied devicemode matches current printer so try to use it */
1152 DocumentPropertiesW(0, 0, name
, PrintStructures
->lpDevMode
, lpdm
,
1153 DM_OUT_BUFFER
| DM_IN_BUFFER
);
1156 GlobalUnlock(lppd
->hDevMode
);
1158 lpdm
= PrintStructures
->lpDevMode
; /* use this as a shortcut */
1160 if(!(lppd
->Flags
& PD_PRINTSETUP
)) {
1161 /* Print range (All/Range/Selection) */
1162 if(lppd
->nFromPage
!= 0xffff)
1163 SetDlgItemInt(hDlg
, edt1
, lppd
->nFromPage
, FALSE
);
1164 if(lppd
->nToPage
!= 0xffff)
1165 SetDlgItemInt(hDlg
, edt2
, lppd
->nToPage
, FALSE
);
1167 CheckRadioButton(hDlg
, rad1
, rad3
, rad1
); /* default */
1168 if (lppd
->Flags
& PD_NOSELECTION
)
1169 EnableWindow(GetDlgItem(hDlg
, rad2
), FALSE
);
1171 if (lppd
->Flags
& PD_SELECTION
)
1172 CheckRadioButton(hDlg
, rad1
, rad3
, rad2
);
1173 if (lppd
->Flags
& PD_NOPAGENUMS
) {
1174 EnableWindow(GetDlgItem(hDlg
, rad3
), FALSE
);
1175 EnableWindow(GetDlgItem(hDlg
, stc2
),FALSE
);
1176 EnableWindow(GetDlgItem(hDlg
, edt1
), FALSE
);
1177 EnableWindow(GetDlgItem(hDlg
, stc3
),FALSE
);
1178 EnableWindow(GetDlgItem(hDlg
, edt2
), FALSE
);
1180 if (lppd
->Flags
& PD_PAGENUMS
)
1181 CheckRadioButton(hDlg
, rad1
, rad3
, rad3
);
1186 * FIXME: The ico3 is not displayed for some reason. I don't know why.
1188 if (lppd
->Flags
& PD_COLLATE
) {
1189 SendDlgItemMessageW(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1190 (LPARAM
)PrintStructures
->hCollateIcon
);
1191 CheckDlgButton(hDlg
, chx2
, 1);
1193 SendDlgItemMessageW(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1194 (LPARAM
)PrintStructures
->hNoCollateIcon
);
1195 CheckDlgButton(hDlg
, chx2
, 0);
1198 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
1199 /* if printer doesn't support it: no Collate */
1200 if (!(lpdm
->dmFields
& DM_COLLATE
)) {
1201 EnableWindow(GetDlgItem(hDlg
, chx2
), FALSE
);
1202 EnableWindow(GetDlgItem(hDlg
, ico3
), FALSE
);
1209 if (lppd
->hDevMode
== 0)
1210 copies
= lppd
->nCopies
;
1212 copies
= lpdm
->u1
.s1
.dmCopies
;
1213 if(copies
== 0) copies
= 1;
1214 else if(copies
< 0) copies
= MAX_COPIES
;
1215 SetDlgItemInt(hDlg
, edt3
, copies
, FALSE
);
1218 if (lppd
->Flags
& PD_USEDEVMODECOPIESANDCOLLATE
) {
1219 /* if printer doesn't support it: no nCopies */
1220 if (!(lpdm
->dmFields
& DM_COPIES
)) {
1221 EnableWindow(GetDlgItem(hDlg
, edt3
), FALSE
);
1222 EnableWindow(GetDlgItem(hDlg
, stc5
), FALSE
);
1227 CheckDlgButton(hDlg
, chx1
, (lppd
->Flags
& PD_PRINTTOFILE
) ? 1 : 0);
1228 if (lppd
->Flags
& PD_DISABLEPRINTTOFILE
)
1229 EnableWindow(GetDlgItem(hDlg
, chx1
), FALSE
);
1230 if (lppd
->Flags
& PD_HIDEPRINTTOFILE
)
1231 ShowWindow(GetDlgItem(hDlg
, chx1
), SW_HIDE
);
1233 } else { /* PD_PRINTSETUP */
1234 BOOL bPortrait
= (lpdm
->u1
.s1
.dmOrientation
== DMORIENT_PORTRAIT
);
1236 PRINTDLG_SetUpPaperComboBoxW(hDlg
, cmb2
,
1237 PrintStructures
->lpPrinterInfo
->pPrinterName
,
1238 PrintStructures
->lpPrinterInfo
->pPortName
,
1240 PRINTDLG_SetUpPaperComboBoxW(hDlg
, cmb3
,
1241 PrintStructures
->lpPrinterInfo
->pPrinterName
,
1242 PrintStructures
->lpPrinterInfo
->pPortName
,
1244 CheckRadioButton(hDlg
, rad1
, rad2
, bPortrait
? rad1
: rad2
);
1245 SendDlgItemMessageW(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1246 (LPARAM
)(bPortrait
? PrintStructures
->hPortraitIcon
:
1247 PrintStructures
->hLandscapeIcon
));
1252 if ((lppd
->Flags
& PD_SHOWHELP
)==0) {
1253 /* hide if PD_SHOWHELP not specified */
1254 ShowWindow(GetDlgItem(hDlg
, pshHelp
), SW_HIDE
);
1259 /***********************************************************************
1260 * check_printer_setup [internal]
1262 static LRESULT
check_printer_setup(HWND hDlg
)
1265 WCHAR resourcestr
[256],resultstr
[256];
1267 EnumPrintersW(PRINTER_ENUM_LOCAL
, NULL
, 2, NULL
, 0, &needed
, &num
);
1270 EnumPrintersW(PRINTER_ENUM_CONNECTIONS
, NULL
, 2, NULL
, 0, &needed
, &num
);
1276 LoadStringW(COMDLG32_hInstance
, PD32_NO_DEVICES
,resultstr
, 255);
1277 LoadStringW(COMDLG32_hInstance
, PD32_PRINT_TITLE
,resourcestr
, 255);
1278 MessageBoxW(hDlg
, resultstr
, resourcestr
,MB_OK
| MB_ICONWARNING
);
1283 /***********************************************************************
1284 * PRINTDLG_WMInitDialog [internal]
1286 static LRESULT
PRINTDLG_WMInitDialog(HWND hDlg
, WPARAM wParam
,
1287 PRINT_PTRA
* PrintStructures
)
1289 LPPRINTDLGA lppd
= PrintStructures
->lpPrintDlg
;
1293 UINT comboID
= (lppd
->Flags
& PD_PRINTSETUP
) ? cmb1
: cmb4
;
1295 /* load Collate ICONs */
1296 /* We load these with LoadImage because they are not a standard
1297 size and we don't want them rescaled */
1298 PrintStructures
->hCollateIcon
=
1299 LoadImageA(COMDLG32_hInstance
, "PD32_COLLATE", IMAGE_ICON
, 0, 0, 0);
1300 PrintStructures
->hNoCollateIcon
=
1301 LoadImageA(COMDLG32_hInstance
, "PD32_NOCOLLATE", IMAGE_ICON
, 0, 0, 0);
1303 /* These can be done with LoadIcon */
1304 PrintStructures
->hPortraitIcon
=
1305 LoadIconA(COMDLG32_hInstance
, "PD32_PORTRAIT");
1306 PrintStructures
->hLandscapeIcon
=
1307 LoadIconA(COMDLG32_hInstance
, "PD32_LANDSCAPE");
1309 /* display the collate/no_collate icon */
1310 SendDlgItemMessageA(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1311 (LPARAM
)PrintStructures
->hNoCollateIcon
);
1313 if(PrintStructures
->hCollateIcon
== 0 ||
1314 PrintStructures
->hNoCollateIcon
== 0 ||
1315 PrintStructures
->hPortraitIcon
== 0 ||
1316 PrintStructures
->hLandscapeIcon
== 0) {
1317 ERR("no icon in resourcefile\n");
1318 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
1319 EndDialog(hDlg
, FALSE
);
1323 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
1324 * must be registered and the Help button must be shown.
1326 if (lppd
->Flags
& PD_SHOWHELP
) {
1327 if((PrintStructures
->HelpMessageID
=
1328 RegisterWindowMessageA(HELPMSGSTRINGA
)) == 0) {
1329 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL
);
1333 PrintStructures
->HelpMessageID
= 0;
1335 if(!(lppd
->Flags
&PD_PRINTSETUP
)) {
1336 PrintStructures
->hwndUpDown
=
1337 CreateUpDownControl(WS_CHILD
| WS_VISIBLE
| WS_BORDER
|
1338 UDS_NOTHOUSANDS
| UDS_ARROWKEYS
|
1339 UDS_ALIGNRIGHT
| UDS_SETBUDDYINT
, 0, 0, 0, 0,
1340 hDlg
, UPDOWN_ID
, COMDLG32_hInstance
,
1341 GetDlgItem(hDlg
, edt3
), MAX_COPIES
, 1, 1);
1344 /* FIXME: I allow more freedom than either Win95 or WinNT,
1345 * which do not agree to what errors should be thrown or not
1346 * in case nToPage or nFromPage is out-of-range.
1348 if (lppd
->nMaxPage
< lppd
->nMinPage
)
1349 lppd
->nMaxPage
= lppd
->nMinPage
;
1350 if (lppd
->nMinPage
== lppd
->nMaxPage
)
1351 lppd
->Flags
|= PD_NOPAGENUMS
;
1352 if (lppd
->nToPage
< lppd
->nMinPage
)
1353 lppd
->nToPage
= lppd
->nMinPage
;
1354 if (lppd
->nToPage
> lppd
->nMaxPage
)
1355 lppd
->nToPage
= lppd
->nMaxPage
;
1356 if (lppd
->nFromPage
< lppd
->nMinPage
)
1357 lppd
->nFromPage
= lppd
->nMinPage
;
1358 if (lppd
->nFromPage
> lppd
->nMaxPage
)
1359 lppd
->nFromPage
= lppd
->nMaxPage
;
1361 /* if we have the combo box, fill it */
1362 if (GetDlgItem(hDlg
,comboID
)) {
1365 pdn
= GlobalLock(lppd
->hDevNames
);
1366 pdm
= GlobalLock(lppd
->hDevMode
);
1368 name
= (char*)pdn
+ pdn
->wDeviceOffset
;
1370 name
= (char*)pdm
->dmDeviceName
;
1371 PRINTDLG_SetUpPrinterListComboA(hDlg
, comboID
, name
);
1372 if(pdm
) GlobalUnlock(lppd
->hDevMode
);
1373 if(pdn
) GlobalUnlock(lppd
->hDevNames
);
1375 /* Now find selected printer and update rest of dlg */
1376 name
= HeapAlloc(GetProcessHeap(),0,256);
1377 if (GetDlgItemTextA(hDlg
, comboID
, name
, 255))
1378 PRINTDLG_ChangePrinterA(hDlg
, name
, PrintStructures
);
1379 HeapFree(GetProcessHeap(),0,name
);
1381 /* else use default printer */
1383 DWORD dwBufLen
= sizeof(name
);
1384 BOOL ret
= GetDefaultPrinterA(name
, &dwBufLen
);
1387 PRINTDLG_ChangePrinterA(hDlg
, name
, PrintStructures
);
1389 FIXME("No default printer found, expect problems!\n");
1394 static LRESULT
PRINTDLG_WMInitDialogW(HWND hDlg
, WPARAM wParam
,
1395 PRINT_PTRW
* PrintStructures
)
1397 LPPRINTDLGW lppd
= PrintStructures
->lpPrintDlg
;
1401 UINT comboID
= (lppd
->Flags
& PD_PRINTSETUP
) ? cmb1
: cmb4
;
1403 /* load Collate ICONs */
1404 /* We load these with LoadImage because they are not a standard
1405 size and we don't want them rescaled */
1406 PrintStructures
->hCollateIcon
=
1407 LoadImageW(COMDLG32_hInstance
, pd32_collateW
, IMAGE_ICON
, 0, 0, 0);
1408 PrintStructures
->hNoCollateIcon
=
1409 LoadImageW(COMDLG32_hInstance
, pd32_nocollateW
, IMAGE_ICON
, 0, 0, 0);
1411 /* These can be done with LoadIcon */
1412 PrintStructures
->hPortraitIcon
=
1413 LoadIconW(COMDLG32_hInstance
, pd32_portraitW
);
1414 PrintStructures
->hLandscapeIcon
=
1415 LoadIconW(COMDLG32_hInstance
, pd32_landscapeW
);
1417 /* display the collate/no_collate icon */
1418 SendDlgItemMessageW(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1419 (LPARAM
)PrintStructures
->hNoCollateIcon
);
1421 if(PrintStructures
->hCollateIcon
== 0 ||
1422 PrintStructures
->hNoCollateIcon
== 0 ||
1423 PrintStructures
->hPortraitIcon
== 0 ||
1424 PrintStructures
->hLandscapeIcon
== 0) {
1425 ERR("no icon in resourcefile\n");
1426 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
1427 EndDialog(hDlg
, FALSE
);
1431 * if lppd->Flags PD_SHOWHELP is specified, a HELPMESGSTRING message
1432 * must be registered and the Help button must be shown.
1434 if (lppd
->Flags
& PD_SHOWHELP
) {
1435 if((PrintStructures
->HelpMessageID
=
1436 RegisterWindowMessageW(HELPMSGSTRINGW
)) == 0) {
1437 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL
);
1441 PrintStructures
->HelpMessageID
= 0;
1443 if(!(lppd
->Flags
&PD_PRINTSETUP
)) {
1444 PrintStructures
->hwndUpDown
=
1445 CreateUpDownControl(WS_CHILD
| WS_VISIBLE
| WS_BORDER
|
1446 UDS_NOTHOUSANDS
| UDS_ARROWKEYS
|
1447 UDS_ALIGNRIGHT
| UDS_SETBUDDYINT
, 0, 0, 0, 0,
1448 hDlg
, UPDOWN_ID
, COMDLG32_hInstance
,
1449 GetDlgItem(hDlg
, edt3
), MAX_COPIES
, 1, 1);
1452 /* FIXME: I allow more freedom than either Win95 or WinNT,
1453 * which do not agree to what errors should be thrown or not
1454 * in case nToPage or nFromPage is out-of-range.
1456 if (lppd
->nMaxPage
< lppd
->nMinPage
)
1457 lppd
->nMaxPage
= lppd
->nMinPage
;
1458 if (lppd
->nMinPage
== lppd
->nMaxPage
)
1459 lppd
->Flags
|= PD_NOPAGENUMS
;
1460 if (lppd
->nToPage
< lppd
->nMinPage
)
1461 lppd
->nToPage
= lppd
->nMinPage
;
1462 if (lppd
->nToPage
> lppd
->nMaxPage
)
1463 lppd
->nToPage
= lppd
->nMaxPage
;
1464 if (lppd
->nFromPage
< lppd
->nMinPage
)
1465 lppd
->nFromPage
= lppd
->nMinPage
;
1466 if (lppd
->nFromPage
> lppd
->nMaxPage
)
1467 lppd
->nFromPage
= lppd
->nMaxPage
;
1469 /* if we have the combo box, fill it */
1470 if (GetDlgItem(hDlg
,comboID
)) {
1473 pdn
= GlobalLock(lppd
->hDevNames
);
1474 pdm
= GlobalLock(lppd
->hDevMode
);
1476 name
= (WCHAR
*)pdn
+ pdn
->wDeviceOffset
;
1478 name
= pdm
->dmDeviceName
;
1479 PRINTDLG_SetUpPrinterListComboW(hDlg
, comboID
, name
);
1480 if(pdm
) GlobalUnlock(lppd
->hDevMode
);
1481 if(pdn
) GlobalUnlock(lppd
->hDevNames
);
1483 /* Now find selected printer and update rest of dlg */
1484 /* ansi is ok here */
1485 name
= HeapAlloc(GetProcessHeap(),0,256*sizeof(WCHAR
));
1486 if (GetDlgItemTextW(hDlg
, comboID
, name
, 255))
1487 PRINTDLG_ChangePrinterW(hDlg
, name
, PrintStructures
);
1488 HeapFree(GetProcessHeap(),0,name
);
1490 /* else use default printer */
1492 DWORD dwBufLen
= sizeof(name
) / sizeof(WCHAR
);
1493 BOOL ret
= GetDefaultPrinterW(name
, &dwBufLen
);
1496 PRINTDLG_ChangePrinterW(hDlg
, name
, PrintStructures
);
1498 FIXME("No default printer found, expect problems!\n");
1503 /***********************************************************************
1504 * PRINTDLG_WMCommand [internal]
1506 static LRESULT
PRINTDLG_WMCommandA(HWND hDlg
, WPARAM wParam
,
1507 LPARAM lParam
, PRINT_PTRA
* PrintStructures
)
1509 LPPRINTDLGA lppd
= PrintStructures
->lpPrintDlg
;
1510 UINT PrinterComboID
= (lppd
->Flags
& PD_PRINTSETUP
) ? cmb1
: cmb4
;
1511 LPDEVMODEA lpdm
= PrintStructures
->lpDevMode
;
1513 switch (LOWORD(wParam
)) {
1515 TRACE(" OK button was hit\n");
1516 if (!PRINTDLG_UpdatePrintDlgA(hDlg
, PrintStructures
)) {
1517 FIXME("Update printdlg was not successful!\n");
1520 EndDialog(hDlg
, TRUE
);
1524 TRACE(" CANCEL button was hit\n");
1525 EndDialog(hDlg
, FALSE
);
1529 TRACE(" HELP button was hit\n");
1530 SendMessageA(lppd
->hwndOwner
, PrintStructures
->HelpMessageID
,
1531 (WPARAM
) hDlg
, (LPARAM
) lppd
);
1534 case chx2
: /* collate pages checkbox */
1535 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
)
1536 SendDlgItemMessageA(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1537 (LPARAM
)PrintStructures
->hCollateIcon
);
1539 SendDlgItemMessageA(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1540 (LPARAM
)PrintStructures
->hNoCollateIcon
);
1542 case edt1
: /* from page nr editbox */
1543 case edt2
: /* to page nr editbox */
1544 if (HIWORD(wParam
)==EN_CHANGE
) {
1547 nFromPage
= GetDlgItemInt(hDlg
, edt1
, NULL
, FALSE
);
1548 nToPage
= GetDlgItemInt(hDlg
, edt2
, NULL
, FALSE
);
1549 if (nFromPage
!= lppd
->nFromPage
|| nToPage
!= lppd
->nToPage
)
1550 CheckRadioButton(hDlg
, rad1
, rad3
, rad3
);
1555 if(HIWORD(wParam
) == EN_CHANGE
) {
1556 INT copies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
1558 EnableWindow(GetDlgItem(hDlg
, chx2
), FALSE
);
1560 EnableWindow(GetDlgItem(hDlg
, chx2
), TRUE
);
1565 case psh1
: /* Print Setup */
1569 if (!PrintStructures
->dlg
.lpPrintDlg16
) {
1570 FIXME("The 32bit print dialog does not have this button!?\n");
1574 memcpy(&pdlg
,PrintStructures
->dlg
.lpPrintDlg16
,sizeof(pdlg
));
1575 pdlg
.Flags
|= PD_PRINTSETUP
;
1576 pdlg
.hwndOwner
= HWND_16(hDlg
);
1577 if (!PrintDlg16(&pdlg
))
1582 case psh2
: /* Properties button */
1585 char PrinterName
[256];
1587 GetDlgItemTextA(hDlg
, PrinterComboID
, PrinterName
, 255);
1588 if (!OpenPrinterA(PrinterName
, &hPrinter
, NULL
)) {
1589 FIXME(" Call to OpenPrinter did not succeed!\n");
1592 DocumentPropertiesA(hDlg
, hPrinter
, PrinterName
,
1593 PrintStructures
->lpDevMode
,
1594 PrintStructures
->lpDevMode
,
1595 DM_IN_BUFFER
| DM_OUT_BUFFER
| DM_IN_PROMPT
);
1596 ClosePrinter(hPrinter
);
1600 case rad1
: /* Paperorientation */
1601 if (lppd
->Flags
& PD_PRINTSETUP
)
1603 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_PORTRAIT
;
1604 SendDlgItemMessageA(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1605 (LPARAM
)(PrintStructures
->hPortraitIcon
));
1609 case rad2
: /* Paperorientation */
1610 if (lppd
->Flags
& PD_PRINTSETUP
)
1612 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_LANDSCAPE
;
1613 SendDlgItemMessageA(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1614 (LPARAM
)(PrintStructures
->hLandscapeIcon
));
1618 case cmb1
: /* Printer Combobox in PRINT SETUP, quality combobox in PRINT16 */
1619 if (PrinterComboID
!= LOWORD(wParam
)) {
1623 case cmb4
: /* Printer combobox */
1624 if (HIWORD(wParam
)==CBN_SELCHANGE
) {
1625 char PrinterName
[256];
1626 GetDlgItemTextA(hDlg
, LOWORD(wParam
), PrinterName
, 255);
1627 PRINTDLG_ChangePrinterA(hDlg
, PrinterName
, PrintStructures
);
1631 case cmb2
: /* Papersize */
1633 DWORD Sel
= SendDlgItemMessageA(hDlg
, cmb2
, CB_GETCURSEL
, 0, 0);
1635 lpdm
->u1
.s1
.dmPaperSize
= SendDlgItemMessageA(hDlg
, cmb2
,
1641 case cmb3
: /* Bin */
1643 DWORD Sel
= SendDlgItemMessageA(hDlg
, cmb3
, CB_GETCURSEL
, 0, 0);
1645 lpdm
->u1
.s1
.dmDefaultSource
= SendDlgItemMessageA(hDlg
, cmb3
,
1646 CB_GETITEMDATA
, Sel
,
1651 if(lppd
->Flags
& PD_PRINTSETUP
) {
1652 switch (LOWORD(wParam
)) {
1653 case rad1
: /* orientation */
1655 if (IsDlgButtonChecked(hDlg
, rad1
) == BST_CHECKED
) {
1656 if(lpdm
->u1
.s1
.dmOrientation
!= DMORIENT_PORTRAIT
) {
1657 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_PORTRAIT
;
1658 SendDlgItemMessageA(hDlg
, stc10
, STM_SETIMAGE
,
1660 (LPARAM
)PrintStructures
->hPortraitIcon
);
1661 SendDlgItemMessageA(hDlg
, ico1
, STM_SETIMAGE
,
1663 (LPARAM
)PrintStructures
->hPortraitIcon
);
1666 if(lpdm
->u1
.s1
.dmOrientation
!= DMORIENT_LANDSCAPE
) {
1667 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_LANDSCAPE
;
1668 SendDlgItemMessageA(hDlg
, stc10
, STM_SETIMAGE
,
1670 (LPARAM
)PrintStructures
->hLandscapeIcon
);
1671 SendDlgItemMessageA(hDlg
, ico1
, STM_SETIMAGE
,
1673 (LPARAM
)PrintStructures
->hLandscapeIcon
);
1682 static LRESULT
PRINTDLG_WMCommandW(HWND hDlg
, WPARAM wParam
,
1683 LPARAM lParam
, PRINT_PTRW
* PrintStructures
)
1685 LPPRINTDLGW lppd
= PrintStructures
->lpPrintDlg
;
1686 UINT PrinterComboID
= (lppd
->Flags
& PD_PRINTSETUP
) ? cmb1
: cmb4
;
1687 LPDEVMODEW lpdm
= PrintStructures
->lpDevMode
;
1689 switch (LOWORD(wParam
)) {
1691 TRACE(" OK button was hit\n");
1692 if (!PRINTDLG_UpdatePrintDlgW(hDlg
, PrintStructures
)) {
1693 FIXME("Update printdlg was not successful!\n");
1696 EndDialog(hDlg
, TRUE
);
1700 TRACE(" CANCEL button was hit\n");
1701 EndDialog(hDlg
, FALSE
);
1705 TRACE(" HELP button was hit\n");
1706 SendMessageW(lppd
->hwndOwner
, PrintStructures
->HelpMessageID
,
1707 (WPARAM
) hDlg
, (LPARAM
) lppd
);
1710 case chx2
: /* collate pages checkbox */
1711 if (IsDlgButtonChecked(hDlg
, chx2
) == BST_CHECKED
)
1712 SendDlgItemMessageW(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1713 (LPARAM
)PrintStructures
->hCollateIcon
);
1715 SendDlgItemMessageW(hDlg
, ico3
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1716 (LPARAM
)PrintStructures
->hNoCollateIcon
);
1718 case edt1
: /* from page nr editbox */
1719 case edt2
: /* to page nr editbox */
1720 if (HIWORD(wParam
)==EN_CHANGE
) {
1723 nFromPage
= GetDlgItemInt(hDlg
, edt1
, NULL
, FALSE
);
1724 nToPage
= GetDlgItemInt(hDlg
, edt2
, NULL
, FALSE
);
1725 if (nFromPage
!= lppd
->nFromPage
|| nToPage
!= lppd
->nToPage
)
1726 CheckRadioButton(hDlg
, rad1
, rad3
, rad3
);
1731 if(HIWORD(wParam
) == EN_CHANGE
) {
1732 INT copies
= GetDlgItemInt(hDlg
, edt3
, NULL
, FALSE
);
1734 EnableWindow(GetDlgItem(hDlg
, chx2
), FALSE
);
1736 EnableWindow(GetDlgItem(hDlg
, chx2
), TRUE
);
1740 case psh1
: /* Print Setup */
1742 ERR("psh1 is called from 16bit code only, we should not get here.\n");
1745 case psh2
: /* Properties button */
1748 WCHAR PrinterName
[256];
1750 if (!GetDlgItemTextW(hDlg
, PrinterComboID
, PrinterName
, 255)) break;
1751 if (!OpenPrinterW(PrinterName
, &hPrinter
, NULL
)) {
1752 FIXME(" Call to OpenPrinter did not succeed!\n");
1755 DocumentPropertiesW(hDlg
, hPrinter
, PrinterName
,
1756 PrintStructures
->lpDevMode
,
1757 PrintStructures
->lpDevMode
,
1758 DM_IN_BUFFER
| DM_OUT_BUFFER
| DM_IN_PROMPT
);
1759 ClosePrinter(hPrinter
);
1763 case rad1
: /* Paperorientation */
1764 if (lppd
->Flags
& PD_PRINTSETUP
)
1766 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_PORTRAIT
;
1767 SendDlgItemMessageW(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1768 (LPARAM
)(PrintStructures
->hPortraitIcon
));
1772 case rad2
: /* Paperorientation */
1773 if (lppd
->Flags
& PD_PRINTSETUP
)
1775 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_LANDSCAPE
;
1776 SendDlgItemMessageW(hDlg
, ico1
, STM_SETIMAGE
, (WPARAM
) IMAGE_ICON
,
1777 (LPARAM
)(PrintStructures
->hLandscapeIcon
));
1781 case cmb1
: /* Printer Combobox in PRINT SETUP */
1783 case cmb4
: /* Printer combobox */
1784 if (HIWORD(wParam
)==CBN_SELCHANGE
) {
1785 WCHAR PrinterName
[256];
1786 GetDlgItemTextW(hDlg
, LOWORD(wParam
), PrinterName
, 255);
1787 PRINTDLG_ChangePrinterW(hDlg
, PrinterName
, PrintStructures
);
1791 case cmb2
: /* Papersize */
1793 DWORD Sel
= SendDlgItemMessageW(hDlg
, cmb2
, CB_GETCURSEL
, 0, 0);
1795 lpdm
->u1
.s1
.dmPaperSize
= SendDlgItemMessageW(hDlg
, cmb2
,
1801 case cmb3
: /* Bin */
1803 DWORD Sel
= SendDlgItemMessageW(hDlg
, cmb3
, CB_GETCURSEL
, 0, 0);
1805 lpdm
->u1
.s1
.dmDefaultSource
= SendDlgItemMessageW(hDlg
, cmb3
,
1806 CB_GETITEMDATA
, Sel
,
1811 if(lppd
->Flags
& PD_PRINTSETUP
) {
1812 switch (LOWORD(wParam
)) {
1813 case rad1
: /* orientation */
1815 if (IsDlgButtonChecked(hDlg
, rad1
) == BST_CHECKED
) {
1816 if(lpdm
->u1
.s1
.dmOrientation
!= DMORIENT_PORTRAIT
) {
1817 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_PORTRAIT
;
1818 SendDlgItemMessageW(hDlg
, stc10
, STM_SETIMAGE
,
1820 (LPARAM
)PrintStructures
->hPortraitIcon
);
1821 SendDlgItemMessageW(hDlg
, ico1
, STM_SETIMAGE
,
1823 (LPARAM
)PrintStructures
->hPortraitIcon
);
1826 if(lpdm
->u1
.s1
.dmOrientation
!= DMORIENT_LANDSCAPE
) {
1827 lpdm
->u1
.s1
.dmOrientation
= DMORIENT_LANDSCAPE
;
1828 SendDlgItemMessageW(hDlg
, stc10
, STM_SETIMAGE
,
1830 (LPARAM
)PrintStructures
->hLandscapeIcon
);
1831 SendDlgItemMessageW(hDlg
, ico1
, STM_SETIMAGE
,
1833 (LPARAM
)PrintStructures
->hLandscapeIcon
);
1842 /***********************************************************************
1843 * PrintDlgProcA [internal]
1845 static INT_PTR CALLBACK
PrintDlgProcA(HWND hDlg
, UINT uMsg
, WPARAM wParam
,
1848 PRINT_PTRA
* PrintStructures
;
1849 INT_PTR res
= FALSE
;
1851 if (uMsg
!=WM_INITDIALOG
) {
1852 PrintStructures
= GetPropW(hDlg
, printdlg_prop
);
1853 if (!PrintStructures
)
1856 PrintStructures
= (PRINT_PTRA
*) lParam
;
1857 SetPropW(hDlg
, printdlg_prop
, PrintStructures
);
1858 if(!check_printer_setup(hDlg
))
1860 EndDialog(hDlg
,FALSE
);
1863 res
= PRINTDLG_WMInitDialog(hDlg
, wParam
, PrintStructures
);
1865 if(PrintStructures
->lpPrintDlg
->Flags
& PD_ENABLEPRINTHOOK
)
1866 res
= PrintStructures
->lpPrintDlg
->lpfnPrintHook(
1867 hDlg
, uMsg
, wParam
, (LPARAM
)PrintStructures
->lpPrintDlg
1872 if(PrintStructures
->lpPrintDlg
->Flags
& PD_ENABLEPRINTHOOK
) {
1873 res
= PrintStructures
->lpPrintDlg
->lpfnPrintHook(hDlg
,uMsg
,wParam
,
1880 return PRINTDLG_WMCommandA(hDlg
, wParam
, lParam
, PrintStructures
);
1883 DestroyIcon(PrintStructures
->hCollateIcon
);
1884 DestroyIcon(PrintStructures
->hNoCollateIcon
);
1885 DestroyIcon(PrintStructures
->hPortraitIcon
);
1886 DestroyIcon(PrintStructures
->hLandscapeIcon
);
1887 if(PrintStructures
->hwndUpDown
)
1888 DestroyWindow(PrintStructures
->hwndUpDown
);
1894 static INT_PTR CALLBACK
PrintDlgProcW(HWND hDlg
, UINT uMsg
, WPARAM wParam
,
1897 PRINT_PTRW
* PrintStructures
;
1898 INT_PTR res
= FALSE
;
1900 if (uMsg
!=WM_INITDIALOG
) {
1901 PrintStructures
= GetPropW(hDlg
, printdlg_prop
);
1902 if (!PrintStructures
)
1905 PrintStructures
= (PRINT_PTRW
*) lParam
;
1906 SetPropW(hDlg
, printdlg_prop
, PrintStructures
);
1907 if(!check_printer_setup(hDlg
))
1909 EndDialog(hDlg
,FALSE
);
1912 res
= PRINTDLG_WMInitDialogW(hDlg
, wParam
, PrintStructures
);
1914 if(PrintStructures
->lpPrintDlg
->Flags
& PD_ENABLEPRINTHOOK
)
1915 res
= PrintStructures
->lpPrintDlg
->lpfnPrintHook(hDlg
, uMsg
, wParam
, (LPARAM
)PrintStructures
->lpPrintDlg
);
1919 if(PrintStructures
->lpPrintDlg
->Flags
& PD_ENABLEPRINTHOOK
) {
1920 res
= PrintStructures
->lpPrintDlg
->lpfnPrintHook(hDlg
,uMsg
,wParam
, lParam
);
1926 return PRINTDLG_WMCommandW(hDlg
, wParam
, lParam
, PrintStructures
);
1929 DestroyIcon(PrintStructures
->hCollateIcon
);
1930 DestroyIcon(PrintStructures
->hNoCollateIcon
);
1931 DestroyIcon(PrintStructures
->hPortraitIcon
);
1932 DestroyIcon(PrintStructures
->hLandscapeIcon
);
1933 if(PrintStructures
->hwndUpDown
)
1934 DestroyWindow(PrintStructures
->hwndUpDown
);
1940 /************************************************************
1942 * PRINTDLG_GetDlgTemplate
1945 static HGLOBAL
PRINTDLG_GetDlgTemplateA(const PRINTDLGA
*lppd
)
1950 if (lppd
->Flags
& PD_PRINTSETUP
) {
1951 if(lppd
->Flags
& PD_ENABLESETUPTEMPLATEHANDLE
) {
1952 hDlgTmpl
= lppd
->hSetupTemplate
;
1953 } else if(lppd
->Flags
& PD_ENABLESETUPTEMPLATE
) {
1954 hResInfo
= FindResourceA(lppd
->hInstance
,
1955 lppd
->lpSetupTemplateName
, (LPSTR
)RT_DIALOG
);
1956 hDlgTmpl
= LoadResource(lppd
->hInstance
, hResInfo
);
1958 hResInfo
= FindResourceA(COMDLG32_hInstance
, "PRINT32_SETUP",
1960 hDlgTmpl
= LoadResource(COMDLG32_hInstance
, hResInfo
);
1963 if(lppd
->Flags
& PD_ENABLEPRINTTEMPLATEHANDLE
) {
1964 hDlgTmpl
= lppd
->hPrintTemplate
;
1965 } else if(lppd
->Flags
& PD_ENABLEPRINTTEMPLATE
) {
1966 hResInfo
= FindResourceA(lppd
->hInstance
,
1967 lppd
->lpPrintTemplateName
,
1969 hDlgTmpl
= LoadResource(lppd
->hInstance
, hResInfo
);
1971 hResInfo
= FindResourceA(COMDLG32_hInstance
, "PRINT32",
1973 hDlgTmpl
= LoadResource(COMDLG32_hInstance
, hResInfo
);
1979 static HGLOBAL
PRINTDLG_GetDlgTemplateW(const PRINTDLGW
*lppd
)
1983 static const WCHAR xpsetup
[] = { 'P','R','I','N','T','3','2','_','S','E','T','U','P',0};
1984 static const WCHAR xprint
[] = { 'P','R','I','N','T','3','2',0};
1986 if (lppd
->Flags
& PD_PRINTSETUP
) {
1987 if(lppd
->Flags
& PD_ENABLESETUPTEMPLATEHANDLE
) {
1988 hDlgTmpl
= lppd
->hSetupTemplate
;
1989 } else if(lppd
->Flags
& PD_ENABLESETUPTEMPLATE
) {
1990 hResInfo
= FindResourceW(lppd
->hInstance
,
1991 lppd
->lpSetupTemplateName
, (LPWSTR
)RT_DIALOG
);
1992 hDlgTmpl
= LoadResource(lppd
->hInstance
, hResInfo
);
1994 hResInfo
= FindResourceW(COMDLG32_hInstance
, xpsetup
, (LPWSTR
)RT_DIALOG
);
1995 hDlgTmpl
= LoadResource(COMDLG32_hInstance
, hResInfo
);
1998 if(lppd
->Flags
& PD_ENABLEPRINTTEMPLATEHANDLE
) {
1999 hDlgTmpl
= lppd
->hPrintTemplate
;
2000 } else if(lppd
->Flags
& PD_ENABLEPRINTTEMPLATE
) {
2001 hResInfo
= FindResourceW(lppd
->hInstance
,
2002 lppd
->lpPrintTemplateName
,
2004 hDlgTmpl
= LoadResource(lppd
->hInstance
, hResInfo
);
2006 hResInfo
= FindResourceW(COMDLG32_hInstance
, xprint
, (LPWSTR
)RT_DIALOG
);
2007 hDlgTmpl
= LoadResource(COMDLG32_hInstance
, hResInfo
);
2013 /***********************************************************************
2018 static BOOL
PRINTDLG_CreateDCA(LPPRINTDLGA lppd
)
2020 DEVNAMES
*pdn
= GlobalLock(lppd
->hDevNames
);
2021 DEVMODEA
*pdm
= GlobalLock(lppd
->hDevMode
);
2023 if(lppd
->Flags
& PD_RETURNDC
) {
2024 lppd
->hDC
= CreateDCA((char*)pdn
+ pdn
->wDriverOffset
,
2025 (char*)pdn
+ pdn
->wDeviceOffset
,
2026 (char*)pdn
+ pdn
->wOutputOffset
,
2028 } else if(lppd
->Flags
& PD_RETURNIC
) {
2029 lppd
->hDC
= CreateICA((char*)pdn
+ pdn
->wDriverOffset
,
2030 (char*)pdn
+ pdn
->wDeviceOffset
,
2031 (char*)pdn
+ pdn
->wOutputOffset
,
2034 GlobalUnlock(lppd
->hDevNames
);
2035 GlobalUnlock(lppd
->hDevMode
);
2036 return lppd
->hDC
? TRUE
: FALSE
;
2039 static BOOL
PRINTDLG_CreateDCW(LPPRINTDLGW lppd
)
2041 DEVNAMES
*pdn
= GlobalLock(lppd
->hDevNames
);
2042 DEVMODEW
*pdm
= GlobalLock(lppd
->hDevMode
);
2044 if(lppd
->Flags
& PD_RETURNDC
) {
2045 lppd
->hDC
= CreateDCW((WCHAR
*)pdn
+ pdn
->wDriverOffset
,
2046 (WCHAR
*)pdn
+ pdn
->wDeviceOffset
,
2047 (WCHAR
*)pdn
+ pdn
->wOutputOffset
,
2049 } else if(lppd
->Flags
& PD_RETURNIC
) {
2050 lppd
->hDC
= CreateICW((WCHAR
*)pdn
+ pdn
->wDriverOffset
,
2051 (WCHAR
*)pdn
+ pdn
->wDeviceOffset
,
2052 (WCHAR
*)pdn
+ pdn
->wOutputOffset
,
2055 GlobalUnlock(lppd
->hDevNames
);
2056 GlobalUnlock(lppd
->hDevMode
);
2057 return lppd
->hDC
? TRUE
: FALSE
;
2060 /***********************************************************************
2061 * PrintDlgA (COMDLG32.@)
2063 * Displays the PRINT dialog box, which enables the user to specify
2064 * specific properties of the print job.
2067 * lppd [IO] ptr to PRINTDLG32 struct
2070 * nonzero if the user pressed the OK button
2071 * zero if the user cancelled the window or an error occurred
2075 * * The Collate Icons do not display, even though they are in the code.
2076 * * The Properties Button(s) should call DocumentPropertiesA().
2079 BOOL WINAPI
PrintDlgA(LPPRINTDLGA lppd
)
2087 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION
);
2091 hInst
= (HINSTANCE
)GetWindowLongPtrA( lppd
->hwndOwner
, GWLP_HINSTANCE
);
2092 if(TRACE_ON(commdlg
)) {
2093 char flagstr
[1000] = "";
2094 const struct pd_flags
*pflag
= pd_flags
;
2095 for( ; pflag
->name
; pflag
++) {
2096 if(lppd
->Flags
& pflag
->flag
)
2097 strcat(flagstr
, pflag
->name
);
2099 TRACE("(%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
2100 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %p\n"
2101 "flags %08x (%s)\n",
2102 lppd
, lppd
->hwndOwner
, lppd
->hDevMode
, lppd
->hDevNames
,
2103 lppd
->nFromPage
, lppd
->nToPage
, lppd
->nMinPage
, lppd
->nMaxPage
,
2104 lppd
->nCopies
, lppd
->hInstance
, lppd
->Flags
, flagstr
);
2107 if(lppd
->lStructSize
!= sizeof(PRINTDLGA
)) {
2108 WARN("structure size failure !!!\n");
2109 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE
);
2113 if(lppd
->Flags
& PD_RETURNDEFAULT
) {
2114 PRINTER_INFO_2A
*pbuf
;
2115 DRIVER_INFO_3A
*dbuf
;
2119 if(lppd
->hDevMode
|| lppd
->hDevNames
) {
2120 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
2121 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
2124 if(!PRINTDLG_OpenDefaultPrinter(&hprn
)) {
2125 WARN("Can't find default printer\n");
2126 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN
);
2130 GetPrinterA(hprn
, 2, NULL
, 0, &needed
);
2131 pbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
2132 GetPrinterA(hprn
, 2, (LPBYTE
)pbuf
, needed
, &needed
);
2134 GetPrinterDriverA(hprn
, NULL
, 3, NULL
, 0, &needed
);
2135 dbuf
= HeapAlloc(GetProcessHeap(),0,needed
);
2136 if (!GetPrinterDriverA(hprn
, NULL
, 3, (LPBYTE
)dbuf
, needed
, &needed
)) {
2137 ERR("GetPrinterDriverA failed, le %d, fix your config for printer %s!\n",
2138 GetLastError(),pbuf
->pPrinterName
);
2139 HeapFree(GetProcessHeap(), 0, dbuf
);
2140 HeapFree(GetProcessHeap(), 0, pbuf
);
2141 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
2146 PRINTDLG_CreateDevNames(&(lppd
->hDevNames
),
2150 lppd
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
, pbuf
->pDevMode
->dmSize
+
2151 pbuf
->pDevMode
->dmDriverExtra
);
2152 ptr
= GlobalLock(lppd
->hDevMode
);
2153 memcpy(ptr
, pbuf
->pDevMode
, pbuf
->pDevMode
->dmSize
+
2154 pbuf
->pDevMode
->dmDriverExtra
);
2155 GlobalUnlock(lppd
->hDevMode
);
2156 HeapFree(GetProcessHeap(), 0, pbuf
);
2157 HeapFree(GetProcessHeap(), 0, dbuf
);
2161 PRINT_PTRA
*PrintStructures
;
2163 /* load Dialog resources,
2164 * depending on Flags indicates Print32 or Print32_setup dialog
2166 hDlgTmpl
= PRINTDLG_GetDlgTemplateA(lppd
);
2168 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
2171 ptr
= LockResource( hDlgTmpl
);
2173 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
2177 PrintStructures
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2178 sizeof(PRINT_PTRA
));
2179 PrintStructures
->lpPrintDlg
= lppd
;
2181 /* and create & process the dialog .
2182 * -1 is failure, 0 is broken hwnd, everything else is ok.
2184 bRet
= (0<DialogBoxIndirectParamA(hInst
, ptr
, lppd
->hwndOwner
,
2186 (LPARAM
)PrintStructures
));
2189 DEVMODEA
*lpdm
= PrintStructures
->lpDevMode
, *lpdmReturn
;
2190 PRINTER_INFO_2A
*pi
= PrintStructures
->lpPrinterInfo
;
2191 DRIVER_INFO_3A
*di
= PrintStructures
->lpDriverInfo
;
2193 if (lppd
->hDevMode
== 0) {
2194 TRACE(" No hDevMode yet... Need to create my own\n");
2195 lppd
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
,
2196 lpdm
->dmSize
+ lpdm
->dmDriverExtra
);
2198 lppd
->hDevMode
= GlobalReAlloc(lppd
->hDevMode
,
2199 lpdm
->dmSize
+ lpdm
->dmDriverExtra
,
2202 lpdmReturn
= GlobalLock(lppd
->hDevMode
);
2203 memcpy(lpdmReturn
, lpdm
, lpdm
->dmSize
+ lpdm
->dmDriverExtra
);
2205 PRINTDLG_CreateDevNames(&(lppd
->hDevNames
),
2210 GlobalUnlock(lppd
->hDevMode
);
2212 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDevMode
);
2213 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpPrinterInfo
);
2214 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDriverInfo
);
2215 HeapFree(GetProcessHeap(), 0, PrintStructures
);
2217 if(bRet
&& (lppd
->Flags
& PD_RETURNDC
|| lppd
->Flags
& PD_RETURNIC
))
2218 bRet
= PRINTDLG_CreateDCA(lppd
);
2220 TRACE("exit! (%d)\n", bRet
);
2224 /***********************************************************************
2225 * PrintDlgW (COMDLG32.@)
2229 BOOL WINAPI
PrintDlgW(LPPRINTDLGW lppd
)
2237 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION
);
2241 hInst
= (HINSTANCE
)GetWindowLongPtrW( lppd
->hwndOwner
, GWLP_HINSTANCE
);
2242 if(TRACE_ON(commdlg
)) {
2243 char flagstr
[1000] = "";
2244 const struct pd_flags
*pflag
= pd_flags
;
2245 for( ; pflag
->name
; pflag
++) {
2246 if(lppd
->Flags
& pflag
->flag
)
2247 strcat(flagstr
, pflag
->name
);
2249 TRACE("(%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
2250 "pp. %d-%d, min p %d, max p %d, copies %d, hinst %p\n"
2251 "flags %08x (%s)\n",
2252 lppd
, lppd
->hwndOwner
, lppd
->hDevMode
, lppd
->hDevNames
,
2253 lppd
->nFromPage
, lppd
->nToPage
, lppd
->nMinPage
, lppd
->nMaxPage
,
2254 lppd
->nCopies
, lppd
->hInstance
, lppd
->Flags
, flagstr
);
2257 if(lppd
->lStructSize
!= sizeof(PRINTDLGW
)) {
2258 WARN("structure size failure !!!\n");
2259 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE
);
2263 if(lppd
->Flags
& PD_RETURNDEFAULT
) {
2264 PRINTER_INFO_2W
*pbuf
;
2265 DRIVER_INFO_3W
*dbuf
;
2269 if(lppd
->hDevMode
|| lppd
->hDevNames
) {
2270 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
2271 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
2274 if(!PRINTDLG_OpenDefaultPrinter(&hprn
)) {
2275 WARN("Can't find default printer\n");
2276 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN
);
2280 GetPrinterW(hprn
, 2, NULL
, 0, &needed
);
2281 pbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
2282 GetPrinterW(hprn
, 2, (LPBYTE
)pbuf
, needed
, &needed
);
2284 GetPrinterDriverW(hprn
, NULL
, 3, NULL
, 0, &needed
);
2285 dbuf
= HeapAlloc(GetProcessHeap(),0,needed
);
2286 if (!GetPrinterDriverW(hprn
, NULL
, 3, (LPBYTE
)dbuf
, needed
, &needed
)) {
2287 ERR("GetPrinterDriverA failed, le %d, fix your config for printer %s!\n",
2288 GetLastError(),debugstr_w(pbuf
->pPrinterName
));
2289 HeapFree(GetProcessHeap(), 0, dbuf
);
2290 HeapFree(GetProcessHeap(), 0, pbuf
);
2291 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
2296 PRINTDLG_CreateDevNamesW(&(lppd
->hDevNames
),
2300 lppd
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
, pbuf
->pDevMode
->dmSize
+
2301 pbuf
->pDevMode
->dmDriverExtra
);
2302 ptr
= GlobalLock(lppd
->hDevMode
);
2303 memcpy(ptr
, pbuf
->pDevMode
, pbuf
->pDevMode
->dmSize
+
2304 pbuf
->pDevMode
->dmDriverExtra
);
2305 GlobalUnlock(lppd
->hDevMode
);
2306 HeapFree(GetProcessHeap(), 0, pbuf
);
2307 HeapFree(GetProcessHeap(), 0, dbuf
);
2311 PRINT_PTRW
*PrintStructures
;
2313 /* load Dialog resources,
2314 * depending on Flags indicates Print32 or Print32_setup dialog
2316 hDlgTmpl
= PRINTDLG_GetDlgTemplateW(lppd
);
2318 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
2321 ptr
= LockResource( hDlgTmpl
);
2323 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE
);
2327 PrintStructures
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2328 sizeof(PRINT_PTRW
));
2329 PrintStructures
->lpPrintDlg
= lppd
;
2331 /* and create & process the dialog .
2332 * -1 is failure, 0 is broken hwnd, everything else is ok.
2334 bRet
= (0<DialogBoxIndirectParamW(hInst
, ptr
, lppd
->hwndOwner
,
2336 (LPARAM
)PrintStructures
));
2339 DEVMODEW
*lpdm
= PrintStructures
->lpDevMode
, *lpdmReturn
;
2340 PRINTER_INFO_2W
*pi
= PrintStructures
->lpPrinterInfo
;
2341 DRIVER_INFO_3W
*di
= PrintStructures
->lpDriverInfo
;
2343 if (lppd
->hDevMode
== 0) {
2344 TRACE(" No hDevMode yet... Need to create my own\n");
2345 lppd
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
,
2346 lpdm
->dmSize
+ lpdm
->dmDriverExtra
);
2349 if((locks
= (GlobalFlags(lppd
->hDevMode
) & GMEM_LOCKCOUNT
))) {
2350 WARN("hDevMode has %d locks on it. Unlocking it now\n", locks
);
2352 GlobalUnlock(lppd
->hDevMode
);
2353 TRACE("Now got %d locks\n", locks
);
2356 lppd
->hDevMode
= GlobalReAlloc(lppd
->hDevMode
,
2357 lpdm
->dmSize
+ lpdm
->dmDriverExtra
,
2360 lpdmReturn
= GlobalLock(lppd
->hDevMode
);
2361 memcpy(lpdmReturn
, lpdm
, lpdm
->dmSize
+ lpdm
->dmDriverExtra
);
2363 if (lppd
->hDevNames
!= 0) {
2365 if((locks
= (GlobalFlags(lppd
->hDevNames
) & GMEM_LOCKCOUNT
))) {
2366 WARN("hDevNames has %d locks on it. Unlocking it now\n", locks
);
2368 GlobalUnlock(lppd
->hDevNames
);
2371 PRINTDLG_CreateDevNamesW(&(lppd
->hDevNames
),
2376 GlobalUnlock(lppd
->hDevMode
);
2378 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDevMode
);
2379 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpPrinterInfo
);
2380 HeapFree(GetProcessHeap(), 0, PrintStructures
->lpDriverInfo
);
2381 HeapFree(GetProcessHeap(), 0, PrintStructures
);
2383 if(bRet
&& (lppd
->Flags
& PD_RETURNDC
|| lppd
->Flags
& PD_RETURNIC
))
2384 bRet
= PRINTDLG_CreateDCW(lppd
);
2386 TRACE("exit! (%d)\n", bRet
);
2390 /***********************************************************************
2395 * cmb1 - printer select (not in standard dialog template)
2397 * cmb3 - source (tray?)
2398 * edt4 - border left
2400 * edt6 - border right
2401 * edt7 - border bottom
2402 * psh3 - "Printer..."
2410 LPPAGESETUPDLGA dlga
;
2411 LPPAGESETUPDLGW dlgw
;
2413 HWND hDlg
; /* Page Setup dialog handle */
2414 RECT rtDrawRect
; /* Drawing rect for page */
2417 static inline DWORD
pagesetup_get_flags(const pagesetup_data
*data
)
2419 return data
->u
.dlgw
->Flags
;
2422 static inline BOOL
is_metric(const pagesetup_data
*data
)
2424 return pagesetup_get_flags(data
) & PSD_INHUNDREDTHSOFMILLIMETERS
;
2427 static inline LONG
tenths_mm_to_size(const pagesetup_data
*data
, LONG size
)
2429 if (is_metric(data
))
2432 return 10 * size
* 100 / 254;
2435 static inline LONG
thousandths_inch_to_size(const pagesetup_data
*data
, LONG size
)
2437 if (is_metric(data
))
2438 return size
* 254 / 100;
2443 static WCHAR
get_decimal_sep(void)
2449 WCHAR buf
[2] = {'.',0};
2450 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_SDECIMAL
, buf
, sizeof(buf
) / sizeof(buf
[0]));
2456 static void size2str(const pagesetup_data
*data
, DWORD size
, LPWSTR strout
)
2458 WCHAR integer_fmt
[] = {'%','d',0};
2459 WCHAR hundredths_fmt
[] = {'%','d','%','c','%','0','2','d',0};
2460 WCHAR thousandths_fmt
[] = {'%','d','%','c','%','0','3','d',0};
2462 /* FIXME use LOCALE_SDECIMAL when the edit parsing code can cope */
2464 if (is_metric(data
))
2467 wsprintfW(strout
, hundredths_fmt
, size
/ 100, get_decimal_sep(), size
% 100);
2469 wsprintfW(strout
, integer_fmt
, size
/ 100);
2474 wsprintfW(strout
, thousandths_fmt
, size
/ 1000, get_decimal_sep(), size
% 1000);
2476 wsprintfW(strout
, integer_fmt
, size
/ 1000);
2481 static inline BOOL
is_default_metric(void)
2484 GetLocaleInfoW(LOCALE_USER_DEFAULT
, LOCALE_IMEASURE
| LOCALE_RETURN_NUMBER
,
2485 (LPWSTR
)&system
, sizeof(system
));
2489 /**********************************************
2491 * Cyclically permute the four members of rc
2492 * If sense is TRUE l -> t -> r -> b
2493 * otherwise l <- t <- r <- b
2495 static inline void rotate_rect(RECT
*rc
, BOOL sense
)
2501 rc
->bottom
= rc
->right
;
2502 rc
->right
= rc
->top
;
2510 rc
->top
= rc
->right
;
2511 rc
->right
= rc
->bottom
;
2516 static void pagesetup_set_orientation(pagesetup_data
*data
, WORD orient
)
2518 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2520 assert(orient
== DMORIENT_PORTRAIT
|| orient
== DMORIENT_LANDSCAPE
);
2523 dm
->u1
.s1
.dmOrientation
= orient
;
2526 DEVMODEA
*dmA
= (DEVMODEA
*)dm
;
2527 dmA
->u1
.s1
.dmOrientation
= orient
;
2529 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2532 static WORD
pagesetup_get_orientation(const pagesetup_data
*data
)
2534 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2538 orient
= dm
->u1
.s1
.dmOrientation
;
2541 DEVMODEA
*dmA
= (DEVMODEA
*)dm
;
2542 orient
= dmA
->u1
.s1
.dmOrientation
;
2544 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2548 static void pagesetup_set_papersize(pagesetup_data
*data
, WORD paper
)
2550 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2553 dm
->u1
.s1
.dmPaperSize
= paper
;
2556 DEVMODEA
*dmA
= (DEVMODEA
*)dm
;
2557 dmA
->u1
.s1
.dmPaperSize
= paper
;
2559 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2562 static WORD
pagesetup_get_papersize(const pagesetup_data
*data
)
2564 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2568 paper
= dm
->u1
.s1
.dmPaperSize
;
2571 DEVMODEA
*dmA
= (DEVMODEA
*)dm
;
2572 paper
= dmA
->u1
.s1
.dmPaperSize
;
2574 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2578 static void pagesetup_set_defaultsource(pagesetup_data
*data
, WORD source
)
2580 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2583 dm
->u1
.s1
.dmDefaultSource
= source
;
2586 DEVMODEA
*dmA
= (DEVMODEA
*)dm
;
2587 dmA
->u1
.s1
.dmDefaultSource
= source
;
2589 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2594 devnames_driver_name
,
2595 devnames_device_name
,
2596 devnames_output_name
2600 static inline WORD
get_devname_offset(const DEVNAMES
*dn
, devnames_name which
)
2604 case devnames_driver_name
: return dn
->wDriverOffset
;
2605 case devnames_device_name
: return dn
->wDeviceOffset
;
2606 case devnames_output_name
: return dn
->wOutputOffset
;
2608 ERR("Souldn't be here\n");
2612 static WCHAR
*pagesetup_get_a_devname(const pagesetup_data
*data
, devnames_name which
)
2617 dn
= GlobalLock(data
->u
.dlgw
->hDevNames
);
2619 name
= strdupW((WCHAR
*)dn
+ get_devname_offset(dn
, which
));
2622 int len
= MultiByteToWideChar(CP_ACP
, 0, (char*)dn
+ get_devname_offset(dn
, which
), -1, NULL
, 0);
2623 name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
2624 MultiByteToWideChar(CP_ACP
, 0, (char*)dn
+ get_devname_offset(dn
, which
), -1, name
, len
);
2626 GlobalUnlock(data
->u
.dlgw
->hDevNames
);
2630 static WCHAR
*pagesetup_get_drvname(const pagesetup_data
*data
)
2632 return pagesetup_get_a_devname(data
, devnames_driver_name
);
2635 static WCHAR
*pagesetup_get_devname(const pagesetup_data
*data
)
2637 return pagesetup_get_a_devname(data
, devnames_device_name
);
2640 static WCHAR
*pagesetup_get_portname(const pagesetup_data
*data
)
2642 return pagesetup_get_a_devname(data
, devnames_output_name
);
2645 static void pagesetup_release_a_devname(const pagesetup_data
*data
, WCHAR
*name
)
2647 HeapFree(GetProcessHeap(), 0, name
);
2650 static void pagesetup_set_devnames(pagesetup_data
*data
, LPCWSTR drv
, LPCWSTR devname
, LPCWSTR port
)
2654 DWORD len
= sizeof(DEVNAMES
), drv_len
, dev_len
, port_len
;
2658 drv_len
= (strlenW(drv
) + 1) * sizeof(WCHAR
);
2659 dev_len
= (strlenW(devname
) + 1) * sizeof(WCHAR
);
2660 port_len
= (strlenW(port
) + 1) * sizeof(WCHAR
);
2664 drv_len
= WideCharToMultiByte(CP_ACP
, 0, drv
, -1, NULL
, 0, NULL
, NULL
);
2665 dev_len
= WideCharToMultiByte(CP_ACP
, 0, devname
, -1, NULL
, 0, NULL
, NULL
);
2666 port_len
= WideCharToMultiByte(CP_ACP
, 0, port
, -1, NULL
, 0, NULL
, NULL
);
2668 len
+= drv_len
+ dev_len
+ port_len
;
2670 if(data
->u
.dlgw
->hDevNames
)
2671 data
->u
.dlgw
->hDevNames
= GlobalReAlloc(data
->u
.dlgw
->hDevNames
, len
, GMEM_MOVEABLE
);
2673 data
->u
.dlgw
->hDevNames
= GlobalAlloc(GMEM_MOVEABLE
, len
);
2675 dn
= GlobalLock(data
->u
.dlgw
->hDevNames
);
2679 WCHAR
*ptr
= (WCHAR
*)(dn
+ 1);
2680 len
= sizeof(DEVNAMES
) / sizeof(WCHAR
);
2681 dn
->wDriverOffset
= len
;
2683 ptr
+= drv_len
/ sizeof(WCHAR
);
2684 len
+= drv_len
/ sizeof(WCHAR
);
2685 dn
->wDeviceOffset
= len
;
2686 strcpyW(ptr
, devname
);
2687 ptr
+= dev_len
/ sizeof(WCHAR
);
2688 len
+= dev_len
/ sizeof(WCHAR
);
2689 dn
->wOutputOffset
= len
;
2694 char *ptr
= (char *)(dn
+ 1);
2695 len
= sizeof(DEVNAMES
);
2696 dn
->wDriverOffset
= len
;
2697 WideCharToMultiByte(CP_ACP
, 0, drv
, -1, ptr
, drv_len
, NULL
, NULL
);
2700 dn
->wDeviceOffset
= len
;
2701 WideCharToMultiByte(CP_ACP
, 0, devname
, -1, ptr
, dev_len
, NULL
, NULL
);
2704 dn
->wOutputOffset
= len
;
2705 WideCharToMultiByte(CP_ACP
, 0, port
, -1, ptr
, port_len
, NULL
, NULL
);
2709 len
= sizeof(def
) / sizeof(def
[0]);
2710 GetDefaultPrinterW(def
, &len
);
2711 if(!lstrcmpW(def
, devname
))
2714 GlobalUnlock(data
->u
.dlgw
->hDevNames
);
2717 static DEVMODEW
*pagesetup_get_devmode(const pagesetup_data
*data
)
2719 DEVMODEW
*dm
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2724 /* We make a copy even in the unicode case because the ptr
2725 may get passed back to us in pagesetup_set_devmode. */
2726 ret
= HeapAlloc(GetProcessHeap(), 0, dm
->dmSize
+ dm
->dmDriverExtra
);
2727 memcpy(ret
, dm
, dm
->dmSize
+ dm
->dmDriverExtra
);
2730 ret
= GdiConvertToDevmodeW((DEVMODEA
*)dm
);
2732 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2736 static void pagesetup_release_devmode(const pagesetup_data
*data
, DEVMODEW
*dm
)
2738 HeapFree(GetProcessHeap(), 0, dm
);
2741 static void pagesetup_set_devmode(pagesetup_data
*data
, DEVMODEW
*dm
)
2743 DEVMODEA
*dmA
= NULL
;
2749 size
= dm
->dmSize
+ dm
->dmDriverExtra
;
2754 dmA
= convert_to_devmodeA(dm
);
2755 size
= dmA
->dmSize
+ dmA
->dmDriverExtra
;
2759 if(data
->u
.dlgw
->hDevMode
)
2760 data
->u
.dlgw
->hDevMode
= GlobalReAlloc(data
->u
.dlgw
->hDevMode
, size
,
2763 data
->u
.dlgw
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
, size
);
2765 dst
= GlobalLock(data
->u
.dlgw
->hDevMode
);
2766 memcpy(dst
, src
, size
);
2767 GlobalUnlock(data
->u
.dlgw
->hDevMode
);
2768 HeapFree(GetProcessHeap(), 0, dmA
);
2771 static inline POINT
*pagesetup_get_papersize_pt(const pagesetup_data
*data
)
2773 return &data
->u
.dlgw
->ptPaperSize
;
2776 static inline RECT
*pagesetup_get_margin_rect(const pagesetup_data
*data
)
2778 return &data
->u
.dlgw
->rtMargin
;
2787 static inline LPPAGESETUPHOOK
pagesetup_get_hook(const pagesetup_data
*data
, hook_type which
)
2791 case page_setup_hook
: return data
->u
.dlgw
->lpfnPageSetupHook
;
2792 case page_paint_hook
: return data
->u
.dlgw
->lpfnPagePaintHook
;
2797 /* This should only be used in calls to hook procs so we return the ptr
2798 already cast to LPARAM */
2799 static inline LPARAM
pagesetup_get_dlg_struct(const pagesetup_data
*data
)
2801 return (LPARAM
)data
->u
.dlgw
;
2804 static inline void swap_point(POINT
*pt
)
2811 static BOOL
pagesetup_update_papersize(pagesetup_data
*data
)
2814 LPWSTR devname
, portname
;
2816 WORD
*words
= NULL
, paperword
;
2817 POINT
*points
= NULL
;
2818 BOOL retval
= FALSE
;
2820 dm
= pagesetup_get_devmode(data
);
2821 devname
= pagesetup_get_devname(data
);
2822 portname
= pagesetup_get_portname(data
);
2824 num
= DeviceCapabilitiesW(devname
, portname
, DC_PAPERS
, NULL
, dm
);
2827 FIXME("No papernames found for %s/%s\n", debugstr_w(devname
), debugstr_w(portname
));
2831 words
= HeapAlloc(GetProcessHeap(), 0, num
* sizeof(WORD
));
2832 points
= HeapAlloc(GetProcessHeap(), 0, num
* sizeof(POINT
));
2834 if (num
!= DeviceCapabilitiesW(devname
, portname
, DC_PAPERS
, (LPWSTR
)words
, dm
))
2836 FIXME("Number of returned words is not %d\n", num
);
2840 if (num
!= DeviceCapabilitiesW(devname
, portname
, DC_PAPERSIZE
, (LPWSTR
)points
, dm
))
2842 FIXME("Number of returned sizes is not %d\n", num
);
2846 paperword
= pagesetup_get_papersize(data
);
2848 for (i
= 0; i
< num
; i
++)
2849 if (words
[i
] == paperword
)
2854 FIXME("Papersize %d not found in list?\n", paperword
);
2858 /* this is _10ths_ of a millimeter */
2859 pagesetup_get_papersize_pt(data
)->x
= tenths_mm_to_size(data
, points
[i
].x
);
2860 pagesetup_get_papersize_pt(data
)->y
= tenths_mm_to_size(data
, points
[i
].y
);
2862 if(pagesetup_get_orientation(data
) == DMORIENT_LANDSCAPE
)
2863 swap_point(pagesetup_get_papersize_pt(data
));
2868 HeapFree(GetProcessHeap(), 0, words
);
2869 HeapFree(GetProcessHeap(), 0, points
);
2870 pagesetup_release_a_devname(data
, portname
);
2871 pagesetup_release_a_devname(data
, devname
);
2872 pagesetup_release_devmode(data
, dm
);
2877 /**********************************************************************************************
2878 * pagesetup_change_printer
2880 * Redefines hDevMode and hDevNames HANDLES and initialises it.
2883 static BOOL
pagesetup_change_printer(LPWSTR name
, pagesetup_data
*data
)
2887 PRINTER_INFO_2W
*prn_info
= NULL
;
2888 DRIVER_INFO_3W
*drv_info
= NULL
;
2889 DEVMODEW
*dm
= NULL
;
2890 BOOL retval
= FALSE
;
2892 if(!OpenPrinterW(name
, &hprn
, NULL
))
2894 ERR("Can't open printer %s\n", debugstr_w(name
));
2898 GetPrinterW(hprn
, 2, NULL
, 0, &needed
);
2899 prn_info
= HeapAlloc(GetProcessHeap(), 0, needed
);
2900 GetPrinterW(hprn
, 2, (LPBYTE
)prn_info
, needed
, &needed
);
2901 GetPrinterDriverW(hprn
, NULL
, 3, NULL
, 0, &needed
);
2902 drv_info
= HeapAlloc(GetProcessHeap(), 0, needed
);
2903 if(!GetPrinterDriverW(hprn
, NULL
, 3, (LPBYTE
)drv_info
, needed
, &needed
))
2905 ERR("GetPrinterDriverA failed for %s, fix your config!\n", debugstr_w(prn_info
->pPrinterName
));
2910 needed
= DocumentPropertiesW(0, 0, name
, NULL
, NULL
, 0);
2913 ERR("DocumentProperties fails on %s\n", debugstr_w(name
));
2917 dm
= HeapAlloc(GetProcessHeap(), 0, needed
);
2918 DocumentPropertiesW(0, 0, name
, dm
, NULL
, DM_OUT_BUFFER
);
2920 pagesetup_set_devmode(data
, dm
);
2921 pagesetup_set_devnames(data
, drv_info
->pDriverPath
, prn_info
->pPrinterName
,
2922 prn_info
->pPortName
);
2926 HeapFree(GetProcessHeap(), 0, dm
);
2927 HeapFree(GetProcessHeap(), 0, prn_info
);
2928 HeapFree(GetProcessHeap(), 0, drv_info
);
2932 /****************************************************************************************
2933 * pagesetup_init_combos
2935 * Fills Printers, Paper and Source combos
2938 static void pagesetup_init_combos(HWND hDlg
, pagesetup_data
*data
)
2941 LPWSTR devname
, portname
;
2943 dm
= pagesetup_get_devmode(data
);
2944 devname
= pagesetup_get_devname(data
);
2945 portname
= pagesetup_get_portname(data
);
2947 PRINTDLG_SetUpPrinterListComboW(hDlg
, cmb1
, devname
);
2948 PRINTDLG_SetUpPaperComboBoxW(hDlg
, cmb2
, devname
, portname
, dm
);
2949 PRINTDLG_SetUpPaperComboBoxW(hDlg
, cmb3
, devname
, portname
, dm
);
2951 pagesetup_release_a_devname(data
, portname
);
2952 pagesetup_release_a_devname(data
, devname
);
2953 pagesetup_release_devmode(data
, dm
);
2957 /****************************************************************************************
2958 * pagesetup_change_printer_dialog
2960 * Pops up another dialog that lets the user pick another printer.
2962 * For now we display the PrintDlg, this should display a striped down version of it.
2964 static void pagesetup_change_printer_dialog(HWND hDlg
, pagesetup_data
*data
)
2967 LPWSTR drvname
, devname
, portname
;
2968 DEVMODEW
*tmp_dm
, *dm
;
2970 memset(&prnt
, 0, sizeof(prnt
));
2971 prnt
.lStructSize
= sizeof(prnt
);
2973 prnt
.hwndOwner
= hDlg
;
2975 drvname
= pagesetup_get_drvname(data
);
2976 devname
= pagesetup_get_devname(data
);
2977 portname
= pagesetup_get_portname(data
);
2979 PRINTDLG_CreateDevNamesW(&prnt
.hDevNames
, drvname
, devname
, portname
);
2980 pagesetup_release_a_devname(data
, portname
);
2981 pagesetup_release_a_devname(data
, devname
);
2982 pagesetup_release_a_devname(data
, drvname
);
2984 tmp_dm
= pagesetup_get_devmode(data
);
2985 prnt
.hDevMode
= GlobalAlloc(GMEM_MOVEABLE
, tmp_dm
->dmSize
+ tmp_dm
->dmDriverExtra
);
2986 dm
= GlobalLock(prnt
.hDevMode
);
2987 memcpy(dm
, tmp_dm
, tmp_dm
->dmSize
+ tmp_dm
->dmDriverExtra
);
2988 GlobalUnlock(prnt
.hDevMode
);
2989 pagesetup_release_devmode(data
, tmp_dm
);
2991 if (PrintDlgW(&prnt
))
2993 DEVMODEW
*dm
= GlobalLock(prnt
.hDevMode
);
2994 DEVNAMES
*dn
= GlobalLock(prnt
.hDevNames
);
2996 pagesetup_set_devnames(data
, (WCHAR
*)dn
+ dn
->wDriverOffset
,
2997 (WCHAR
*)dn
+ dn
->wDeviceOffset
, (WCHAR
*)dn
+ dn
->wOutputOffset
);
2998 pagesetup_set_devmode(data
, dm
);
2999 GlobalUnlock(prnt
.hDevNames
);
3000 GlobalUnlock(prnt
.hDevMode
);
3001 pagesetup_init_combos(hDlg
, data
);
3004 GlobalFree(prnt
.hDevMode
);
3005 GlobalFree(prnt
.hDevNames
);
3009 /******************************************************************************************
3010 * pagesetup_change_preview
3012 * Changes paper preview size / position
3015 static void pagesetup_change_preview(const pagesetup_data
*data
)
3017 LONG width
, height
, x
, y
;
3019 const int shadow
= 4;
3021 if(pagesetup_get_orientation(data
) == DMORIENT_LANDSCAPE
)
3023 width
= data
->rtDrawRect
.right
- data
->rtDrawRect
.left
;
3024 height
= pagesetup_get_papersize_pt(data
)->y
* width
/ pagesetup_get_papersize_pt(data
)->x
;
3028 height
= data
->rtDrawRect
.bottom
- data
->rtDrawRect
.top
;
3029 width
= pagesetup_get_papersize_pt(data
)->x
* height
/ pagesetup_get_papersize_pt(data
)->y
;
3031 x
= (data
->rtDrawRect
.right
+ data
->rtDrawRect
.left
- width
) / 2;
3032 y
= (data
->rtDrawRect
.bottom
+ data
->rtDrawRect
.top
- height
) / 2;
3033 TRACE("draw rect %s x=%d, y=%d, w=%d, h=%d\n",
3034 wine_dbgstr_rect(&data
->rtDrawRect
), x
, y
, width
, height
);
3036 MoveWindow(GetDlgItem(data
->hDlg
, rct2
), x
+ width
, y
+ shadow
, shadow
, height
, FALSE
);
3037 MoveWindow(GetDlgItem(data
->hDlg
, rct3
), x
+ shadow
, y
+ height
, width
, shadow
, FALSE
);
3038 MoveWindow(GetDlgItem(data
->hDlg
, rct1
), x
, y
, width
, height
, FALSE
);
3040 tmp
= data
->rtDrawRect
;
3041 tmp
.right
+= shadow
;
3042 tmp
.bottom
+= shadow
;
3043 InvalidateRect(data
->hDlg
, &tmp
, TRUE
);
3046 static inline LONG
*element_from_margin_id(RECT
*rc
, WORD id
)
3050 case edt4
: return &rc
->left
;
3051 case edt5
: return &rc
->top
;
3052 case edt6
: return &rc
->right
;
3053 case edt7
: return &rc
->bottom
;
3058 static void update_margin_edits(HWND hDlg
, const pagesetup_data
*data
, WORD id
)
3063 for(idx
= edt4
; idx
<= edt7
; idx
++)
3065 if(id
== 0 || id
== idx
)
3067 size2str(data
, *element_from_margin_id(pagesetup_get_margin_rect(data
), idx
), str
);
3068 SetDlgItemTextW(hDlg
, idx
, str
);
3073 static void margin_edit_notification(HWND hDlg
, const pagesetup_data
*data
, WORD msg
, WORD id
)
3081 LONG
*value
= element_from_margin_id(pagesetup_get_margin_rect(data
), id
);
3083 if (GetDlgItemTextW(hDlg
, id
, buf
, sizeof(buf
) / sizeof(buf
[0])) != 0)
3086 WCHAR decimal
= get_decimal_sep();
3088 val
= strtolW(buf
, &end
, 10);
3089 if(end
!= buf
|| *end
== decimal
)
3091 int mult
= is_metric(data
) ? 100 : 1000;
3100 val
+= (*end
- '0') * mult
;
3112 update_margin_edits(hDlg
, data
, id
);
3117 static void set_margin_groupbox_title(HWND hDlg
, const pagesetup_data
*data
)
3121 if(LoadStringW(COMDLG32_hInstance
, is_metric(data
) ? PD32_MARGINS_IN_MILLIMETERS
: PD32_MARGINS_IN_INCHES
,
3122 title
, sizeof(title
)/sizeof(title
[0])))
3123 SetDlgItemTextW(hDlg
, grp4
, title
);
3126 static void pagesetup_update_orientation_buttons(HWND hDlg
, const pagesetup_data
*data
)
3128 if (pagesetup_get_orientation(data
) == DMORIENT_LANDSCAPE
)
3129 CheckRadioButton(hDlg
, rad1
, rad2
, rad2
);
3131 CheckRadioButton(hDlg
, rad1
, rad2
, rad1
);
3134 /****************************************************************************************
3135 * pagesetup_printer_properties
3137 * Handle invocation of the 'Properties' button (not present in the default template).
3139 static void pagesetup_printer_properties(HWND hDlg
, pagesetup_data
*data
)
3147 devname
= pagesetup_get_devname(data
);
3149 if (!OpenPrinterW(devname
, &hprn
, NULL
))
3151 FIXME("Call to OpenPrinter did not succeed!\n");
3152 pagesetup_release_a_devname(data
, devname
);
3156 dm
= pagesetup_get_devmode(data
);
3157 DocumentPropertiesW(hDlg
, hprn
, devname
, dm
, dm
, DM_IN_BUFFER
| DM_OUT_BUFFER
| DM_IN_PROMPT
);
3158 pagesetup_set_devmode(data
, dm
);
3159 pagesetup_release_devmode(data
, dm
);
3160 pagesetup_release_a_devname(data
, devname
);
3163 /* Changing paper */
3164 pagesetup_update_papersize(data
);
3165 pagesetup_update_orientation_buttons(hDlg
, data
);
3167 /* Changing paper preview */
3168 pagesetup_change_preview(data
);
3170 /* Selecting paper in combo */
3171 count
= SendDlgItemMessageW(hDlg
, cmb2
, CB_GETCOUNT
, 0, 0);
3174 WORD paperword
= pagesetup_get_papersize(data
);
3175 for(i
= 0; i
< count
; i
++)
3177 if(SendDlgItemMessageW(hDlg
, cmb2
, CB_GETITEMDATA
, i
, 0) == paperword
) {
3178 SendDlgItemMessageW(hDlg
, cmb2
, CB_SETCURSEL
, i
, 0);
3185 /********************************************************************************
3186 * pagesetup_wm_command
3187 * process WM_COMMAND message for PageSetupDlg
3190 * hDlg [in] Main dialog HANDLE
3191 * wParam [in] WM_COMMAND wParam
3192 * lParam [in] WM_COMMAND lParam
3193 * pda [in/out] ptr to PageSetupDataA
3196 static BOOL
pagesetup_wm_command(HWND hDlg
, WPARAM wParam
, LPARAM lParam
, pagesetup_data
*data
)
3198 WORD msg
= HIWORD(wParam
);
3199 WORD id
= LOWORD(wParam
);
3201 TRACE("loword (lparam) %d, wparam 0x%lx, lparam %08lx\n",
3202 LOWORD(lParam
),wParam
,lParam
);
3205 EndDialog(hDlg
, TRUE
);
3209 EndDialog(hDlg
, FALSE
);
3212 case psh3
: /* Printer... */
3213 pagesetup_change_printer_dialog(hDlg
, data
);
3216 case rad1
: /* Portrait */
3217 case rad2
: /* Landscape */
3218 if((id
== rad1
&& pagesetup_get_orientation(data
) == DMORIENT_LANDSCAPE
) ||
3219 (id
== rad2
&& pagesetup_get_orientation(data
) == DMORIENT_PORTRAIT
))
3221 pagesetup_set_orientation(data
, (id
== rad1
) ? DMORIENT_PORTRAIT
: DMORIENT_LANDSCAPE
);
3222 pagesetup_update_papersize(data
);
3223 rotate_rect(pagesetup_get_margin_rect(data
), (id
== rad2
));
3224 update_margin_edits(hDlg
, data
, 0);
3225 pagesetup_change_preview(data
);
3228 case cmb1
: /* Printer combo */
3229 if(msg
== CBN_SELCHANGE
)
3232 GetDlgItemTextW(hDlg
, id
, name
, sizeof(name
) / sizeof(name
[0]));
3233 pagesetup_change_printer(name
, data
);
3234 pagesetup_init_combos(hDlg
, data
);
3237 case cmb2
: /* Paper combo */
3238 if(msg
== CBN_SELCHANGE
)
3240 DWORD paperword
= SendDlgItemMessageW(hDlg
, cmb2
, CB_GETITEMDATA
,
3241 SendDlgItemMessageW(hDlg
, cmb2
, CB_GETCURSEL
, 0, 0), 0);
3242 if (paperword
!= CB_ERR
)
3244 pagesetup_set_papersize(data
, paperword
);
3245 pagesetup_update_papersize(data
);
3246 pagesetup_change_preview(data
);
3248 FIXME("could not get dialog text for papersize cmbbox?\n");
3251 case cmb3
: /* Paper Source */
3252 if(msg
== CBN_SELCHANGE
)
3254 WORD source
= SendDlgItemMessageW(hDlg
, cmb3
, CB_GETITEMDATA
,
3255 SendDlgItemMessageW(hDlg
, cmb3
, CB_GETCURSEL
, 0, 0), 0);
3256 pagesetup_set_defaultsource(data
, source
);
3259 case psh2
: /* Printer Properties button */
3260 pagesetup_printer_properties(hDlg
, data
);
3266 margin_edit_notification(hDlg
, data
, msg
, id
);
3269 InvalidateRect(GetDlgItem(hDlg
, rct1
), NULL
, TRUE
);
3273 /***********************************************************************
3274 * default_page_paint_hook
3275 * Default hook paint procedure that receives WM_PSD_* messages from the dialog box
3276 * whenever the sample page is redrawn.
3278 static UINT_PTR
default_page_paint_hook(HWND hwndDlg
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
,
3279 const pagesetup_data
*data
)
3281 LPRECT lprc
= (LPRECT
) lParam
;
3282 HDC hdc
= (HDC
) wParam
;
3285 HFONT hfont
, holdfont
;
3287 TRACE("uMsg: WM_USER+%d\n",uMsg
-WM_USER
);
3288 /* Call user paint hook if enable */
3289 if (pagesetup_get_flags(data
) & PSD_ENABLEPAGEPAINTHOOK
)
3290 if (pagesetup_get_hook(data
, page_paint_hook
)(hwndDlg
, uMsg
, wParam
, lParam
))
3294 /* LPPAGESETUPDLG in lParam */
3295 case WM_PSD_PAGESETUPDLG
:
3296 /* Inform about the sample page rectangle */
3297 case WM_PSD_FULLPAGERECT
:
3298 /* Inform about the margin rectangle */
3299 case WM_PSD_MINMARGINRECT
:
3302 /* Draw dashed rectangle showing margins */
3303 case WM_PSD_MARGINRECT
:
3304 hpen
= CreatePen(PS_DASH
, 1, GetSysColor(COLOR_3DSHADOW
));
3305 holdpen
= SelectObject(hdc
, hpen
);
3306 Rectangle(hdc
, lprc
->left
, lprc
->top
, lprc
->right
, lprc
->bottom
);
3307 DeleteObject(SelectObject(hdc
, holdpen
));
3309 /* Draw the fake document */
3310 case WM_PSD_GREEKTEXTRECT
:
3311 /* select a nice scalable font, because we want the text really small */
3312 SystemParametersInfoW(SPI_GETICONTITLELOGFONT
, sizeof(lf
), &lf
, 0);
3313 lf
.lfHeight
= 6; /* value chosen based on visual effect */
3314 hfont
= CreateFontIndirectW(&lf
);
3315 holdfont
= SelectObject(hdc
, hfont
);
3317 /* if text not loaded, then do so now */
3318 if (wszFakeDocumentText
[0] == '\0')
3319 LoadStringW(COMDLG32_hInstance
,
3321 wszFakeDocumentText
,
3322 sizeof(wszFakeDocumentText
)/sizeof(wszFakeDocumentText
[0]));
3324 oldbkmode
= SetBkMode(hdc
, TRANSPARENT
);
3325 DrawTextW(hdc
, wszFakeDocumentText
, -1, lprc
, DT_TOP
|DT_LEFT
|DT_NOPREFIX
|DT_WORDBREAK
);
3326 SetBkMode(hdc
, oldbkmode
);
3328 DeleteObject(SelectObject(hdc
, holdfont
));
3331 /* Envelope stamp */
3332 case WM_PSD_ENVSTAMPRECT
:
3333 /* Return address */
3334 case WM_PSD_YAFULLPAGERECT
:
3335 FIXME("envelope/stamp is not implemented\n");
3338 FIXME("Unknown message %x\n",uMsg
);
3344 /***********************************************************************
3346 * The main paint procedure for the PageSetupDlg function.
3347 * The Page Setup dialog box includes an image of a sample page that shows how
3348 * the user's selections affect the appearance of the printed output.
3349 * The image consists of a rectangle that represents the selected paper
3350 * or envelope type, with a dotted-line rectangle representing
3351 * the current margins, and partial (Greek text) characters
3352 * to show how text looks on the printed page.
3354 * The following messages in the order sends to user hook procedure:
3355 * WM_PSD_PAGESETUPDLG Draw the contents of the sample page
3356 * WM_PSD_FULLPAGERECT Inform about the bounding rectangle
3357 * WM_PSD_MINMARGINRECT Inform about the margin rectangle (min margin?)
3358 * WM_PSD_MARGINRECT Draw the margin rectangle
3359 * WM_PSD_GREEKTEXTRECT Draw the Greek text inside the margin rectangle
3360 * If any of first three messages returns TRUE, painting done.
3363 * hWnd [in] Handle to the Page Setup dialog box
3364 * uMsg [in] Received message
3367 * WM_PSD_ENVSTAMPRECT Draw in the envelope-stamp rectangle (for envelopes only)
3368 * WM_PSD_YAFULLPAGERECT Draw the return address portion (for envelopes and other paper sizes)
3371 * FALSE if all done correctly
3376 static LRESULT CALLBACK
3377 PRINTDLG_PagePaintProc(HWND hWnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3380 RECT rcClient
, rcMargin
;
3383 HBRUSH hbrush
, holdbrush
;
3384 pagesetup_data
*data
;
3385 int papersize
=0, orientation
=0; /* FIXME: set this values for user paint hook */
3386 double scalx
, scaly
;
3388 if (uMsg
!= WM_PAINT
)
3389 return CallWindowProcA(lpfnStaticWndProc
, hWnd
, uMsg
, wParam
, lParam
);
3391 /* Processing WM_PAINT message */
3392 data
= GetPropW(hWnd
, pagesetupdlg_prop
);
3394 WARN("__WINE_PAGESETUPDLGDATA prop not set?\n");
3397 if (default_page_paint_hook(hWnd
, WM_PSD_PAGESETUPDLG
, MAKELONG(papersize
, orientation
),
3398 pagesetup_get_dlg_struct(data
), data
))
3401 hdc
= BeginPaint(hWnd
, &ps
);
3402 GetClientRect(hWnd
, &rcClient
);
3404 scalx
= rcClient
.right
/ (double)pagesetup_get_papersize_pt(data
)->x
;
3405 scaly
= rcClient
.bottom
/ (double)pagesetup_get_papersize_pt(data
)->y
;
3406 rcMargin
= rcClient
;
3408 rcMargin
.left
+= pagesetup_get_margin_rect(data
)->left
* scalx
;
3409 rcMargin
.top
+= pagesetup_get_margin_rect(data
)->top
* scaly
;
3410 rcMargin
.right
-= pagesetup_get_margin_rect(data
)->right
* scalx
;
3411 rcMargin
.bottom
-= pagesetup_get_margin_rect(data
)->bottom
* scaly
;
3413 /* if the space is too small then we make sure to not draw anything */
3414 rcMargin
.left
= min(rcMargin
.left
, rcMargin
.right
);
3415 rcMargin
.top
= min(rcMargin
.top
, rcMargin
.bottom
);
3417 if (!default_page_paint_hook(hWnd
, WM_PSD_FULLPAGERECT
, (WPARAM
)hdc
, (LPARAM
)&rcClient
, data
) &&
3418 !default_page_paint_hook(hWnd
, WM_PSD_MINMARGINRECT
, (WPARAM
)hdc
, (LPARAM
)&rcMargin
, data
) )
3420 /* fill background */
3421 hbrush
= GetSysColorBrush(COLOR_3DHIGHLIGHT
);
3422 FillRect(hdc
, &rcClient
, hbrush
);
3423 holdbrush
= SelectObject(hdc
, hbrush
);
3425 hpen
= CreatePen(PS_SOLID
, 1, GetSysColor(COLOR_3DSHADOW
));
3426 holdpen
= SelectObject(hdc
, hpen
);
3428 /* paint left edge */
3429 MoveToEx(hdc
, rcClient
.left
, rcClient
.top
, NULL
);
3430 LineTo(hdc
, rcClient
.left
, rcClient
.bottom
-1);
3432 /* paint top edge */
3433 MoveToEx(hdc
, rcClient
.left
, rcClient
.top
, NULL
);
3434 LineTo(hdc
, rcClient
.right
, rcClient
.top
);
3436 hpen
= CreatePen(PS_SOLID
, 1, GetSysColor(COLOR_3DDKSHADOW
));
3437 DeleteObject(SelectObject(hdc
, hpen
));
3439 /* paint right edge */
3440 MoveToEx(hdc
, rcClient
.right
-1, rcClient
.top
, NULL
);
3441 LineTo(hdc
, rcClient
.right
-1, rcClient
.bottom
);
3443 /* paint bottom edge */
3444 MoveToEx(hdc
, rcClient
.left
, rcClient
.bottom
-1, NULL
);
3445 LineTo(hdc
, rcClient
.right
, rcClient
.bottom
-1);
3447 DeleteObject(SelectObject(hdc
, holdpen
));
3448 DeleteObject(SelectObject(hdc
, holdbrush
));
3450 default_page_paint_hook(hWnd
, WM_PSD_MARGINRECT
, (WPARAM
)hdc
, (LPARAM
)&rcMargin
, data
);
3452 /* give text a bit of a space from the frame */
3455 rcMargin
.right
-= 2;
3456 rcMargin
.bottom
-= 2;
3458 /* if the space is too small then we make sure to not draw anything */
3459 rcMargin
.left
= min(rcMargin
.left
, rcMargin
.right
);
3460 rcMargin
.top
= min(rcMargin
.top
, rcMargin
.bottom
);
3462 default_page_paint_hook(hWnd
, WM_PSD_GREEKTEXTRECT
, (WPARAM
)hdc
, (LPARAM
)&rcMargin
, data
);
3465 EndPaint(hWnd
, &ps
);
3469 /*******************************************************
3470 * The margin edit controls are subclassed to filter
3471 * anything other than numbers and the decimal separator.
3473 static LRESULT CALLBACK
pagesetup_margin_editproc(HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
3477 WCHAR decimal
= get_decimal_sep();
3478 WCHAR wc
= (WCHAR
)wparam
;
3479 if(!isdigitW(wc
) && wc
!= decimal
&& wc
!= VK_BACK
) return 0;
3481 return CallWindowProcW(edit_wndproc
, hwnd
, msg
, wparam
, lparam
);
3484 static void subclass_margin_edits(HWND hDlg
)
3489 for(id
= edt4
; id
<= edt7
; id
++)
3491 old_proc
= (WNDPROC
)SetWindowLongPtrW(GetDlgItem(hDlg
, id
),
3493 (ULONG_PTR
)pagesetup_margin_editproc
);
3494 InterlockedCompareExchangePointer((void**)&edit_wndproc
, old_proc
, NULL
);
3498 /***********************************************************************
3499 * pagesetup_dlg_proc
3501 * Message handler for PageSetupDlg
3503 static INT_PTR CALLBACK
pagesetup_dlg_proc(HWND hDlg
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3505 pagesetup_data
*data
;
3506 INT_PTR res
= FALSE
;
3509 if (uMsg
== WM_INITDIALOG
) { /*Init dialog*/
3510 data
= (pagesetup_data
*)lParam
;
3513 hDrawWnd
= GetDlgItem(hDlg
, rct1
);
3514 TRACE("set property to %p\n", data
);
3515 SetPropW(hDlg
, pagesetupdlg_prop
, data
);
3516 SetPropW(hDrawWnd
, pagesetupdlg_prop
, data
);
3517 GetWindowRect(hDrawWnd
, &data
->rtDrawRect
); /* Calculating rect in client coordinates where paper draws */
3518 ScreenToClient(hDlg
, (LPPOINT
)&data
->rtDrawRect
);
3519 ScreenToClient(hDlg
, (LPPOINT
)(&data
->rtDrawRect
.right
));
3520 lpfnStaticWndProc
= (WNDPROC
)SetWindowLongPtrW(
3523 (ULONG_PTR
)PRINTDLG_PagePaintProc
);
3525 /* FIXME: Paint hook. Must it be at begin of initialization or at end? */
3527 if (pagesetup_get_flags(data
) & PSD_ENABLEPAGESETUPHOOK
)
3529 if (!pagesetup_get_hook(data
, page_setup_hook
)(hDlg
, uMsg
, wParam
,
3530 pagesetup_get_dlg_struct(data
)))
3531 FIXME("Setup page hook failed?\n");
3534 /* if printer button disabled */
3535 if (pagesetup_get_flags(data
) & PSD_DISABLEPRINTER
)
3536 EnableWindow(GetDlgItem(hDlg
, psh3
), FALSE
);
3537 /* if margin edit boxes disabled */
3538 if (pagesetup_get_flags(data
) & PSD_DISABLEMARGINS
)
3540 EnableWindow(GetDlgItem(hDlg
, edt4
), FALSE
);
3541 EnableWindow(GetDlgItem(hDlg
, edt5
), FALSE
);
3542 EnableWindow(GetDlgItem(hDlg
, edt6
), FALSE
);
3543 EnableWindow(GetDlgItem(hDlg
, edt7
), FALSE
);
3546 /* Set orientation radiobuttons properly */
3547 pagesetup_update_orientation_buttons(hDlg
, data
);
3549 /* if orientation disabled */
3550 if (pagesetup_get_flags(data
) & PSD_DISABLEORIENTATION
)
3552 EnableWindow(GetDlgItem(hDlg
,rad1
),FALSE
);
3553 EnableWindow(GetDlgItem(hDlg
,rad2
),FALSE
);
3556 /* We fill them out enabled or not */
3557 if (!(pagesetup_get_flags(data
) & PSD_MARGINS
))
3559 /* default is 1 inch */
3560 LONG size
= thousandths_inch_to_size(data
, 1000);
3561 SetRect(pagesetup_get_margin_rect(data
), size
, size
, size
, size
);
3563 update_margin_edits(hDlg
, data
, 0);
3564 subclass_margin_edits(hDlg
);
3565 set_margin_groupbox_title(hDlg
, data
);
3567 /* if paper disabled */
3568 if (pagesetup_get_flags(data
) & PSD_DISABLEPAPER
)
3570 EnableWindow(GetDlgItem(hDlg
,cmb2
),FALSE
);
3571 EnableWindow(GetDlgItem(hDlg
,cmb3
),FALSE
);
3574 /* filling combos: printer, paper, source. selecting current printer (from DEVMODEA) */
3575 pagesetup_init_combos(hDlg
, data
);
3576 pagesetup_update_papersize(data
);
3577 pagesetup_set_defaultsource(data
, DMBIN_FORMSOURCE
); /* FIXME: This is the auto select bin. Is this correct? */
3579 /* Drawing paper prev */
3580 pagesetup_change_preview(data
);
3583 data
= GetPropW(hDlg
, pagesetupdlg_prop
);
3586 WARN("__WINE_PAGESETUPDLGDATA prop not set?\n");
3589 if (pagesetup_get_flags(data
) & PSD_ENABLEPAGESETUPHOOK
)
3591 res
= pagesetup_get_hook(data
, page_setup_hook
)(hDlg
, uMsg
, wParam
, lParam
);
3592 if (res
) return res
;
3597 return pagesetup_wm_command(hDlg
, wParam
, lParam
, data
);
3602 static WCHAR
*get_default_printer(void)
3607 GetDefaultPrinterW(NULL
, &len
);
3610 name
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
3611 GetDefaultPrinterW(name
, &len
);
3616 static void pagesetup_dump_dlg_struct(pagesetup_data
*data
)
3618 if(TRACE_ON(commdlg
))
3620 char flagstr
[1000] = "";
3621 const struct pd_flags
*pflag
= psd_flags
;
3622 for( ; pflag
->name
; pflag
++)
3624 if(pagesetup_get_flags(data
) & pflag
->flag
)
3626 strcat(flagstr
, pflag
->name
);
3627 strcat(flagstr
, "|");
3630 TRACE("%s: (%p): hwndOwner = %p, hDevMode = %p, hDevNames = %p\n"
3631 "hinst %p, flags %08x (%s)\n",
3632 data
->unicode
? "unicode" : "ansi",
3633 data
->u
.dlgw
, data
->u
.dlgw
->hwndOwner
, data
->u
.dlgw
->hDevMode
,
3634 data
->u
.dlgw
->hDevNames
, data
->u
.dlgw
->hInstance
,
3635 pagesetup_get_flags(data
), flagstr
);
3639 static void *pagesetup_get_template(pagesetup_data
*data
)
3642 HGLOBAL tmpl_handle
;
3644 if(pagesetup_get_flags(data
) & PSD_ENABLEPAGESETUPTEMPLATEHANDLE
)
3646 tmpl_handle
= data
->u
.dlgw
->hPageSetupTemplate
;
3648 else if(pagesetup_get_flags(data
) & PSD_ENABLEPAGESETUPTEMPLATE
)
3651 res
= FindResourceW(data
->u
.dlgw
->hInstance
,
3652 data
->u
.dlgw
->lpPageSetupTemplateName
, MAKEINTRESOURCEW(RT_DIALOG
));
3654 res
= FindResourceA(data
->u
.dlga
->hInstance
,
3655 data
->u
.dlga
->lpPageSetupTemplateName
, MAKEINTRESOURCEA(RT_DIALOG
));
3656 tmpl_handle
= LoadResource(data
->u
.dlgw
->hInstance
, res
);
3660 res
= FindResourceW(COMDLG32_hInstance
, MAKEINTRESOURCEW(PAGESETUPDLGORD
),
3661 MAKEINTRESOURCEW(RT_DIALOG
));
3662 tmpl_handle
= LoadResource(COMDLG32_hInstance
, res
);
3664 return LockResource(tmpl_handle
);
3667 static BOOL
pagesetup_common(pagesetup_data
*data
)
3672 if(!pagesetup_get_dlg_struct(data
))
3674 COMDLG32_SetCommDlgExtendedError(CDERR_INITIALIZATION
);
3678 pagesetup_dump_dlg_struct(data
);
3680 if(data
->u
.dlgw
->lStructSize
!= sizeof(PAGESETUPDLGW
))
3682 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE
);
3686 if ((pagesetup_get_flags(data
) & PSD_ENABLEPAGEPAINTHOOK
) &&
3687 (pagesetup_get_hook(data
, page_paint_hook
) == NULL
))
3689 COMDLG32_SetCommDlgExtendedError(CDERR_NOHOOK
);
3693 if(!(pagesetup_get_flags(data
) & (PSD_INTHOUSANDTHSOFINCHES
| PSD_INHUNDREDTHSOFMILLIMETERS
)))
3694 data
->u
.dlgw
->Flags
|= is_default_metric() ?
3695 PSD_INHUNDREDTHSOFMILLIMETERS
: PSD_INTHOUSANDTHSOFINCHES
;
3697 if (!data
->u
.dlgw
->hDevMode
|| !data
->u
.dlgw
->hDevNames
)
3699 WCHAR
*def
= get_default_printer();
3702 if (!(pagesetup_get_flags(data
) & PSD_NOWARNING
))
3705 LoadStringW(COMDLG32_hInstance
, PD32_NO_DEFAULT_PRINTER
, errstr
, 255);
3706 MessageBoxW(data
->u
.dlgw
->hwndOwner
, errstr
, 0, MB_OK
| MB_ICONERROR
);
3708 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN
);
3711 pagesetup_change_printer(def
, data
);
3712 HeapFree(GetProcessHeap(), 0, def
);
3715 if (pagesetup_get_flags(data
) & PSD_RETURNDEFAULT
)
3717 pagesetup_update_papersize(data
);
3721 tmpl
= pagesetup_get_template(data
);
3723 ret
= DialogBoxIndirectParamW(data
->u
.dlgw
->hInstance
, tmpl
,
3724 data
->u
.dlgw
->hwndOwner
,
3725 pagesetup_dlg_proc
, (LPARAM
)data
) > 0;
3729 /***********************************************************************
3730 * PageSetupDlgA (COMDLG32.@)
3732 * Displays the PAGE SETUP dialog box, which enables the user to specify
3733 * specific properties of a printed page such as
3734 * size, source, orientation and the width of the page margins.
3737 * setupdlg [IO] PAGESETUPDLGA struct
3740 * TRUE if the user pressed the OK button
3741 * FALSE if the user cancelled the window or an error occurred
3744 * The values of hDevMode and hDevNames are filled on output and can be
3745 * changed in PAGESETUPDLG when they are passed in PageSetupDlg.
3748 BOOL WINAPI
PageSetupDlgA(LPPAGESETUPDLGA setupdlg
)
3750 pagesetup_data data
;
3752 data
.unicode
= FALSE
;
3753 data
.u
.dlga
= setupdlg
;
3755 return pagesetup_common(&data
);
3758 /***********************************************************************
3759 * PageSetupDlgW (COMDLG32.@)
3761 * See PageSetupDlgA.
3763 BOOL WINAPI
PageSetupDlgW(LPPAGESETUPDLGW setupdlg
)
3765 pagesetup_data data
;
3767 data
.unicode
= TRUE
;
3768 data
.u
.dlgw
= setupdlg
;
3770 return pagesetup_common(&data
);
3773 /***********************************************************************
3774 * PrintDlgExA (COMDLG32.@)
3782 HRESULT WINAPI
PrintDlgExA(LPPRINTDLGEXA lppd
)
3785 FIXME("(%p) stub\n", lppd
);
3786 if ((lppd
== NULL
) || (lppd
->lStructSize
!= sizeof(PRINTDLGEXA
))) {
3787 return E_INVALIDARG
;
3790 if (!IsWindow(lppd
->hwndOwner
)) {
3797 /***********************************************************************
3798 * PrintDlgExW (COMDLG32.@)
3800 * Display the property sheet style PRINT dialog box
3803 * lppd [IO] ptr to PRINTDLGEX struct
3807 * Failure: One of the following COM error codes:
3808 * E_OUTOFMEMORY Insufficient memory.
3809 * E_INVALIDARG One or more arguments are invalid.
3810 * E_POINTER Invalid pointer.
3811 * E_HANDLE Invalid handle.
3812 * E_FAIL Unspecified error.
3815 * This Dialog enables the user to specify specific properties of the print job.
3816 * The property sheet can also have additional application-specific and
3817 * driver-specific property pages.
3820 * Not fully implemented
3823 HRESULT WINAPI
PrintDlgExW(LPPRINTDLGEXW lppd
)
3828 FIXME("(%p) not fully implemented\n", lppd
);
3830 if ((lppd
== NULL
) || (lppd
->lStructSize
!= sizeof(PRINTDLGEXW
))) {
3831 return E_INVALIDARG
;
3834 if (!IsWindow(lppd
->hwndOwner
)) {
3838 if (lppd
->Flags
& PD_RETURNDEFAULT
) {
3839 PRINTER_INFO_2W
*pbuf
;
3840 DRIVER_INFO_2W
*dbuf
;
3842 DWORD needed
= 1024;
3845 if (lppd
->hDevMode
|| lppd
->hDevNames
) {
3846 WARN("hDevMode or hDevNames non-zero for PD_RETURNDEFAULT\n");
3847 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
3848 return E_INVALIDARG
;
3850 if (!PRINTDLG_OpenDefaultPrinter(&hprn
)) {
3851 WARN("Can't find default printer\n");
3852 COMDLG32_SetCommDlgExtendedError(PDERR_NODEFAULTPRN
);
3856 pbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
3857 bRet
= GetPrinterW(hprn
, 2, (LPBYTE
)pbuf
, needed
, &needed
);
3858 if (!bRet
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)) {
3859 HeapFree(GetProcessHeap(), 0, pbuf
);
3860 pbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
3861 bRet
= GetPrinterW(hprn
, 2, (LPBYTE
)pbuf
, needed
, &needed
);
3864 HeapFree(GetProcessHeap(), 0, pbuf
);
3870 dbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
3871 bRet
= GetPrinterDriverW(hprn
, NULL
, 3, (LPBYTE
)dbuf
, needed
, &needed
);
3872 if (!bRet
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER
)) {
3873 HeapFree(GetProcessHeap(), 0, dbuf
);
3874 dbuf
= HeapAlloc(GetProcessHeap(), 0, needed
);
3875 bRet
= GetPrinterDriverW(hprn
, NULL
, 3, (LPBYTE
)dbuf
, needed
, &needed
);
3878 ERR("GetPrinterDriverW failed, last error %d, fix your config for printer %s!\n",
3879 GetLastError(), debugstr_w(pbuf
->pPrinterName
));
3880 HeapFree(GetProcessHeap(), 0, dbuf
);
3881 HeapFree(GetProcessHeap(), 0, pbuf
);
3882 COMDLG32_SetCommDlgExtendedError(PDERR_RETDEFFAILURE
);
3888 PRINTDLG_CreateDevNamesW(&(lppd
->hDevNames
),
3892 lppd
->hDevMode
= GlobalAlloc(GMEM_MOVEABLE
, pbuf
->pDevMode
->dmSize
+
3893 pbuf
->pDevMode
->dmDriverExtra
);
3894 if (lppd
->hDevMode
) {
3895 ptr
= GlobalLock(lppd
->hDevMode
);
3897 memcpy(ptr
, pbuf
->pDevMode
, pbuf
->pDevMode
->dmSize
+
3898 pbuf
->pDevMode
->dmDriverExtra
);
3899 GlobalUnlock(lppd
->hDevMode
);
3903 HeapFree(GetProcessHeap(), 0, pbuf
);
3904 HeapFree(GetProcessHeap(), 0, dbuf
);