?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Do not distinguish exterior wizard pages by their position, but
[wine/multimedia.git] / dlls / comctl32 / propsheet.c
blob061ed9fc8d06d85fa9416425ee758457abf04141
1 /*
2 * Property Sheets
3 *
4 * Copyright 1998 Francis Beaudet
5 * Copyright 1999 Thuy Nguyen
6 * Copyright 2004 Maxime Bellenge
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * TODO:
23 * - Tab order
24 * - Unicode property sheets
25 */
26
27 #include <stdarg.h>
28 #include <string.h>
29
30 #define NONAMELESSUNION
31 #define NONAMELESSSTRUCT
32 #include "windef.h"
33 #include "winbase.h"
34 #include "wingdi.h"
35 #include "winuser.h"
36 #include "winnls.h"
37 #include "commctrl.h"
38 #include "prsht.h"
39 #include "comctl32.h"
40
41 #include "wine/debug.h"
42 #include "wine/unicode.h"
43
44 /******************************************************************************
45 * Data structures
46 */
47 #include "pshpack2.h"
48
49 typedef struct
50 {
51 WORD dlgVer;
52 WORD signature;
53 DWORD helpID;
54 DWORD exStyle;
55 DWORD style;
56 } MyDLGTEMPLATEEX;
57
58 typedef struct
59 {
60 DWORD helpid;
61 DWORD exStyle;
62 DWORD style;
63 short x;
64 short y;
65 short cx;
66 short cy;
67 DWORD id;
68 } MyDLGITEMTEMPLATEEX;
69 #include "poppack.h"
70
71 typedef struct tagPropPageInfo
72 {
73 HPROPSHEETPAGE hpage; /* to keep track of pages not passed to PropertySheet */
74 HWND hwndPage;
75 BOOL isDirty;
76 LPCWSTR pszText;
77 BOOL hasHelp;
78 BOOL useCallback;
79 BOOL hasIcon;
80 } PropPageInfo;
81
82 typedef struct tagPropSheetInfo
83 {
84 HWND hwnd;
85 PROPSHEETHEADERW ppshheader;
86 BOOL unicode;
87 LPWSTR strPropertiesFor;
88 int nPages;
89 int active_page;
90 BOOL isModeless;
91 BOOL hasHelp;
92 BOOL hasApply;
93 BOOL useCallback;
94 BOOL restartWindows;
95 BOOL rebootSystem;
96 BOOL activeValid;
97 PropPageInfo* proppage;
98 HFONT hFont;
99 HFONT hFontBold;
100 int x;
101 int y;
102 int width;
103 int height;
104 HIMAGELIST hImageList;
105 } PropSheetInfo;
106
107 typedef struct
108 {
109 int x;
110 int y;
111 } PADDING_INFO;
112
113 /******************************************************************************
114 * Defines and global variables
115 */
116
117 const WCHAR PropSheetInfoStr[] =
118 {'P','r','o','p','e','r','t','y','S','h','e','e','t','I','n','f','o',0 };
119
120 #define PSP_INTERNAL_UNICODE 0x80000000
121
122 #define MAX_CAPTION_LENGTH 255
123 #define MAX_TABTEXT_LENGTH 255
124 #define MAX_BUTTONTEXT_LENGTH 64
125
126 #define INTRNL_ANY_WIZARD (PSH_WIZARD | PSH_WIZARD97_OLD | PSH_WIZARD97_NEW | PSH_WIZARD_LITE)
127
128 /******************************************************************************
129 * Prototypes
130 */
131 static int PROPSHEET_CreateDialog(PropSheetInfo* psInfo);
132 static BOOL PROPSHEET_SizeMismatch(HWND hwndDlg, PropSheetInfo* psInfo);
133 static BOOL PROPSHEET_AdjustSize(HWND hwndDlg, PropSheetInfo* psInfo);
134 static BOOL PROPSHEET_AdjustButtons(HWND hwndParent, PropSheetInfo* psInfo);
135 static BOOL PROPSHEET_CollectSheetInfoA(LPCPROPSHEETHEADERA lppsh,
136 PropSheetInfo * psInfo);
137 static BOOL PROPSHEET_CollectSheetInfoW(LPCPROPSHEETHEADERW lppsh,
138 PropSheetInfo * psInfo);
139 static BOOL PROPSHEET_CollectPageInfo(LPCPROPSHEETPAGEW lppsp,
140 PropSheetInfo * psInfo,
141 int index);
142 static BOOL PROPSHEET_CreateTabControl(HWND hwndParent,
143 PropSheetInfo * psInfo);
144 static BOOL PROPSHEET_CreatePage(HWND hwndParent, int index,
145 const PropSheetInfo * psInfo,
146 LPCPROPSHEETPAGEW ppshpage);
147 static BOOL PROPSHEET_ShowPage(HWND hwndDlg, int index, PropSheetInfo * psInfo);
148 static PADDING_INFO PROPSHEET_GetPaddingInfo(HWND hwndDlg);
149 static BOOL PROPSHEET_Back(HWND hwndDlg);
150 static BOOL PROPSHEET_Next(HWND hwndDlg);
151 static BOOL PROPSHEET_Finish(HWND hwndDlg);
152 static BOOL PROPSHEET_Apply(HWND hwndDlg, LPARAM lParam);
153 static void PROPSHEET_Cancel(HWND hwndDlg, LPARAM lParam);
154 static void PROPSHEET_Help(HWND hwndDlg);
155 static void PROPSHEET_Changed(HWND hwndDlg, HWND hwndDirtyPage);
156 static void PROPSHEET_UnChanged(HWND hwndDlg, HWND hwndCleanPage);
157 static void PROPSHEET_PressButton(HWND hwndDlg, int buttonID);
158 static void PROPSHEET_SetFinishTextA(HWND hwndDlg, LPCSTR lpszText);
159 static void PROPSHEET_SetFinishTextW(HWND hwndDlg, LPCWSTR lpszText);
160 static void PROPSHEET_SetTitleA(HWND hwndDlg, DWORD dwStyle, LPCSTR lpszText);
161 static void PROPSHEET_SetTitleW(HWND hwndDlg, DWORD dwStyle, LPCWSTR lpszText);
162 static BOOL PROPSHEET_CanSetCurSel(HWND hwndDlg);
163 static BOOL PROPSHEET_SetCurSel(HWND hwndDlg,
164 int index,
165 int skipdir,
166 HPROPSHEETPAGE hpage);
167 static void PROPSHEET_SetCurSelId(HWND hwndDlg, int id);
168 static LRESULT PROPSHEET_QuerySiblings(HWND hwndDlg,
169 WPARAM wParam, LPARAM lParam);
170 static BOOL PROPSHEET_AddPage(HWND hwndDlg,
171 HPROPSHEETPAGE hpage);
172
173 static BOOL PROPSHEET_RemovePage(HWND hwndDlg,
174 int index,
175 HPROPSHEETPAGE hpage);
176 static void PROPSHEET_CleanUp(HWND hwndDlg);
177 static int PROPSHEET_GetPageIndex(HPROPSHEETPAGE hpage, PropSheetInfo* psInfo);
178 static void PROPSHEET_SetWizButtons(HWND hwndDlg, DWORD dwFlags);
179 static PADDING_INFO PROPSHEET_GetPaddingInfoWizard(HWND hwndDlg, const PropSheetInfo* psInfo);
180 static BOOL PROPSHEET_IsDialogMessage(HWND hwnd, LPMSG lpMsg);
181 static BOOL PROPSHEET_DoCommand(HWND hwnd, WORD wID);
182
183 INT_PTR CALLBACK
184 PROPSHEET_DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
185
186 WINE_DEFAULT_DEBUG_CHANNEL(propsheet);
187
188 #define add_flag(a) if (dwFlags & a) {strcat(string, #a );strcat(string," ");}
189 /******************************************************************************
190 * PROPSHEET_UnImplementedFlags
191 *
192 * Document use of flags we don't implement yet.
193 */
194 static VOID PROPSHEET_UnImplementedFlags(DWORD dwFlags)
195 {
196 CHAR string[256];
197
198 string[0] = '\0';
199
200 /*
201 * unhandled header flags:
202 * PSH_DEFAULT 0x00000000
203 * PSH_WIZARDHASFINISH 0x00000010
204 * PSH_RTLREADING 0x00000800
205 * PSH_WIZARDCONTEXTHELP 0x00001000
206 * PSH_WATERMARK 0x00008000
207 * PSH_USEHBMWATERMARK 0x00010000
208 * PSH_USEHPLWATERMARK 0x00020000
209 * PSH_STRETCHWATERMARK 0x00040000
210 * PSH_HEADER 0x00080000
211 * PSH_USEHBMHEADER 0x00100000
212 * PSH_USEPAGELANG 0x00200000
213 * PSH_WIZARD_LITE 0x00400000 also not in .h
214 * PSH_WIZARD97 0x01000000 (IE 5 and above)
215 * PSH_NOCONTEXTHELP 0x02000000 also not in .h
216 */
217
218 add_flag(PSH_WIZARDHASFINISH);
219 add_flag(PSH_RTLREADING);
220 add_flag(PSH_WIZARDCONTEXTHELP);
221 add_flag(PSH_STRETCHWATERMARK);
222 add_flag(PSH_USEPAGELANG);
223 add_flag(PSH_WIZARD_LITE);
224 add_flag(PSH_NOCONTEXTHELP);
225 if (string[0] != '\0')
226 FIXME("%s\n", string);
227 }
228 #undef add_flag
229
230 /******************************************************************************
231 * PROPSHEET_GetPageRect
232 *
233 * Retrieve rect from tab control and map into the dialog for SetWindowPos
234 */
235 static void PROPSHEET_GetPageRect(const PropSheetInfo * psInfo, HWND hwndDlg, RECT *rc)
236 {
237 HWND hwndTabCtrl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
238
239 GetClientRect(hwndTabCtrl, rc);
240 SendMessageW(hwndTabCtrl, TCM_ADJUSTRECT, FALSE, (LPARAM)rc);
241 MapWindowPoints(hwndTabCtrl, hwndDlg, (LPPOINT)rc, 2);
242 }
243
244 /******************************************************************************
245 * PROPSHEET_FindPageByResId
246 *
247 * Find page index corresponding to page resource id.
248 */
249 INT PROPSHEET_FindPageByResId(PropSheetInfo * psInfo, LRESULT resId)
250 {
251 INT i;
252
253 for (i = 0; i < psInfo->nPages; i++)
254 {
255 LPCPROPSHEETPAGEA lppsp = (LPCPROPSHEETPAGEA)psInfo->proppage[i].hpage;
256
257 /* Fixme: if resource ID is a string shall we use strcmp ??? */
258 if (lppsp->u.pszTemplate == (LPVOID)resId)
259 break;
260 }
261
262 return i;
263 }
264
265 /******************************************************************************
266 * PROPSHEET_AtoW
267 *
268 * Convert ASCII to Unicode since all data is saved as Unicode.
269 */
270 static void PROPSHEET_AtoW(LPCWSTR *tostr, LPCSTR frstr)
271 {
272 INT len;
273
274 TRACE("<%s>\n", frstr);
275 len = MultiByteToWideChar(CP_ACP, 0, frstr, -1, 0, 0);
276 *tostr = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
277 MultiByteToWideChar(CP_ACP, 0, frstr, -1, (LPWSTR)*tostr, len);
278 }
279
280 /******************************************************************************
281 * PROPSHEET_CollectSheetInfoA
282 *
283 * Collect relevant data.
284 */
285 static BOOL PROPSHEET_CollectSheetInfoA(LPCPROPSHEETHEADERA lppsh,
286 PropSheetInfo * psInfo)
287 {
288 DWORD dwSize = min(lppsh->dwSize,sizeof(PROPSHEETHEADERA));
289 DWORD dwFlags = lppsh->dwFlags;
290
291 psInfo->hasHelp = dwFlags & PSH_HASHELP;
292 psInfo->hasApply = !(dwFlags & PSH_NOAPPLYNOW);
293 psInfo->useCallback = (dwFlags & PSH_USECALLBACK )&& (lppsh->pfnCallback);
294 psInfo->isModeless = dwFlags & PSH_MODELESS;
295
296 memcpy(&psInfo->ppshheader,lppsh,dwSize);
297 TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%p\nhInstance\t%p\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
298 lppsh->dwSize, lppsh->dwFlags, lppsh->hwndParent, lppsh->hInstance,
299 debugstr_a(lppsh->pszCaption), lppsh->nPages, lppsh->pfnCallback);
300
301 PROPSHEET_UnImplementedFlags(lppsh->dwFlags);
302
303 if (lppsh->dwFlags & INTRNL_ANY_WIZARD)
304 psInfo->ppshheader.pszCaption = NULL;
305 else
306 {
307 if (HIWORD(lppsh->pszCaption))
308 {
309 int len = MultiByteToWideChar(CP_ACP, 0, lppsh->pszCaption, -1, NULL, 0);
310 psInfo->ppshheader.pszCaption = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
311 MultiByteToWideChar(CP_ACP, 0, lppsh->pszCaption, -1, (LPWSTR) psInfo->ppshheader.pszCaption, len);
312 }
313 }
314 psInfo->nPages = lppsh->nPages;
315
316 if (dwFlags & PSH_USEPSTARTPAGE)
317 {
318 TRACE("PSH_USEPSTARTPAGE is on\n");
319 psInfo->active_page = 0;
320 }
321 else
322 psInfo->active_page = lppsh->u2.nStartPage;
323
324 if (psInfo->active_page < 0 || psInfo->active_page >= psInfo->nPages)
325 psInfo->active_page = 0;
326
327 psInfo->restartWindows = FALSE;
328 psInfo->rebootSystem = FALSE;
329 psInfo->hImageList = 0;
330 psInfo->activeValid = FALSE;
331
332 return TRUE;
333 }
334
335 /******************************************************************************
336 * PROPSHEET_CollectSheetInfoW
337 *
338 * Collect relevant data.
339 */
340 static BOOL PROPSHEET_CollectSheetInfoW(LPCPROPSHEETHEADERW lppsh,
341 PropSheetInfo * psInfo)
342 {
343 DWORD dwSize = min(lppsh->dwSize,sizeof(PROPSHEETHEADERW));
344 DWORD dwFlags = lppsh->dwFlags;
345
346 psInfo->hasHelp = dwFlags & PSH_HASHELP;
347 psInfo->hasApply = !(dwFlags & PSH_NOAPPLYNOW);
348 psInfo->useCallback = (dwFlags & PSH_USECALLBACK) && (lppsh->pfnCallback);
349 psInfo->isModeless = dwFlags & PSH_MODELESS;
350
351 memcpy(&psInfo->ppshheader,lppsh,dwSize);
352 TRACE("\n** PROPSHEETHEADER **\ndwSize\t\t%ld\ndwFlags\t\t%08lx\nhwndParent\t%p\nhInstance\t%p\npszCaption\t'%s'\nnPages\t\t%d\npfnCallback\t%p\n",
353 lppsh->dwSize, lppsh->dwFlags, lppsh->hwndParent, lppsh->hInstance, debugstr_w(lppsh->pszCaption), lppsh->nPages, lppsh->pfnCallback);
354
355 PROPSHEET_UnImplementedFlags(lppsh->dwFlags);
356
357 if (lppsh->dwFlags & INTRNL_ANY_WIZARD)
358 psInfo->ppshheader.pszCaption = NULL;
359 else
360 {
361 if (HIWORD(lppsh->pszCaption))
362 {
363 int len = strlenW(lppsh->pszCaption);
364 psInfo->ppshheader.pszCaption = HeapAlloc( GetProcessHeap(), 0, (len+1)*sizeof(WCHAR) );
365 strcpyW( (WCHAR *)psInfo->ppshheader.pszCaption, lppsh->pszCaption );
366 }
367 }
368 psInfo->nPages = lppsh->nPages;
369
370 if (dwFlags & PSH_USEPSTARTPAGE)
371 {
372 TRACE("PSH_USEPSTARTPAGE is on\n");
373 psInfo->active_page = 0;
374 }
375 else
376 psInfo->active_page = lppsh->u2.nStartPage;
377
378 if (psInfo->active_page < 0 || psInfo->active_page >= psInfo->nPages)
379 psInfo->active_page = 0;
380
381 psInfo->restartWindows = FALSE;
382 psInfo->rebootSystem = FALSE;
383 psInfo->hImageList = 0;
384 psInfo->activeValid = FALSE;
385
386 return TRUE;
387 }
388
389 /******************************************************************************
390 * PROPSHEET_CollectPageInfo
391 *
392 * Collect property sheet data.
393 * With code taken from DIALOG_ParseTemplate32.
394 */
395 BOOL PROPSHEET_CollectPageInfo(LPCPROPSHEETPAGEW lppsp,
396 PropSheetInfo * psInfo,
397 int index)
398 {
399 DLGTEMPLATE* pTemplate;
400 const WORD* p;
401 DWORD dwFlags;
402 int width, height;
403
404 TRACE("\n");
405 psInfo->proppage[index].hpage = (HPROPSHEETPAGE)lppsp;
406 psInfo->proppage[index].hwndPage = 0;
407 psInfo->proppage[index].isDirty = FALSE;
408
409 /*
410 * Process property page flags.
411 */
412 dwFlags = lppsp->dwFlags;
413 psInfo->proppage[index].useCallback = (dwFlags & PSP_USECALLBACK) && (lppsp->pfnCallback);
414 psInfo->proppage[index].hasHelp = dwFlags & PSP_HASHELP;
415 psInfo->proppage[index].hasIcon = dwFlags & (PSP_USEHICON | PSP_USEICONID);
416
417 /* as soon as we have a page with the help flag, set the sheet flag on */
418 if (psInfo->proppage[index].hasHelp)
419 psInfo->hasHelp = TRUE;
420
421 /*
422 * Process page template.
423 */
424 if (dwFlags & PSP_DLGINDIRECT)
425 pTemplate = (DLGTEMPLATE*)lppsp->u.pResource;
426 else if(dwFlags & PSP_INTERNAL_UNICODE )
427 {
428 HRSRC hResource = FindResourceW(lppsp->hInstance,
429 lppsp->u.pszTemplate,
430 (LPWSTR)RT_DIALOG);
431 HGLOBAL hTemplate = LoadResource(lppsp->hInstance,
432 hResource);
433 pTemplate = (LPDLGTEMPLATEW)LockResource(hTemplate);
434 }
435 else
436 {
437 HRSRC hResource = FindResourceA(lppsp->hInstance,
438 (LPSTR)lppsp->u.pszTemplate,
439 (LPSTR)RT_DIALOG);
440 HGLOBAL hTemplate = LoadResource(lppsp->hInstance,
441 hResource);
442 pTemplate = (LPDLGTEMPLATEA)LockResource(hTemplate);
443 }
444
445 /*
446 * Extract the size of the page and the caption.
447 */
448 if (!pTemplate)
449 return FALSE;
450
451 p = (const WORD *)pTemplate;
452
453 if (((MyDLGTEMPLATEEX*)pTemplate)->signature == 0xFFFF)
454 {
455 /* DLGTEMPLATEEX (not defined in any std. header file) */
456
457 p++; /* dlgVer */
458 p++; /* signature */
459 p += 2; /* help ID */
460 p += 2; /* ext style */
461 p += 2; /* style */
462 }
463 else
464 {
465 /* DLGTEMPLATE */
466
467 p += 2; /* style */
468 p += 2; /* ext style */
469 }
470
471 p++; /* nb items */
472 p++; /* x */
473 p++; /* y */
474 width = (WORD)*p; p++;
475 height = (WORD)*p; p++;
476
477 /* remember the largest width and height */
478 if (width > psInfo->width)
479 psInfo->width = width;
480
481 if (height > psInfo->height)
482 psInfo->height = height;
483
484 /* menu */
485 switch ((WORD)*p)
486 {
487 case 0x0000:
488 p++;
489 break;
490 case 0xffff:
491 p += 2;
492 break;
493 default:
494 p += lstrlenW( (LPCWSTR)p ) + 1;
495 break;
496 }
497
498 /* class */
499 switch ((WORD)*p)
500 {
501 case 0x0000:
502 p++;
503 break;
504 case 0xffff:
505 p += 2;
506 break;
507 default:
508 p += lstrlenW( (LPCWSTR)p ) + 1;
509 break;
510 }
511
512 /* Extract the caption */
513 psInfo->proppage[index].pszText = (LPCWSTR)p;
514 TRACE("Tab %d %s\n",index,debugstr_w((LPCWSTR)p));
515 p += lstrlenW((LPCWSTR)p) + 1;
516
517 if (dwFlags & PSP_USETITLE)
518 {
519 WCHAR szTitle[256];
520 const WCHAR *pTitle;
521 static const WCHAR pszNull[] = { '(','n','u','l','l',')',0 };
522 int len;
523
524 if ( !HIWORD( lppsp->pszTitle ) )
525 {
526 if (!LoadStringW( lppsp->hInstance, (UINT)lppsp->pszTitle,szTitle,sizeof(szTitle) ))
527 {
528 pTitle = pszNull;
529 FIXME("Could not load resource #%04x?\n",LOWORD(lppsp->pszTitle));
530 }
531 else
532 pTitle = szTitle;
533 }
534 else
535 pTitle = lppsp->pszTitle;
536
537 len = strlenW(pTitle);
538 psInfo->proppage[index].pszText = Alloc( (len+1)*sizeof (WCHAR) );
539 strcpyW( (LPWSTR)psInfo->proppage[index].pszText,pTitle);
540 }
541
542 /*
543 * Build the image list for icons
544 */
545 if ((dwFlags & PSP_USEHICON) || (dwFlags & PSP_USEICONID))
546 {
547 HICON hIcon;
548 int icon_cx = GetSystemMetrics(SM_CXSMICON);
549 int icon_cy = GetSystemMetrics(SM_CYSMICON);
550
551 if (dwFlags & PSP_USEICONID)
552 hIcon = LoadImageW(lppsp->hInstance, lppsp->u2.pszIcon, IMAGE_ICON,
553 icon_cx, icon_cy, LR_DEFAULTCOLOR);
554 else
555 hIcon = lppsp->u2.hIcon;
556
557 if ( hIcon )
558 {
559 if (psInfo->hImageList == 0 )
560 psInfo->hImageList = ImageList_Create(icon_cx, icon_cy, ILC_COLOR, 1, 1);
561
562 ImageList_AddIcon(psInfo->hImageList, hIcon);
563 }
564
565 }
566
567 return TRUE;
568 }
569
570 /******************************************************************************
571 * PROPSHEET_CreateDialog
572 *
573 * Creates the actual property sheet.
574 */
575 int PROPSHEET_CreateDialog(PropSheetInfo* psInfo)
576 {
577 LRESULT ret;
578 LPCVOID template;
579 LPVOID temp = 0;
580 HRSRC hRes;
581 DWORD resSize;
582 WORD resID = IDD_PROPSHEET;
583
584 TRACE("\n");
585 if (psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD)
586 resID = IDD_WIZARD;
587
588 if( psInfo->unicode )
589 {
590 if(!(hRes = FindResourceW(COMCTL32_hModule,
591 MAKEINTRESOURCEW(resID),
592 (LPWSTR)RT_DIALOG)))
593 return -1;
594 }
595 else
596 {
597 if(!(hRes = FindResourceA(COMCTL32_hModule,
598 MAKEINTRESOURCEA(resID),
599 (LPSTR)RT_DIALOG)))
600 return -1;
601 }
602
603 if(!(template = (LPVOID)LoadResource(COMCTL32_hModule, hRes)))
604 return -1;
605
606 /*
607 * Make a copy of the dialog template.
608 */
609 resSize = SizeofResource(COMCTL32_hModule, hRes);
610
611 temp = Alloc(resSize);
612
613 if (!temp)
614 return -1;
615
616 memcpy(temp, template, resSize);
617
618 if (psInfo->useCallback)
619 (*(psInfo->ppshheader.pfnCallback))(0, PSCB_PRECREATE, (LPARAM)temp);
620
621 if( psInfo->unicode )
622 {
623 if (!(psInfo->ppshheader.dwFlags & PSH_MODELESS))
624 ret = DialogBoxIndirectParamW(psInfo->ppshheader.hInstance,
625 (LPDLGTEMPLATEW) temp,
626 psInfo->ppshheader.hwndParent,
627 PROPSHEET_DialogProc,
628 (LPARAM)psInfo);
629 else
630 {
631 ret = (int)CreateDialogIndirectParamW(psInfo->ppshheader.hInstance,
632 (LPDLGTEMPLATEW) temp,
633 psInfo->ppshheader.hwndParent,
634 PROPSHEET_DialogProc,
635 (LPARAM)psInfo);
636 if ( !ret ) ret = -1;
637 }
638 }
639 else
640 {
641 if (!(psInfo->ppshheader.dwFlags & PSH_MODELESS))
642 ret = DialogBoxIndirectParamA(psInfo->ppshheader.hInstance,
643 (LPDLGTEMPLATEA) temp,
644 psInfo->ppshheader.hwndParent,
645 PROPSHEET_DialogProc,
646 (LPARAM)psInfo);
647 else
648 {
649 ret = (int)CreateDialogIndirectParamA(psInfo->ppshheader.hInstance,
650 (LPDLGTEMPLATEA) temp,
651 psInfo->ppshheader.hwndParent,
652 PROPSHEET_DialogProc,
653 (LPARAM)psInfo);
654 if ( !ret ) ret = -1;
655 }
656 }
657
658 Free(temp);
659
660 return ret;
661 }
662
663 /******************************************************************************
664 * PROPSHEET_SizeMismatch
665 *
666 * Verify that the tab control and the "largest" property sheet page dlg. template
667 * match in size.
668 */
669 static BOOL PROPSHEET_SizeMismatch(HWND hwndDlg, PropSheetInfo* psInfo)
670 {
671 HWND hwndTabCtrl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
672 RECT rcOrigTab, rcPage;
673
674 /*
675 * Original tab size.
676 */
677 GetClientRect(hwndTabCtrl, &rcOrigTab);
678 TRACE("orig tab %ld %ld %ld %ld\n", rcOrigTab.left, rcOrigTab.top,
679 rcOrigTab.right, rcOrigTab.bottom);
680
681 /*
682 * Biggest page size.
683 */
684 rcPage.left = psInfo->x;
685 rcPage.top = psInfo->y;
686 rcPage.right = psInfo->width;
687 rcPage.bottom = psInfo->height;
688
689 MapDialogRect(hwndDlg, &rcPage);
690 TRACE("biggest page %ld %ld %ld %ld\n", rcPage.left, rcPage.top,
691 rcPage.right, rcPage.bottom);
692
693 if ( (rcPage.right - rcPage.left) != (rcOrigTab.right - rcOrigTab.left) )
694 return TRUE;
695 if ( (rcPage.bottom - rcPage.top) != (rcOrigTab.bottom - rcOrigTab.top) )
696 return TRUE;
697
698 return FALSE;
699 }
700
701 /******************************************************************************
702 * PROPSHEET_IsTooSmallWizard
703 *
704 * Verify that the default property sheet is big enough.
705 */
706 static BOOL PROPSHEET_IsTooSmallWizard(HWND hwndDlg, PropSheetInfo* psInfo)
707 {
708 RECT rcSheetRect, rcPage, rcLine, rcSheetClient;
709 HWND hwndLine = GetDlgItem(hwndDlg, IDC_SUNKEN_LINE);
710 PADDING_INFO padding = PROPSHEET_GetPaddingInfoWizard(hwndDlg, psInfo);
711
712 GetClientRect(hwndDlg, &rcSheetClient);
713 GetWindowRect(hwndDlg, &rcSheetRect);
714 GetWindowRect(hwndLine, &rcLine);
715
716 /* Remove the space below the sunken line */
717 rcSheetClient.bottom -= (rcSheetRect.bottom - rcLine.top);
718
719 /* Remove the buffer zone all around the edge */
720 rcSheetClient.bottom -= (padding.y * 2);
721 rcSheetClient.right -= (padding.x * 2);
722
723 /*
724 * Biggest page size.
725 */
726 rcPage.left = psInfo->x;
727 rcPage.top = psInfo->y;
728 rcPage.right = psInfo->width;
729 rcPage.bottom = psInfo->height;
730
731 MapDialogRect(hwndDlg, &rcPage);
732 TRACE("biggest page %ld %ld %ld %ld\n", rcPage.left, rcPage.top,
733 rcPage.right, rcPage.bottom);
734
735 if (rcPage.right > rcSheetClient.right)
736 return TRUE;
737
738 if (rcPage.bottom > rcSheetClient.bottom)
739 return TRUE;
740
741 return FALSE;
742 }
743
744 /******************************************************************************
745 * PROPSHEET_AdjustSize
746 *
747 * Resizes the property sheet and the tab control to fit the largest page.
748 */
749 static BOOL PROPSHEET_AdjustSize(HWND hwndDlg, PropSheetInfo* psInfo)
750 {
751 HWND hwndTabCtrl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
752 HWND hwndButton = GetDlgItem(hwndDlg, IDOK);
753 RECT rc,tabRect;
754 int tabOffsetX, tabOffsetY, buttonHeight;
755 PADDING_INFO padding = PROPSHEET_GetPaddingInfo(hwndDlg);
756 RECT units;
757
758 /* Get the height of buttons */
759 GetClientRect(hwndButton, &rc);
760 buttonHeight = rc.bottom;
761
762 /*
763 * Biggest page size.
764 */
765 rc.left = psInfo->x;
766 rc.top = psInfo->y;
767 rc.right = psInfo->width;
768 rc.bottom = psInfo->height;
769
770 MapDialogRect(hwndDlg, &rc);
771
772 /* retrieve the dialog units */
773 units.left = units.right = 4;
774 units.top = units.bottom = 8;
775 MapDialogRect(hwndDlg, &units);
776
777 /*
778 * Resize the tab control.
779 */
780 GetClientRect(hwndTabCtrl,&tabRect);
781
782 SendMessageW(hwndTabCtrl, TCM_ADJUSTRECT, FALSE, (LPARAM)&tabRect);
783
784 if ((rc.bottom - rc.top) < (tabRect.bottom - tabRect.top))
785 {
786 rc.bottom = rc.top + tabRect.bottom - tabRect.top;
787 psInfo->height = MulDiv((rc.bottom - rc.top),8,units.top);
788 }
789
790 if ((rc.right - rc.left) < (tabRect.right - tabRect.left))
791 {
792 rc.right = rc.left + tabRect.right - tabRect.left;
793 psInfo->width = MulDiv((rc.right - rc.left),4,units.left);
794 }
795
796 SendMessageW(hwndTabCtrl, TCM_ADJUSTRECT, TRUE, (LPARAM)&rc);
797
798 tabOffsetX = -(rc.left);
799 tabOffsetY = -(rc.top);
800
801 rc.right -= rc.left;
802 rc.bottom -= rc.top;
803 TRACE("setting tab %08lx, rc (0,0)-(%ld,%ld)\n",
804 (DWORD)hwndTabCtrl, rc.right, rc.bottom);
805 SetWindowPos(hwndTabCtrl, 0, 0, 0, rc.right, rc.bottom,
806 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
807
808 GetClientRect(hwndTabCtrl, &rc);
809
810 TRACE("tab client rc %ld %ld %ld %ld\n",
811 rc.left, rc.top, rc.right, rc.bottom);
812
813 rc.right += ((padding.x * 2) + tabOffsetX);
814 rc.bottom += (buttonHeight + (3 * padding.y) + tabOffsetY);
815
816 /*
817 * Resize the property sheet.
818 */
819 TRACE("setting dialog %08lx, rc (0,0)-(%ld,%ld)\n",
820 (DWORD)hwndDlg, rc.right, rc.bottom);
821 SetWindowPos(hwndDlg, 0, 0, 0, rc.right, rc.bottom,
822 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
823 return TRUE;
824 }
825
826 /******************************************************************************
827 * PROPSHEET_AdjustSizeWizard
828 *
829 * Resizes the property sheet to fit the largest page.
830 */
831 static BOOL PROPSHEET_AdjustSizeWizard(HWND hwndDlg, PropSheetInfo* psInfo)
832 {
833 HWND hwndButton = GetDlgItem(hwndDlg, IDCANCEL);
834 HWND hwndLine = GetDlgItem(hwndDlg, IDC_SUNKEN_LINE);
835 HWND hwndTabCtrl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
836 RECT rc,tabRect;
837 int buttonHeight, lineHeight;
838 PADDING_INFO padding = PROPSHEET_GetPaddingInfoWizard(hwndDlg, psInfo);
839 RECT units;
840
841 /* Get the height of buttons */
842 GetClientRect(hwndButton, &rc);
843 buttonHeight = rc.bottom;
844
845 GetClientRect(hwndLine, &rc);
846 lineHeight = rc.bottom;
847
848 /* retrieve the dialog units */
849 units.left = units.right = 4;
850 units.top = units.bottom = 8;
851 MapDialogRect(hwndDlg, &units);
852
853 /*
854 * Biggest page size.
855 */
856 rc.left = psInfo->x;
857 rc.top = psInfo->y;
858 rc.right = psInfo->width;
859 rc.bottom = psInfo->height;
860
861 MapDialogRect(hwndDlg, &rc);
862
863 GetClientRect(hwndTabCtrl,&tabRect);
864
865 if ((rc.bottom - rc.top) < (tabRect.bottom - tabRect.top))
866 {
867 rc.bottom = rc.top + tabRect.bottom - tabRect.top;
868 psInfo->height = MulDiv((rc.bottom - rc.top), 8, units.top);
869 }
870
871 if ((rc.right - rc.left) < (tabRect.right - tabRect.left))
872 {
873 rc.right = rc.left + tabRect.right - tabRect.left;
874 psInfo->width = MulDiv((rc.right - rc.left), 4, units.left);
875 }
876
877 TRACE("Biggest page %ld %ld %ld %ld\n", rc.left, rc.top, rc.right, rc.bottom);
878 TRACE(" constants padx=%d, pady=%d, butH=%d, lH=%d\n",
879 padding.x, padding.y, buttonHeight, lineHeight);
880
881 /* Make room */
882 rc.right += (padding.x * 2);
883 rc.bottom += (buttonHeight + lineHeight);
884 if (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW))
885 rc.bottom += (4 * padding.y);
886 else
887 rc.bottom += (5 * padding.y);
888
889 /*
890 * Resize the property sheet.
891 */
892 TRACE("setting dialog %08lx, rc (0,0)-(%ld,%ld)\n",
893 (DWORD)hwndDlg, rc.right, rc.bottom);
894 SetWindowPos(hwndDlg, 0, 0, 0, rc.right, rc.bottom,
895 SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
896 return TRUE;
897 }
898
899 /******************************************************************************
900 * PROPSHEET_AdjustButtons
901 *
902 * Adjusts the buttons' positions.
903 */
904 static BOOL PROPSHEET_AdjustButtons(HWND hwndParent, PropSheetInfo* psInfo)
905 {
906 HWND hwndButton = GetDlgItem(hwndParent, IDOK);
907 RECT rcSheet;
908 int x, y;
909 int num_buttons = 2;
910 int buttonWidth, buttonHeight;
911 PADDING_INFO padding = PROPSHEET_GetPaddingInfo(hwndParent);
912
913 if (psInfo->hasApply)
914 num_buttons++;
915
916 if (psInfo->hasHelp)
917 num_buttons++;
918
919 /*
920 * Obtain the size of the buttons.
921 */
922 GetClientRect(hwndButton, &rcSheet);
923 buttonWidth = rcSheet.right;
924 buttonHeight = rcSheet.bottom;
925
926 /*
927 * Get the size of the property sheet.
928 */
929 GetClientRect(hwndParent, &rcSheet);
930
931 /*
932 * All buttons will be at this y coordinate.
933 */
934 y = rcSheet.bottom - (padding.y + buttonHeight);
935
936 /*
937 * Position OK button and make it default.
938 */
939 hwndButton = GetDlgItem(hwndParent, IDOK);
940
941 x = rcSheet.right - ((padding.x + buttonWidth) * num_buttons);
942
943 SetWindowPos(hwndButton, 0, x, y, 0, 0,
944 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
945
946 SendMessageA(hwndParent, DM_SETDEFID, IDOK, 0);
947
948
949 /*
950 * Position Cancel button.
951 */
952 hwndButton = GetDlgItem(hwndParent, IDCANCEL);
953
954 x = rcSheet.right - ((padding.x + buttonWidth) * (num_buttons - 1));
955
956 SetWindowPos(hwndButton, 0, x, y, 0, 0,
957 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
958
959 /*
960 * Position Apply button.
961 */
962 hwndButton = GetDlgItem(hwndParent, IDC_APPLY_BUTTON);
963
964 if (psInfo->hasApply)
965 {
966 if (psInfo->hasHelp)
967 x = rcSheet.right - ((padding.x + buttonWidth) * 2);
968 else
969 x = rcSheet.right - (padding.x + buttonWidth);
970
971 SetWindowPos(hwndButton, 0, x, y, 0, 0,
972 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
973
974 EnableWindow(hwndButton, FALSE);
975 }
976 else
977 ShowWindow(hwndButton, SW_HIDE);
978
979 /*
980 * Position Help button.
981 */
982 hwndButton = GetDlgItem(hwndParent, IDHELP);
983
984 if (psInfo->hasHelp)
985 {
986 x = rcSheet.right - (padding.x + buttonWidth);
987
988 SetWindowPos(hwndButton, 0, x, y, 0, 0,
989 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
990 }
991 else
992 ShowWindow(hwndButton, SW_HIDE);
993
994 return TRUE;
995 }
996
997 /******************************************************************************
998 * PROPSHEET_AdjustButtonsWizard
999 *
1000 * Adjusts the buttons' positions.
1001 */
1002 static BOOL PROPSHEET_AdjustButtonsWizard(HWND hwndParent,
1003 PropSheetInfo* psInfo)
1004 {
1005 HWND hwndButton = GetDlgItem(hwndParent, IDCANCEL);
1006 HWND hwndLine = GetDlgItem(hwndParent, IDC_SUNKEN_LINE);
1007 HWND hwndLineHeader = GetDlgItem(hwndParent, IDC_SUNKEN_LINEHEADER);
1008 RECT rcSheet;
1009 int x, y;
1010 int num_buttons = 3;
1011 int buttonWidth, buttonHeight, lineHeight, lineWidth;
1012 PADDING_INFO padding = PROPSHEET_GetPaddingInfoWizard(hwndParent, psInfo);
1013
1014 if (psInfo->hasHelp)
1015 num_buttons++;
1016
1017 /*
1018 * Obtain the size of the buttons.
1019 */
1020 GetClientRect(hwndButton, &rcSheet);
1021 buttonWidth = rcSheet.right;
1022 buttonHeight = rcSheet.bottom;
1023
1024 GetClientRect(hwndLine, &rcSheet);
1025 lineHeight = rcSheet.bottom;
1026
1027 /*
1028 * Get the size of the property sheet.
1029 */
1030 GetClientRect(hwndParent, &rcSheet);
1031
1032 /*
1033 * All buttons will be at this y coordinate.
1034 */
1035 y = rcSheet.bottom - (padding.y + buttonHeight);
1036
1037 /*
1038 * Position the Next and the Finish buttons.
1039 */
1040 hwndButton = GetDlgItem(hwndParent, IDC_NEXT_BUTTON);
1041
1042 x = rcSheet.right - ((padding.x + buttonWidth) * (num_buttons - 1));
1043
1044 SetWindowPos(hwndButton, 0, x, y, 0, 0,
1045 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1046
1047 hwndButton = GetDlgItem(hwndParent, IDC_FINISH_BUTTON);
1048
1049 SetWindowPos(hwndButton, 0, x, y, 0, 0,
1050 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1051
1052 ShowWindow(hwndButton, SW_HIDE);
1053
1054 /*
1055 * Position the Back button.
1056 */
1057 hwndButton = GetDlgItem(hwndParent, IDC_BACK_BUTTON);
1058
1059 x -= buttonWidth;
1060
1061 SetWindowPos(hwndButton, 0, x, y, 0, 0,
1062 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1063
1064 /*
1065 * Position the Cancel button.
1066 */
1067 hwndButton = GetDlgItem(hwndParent, IDCANCEL);
1068
1069 x = rcSheet.right - ((padding.x + buttonWidth) * (num_buttons - 2));
1070
1071 SetWindowPos(hwndButton, 0, x, y, 0, 0,
1072 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1073
1074 /*
1075 * Position Help button.
1076 */
1077 hwndButton = GetDlgItem(hwndParent, IDHELP);
1078
1079 if (psInfo->hasHelp)
1080 {
1081 x = rcSheet.right - (padding.x + buttonWidth);
1082
1083 SetWindowPos(hwndButton, 0, x, y, 0, 0,
1084 SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
1085 }
1086 else
1087 ShowWindow(hwndButton, SW_HIDE);
1088
1089 if (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW))
1090 padding.x = 0;
1091
1092 /*
1093 * Position and resize the sunken line.
1094 */
1095 x = padding.x;
1096 y = rcSheet.bottom - ((padding.y * 2) + buttonHeight + lineHeight);
1097
1098 lineWidth = rcSheet.right - (padding.x * 2);
1099
1100 SetWindowPos(hwndLine, 0, x, y, lineWidth, 2,
1101 SWP_NOZORDER | SWP_NOACTIVATE);
1102
1103 /*
1104 * Position and resize the header sunken line.
1105 */
1106
1107 SetWindowPos(hwndLineHeader, 0, 0, 0, rcSheet.right, 2,
1108 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
1109 if (!(psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW)))
1110 ShowWindow(hwndLineHeader, SW_HIDE);
1111
1112 return TRUE;
1113 }
1114
1115 /******************************************************************************
1116 * PROPSHEET_GetPaddingInfo
1117 *
1118 * Returns the layout information.
1119 */
1120 static PADDING_INFO PROPSHEET_GetPaddingInfo(HWND hwndDlg)
1121 {
1122 HWND hwndTab = GetDlgItem(hwndDlg, IDC_TABCONTROL);
1123 RECT rcTab;
1124 POINT tl;
1125 PADDING_INFO padding;
1126
1127 GetWindowRect(hwndTab, &rcTab);
1128
1129 tl.x = rcTab.left;
1130 tl.y = rcTab.top;
1131
1132 ScreenToClient(hwndDlg, &tl);
1133
1134 padding.x = tl.x;
1135 padding.y = tl.y;
1136
1137 return padding;
1138 }
1139
1140 /******************************************************************************
1141 * PROPSHEET_GetPaddingInfoWizard
1142 *
1143 * Returns the layout information.
1144 * Vertical spacing is the distance between the line and the buttons.
1145 * Do NOT use the Help button to gather padding information when it isn't mapped
1146 * (PSH_HASHELP), as app writers aren't forced to supply correct coordinates
1147 * for it in this case !
1148 * FIXME: I'm not sure about any other coordinate problems with these evil
1149 * buttons. Fix it in case additional problems appear or maybe calculate
1150 * a padding in a completely different way, as this is somewhat messy.
1151 */
1152 static PADDING_INFO PROPSHEET_GetPaddingInfoWizard(HWND hwndDlg, const PropSheetInfo*
1153 psInfo)
1154 {
1155 PADDING_INFO padding;
1156 RECT rc;
1157 HWND hwndControl;
1158 INT idButton;
1159 POINT ptButton, ptLine;
1160
1161 TRACE("\n");
1162 if (psInfo->hasHelp)
1163 {
1164 idButton = IDHELP;
1165 }
1166 else
1167 {
1168 if (psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD)
1169 {
1170 idButton = IDC_NEXT_BUTTON;
1171 }
1172 else
1173 {
1174 /* hopefully this is ok */
1175 idButton = IDCANCEL;
1176 }
1177 }
1178
1179 hwndControl = GetDlgItem(hwndDlg, idButton);
1180 GetWindowRect(hwndControl, &rc);
1181
1182 ptButton.x = rc.left;
1183 ptButton.y = rc.top;
1184
1185 ScreenToClient(hwndDlg, &ptButton);
1186
1187 /* Line */
1188 hwndControl = GetDlgItem(hwndDlg, IDC_SUNKEN_LINE);
1189 GetWindowRect(hwndControl, &rc);
1190
1191 ptLine.x = rc.left;
1192 ptLine.y = rc.bottom;
1193
1194 ScreenToClient(hwndDlg, &ptLine);
1195
1196 padding.y = ptButton.y - ptLine.y;
1197
1198 if (padding.y < 0)
1199 ERR("padding negative ! Please report this !\n");
1200
1201 /* this is most probably not correct, but the best we have now */
1202 padding.x = padding.y;
1203 return padding;
1204 }
1205
1206 /******************************************************************************
1207 * PROPSHEET_CreateTabControl
1208 *
1209 * Insert the tabs in the tab control.
1210 */
1211 static BOOL PROPSHEET_CreateTabControl(HWND hwndParent,
1212 PropSheetInfo * psInfo)
1213 {
1214 HWND hwndTabCtrl = GetDlgItem(hwndParent, IDC_TABCONTROL);
1215 TCITEMW item;
1216 int i, nTabs;
1217 int iImage = 0;
1218
1219 TRACE("\n");
1220 item.mask = TCIF_TEXT;
1221 item.cchTextMax = MAX_TABTEXT_LENGTH;
1222
1223 nTabs = psInfo->nPages;
1224
1225 /*
1226 * Set the image list for icons.
1227 */
1228 if (psInfo->hImageList)
1229 {
1230 SendMessageW(hwndTabCtrl, TCM_SETIMAGELIST, 0, (LPARAM)psInfo->hImageList);
1231 }
1232
1233 SendMessageW(GetDlgItem(hwndTabCtrl, IDC_TABCONTROL), WM_SETREDRAW, 0, 0);
1234 for (i = 0; i < nTabs; i++)
1235 {
1236 if ( psInfo->proppage[i].hasIcon )
1237 {
1238 item.mask |= TCIF_IMAGE;
1239 item.iImage = iImage++;
1240 }
1241 else
1242 {
1243 item.mask &= ~TCIF_IMAGE;
1244 }
1245
1246 item.pszText = (LPWSTR) psInfo->proppage[i].pszText;
1247 SendMessageW(hwndTabCtrl, TCM_INSERTITEMW, (WPARAM)i, (LPARAM)&item);
1248 }
1249 SendMessageW(GetDlgItem(hwndTabCtrl, IDC_TABCONTROL), WM_SETREDRAW, 1, 0);
1250
1251 return TRUE;
1252 }
1253 /*
1254 * Get the size of an in-memory Template
1255 *
1256 *( Based on the code of PROPSHEET_CollectPageInfo)
1257 * See also dialog.c/DIALOG_ParseTemplate32().
1258 */
1259
1260 static UINT GetTemplateSize(DLGTEMPLATE* pTemplate)
1261
1262 {
1263 const WORD* p = (const WORD *)pTemplate;
1264 BOOL istemplateex = (((MyDLGTEMPLATEEX*)pTemplate)->signature == 0xFFFF);
1265 WORD nrofitems;
1266
1267 if (istemplateex)
1268 {
1269 /* DLGTEMPLATEEX (not defined in any std. header file) */
1270
1271 TRACE("is DLGTEMPLATEEX\n");
1272 p++; /* dlgVer */
1273 p++; /* signature */
1274 p += 2; /* help ID */
1275 p += 2; /* ext style */
1276 p += 2; /* style */
1277 }
1278 else
1279 {
1280 /* DLGTEMPLATE */
1281
1282 TRACE("is DLGTEMPLATE\n");
1283 p += 2; /* style */
1284 p += 2; /* ext style */
1285 }
1286
1287 nrofitems = (WORD)*p; p++; /* nb items */
1288 p++; /* x */
1289 p++; /* y */
1290 p++; /* width */
1291 p++; /* height */
1292
1293 /* menu */
1294 switch ((WORD)*p)
1295 {
1296 case 0x0000:
1297 p++;
1298 break;
1299 case 0xffff:
1300 p += 2;
1301 break;
1302 default:
1303 TRACE("menu %s\n",debugstr_w((LPCWSTR)p));
1304 p += lstrlenW( (LPCWSTR)p ) + 1;
1305 break;
1306 }
1307
1308 /* class */
1309 switch ((WORD)*p)
1310 {
1311 case 0x0000:
1312 p++;
1313 break;
1314 case 0xffff:
1315 p += 2; /* 0xffff plus predefined window class ordinal value */
1316 break;
1317 default:
1318 TRACE("class %s\n",debugstr_w((LPCWSTR)p));
1319 p += lstrlenW( (LPCWSTR)p ) + 1;
1320 break;
1321 }
1322
1323 /* title */
1324 TRACE("title %s\n",debugstr_w((LPCWSTR)p));
1325 p += lstrlenW((LPCWSTR)p) + 1;
1326
1327 /* font, if DS_SETFONT set */
1328 if ((DS_SETFONT & ((istemplateex)? ((MyDLGTEMPLATEEX*)pTemplate)->style :
1329 pTemplate->style)))
1330 {
1331 p+=(istemplateex)?3:1;
1332 TRACE("font %s\n",debugstr_w((LPCWSTR)p));
1333 p += lstrlenW( (LPCWSTR)p ) + 1; /* the font name */
1334 }
1335
1336 /* now process the DLGITEMTEMPLATE(EX) structs (plus custom data)
1337 * that are following the DLGTEMPLATE(EX) data */
1338 TRACE("%d items\n",nrofitems);
1339 while (nrofitems > 0)
1340 {
1341 p = (WORD*)(((DWORD)p + 3) & ~3); /* DWORD align */
1342
1343 /* skip header */
1344 p += (istemplateex ? sizeof(MyDLGITEMTEMPLATEEX) : sizeof(DLGITEMTEMPLATE))/sizeof(WORD);
1345
1346 /* check class */
1347 switch ((WORD)*p)
1348 {
1349 case 0x0000:
1350 p++;
1351 break;
1352 case 0xffff:
1353 TRACE("class ordinal 0x%08lx\n",*(DWORD*)p);
1354 p += 2;
1355 break;
1356 default:
1357 TRACE("class %s\n",debugstr_w((LPCWSTR)p));
1358 p += lstrlenW( (LPCWSTR)p ) + 1;
1359 break;
1360 }
1361
1362 /* check title text */
1363 switch ((WORD)*p)
1364 {
1365 case 0x0000:
1366 p++;
1367 break;
1368 case 0xffff:
1369 TRACE("text ordinal 0x%08lx\n",*(DWORD*)p);
1370 p += 2;
1371 break;
1372 default:
1373 TRACE("text %s\n",debugstr_w((LPCWSTR)p));
1374 p += lstrlenW( (LPCWSTR)p ) + 1;
1375 break;
1376 }
1377 p += *p / sizeof(WORD) + 1; /* Skip extra data */
1378 --nrofitems;
1379 }
1380
1381 TRACE("%p %p size 0x%08x\n",p, (WORD*)pTemplate,sizeof(WORD)*(p - (WORD*)pTemplate));
1382 return (p - (WORD*)pTemplate)*sizeof(WORD);
1383
1384 }
1385
1386 /******************************************************************************
1387 * PROPSHEET_CreatePage
1388 *
1389 * Creates a page.
1390 */
1391 static BOOL PROPSHEET_CreatePage(HWND hwndParent,
1392 int index,
1393 const PropSheetInfo * psInfo,
1394 LPCPROPSHEETPAGEW ppshpage)
1395 {
1396 DLGTEMPLATE* pTemplate;
1397 HWND hwndPage;
1398 RECT rc;
1399 PADDING_INFO padding;
1400 UINT pageWidth,pageHeight;
1401 DWORD resSize;
1402 LPVOID temp = NULL;
1403
1404 TRACE("index %d\n", index);
1405
1406 if (ppshpage == NULL)
1407 {
1408 return FALSE;
1409 }
1410
1411 if (ppshpage->dwFlags & PSP_DLGINDIRECT)
1412 {
1413 pTemplate = (DLGTEMPLATE*)ppshpage->u.pResource;
1414 resSize = GetTemplateSize(pTemplate);
1415 }
1416 else if(ppshpage->dwFlags & PSP_INTERNAL_UNICODE)
1417 {
1418 HRSRC hResource;
1419 HANDLE hTemplate;
1420
1421 hResource = FindResourceW(ppshpage->hInstance,
1422 ppshpage->u.pszTemplate,
1423 (LPWSTR)RT_DIALOG);
1424 if(!hResource)
1425 return FALSE;
1426
1427 resSize = SizeofResource(ppshpage->hInstance, hResource);
1428
1429 hTemplate = LoadResource(ppshpage->hInstance, hResource);
1430 if(!hTemplate)
1431 return FALSE;
1432
1433 pTemplate = (LPDLGTEMPLATEW)LockResource(hTemplate);
1434 /*
1435 * Make a copy of the dialog template to make it writable
1436 */
1437 }
1438 else
1439 {
1440 HRSRC hResource;
1441 HANDLE hTemplate;
1442
1443 hResource = FindResourceA(ppshpage->hInstance,
1444 (LPSTR)ppshpage->u.pszTemplate,
1445 (LPSTR)RT_DIALOG);
1446 if(!hResource)
1447 return FALSE;
1448
1449 resSize = SizeofResource(ppshpage->hInstance, hResource);
1450
1451 hTemplate = LoadResource(ppshpage->hInstance, hResource);
1452 if(!hTemplate)
1453 return FALSE;
1454
1455 pTemplate = (LPDLGTEMPLATEA)LockResource(hTemplate);
1456 /*
1457 * Make a copy of the dialog template to make it writable
1458 */
1459 }
1460 temp = Alloc(resSize);
1461 if (!temp)
1462 return FALSE;
1463
1464 TRACE("copying pTemplate %p into temp %p (%ld)\n", pTemplate, temp, resSize);
1465 memcpy(temp, pTemplate, resSize);
1466 pTemplate = temp;
1467
1468 if (((MyDLGTEMPLATEEX*)pTemplate)->signature == 0xFFFF)
1469 {
1470 ((MyDLGTEMPLATEEX*)pTemplate)->style |= WS_CHILD | DS_CONTROL;
1471 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~DS_MODALFRAME;
1472 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_CAPTION;
1473 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_SYSMENU;
1474 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_POPUP;
1475 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_DISABLED;
1476 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_VISIBLE;
1477 ((MyDLGTEMPLATEEX*)pTemplate)->style &= ~WS_THICKFRAME;
1478
1479 ((MyDLGTEMPLATEEX*)pTemplate)->exStyle |= WS_EX_CONTROLPARENT;
1480 }
1481 else
1482 {
1483 pTemplate->style |= WS_CHILD | DS_CONTROL;
1484 pTemplate->style &= ~DS_MODALFRAME;
1485 pTemplate->style &= ~WS_CAPTION;
1486 pTemplate->style &= ~WS_SYSMENU;
1487 pTemplate->style &= ~WS_POPUP;
1488 pTemplate->style &= ~WS_DISABLED;
1489 pTemplate->style &= ~WS_VISIBLE;
1490 pTemplate->style &= ~WS_THICKFRAME;
1491
1492 pTemplate->dwExtendedStyle |= WS_EX_CONTROLPARENT;
1493 }
1494
1495 if (psInfo->proppage[index].useCallback)
1496 (*(ppshpage->pfnCallback))(0, PSPCB_CREATE,
1497 (LPPROPSHEETPAGEW)ppshpage);
1498
1499 if(ppshpage->dwFlags & PSP_INTERNAL_UNICODE)
1500 hwndPage = CreateDialogIndirectParamW(ppshpage->hInstance,
1501 pTemplate,
1502 hwndParent,
1503 ppshpage->pfnDlgProc,
1504 (LPARAM)ppshpage);
1505 else
1506 hwndPage = CreateDialogIndirectParamA(ppshpage->hInstance,
1507 pTemplate,
1508 hwndParent,
1509 ppshpage->pfnDlgProc,
1510 (LPARAM)ppshpage);
1511 /* Free a no more needed copy */
1512 if(temp)
1513 Free(temp);
1514
1515 psInfo->proppage[index].hwndPage = hwndPage;
1516
1517 /* NOTE: This code should be most probably moved to PROPSHEET_SetCurSel,
1518 * but until it will be proved with test case it's left here. */
1519 if (psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD) {
1520 int offsety = 0;
1521 HWND hwndChild;
1522 RECT r;
1523
1524 rc.left = psInfo->x;
1525 rc.top = psInfo->y;
1526 rc.right = psInfo->width;
1527 rc.bottom = psInfo->height;
1528
1529 MapDialogRect(hwndParent, &rc);
1530
1531 pageWidth = rc.right - rc.left;
1532 pageHeight = rc.bottom - rc.top;
1533
1534 padding = PROPSHEET_GetPaddingInfoWizard(hwndParent, psInfo);
1535 TRACE("setting page %08lx, rc (%ld,%ld)-(%ld,%ld) w=%d, h=%d, padx=%d, pady=%d\n",
1536 (DWORD)hwndPage, rc.left, rc.top, rc.right, rc.bottom,
1537 pageWidth, pageHeight, padding.x, padding.y);
1538
1539 if (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_NEW | PSH_WIZARD97_OLD) &&
1540 psInfo->ppshheader.dwFlags & PSH_HEADER)
1541 {
1542 hwndChild = GetDlgItem(hwndParent, IDC_SUNKEN_LINEHEADER);
1543
1544 GetClientRect(hwndChild, &r);
1545 MapWindowPoints(hwndChild, hwndParent, (LPPOINT) &r, 2);
1546 offsety = (ppshpage->dwFlags & PSP_HIDEHEADER)?0:r.bottom + 1;
1547 }
1548
1549 SetWindowPos(hwndPage, HWND_TOP,
1550 rc.left + padding.x/2,
1551 rc.top + padding.y/2 + offsety,
1552 pageWidth, pageHeight - offsety, 0);
1553 }
1554
1555 return TRUE;
1556 }
1557
1558 /******************************************************************************
1559 * PROPSHEET_LoadWizardBitmaps
1560 *
1561 * Loads the watermark and header bitmaps for a wizard.
1562 */
1563 static VOID PROPSHEET_LoadWizardBitmaps(PropSheetInfo *psInfo)
1564 {
1565 if (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_NEW | PSH_WIZARD97_OLD))
1566 {
1567 /* if PSH_USEHBMWATERMARK is not set, load the resource from pszbmWatermark
1568 and put the HBITMAP in hbmWatermark. Thus all the rest of the code always
1569 considers hbmWatermark as valid. */
1570 if ((psInfo->ppshheader.dwFlags & PSH_WATERMARK) &&
1571 !(psInfo->ppshheader.dwFlags & PSH_USEHBMWATERMARK))
1572 {
1573 ((PropSheetInfo *)psInfo)->ppshheader.u4.hbmWatermark =
1574 CreateMappedBitmap(psInfo->ppshheader.hInstance, (INT)psInfo->ppshheader.u4.pszbmWatermark, 0, NULL, 0);
1575 }
1576
1577 /* Same behavior as for watermarks */
1578 if ((psInfo->ppshheader.dwFlags & PSH_HEADER) &&
1579 !(psInfo->ppshheader.dwFlags & PSH_USEHBMHEADER))
1580 {
1581 ((PropSheetInfo *)psInfo)->ppshheader.u5.hbmHeader =
1582 CreateMappedBitmap(psInfo->ppshheader.hInstance, (INT)psInfo->ppshheader.u5.pszbmHeader, 0, NULL, 0);
1583 }
1584 }
1585 }
1586
1587
1588 /******************************************************************************
1589 * PROPSHEET_ShowPage
1590 *
1591 * Displays or creates the specified page.
1592 */
1593 static BOOL PROPSHEET_ShowPage(HWND hwndDlg, int index, PropSheetInfo * psInfo)
1594 {
1595 HWND hwndTabCtrl;
1596 HWND hwndLineHeader;
1597 LPCPROPSHEETPAGEW ppshpage;
1598
1599 TRACE("active_page %d, index %d\n", psInfo->active_page, index);
1600 if (index == psInfo->active_page)
1601 {
1602 if (GetTopWindow(hwndDlg) != psInfo->proppage[index].hwndPage)
1603 SetWindowPos(psInfo->proppage[index].hwndPage, HWND_TOP, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE);
1604 return TRUE;
1605 }
1606
1607 ppshpage = (LPCPROPSHEETPAGEW)psInfo->proppage[index].hpage;
1608 if (psInfo->proppage[index].hwndPage == 0)
1609 {
1610 PROPSHEET_CreatePage(hwndDlg, index, psInfo, ppshpage);
1611 }
1612
1613 if ((psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD) &&
1614 (ppshpage->dwFlags & PSP_USETITLE))
1615 {
1616 PROPSHEET_SetTitleW(hwndDlg, psInfo->ppshheader.dwFlags,
1617 psInfo->proppage[index].pszText);
1618 }
1619
1620 if (psInfo->active_page != -1)
1621 ShowWindow(psInfo->proppage[psInfo->active_page].hwndPage, SW_HIDE);
1622
1623 ShowWindow(psInfo->proppage[index].hwndPage, SW_SHOW);
1624
1625 /* Synchronize current selection with tab control
1626 * It seems to be needed even in case of PSH_WIZARD (no tab controls there) */
1627 hwndTabCtrl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
1628 SendMessageW(hwndTabCtrl, TCM_SETCURSEL, index, 0);
1629
1630 psInfo->active_page = index;
1631 psInfo->activeValid = TRUE;
1632
1633 if (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW) )
1634 {
1635 hwndLineHeader = GetDlgItem(hwndDlg, IDC_SUNKEN_LINEHEADER);
1636 ppshpage = (LPCPROPSHEETPAGEW)psInfo->proppage[index].hpage;
1637
1638 if ((ppshpage->dwFlags & PSP_HIDEHEADER) || (!(psInfo->ppshheader.dwFlags & PSH_HEADER)) )
1639 ShowWindow(hwndLineHeader, SW_HIDE);
1640 else
1641 ShowWindow(hwndLineHeader, SW_SHOW);
1642 }
1643
1644 InvalidateRgn(hwndDlg, NULL, TRUE);
1645 UpdateWindow(hwndDlg);
1646
1647 return TRUE;
1648 }
1649
1650 /******************************************************************************
1651 * PROPSHEET_Back
1652 */
1653 static BOOL PROPSHEET_Back(HWND hwndDlg)
1654 {
1655 PSHNOTIFY psn;
1656 HWND hwndPage;
1657 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1658 PropSheetInfoStr);
1659 LRESULT result;
1660 int idx;
1661
1662 TRACE("active_page %d\n", psInfo->active_page);
1663 if (psInfo->active_page < 0)
1664 return FALSE;
1665
1666 psn.hdr.code = PSN_WIZBACK;
1667 psn.hdr.hwndFrom = hwndDlg;
1668 psn.hdr.idFrom = 0;
1669 psn.lParam = 0;
1670
1671 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1672
1673 result = SendMessageW(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1674 if (result == -1)
1675 return FALSE;
1676 else if (result == 0)
1677 idx = psInfo->active_page - 1;
1678 else
1679 idx = PROPSHEET_FindPageByResId(psInfo, result);
1680
1681 if (idx >= 0 && idx < psInfo->nPages)
1682 {
1683 if (PROPSHEET_CanSetCurSel(hwndDlg))
1684 PROPSHEET_SetCurSel(hwndDlg, idx, -1, 0);
1685 }
1686 return TRUE;
1687 }
1688
1689 /******************************************************************************
1690 * PROPSHEET_Next
1691 */
1692 static BOOL PROPSHEET_Next(HWND hwndDlg)
1693 {
1694 PSHNOTIFY psn;
1695 HWND hwndPage;
1696 LRESULT msgResult = 0;
1697 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1698 PropSheetInfoStr);
1699 int idx;
1700
1701 TRACE("active_page %d\n", psInfo->active_page);
1702 if (psInfo->active_page < 0)
1703 return FALSE;
1704
1705 psn.hdr.code = PSN_WIZNEXT;
1706 psn.hdr.hwndFrom = hwndDlg;
1707 psn.hdr.idFrom = 0;
1708 psn.lParam = 0;
1709
1710 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1711
1712 msgResult = SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1713 if (msgResult == -1)
1714 return FALSE;
1715 else if (msgResult == 0)
1716 idx = psInfo->active_page + 1;
1717 else
1718 idx = PROPSHEET_FindPageByResId(psInfo, msgResult);
1719
1720 if (idx < psInfo->nPages )
1721 {
1722 if (PROPSHEET_CanSetCurSel(hwndDlg) != FALSE)
1723 PROPSHEET_SetCurSel(hwndDlg, idx, 1, 0);
1724 }
1725
1726 return TRUE;
1727 }
1728
1729 /******************************************************************************
1730 * PROPSHEET_Finish
1731 */
1732 static BOOL PROPSHEET_Finish(HWND hwndDlg)
1733 {
1734 PSHNOTIFY psn;
1735 HWND hwndPage;
1736 LRESULT msgResult = 0;
1737 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1738 PropSheetInfoStr);
1739
1740 TRACE("active_page %d\n", psInfo->active_page);
1741 if (psInfo->active_page < 0)
1742 return FALSE;
1743
1744 psn.hdr.code = PSN_WIZFINISH;
1745 psn.hdr.hwndFrom = hwndDlg;
1746 psn.hdr.idFrom = 0;
1747 psn.lParam = 0;
1748
1749 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1750
1751 msgResult = SendMessageW(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1752
1753 TRACE("msg result %ld\n", msgResult);
1754
1755 if (msgResult != 0)
1756 return FALSE;
1757
1758 if (psInfo->isModeless)
1759 psInfo->activeValid = FALSE;
1760 else
1761 EndDialog(hwndDlg, TRUE);
1762
1763 return TRUE;
1764 }
1765
1766 /******************************************************************************
1767 * PROPSHEET_Apply
1768 */
1769 static BOOL PROPSHEET_Apply(HWND hwndDlg, LPARAM lParam)
1770 {
1771 int i;
1772 HWND hwndPage;
1773 PSHNOTIFY psn;
1774 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1775 PropSheetInfoStr);
1776
1777 TRACE("active_page %d\n", psInfo->active_page);
1778 if (psInfo->active_page < 0)
1779 return FALSE;
1780
1781 psn.hdr.hwndFrom = hwndDlg;
1782 psn.hdr.idFrom = 0;
1783 psn.lParam = 0;
1784
1785
1786 /*
1787 * Send PSN_KILLACTIVE to the current page.
1788 */
1789 psn.hdr.code = PSN_KILLACTIVE;
1790
1791 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1792
1793 if (SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn) != FALSE)
1794 return FALSE;
1795
1796 /*
1797 * Send PSN_APPLY to all pages.
1798 */
1799 psn.hdr.code = PSN_APPLY;
1800 psn.lParam = lParam;
1801
1802 for (i = 0; i < psInfo->nPages; i++)
1803 {
1804 hwndPage = psInfo->proppage[i].hwndPage;
1805 if (hwndPage)
1806 {
1807 switch (SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn))
1808 {
1809 case PSNRET_INVALID:
1810 PROPSHEET_ShowPage(hwndDlg, i, psInfo);
1811 /* fall through */
1812 case PSNRET_INVALID_NOCHANGEPAGE:
1813 return FALSE;
1814 }
1815 }
1816 }
1817
1818 if(lParam)
1819 {
1820 psInfo->activeValid = FALSE;
1821 }
1822 else if(psInfo->active_page >= 0)
1823 {
1824 psn.hdr.code = PSN_SETACTIVE;
1825 psn.lParam = 0;
1826 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1827 SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1828 }
1829
1830 return TRUE;
1831 }
1832
1833 /******************************************************************************
1834 * PROPSHEET_Cancel
1835 */
1836 static void PROPSHEET_Cancel(HWND hwndDlg, LPARAM lParam)
1837 {
1838 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1839 PropSheetInfoStr);
1840 HWND hwndPage;
1841 PSHNOTIFY psn;
1842 int i;
1843
1844 TRACE("active_page %d\n", psInfo->active_page);
1845 if (psInfo->active_page < 0)
1846 return;
1847
1848 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1849 psn.hdr.code = PSN_QUERYCANCEL;
1850 psn.hdr.hwndFrom = hwndDlg;
1851 psn.hdr.idFrom = 0;
1852 psn.lParam = 0;
1853
1854 if (SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn))
1855 return;
1856
1857 psn.hdr.code = PSN_RESET;
1858 psn.lParam = lParam;
1859
1860 for (i = 0; i < psInfo->nPages; i++)
1861 {
1862 hwndPage = psInfo->proppage[i].hwndPage;
1863
1864 if (hwndPage)
1865 SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1866 }
1867
1868 if (psInfo->isModeless)
1869 {
1870 /* makes PSM_GETCURRENTPAGEHWND return NULL */
1871 psInfo->activeValid = FALSE;
1872 }
1873 else
1874 EndDialog(hwndDlg, FALSE);
1875 }
1876
1877 /******************************************************************************
1878 * PROPSHEET_Help
1879 */
1880 static void PROPSHEET_Help(HWND hwndDlg)
1881 {
1882 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1883 PropSheetInfoStr);
1884 HWND hwndPage;
1885 PSHNOTIFY psn;
1886
1887 TRACE("active_page %d\n", psInfo->active_page);
1888 if (psInfo->active_page < 0)
1889 return;
1890
1891 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
1892 psn.hdr.code = PSN_HELP;
1893 psn.hdr.hwndFrom = hwndDlg;
1894 psn.hdr.idFrom = 0;
1895 psn.lParam = 0;
1896
1897 SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
1898 }
1899
1900 /******************************************************************************
1901 * PROPSHEET_Changed
1902 */
1903 static void PROPSHEET_Changed(HWND hwndDlg, HWND hwndDirtyPage)
1904 {
1905 int i;
1906 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1907 PropSheetInfoStr);
1908
1909 TRACE("\n");
1910 if (!psInfo) return;
1911 /*
1912 * Set the dirty flag of this page.
1913 */
1914 for (i = 0; i < psInfo->nPages; i++)
1915 {
1916 if (psInfo->proppage[i].hwndPage == hwndDirtyPage)
1917 psInfo->proppage[i].isDirty = TRUE;
1918 }
1919
1920 /*
1921 * Enable the Apply button.
1922 */
1923 if (psInfo->hasApply)
1924 {
1925 HWND hwndApplyBtn = GetDlgItem(hwndDlg, IDC_APPLY_BUTTON);
1926
1927 EnableWindow(hwndApplyBtn, TRUE);
1928 }
1929 }
1930
1931 /******************************************************************************
1932 * PROPSHEET_UnChanged
1933 */
1934 static void PROPSHEET_UnChanged(HWND hwndDlg, HWND hwndCleanPage)
1935 {
1936 int i;
1937 BOOL noPageDirty = TRUE;
1938 HWND hwndApplyBtn = GetDlgItem(hwndDlg, IDC_APPLY_BUTTON);
1939 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
1940 PropSheetInfoStr);
1941
1942 TRACE("\n");
1943 if ( !psInfo ) return;
1944 for (i = 0; i < psInfo->nPages; i++)
1945 {
1946 /* set the specified page as clean */
1947 if (psInfo->proppage[i].hwndPage == hwndCleanPage)
1948 psInfo->proppage[i].isDirty = FALSE;
1949
1950 /* look to see if there's any dirty pages */
1951 if (psInfo->proppage[i].isDirty)
1952 noPageDirty = FALSE;
1953 }
1954
1955 /*
1956 * Disable Apply button.
1957 */
1958 if (noPageDirty)
1959 EnableWindow(hwndApplyBtn, FALSE);
1960 }
1961
1962 /******************************************************************************
1963 * PROPSHEET_PressButton
1964 */
1965 static void PROPSHEET_PressButton(HWND hwndDlg, int buttonID)
1966 {
1967 TRACE("buttonID %d\n", buttonID);
1968 switch (buttonID)
1969 {
1970 case PSBTN_APPLYNOW:
1971 PROPSHEET_DoCommand(hwndDlg, IDC_APPLY_BUTTON);
1972 break;
1973 case PSBTN_BACK:
1974 PROPSHEET_Back(hwndDlg);
1975 break;
1976 case PSBTN_CANCEL:
1977 PROPSHEET_DoCommand(hwndDlg, IDCANCEL);
1978 break;
1979 case PSBTN_FINISH:
1980 PROPSHEET_Finish(hwndDlg);
1981 break;
1982 case PSBTN_HELP:
1983 PROPSHEET_DoCommand(hwndDlg, IDHELP);
1984 break;
1985 case PSBTN_NEXT:
1986 PROPSHEET_Next(hwndDlg);
1987 break;
1988 case PSBTN_OK:
1989 PROPSHEET_DoCommand(hwndDlg, IDOK);
1990 break;
1991 default:
1992 FIXME("Invalid button index %d\n", buttonID);
1993 }
1994 }
1995
1996
1997 /*************************************************************************
1998 * BOOL PROPSHEET_CanSetCurSel [Internal]
1999 *
2000 * Test whether the current page can be changed by sending a PSN_KILLACTIVE
2001 *
2002 * PARAMS
2003 * hwndDlg [I] handle to a Dialog hWnd
2004 *
2005 * RETURNS
2006 * TRUE if Current Selection can change
2007 *
2008 * NOTES
2009 */
2010 static BOOL PROPSHEET_CanSetCurSel(HWND hwndDlg)
2011 {
2012 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2013 PropSheetInfoStr);
2014 HWND hwndPage;
2015 PSHNOTIFY psn;
2016 BOOL res = FALSE;
2017
2018 TRACE("active_page %d\n", psInfo->active_page);
2019 if (!psInfo)
2020 {
2021 res = FALSE;
2022 goto end;
2023 }
2024
2025 if (psInfo->active_page < 0)
2026 {
2027 res = TRUE;
2028 goto end;
2029 }
2030
2031 /*
2032 * Notify the current page.
2033 */
2034 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
2035 psn.hdr.code = PSN_KILLACTIVE;
2036 psn.hdr.hwndFrom = hwndDlg;
2037 psn.hdr.idFrom = 0;
2038 psn.lParam = 0;
2039
2040 res = !SendMessageA(hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
2041
2042 end:
2043 TRACE("<-- %d\n", res);
2044 return res;
2045 }
2046
2047 /******************************************************************************
2048 * PROPSHEET_SetCurSel
2049 */
2050 static BOOL PROPSHEET_SetCurSel(HWND hwndDlg,
2051 int index,
2052 int skipdir,
2053 HPROPSHEETPAGE hpage
2054 )
2055 {
2056 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg, PropSheetInfoStr);
2057 HWND hwndHelp = GetDlgItem(hwndDlg, IDHELP);
2058 HWND hwndTabControl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
2059
2060 TRACE("index %d, skipdir %d, hpage %p\n", index, skipdir, hpage);
2061 /* hpage takes precedence over index */
2062 if (hpage != NULL)
2063 index = PROPSHEET_GetPageIndex(hpage, psInfo);
2064
2065 if (index < 0 || index >= psInfo->nPages)
2066 {
2067 TRACE("Could not find page to select!\n");
2068 return FALSE;
2069 }
2070
2071 while (1) {
2072 int result;
2073 PSHNOTIFY psn;
2074 RECT rc;
2075
2076 if (hwndTabControl)
2077 SendMessageW(hwndTabControl, TCM_SETCURSEL, index, 0);
2078
2079 psn.hdr.code = PSN_SETACTIVE;
2080 psn.hdr.hwndFrom = hwndDlg;
2081 psn.hdr.idFrom = 0;
2082 psn.lParam = 0;
2083
2084 if (!psInfo->proppage[index].hwndPage) {
2085 LPCPROPSHEETPAGEW ppshpage = (LPCPROPSHEETPAGEW)psInfo->proppage[index].hpage;
2086 PROPSHEET_CreatePage(hwndDlg, index, psInfo, ppshpage);
2087 }
2088
2089 /* NOTE: The resizing happens every time the page is selected and
2090 * not only when it's created (some applications depend on it). */
2091 if (!(psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD)) {
2092 /*
2093 * Ask the Tab control to reduce the client rectangle to that
2094 * it has available.
2095 */
2096 PROPSHEET_GetPageRect(psInfo, hwndDlg, &rc);
2097 TRACE("setting page %p, rc (%ld,%ld)-(%ld,%ld) w=%ld, h=%ld\n",
2098 psInfo->proppage[index].hwndPage, rc.left, rc.top, rc.right, rc.bottom,
2099 rc.right - rc.left, rc.bottom - rc.top);
2100 SetWindowPos(psInfo->proppage[index].hwndPage, HWND_TOP,
2101 rc.left, rc.top,
2102 rc.right - rc.left, rc.bottom - rc.top, 0);
2103 }
2104
2105 result = SendMessageW(psInfo->proppage[index].hwndPage, WM_NOTIFY, 0, (LPARAM) &psn);
2106 if (!result)
2107 break;
2108 if (result == -1) {
2109 index+=skipdir;
2110 if (index < 0) {
2111 index = 0;
2112 WARN("Tried to skip before first property sheet page!\n");
2113 break;
2114 }
2115 if (index >= psInfo->nPages) {
2116 WARN("Tried to skip after last property sheet page!\n");
2117 index = psInfo->nPages-1;
2118 break;
2119 }
2120 }
2121 else if (result != 0)
2122 {
2123 int old_index = index;
2124 index = PROPSHEET_FindPageByResId(psInfo, result);
2125 if(index >= psInfo->nPages) {
2126 index = old_index;
2127 WARN("Tried to skip to nonexistant page by res id\n");
2128 break;
2129 }
2130 continue;
2131 }
2132 }
2133 /*
2134 * Display the new page.
2135 */
2136 PROPSHEET_ShowPage(hwndDlg, index, psInfo);
2137
2138 if (psInfo->proppage[index].hasHelp)
2139 EnableWindow(hwndHelp, TRUE);
2140 else
2141 EnableWindow(hwndHelp, FALSE);
2142
2143 return TRUE;
2144 }
2145
2146 /******************************************************************************
2147 * PROPSHEET_SetCurSelId
2148 *
2149 * Selects the page, specified by resource id.
2150 */
2151 static void PROPSHEET_SetCurSelId(HWND hwndDlg, int id)
2152 {
2153 int idx;
2154 PropSheetInfo* psInfo =
2155 (PropSheetInfo*) GetPropW(hwndDlg, PropSheetInfoStr);
2156
2157 idx = PROPSHEET_FindPageByResId(psInfo, id);
2158 if (idx < psInfo->nPages )
2159 {
2160 if (PROPSHEET_CanSetCurSel(hwndDlg) != FALSE)
2161 PROPSHEET_SetCurSel(hwndDlg, idx, 1, 0);
2162 }
2163 }
2164
2165 /******************************************************************************
2166 * PROPSHEET_SetTitleA
2167 */
2168 static void PROPSHEET_SetTitleA(HWND hwndDlg, DWORD dwStyle, LPCSTR lpszText)
2169 {
2170 if(HIWORD(lpszText))
2171 {
2172 WCHAR szTitle[256];
2173 MultiByteToWideChar(CP_ACP, 0, lpszText, -1,
2174 szTitle, sizeof(szTitle));
2175 PROPSHEET_SetTitleW(hwndDlg, dwStyle, szTitle);
2176 }
2177 else
2178 {
2179 PROPSHEET_SetTitleW(hwndDlg, dwStyle, (LPCWSTR)lpszText);
2180 }
2181 }
2182
2183 /******************************************************************************
2184 * PROPSHEET_SetTitleW
2185 */
2186 static void PROPSHEET_SetTitleW(HWND hwndDlg, DWORD dwStyle, LPCWSTR lpszText)
2187 {
2188 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg, PropSheetInfoStr);
2189 WCHAR szTitle[256];
2190
2191 TRACE("'%s' (style %08lx)\n", debugstr_w(lpszText), dwStyle);
2192 if (HIWORD(lpszText) == 0) {
2193 if (!LoadStringW(psInfo->ppshheader.hInstance,
2194 LOWORD(lpszText), szTitle, sizeof(szTitle)-sizeof(WCHAR)))
2195 return;
2196 lpszText = szTitle;
2197 }
2198 if (dwStyle & PSH_PROPTITLE)
2199 {
2200 WCHAR* dest;
2201 int lentitle = strlenW(lpszText);
2202 int lenprop = strlenW(psInfo->strPropertiesFor);
2203
2204 dest = Alloc( (lentitle + lenprop + 1)*sizeof (WCHAR));
2205 strcpyW(dest, psInfo->strPropertiesFor);
2206 strcatW(dest, lpszText);
2207
2208 SetWindowTextW(hwndDlg, dest);
2209 Free(dest);
2210 }
2211 else
2212 SetWindowTextW(hwndDlg, lpszText);
2213 }
2214
2215 /******************************************************************************
2216 * PROPSHEET_SetFinishTextA
2217 */
2218 static void PROPSHEET_SetFinishTextA(HWND hwndDlg, LPCSTR lpszText)
2219 {
2220 HWND hwndButton = GetDlgItem(hwndDlg, IDC_FINISH_BUTTON);
2221
2222 TRACE("'%s'\n", lpszText);
2223 /* Set text, show and enable the Finish button */
2224 SetWindowTextA(hwndButton, lpszText);
2225 ShowWindow(hwndButton, SW_SHOW);
2226 EnableWindow(hwndButton, TRUE);
2227
2228 /* Make it default pushbutton */
2229 SendMessageA(hwndDlg, DM_SETDEFID, IDC_FINISH_BUTTON, 0);
2230
2231 /* Hide Back button */
2232 hwndButton = GetDlgItem(hwndDlg, IDC_BACK_BUTTON);
2233 ShowWindow(hwndButton, SW_HIDE);
2234
2235 /* Hide Next button */
2236 hwndButton = GetDlgItem(hwndDlg, IDC_NEXT_BUTTON);
2237 ShowWindow(hwndButton, SW_HIDE);
2238 }
2239
2240 /******************************************************************************
2241 * PROPSHEET_SetFinishTextW
2242 */
2243 static void PROPSHEET_SetFinishTextW(HWND hwndDlg, LPCWSTR lpszText)
2244 {
2245 HWND hwndButton = GetDlgItem(hwndDlg, IDC_FINISH_BUTTON);
2246
2247 TRACE("'%s'\n", debugstr_w(lpszText));
2248 /* Set text, show and enable the Finish button */
2249 SetWindowTextW(hwndButton, lpszText);
2250 ShowWindow(hwndButton, SW_SHOW);
2251 EnableWindow(hwndButton, TRUE);
2252
2253 /* Make it default pushbutton */
2254 SendMessageW(hwndDlg, DM_SETDEFID, IDC_FINISH_BUTTON, 0);
2255
2256 /* Hide Back button */
2257 hwndButton = GetDlgItem(hwndDlg, IDC_BACK_BUTTON);
2258 ShowWindow(hwndButton, SW_HIDE);
2259
2260 /* Hide Next button */
2261 hwndButton = GetDlgItem(hwndDlg, IDC_NEXT_BUTTON);
2262 ShowWindow(hwndButton, SW_HIDE);
2263 }
2264
2265 /******************************************************************************
2266 * PROPSHEET_QuerySiblings
2267 */
2268 static LRESULT PROPSHEET_QuerySiblings(HWND hwndDlg,
2269 WPARAM wParam, LPARAM lParam)
2270 {
2271 int i = 0;
2272 HWND hwndPage;
2273 LRESULT msgResult = 0;
2274 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2275 PropSheetInfoStr);
2276
2277 while ((i < psInfo->nPages) && (msgResult == 0))
2278 {
2279 hwndPage = psInfo->proppage[i].hwndPage;
2280 msgResult = SendMessageA(hwndPage, PSM_QUERYSIBLINGS, wParam, lParam);
2281 i++;
2282 }
2283
2284 return msgResult;
2285 }
2286
2287
2288 /******************************************************************************
2289 * PROPSHEET_AddPage
2290 */
2291 static BOOL PROPSHEET_AddPage(HWND hwndDlg,
2292 HPROPSHEETPAGE hpage)
2293 {
2294 PropSheetInfo * psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2295 PropSheetInfoStr);
2296 HWND hwndTabControl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
2297 TCITEMW item;
2298 LPCPROPSHEETPAGEW ppsp = (LPCPROPSHEETPAGEW)hpage;
2299
2300 TRACE("hpage %p\n", hpage);
2301 /*
2302 * Allocate and fill in a new PropPageInfo entry.
2303 */
2304 psInfo->proppage = (PropPageInfo*) ReAlloc(psInfo->proppage,
2305 sizeof(PropPageInfo) *
2306 (psInfo->nPages + 1));
2307 if (!PROPSHEET_CollectPageInfo(ppsp, psInfo, psInfo->nPages))
2308 return FALSE;
2309
2310 psInfo->proppage[psInfo->nPages].hpage = hpage;
2311
2312 if (ppsp->dwFlags & PSP_PREMATURE)
2313 {
2314 /* Create the page but don't show it */
2315 PROPSHEET_CreatePage(hwndDlg, psInfo->nPages, psInfo, ppsp);
2316 }
2317
2318 /*
2319 * Add a new tab to the tab control.
2320 */
2321 item.mask = TCIF_TEXT;
2322 item.pszText = (LPWSTR) psInfo->proppage[psInfo->nPages].pszText;
2323 item.cchTextMax = MAX_TABTEXT_LENGTH;
2324
2325 if (psInfo->hImageList)
2326 {
2327 SendMessageW(hwndTabControl, TCM_SETIMAGELIST, 0, (LPARAM)psInfo->hImageList);
2328 }
2329
2330 if ( psInfo->proppage[psInfo->nPages].hasIcon )
2331 {
2332 item.mask |= TCIF_IMAGE;
2333 item.iImage = psInfo->nPages;
2334 }
2335
2336 SendMessageW(hwndTabControl, TCM_INSERTITEMW, psInfo->nPages + 1,
2337 (LPARAM)&item);
2338
2339 psInfo->nPages++;
2340
2341 /* If it is the only page - show it */
2342 if(psInfo->nPages == 1)
2343 PROPSHEET_SetCurSel(hwndDlg, 0, 1, 0);
2344 return TRUE;
2345 }
2346
2347 /******************************************************************************
2348 * PROPSHEET_RemovePage
2349 */
2350 static BOOL PROPSHEET_RemovePage(HWND hwndDlg,
2351 int index,
2352 HPROPSHEETPAGE hpage)
2353 {
2354 PropSheetInfo * psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2355 PropSheetInfoStr);
2356 HWND hwndTabControl = GetDlgItem(hwndDlg, IDC_TABCONTROL);
2357 PropPageInfo* oldPages;
2358
2359 TRACE("index %d, hpage %p\n", index, hpage);
2360 if (!psInfo) {
2361 return FALSE;
2362 }
2363 /*
2364 * hpage takes precedence over index.
2365 */
2366 if (hpage != 0)
2367 {
2368 index = PROPSHEET_GetPageIndex(hpage, psInfo);
2369 }
2370
2371 /* Make sure that index is within range */
2372 if (index < 0 || index >= psInfo->nPages)
2373 {
2374 TRACE("Could not find page to remove!\n");
2375 return FALSE;
2376 }
2377
2378 TRACE("total pages %d removing page %d active page %d\n",
2379 psInfo->nPages, index, psInfo->active_page);
2380 /*
2381 * Check if we're removing the active page.
2382 */
2383 if (index == psInfo->active_page)
2384 {
2385 if (psInfo->nPages > 1)
2386 {
2387 if (index > 0)
2388 {
2389 /* activate previous page */
2390 PROPSHEET_SetCurSel(hwndDlg, index - 1, -1, 0);
2391 }
2392 else
2393 {
2394 /* activate the next page */
2395 PROPSHEET_SetCurSel(hwndDlg, index + 1, 1, 0);
2396 psInfo->active_page = index;
2397 }
2398 }
2399 else
2400 {
2401 psInfo->active_page = -1;
2402 if (!psInfo->isModeless)
2403 {
2404 EndDialog(hwndDlg, FALSE);
2405 return TRUE;
2406 }
2407 }
2408 }
2409 else if (index < psInfo->active_page)
2410 psInfo->active_page--;
2411
2412 /* Destroy page dialog window */
2413 DestroyWindow(psInfo->proppage[index].hwndPage);
2414
2415 /* Free page resources */
2416 if(psInfo->proppage[index].hpage)
2417 {
2418 PROPSHEETPAGEW* psp = (PROPSHEETPAGEW*)psInfo->proppage[index].hpage;
2419
2420 if ((psp->dwFlags & PSP_USETITLE) && psInfo->proppage[index].pszText)
2421 HeapFree(GetProcessHeap(), 0, (LPVOID)psInfo->proppage[index].pszText);
2422
2423 DestroyPropertySheetPage(psInfo->proppage[index].hpage);
2424 }
2425
2426 /* Remove the tab */
2427 SendMessageW(hwndTabControl, TCM_DELETEITEM, index, 0);
2428
2429 oldPages = psInfo->proppage;
2430 psInfo->nPages--;
2431 psInfo->proppage = Alloc(sizeof(PropPageInfo) * psInfo->nPages);
2432
2433 if (index > 0)
2434 memcpy(&psInfo->proppage[0], &oldPages[0], index * sizeof(PropPageInfo));
2435
2436 if (index < psInfo->nPages)
2437 memcpy(&psInfo->proppage[index], &oldPages[index + 1],
2438 (psInfo->nPages - index) * sizeof(PropPageInfo));
2439
2440 Free(oldPages);
2441
2442 return FALSE;
2443 }
2444
2445 /******************************************************************************
2446 * PROPSHEET_SetWizButtons
2447 *
2448 * This code will work if (and assumes that) the Next button is on top of the
2449 * Finish button. ie. Finish comes after Next in the Z order.
2450 * This means make sure the dialog template reflects this.
2451 *
2452 */
2453 static void PROPSHEET_SetWizButtons(HWND hwndDlg, DWORD dwFlags)
2454 {
2455 HWND hwndBack = GetDlgItem(hwndDlg, IDC_BACK_BUTTON);
2456 HWND hwndNext = GetDlgItem(hwndDlg, IDC_NEXT_BUTTON);
2457 HWND hwndFinish = GetDlgItem(hwndDlg, IDC_FINISH_BUTTON);
2458
2459 TRACE("%ld\n", dwFlags);
2460
2461 EnableWindow(hwndBack, FALSE);
2462 EnableWindow(hwndNext, FALSE);
2463 EnableWindow(hwndFinish, FALSE);
2464
2465 if (dwFlags & PSWIZB_BACK)
2466 EnableWindow(hwndBack, TRUE);
2467
2468 if (dwFlags & PSWIZB_NEXT)
2469 {
2470 /* Hide the Finish button */
2471 ShowWindow(hwndFinish, SW_HIDE);
2472
2473 /* Show and enable the Next button */
2474 ShowWindow(hwndNext, SW_SHOW);
2475 EnableWindow(hwndNext, TRUE);
2476
2477 /* Set the Next button as the default pushbutton */
2478 SendMessageA(hwndDlg, DM_SETDEFID, IDC_NEXT_BUTTON, 0);
2479 }
2480
2481 if ((dwFlags & PSWIZB_FINISH) || (dwFlags & PSWIZB_DISABLEDFINISH))
2482 {
2483 /* Hide the Next button */
2484 ShowWindow(hwndNext, SW_HIDE);
2485
2486 /* Show the Finish button */
2487 ShowWindow(hwndFinish, SW_SHOW);
2488
2489 if (dwFlags & PSWIZB_FINISH)
2490 EnableWindow(hwndFinish, TRUE);
2491
2492 /* Set the Finish button as the default pushbutton */
2493 SendMessageA(hwndDlg, DM_SETDEFID, IDC_FINISH_BUTTON, 0);
2494 }
2495 }
2496
2497 /******************************************************************************
2498 * PROPSHEET_InsertPage
2499 */
2500 static BOOL PROPSHEET_InsertPage(HWND hwndDlg, HPROPSHEETPAGE hpageInsertAfter, HPROPSHEETPAGE hpage)
2501 {
2502 if (!HIWORD(hpageInsertAfter))
2503 FIXME("(%p, %d, %p): stub\n", hwndDlg, LOWORD(hpageInsertAfter), hpage);
2504 else
2505 FIXME("(%p, %p, %p): stub\n", hwndDlg, hpageInsertAfter, hpage);
2506 return FALSE;
2507 }
2508
2509 /******************************************************************************
2510 * PROPSHEET_SetHeaderTitleW
2511 */
2512 static void PROPSHEET_SetHeaderTitleW(HWND hwndDlg, int iPageIndex, LPCWSTR pszHeaderTitle)
2513 {
2514 FIXME("(%p, %d, %s): stub\n", hwndDlg, iPageIndex, debugstr_w(pszHeaderTitle));
2515 }
2516
2517 /******************************************************************************
2518 * PROPSHEET_SetHeaderTitleA
2519 */
2520 static void PROPSHEET_SetHeaderTitleA(HWND hwndDlg, int iPageIndex, LPCSTR pszHeaderTitle)
2521 {
2522 FIXME("(%p, %d, %s): stub\n", hwndDlg, iPageIndex, debugstr_a(pszHeaderTitle));
2523 }
2524
2525 /******************************************************************************
2526 * PROPSHEET_SetHeaderSubTitleW
2527 */
2528 static void PROPSHEET_SetHeaderSubTitleW(HWND hwndDlg, int iPageIndex, LPCWSTR pszHeaderSubTitle)
2529 {
2530 FIXME("(%p, %d, %s): stub\n", hwndDlg, iPageIndex, debugstr_w(pszHeaderSubTitle));
2531 }
2532
2533 /******************************************************************************
2534 * PROPSHEET_SetHeaderSubTitleA
2535 */
2536 static void PROPSHEET_SetHeaderSubTitleA(HWND hwndDlg, int iPageIndex, LPCSTR pszHeaderSubTitle)
2537 {
2538 FIXME("(%p, %d, %s): stub\n", hwndDlg, iPageIndex, debugstr_a(pszHeaderSubTitle));
2539 }
2540
2541 /******************************************************************************
2542 * PROPSHEET_HwndToIndex
2543 */
2544 static LRESULT PROPSHEET_HwndToIndex(HWND hwndDlg, HWND hPageDlg)
2545 {
2546 int index;
2547 PropSheetInfo * psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2548 PropSheetInfoStr);
2549
2550 TRACE("(%p, %p)\n", hwndDlg, hPageDlg);
2551
2552 for (index = 0; index < psInfo->nPages; index++)
2553 if (psInfo->proppage[index].hwndPage == hPageDlg)
2554 return index;
2555 WARN("%p not found\n", hPageDlg);
2556 return -1;
2557 }
2558
2559 /******************************************************************************
2560 * PROPSHEET_IndexToHwnd
2561 */
2562 static LRESULT PROPSHEET_IndexToHwnd(HWND hwndDlg, int iPageIndex)
2563 {
2564 PropSheetInfo * psInfo = (PropSheetInfo*) GetPropW(hwndDlg,
2565 PropSheetInfoStr);
2566 TRACE("(%p, %d)\n", hwndDlg, iPageIndex);
2567 if (iPageIndex<0 || iPageIndex>=psInfo->nPages) {
2568 WARN("%d out of range.\n", iPageIndex);
2569 return 0;
2570 }
2571 return (LRESULT)psInfo->proppage[iPageIndex].hwndPage;
2572 }
2573
2574 /******************************************************************************
2575 * PROPSHEET_PageToIndex
2576 */
2577 static LRESULT PROPSHEET_PageToIndex(HWND hwndDlg, HPROPSHEETPAGE hPage)
2578 {
2579 FIXME("(%p, %p): stub\n", hwndDlg, hPage);
2580 return -1;
2581 }
2582
2583 /******************************************************************************
2584 * PROPSHEET_IndexToPage
2585 */
2586 static LRESULT PROPSHEET_IndexToPage(HWND hwndDlg, int iPageIndex)
2587 {
2588 FIXME("(%p, %d): stub\n", hwndDlg, iPageIndex);
2589 return 0;
2590 }
2591
2592 /******************************************************************************
2593 * PROPSHEET_IdToIndex
2594 */
2595 static LRESULT PROPSHEET_IdToIndex(HWND hwndDlg, int iPageId)
2596 {
2597 FIXME("(%p, %d): stub\n", hwndDlg, iPageId);
2598 return -1;
2599 }
2600
2601 /******************************************************************************
2602 * PROPSHEET_IndexToId
2603 */
2604 static LRESULT PROPSHEET_IndexToId(HWND hwndDlg, int iPageIndex)
2605 {
2606 FIXME("(%p, %d): stub\n", hwndDlg, iPageIndex);
2607 return 0;
2608 }
2609
2610 /******************************************************************************
2611 * PROPSHEET_GetResult
2612 */
2613 static LRESULT PROPSHEET_GetResult(HWND hwndDlg)
2614 {
2615 FIXME("(%p): stub\n", hwndDlg);
2616 return -1;
2617 }
2618
2619 /******************************************************************************
2620 * PROPSHEET_RecalcPageSizes
2621 */
2622 static BOOL PROPSHEET_RecalcPageSizes(HWND hwndDlg)
2623 {
2624 FIXME("(%p): stub\n", hwndDlg);
2625 return FALSE;
2626 }
2627
2628 /******************************************************************************
2629 * PROPSHEET_GetPageIndex
2630 *
2631 * Given a HPROPSHEETPAGE, returns the index of the corresponding page from
2632 * the array of PropPageInfo.
2633 */
2634 static int PROPSHEET_GetPageIndex(HPROPSHEETPAGE hpage, PropSheetInfo* psInfo)
2635 {
2636 BOOL found = FALSE;
2637 int index = 0;
2638
2639 TRACE("hpage %p\n", hpage);
2640 while ((index < psInfo->nPages) && (found == FALSE))
2641 {
2642 if (psInfo->proppage[index].hpage == hpage)
2643 found = TRUE;
2644 else
2645 index++;
2646 }
2647
2648 if (found == FALSE)
2649 index = -1;
2650
2651 return index;
2652 }
2653
2654 /******************************************************************************
2655 * PROPSHEET_CleanUp
2656 */
2657 static void PROPSHEET_CleanUp(HWND hwndDlg)
2658 {
2659 int i;
2660 PropSheetInfo* psInfo = (PropSheetInfo*) RemovePropW(hwndDlg,
2661 PropSheetInfoStr);
2662
2663 TRACE("\n");
2664 if (!psInfo) return;
2665 if (HIWORD(psInfo->ppshheader.pszCaption))
2666 HeapFree(GetProcessHeap(), 0, (LPVOID)psInfo->ppshheader.pszCaption);
2667
2668 for (i = 0; i < psInfo->nPages; i++)
2669 {
2670 PROPSHEETPAGEA* psp = (PROPSHEETPAGEA*)psInfo->proppage[i].hpage;
2671
2672 if(psInfo->proppage[i].hwndPage)
2673 DestroyWindow(psInfo->proppage[i].hwndPage);
2674
2675 if(psp)
2676 {
2677 if ((psp->dwFlags & PSP_USETITLE) && psInfo->proppage[i].pszText)
2678 HeapFree(GetProcessHeap(), 0, (LPVOID)psInfo->proppage[i].pszText);
2679
2680 DestroyPropertySheetPage(psInfo->proppage[i].hpage);
2681 }
2682 }
2683
2684 DeleteObject(psInfo->hFont);
2685 DeleteObject(psInfo->hFontBold);
2686 /* If we created the bitmaps, destroy them */
2687 if ((psInfo->ppshheader.dwFlags & PSH_WATERMARK) &&
2688 (!(psInfo->ppshheader.dwFlags & PSH_USEHBMWATERMARK)) )
2689 DeleteObject(psInfo->ppshheader.u4.hbmWatermark);
2690 if ((psInfo->ppshheader.dwFlags & PSH_HEADER) &&
2691 (!(psInfo->ppshheader.dwFlags & PSH_USEHBMHEADER)) )
2692 DeleteObject(psInfo->ppshheader.u5.hbmHeader);
2693
2694 Free(psInfo->proppage);
2695 Free(psInfo->strPropertiesFor);
2696 ImageList_Destroy(psInfo->hImageList);
2697
2698 GlobalFree((HGLOBAL)psInfo);
2699 }
2700
2701 /******************************************************************************
2702 * PropertySheet (COMCTL32.@)
2703 * PropertySheetA (COMCTL32.@)
2704 *
2705 * Creates a property sheet in the specified property sheet header.
2706 *
2707 * RETURNS
2708 * Modal property sheets: Positive if successful or -1 otherwise.
2709 * Modeless property sheets: Property sheet handle.
2710 * Or:
2711 *| ID_PSREBOOTSYSTEM - The user must reboot the computer for the changes to take effect.
2712 *| ID_PSRESTARTWINDOWS - The user must restart Windows for the changes to take effect.
2713 */
2714 INT WINAPI PropertySheetA(LPCPROPSHEETHEADERA lppsh)
2715 {
2716 int bRet = 0;
2717 PropSheetInfo* psInfo = (PropSheetInfo*) GlobalAlloc(GPTR,
2718 sizeof(PropSheetInfo));
2719 UINT i, n;
2720 BYTE* pByte;
2721
2722 TRACE("(%p)\n", lppsh);
2723
2724 PROPSHEET_CollectSheetInfoA(lppsh, psInfo);
2725
2726 psInfo->proppage = (PropPageInfo*) Alloc(sizeof(PropPageInfo) *
2727 lppsh->nPages);
2728 pByte = (BYTE*) psInfo->ppshheader.u3.ppsp;
2729
2730 for (n = i = 0; i < lppsh->nPages; i++, n++)
2731 {
2732 if (!(lppsh->dwFlags & PSH_PROPSHEETPAGE))
2733 psInfo->proppage[n].hpage = psInfo->ppshheader.u3.phpage[i];
2734 else
2735 {
2736 psInfo->proppage[n].hpage = CreatePropertySheetPageA((LPCPROPSHEETPAGEA)pByte);
2737 pByte += ((LPPROPSHEETPAGEA)pByte)->dwSize;
2738 }
2739
2740 if (!PROPSHEET_CollectPageInfo((LPCPROPSHEETPAGEW)psInfo->proppage[n].hpage,
2741 psInfo, n))
2742 {
2743 if (lppsh->dwFlags & PSH_PROPSHEETPAGE)
2744 DestroyPropertySheetPage(psInfo->proppage[n].hpage);
2745 n--;
2746 psInfo->nPages--;
2747 }
2748 }
2749
2750 psInfo->unicode = FALSE;
2751 bRet = PROPSHEET_CreateDialog(psInfo);
2752
2753 return bRet;
2754 }
2755
2756 /******************************************************************************
2757 * PropertySheetW (COMCTL32.@)
2758 *
2759 * See PropertySheetA.
2760 */
2761 INT WINAPI PropertySheetW(LPCPROPSHEETHEADERW lppsh)
2762 {
2763 int bRet = 0;
2764 PropSheetInfo* psInfo = (PropSheetInfo*) GlobalAlloc(GPTR,
2765 sizeof(PropSheetInfo));
2766 UINT i, n;
2767 BYTE* pByte;
2768
2769 TRACE("(%p)\n", lppsh);
2770
2771 PROPSHEET_CollectSheetInfoW(lppsh, psInfo);
2772
2773 psInfo->proppage = (PropPageInfo*) Alloc(sizeof(PropPageInfo) *
2774 lppsh->nPages);
2775 pByte = (BYTE*) psInfo->ppshheader.u3.ppsp;
2776
2777 for (n = i = 0; i < lppsh->nPages; i++, n++)
2778 {
2779 if (!(lppsh->dwFlags & PSH_PROPSHEETPAGE))
2780 psInfo->proppage[n].hpage = psInfo->ppshheader.u3.phpage[i];
2781 else
2782 {
2783 psInfo->proppage[n].hpage = CreatePropertySheetPageW((LPCPROPSHEETPAGEW)pByte);
2784 pByte += ((LPPROPSHEETPAGEW)pByte)->dwSize;
2785 }
2786
2787 if (!PROPSHEET_CollectPageInfo((LPCPROPSHEETPAGEW)psInfo->proppage[n].hpage,
2788 psInfo, n))
2789 {
2790 if (lppsh->dwFlags & PSH_PROPSHEETPAGE)
2791 DestroyPropertySheetPage(psInfo->proppage[n].hpage);
2792 n--;
2793 psInfo->nPages--;
2794 }
2795 }
2796
2797 psInfo->unicode = TRUE;
2798 bRet = PROPSHEET_CreateDialog(psInfo);
2799
2800 return bRet;
2801 }
2802
2803 /******************************************************************************
2804 * CreatePropertySheetPage (COMCTL32.@)
2805 * CreatePropertySheetPageA (COMCTL32.@)
2806 *
2807 * Creates a new property sheet page.
2808 *
2809 * RETURNS
2810 * Success: Handle to new property sheet page.
2811 * Failure: NULL.
2812 *
2813 * NOTES
2814 * An application must use the PSM_ADDPAGE message to add the new page to
2815 * an existing property sheet.
2816 */
2817 HPROPSHEETPAGE WINAPI CreatePropertySheetPageA(
2818 LPCPROPSHEETPAGEA lpPropSheetPage)
2819 {
2820 PROPSHEETPAGEW* ppsp = Alloc(sizeof(PROPSHEETPAGEW));
2821
2822 memcpy(ppsp,lpPropSheetPage,min(lpPropSheetPage->dwSize,sizeof(PROPSHEETPAGEA)));
2823
2824 ppsp->dwFlags &= ~ PSP_INTERNAL_UNICODE;
2825 if ( !(ppsp->dwFlags & PSP_DLGINDIRECT) && HIWORD( ppsp->u.pszTemplate ) )
2826 {
2827 int len = strlen(lpPropSheetPage->u.pszTemplate);
2828
2829 ppsp->u.pszTemplate = HeapAlloc( GetProcessHeap(),0,len+1 );
2830 strcpy( (LPSTR)ppsp->u.pszTemplate, lpPropSheetPage->u.pszTemplate );
2831 }
2832 if ( (ppsp->dwFlags & PSP_USEICONID) && HIWORD( ppsp->u2.pszIcon ) )
2833 {
2834 PROPSHEET_AtoW(&ppsp->u2.pszIcon, lpPropSheetPage->u2.pszIcon);
2835 }
2836
2837 if ((ppsp->dwFlags & PSP_USETITLE) && HIWORD( ppsp->pszTitle ))
2838 {
2839 PROPSHEET_AtoW(&ppsp->pszTitle, lpPropSheetPage->pszTitle);
2840 }
2841 else if ( !(ppsp->dwFlags & PSP_USETITLE) )
2842 ppsp->pszTitle = NULL;
2843
2844 return (HPROPSHEETPAGE)ppsp;
2845 }
2846
2847 /******************************************************************************
2848 * CreatePropertySheetPageW (COMCTL32.@)
2849 *
2850 * See CreatePropertySheetA.
2851 */
2852 HPROPSHEETPAGE WINAPI CreatePropertySheetPageW(LPCPROPSHEETPAGEW lpPropSheetPage)
2853 {
2854 PROPSHEETPAGEW* ppsp = Alloc(sizeof(PROPSHEETPAGEW));
2855
2856 memcpy(ppsp,lpPropSheetPage,min(lpPropSheetPage->dwSize,sizeof(PROPSHEETPAGEW)));
2857
2858 ppsp->dwFlags |= PSP_INTERNAL_UNICODE;
2859
2860 if ( !(ppsp->dwFlags & PSP_DLGINDIRECT) && HIWORD( ppsp->u.pszTemplate ) )
2861 {
2862 int len = strlenW(lpPropSheetPage->u.pszTemplate);
2863
2864 ppsp->u.pszTemplate = HeapAlloc( GetProcessHeap(),0,(len+1)*sizeof (WCHAR) );
2865 strcpyW( (WCHAR *)ppsp->u.pszTemplate, lpPropSheetPage->u.pszTemplate );
2866 }
2867 if ( (ppsp->dwFlags & PSP_USEICONID) && HIWORD( ppsp->u2.pszIcon ) )
2868 {
2869 int len = strlenW(lpPropSheetPage->u2.pszIcon);
2870 ppsp->u2.pszIcon = HeapAlloc( GetProcessHeap(), 0, (len+1)*sizeof (WCHAR) );
2871 strcpyW( (WCHAR *)ppsp->u2.pszIcon, lpPropSheetPage->u2.pszIcon );
2872 }
2873
2874 if ((ppsp->dwFlags & PSP_USETITLE) && HIWORD( ppsp->pszTitle ))
2875 {
2876 int len = strlenW(lpPropSheetPage->pszTitle);
2877 ppsp->pszTitle = HeapAlloc( GetProcessHeap(), 0, (len+1)*sizeof (WCHAR) );
2878 strcpyW( (WCHAR *)ppsp->pszTitle, lpPropSheetPage->pszTitle );
2879 }
2880 else if ( !(ppsp->dwFlags & PSP_USETITLE) )
2881 ppsp->pszTitle = NULL;
2882
2883 return (HPROPSHEETPAGE)ppsp;
2884 }
2885
2886 /******************************************************************************
2887 * DestroyPropertySheetPage (COMCTL32.@)
2888 *
2889 * Destroys a property sheet page previously created with
2890 * CreatePropertySheetA() or CreatePropertySheetW() and frees the associated
2891 * memory.
2892 *
2893 * RETURNS
2894 * Success: TRUE
2895 * Failure: FALSE
2896 */
2897 BOOL WINAPI DestroyPropertySheetPage(HPROPSHEETPAGE hPropPage)
2898 {
2899 PROPSHEETPAGEW *psp = (PROPSHEETPAGEW *)hPropPage;
2900
2901 if (!psp)
2902 return FALSE;
2903
2904 if ( !(psp->dwFlags & PSP_DLGINDIRECT) && HIWORD( psp->u.pszTemplate ) )
2905 HeapFree(GetProcessHeap(), 0, (LPVOID)psp->u.pszTemplate);
2906
2907 if ( (psp->dwFlags & PSP_USEICONID) && HIWORD( psp->u2.pszIcon ) )
2908 HeapFree(GetProcessHeap(), 0, (LPVOID)psp->u2.pszIcon);
2909
2910 if ((psp->dwFlags & PSP_USETITLE) && HIWORD( psp->pszTitle ))
2911 HeapFree(GetProcessHeap(), 0, (LPVOID)psp->pszTitle);
2912
2913 Free(hPropPage);
2914
2915 return TRUE;
2916 }
2917
2918 /******************************************************************************
2919 * PROPSHEET_IsDialogMessage
2920 */
2921 static BOOL PROPSHEET_IsDialogMessage(HWND hwnd, LPMSG lpMsg)
2922 {
2923 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd, PropSheetInfoStr);
2924
2925 TRACE("\n");
2926 if (!psInfo || (hwnd != lpMsg->hwnd && !IsChild(hwnd, lpMsg->hwnd)))
2927 return FALSE;
2928
2929 if (lpMsg->message == WM_KEYDOWN && (GetKeyState(VK_CONTROL) & 0x8000))
2930 {
2931 int new_page = 0;
2932 INT dlgCode = SendMessageA(lpMsg->hwnd, WM_GETDLGCODE, 0, (LPARAM)lpMsg);
2933
2934 if (!(dlgCode & DLGC_WANTMESSAGE))
2935 {
2936 switch (lpMsg->wParam)
2937 {
2938 case VK_TAB:
2939 if (GetKeyState(VK_SHIFT) & 0x8000)
2940 new_page = -1;
2941 else
2942 new_page = 1;
2943 break;
2944
2945 case VK_NEXT: new_page = 1; break;
2946 case VK_PRIOR: new_page = -1; break;
2947 }
2948 }
2949
2950 if (new_page)
2951 {
2952 if (PROPSHEET_CanSetCurSel(hwnd) != FALSE)
2953 {
2954 new_page += psInfo->active_page;
2955
2956 if (new_page < 0)
2957 new_page = psInfo->nPages - 1;
2958 else if (new_page >= psInfo->nPages)
2959 new_page = 0;
2960
2961 PROPSHEET_SetCurSel(hwnd, new_page, 1, 0);
2962 }
2963
2964 return TRUE;
2965 }
2966 }
2967
2968 return IsDialogMessageA(hwnd, lpMsg);
2969 }
2970
2971 /******************************************************************************
2972 * PROPSHEET_DoCommand
2973 */
2974 static BOOL PROPSHEET_DoCommand(HWND hwnd, WORD wID)
2975 {
2976
2977 switch (wID) {
2978
2979 case IDOK:
2980 case IDC_APPLY_BUTTON:
2981 {
2982 HWND hwndApplyBtn = GetDlgItem(hwnd, IDC_APPLY_BUTTON);
2983
2984 if (PROPSHEET_Apply(hwnd, wID == IDOK ? 1: 0) == FALSE)
2985 break;
2986
2987 if (wID == IDOK)
2988 {
2989 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd,
2990 PropSheetInfoStr);
2991 int result = TRUE;
2992
2993 if (psInfo->restartWindows)
2994 result = ID_PSRESTARTWINDOWS;
2995
2996 /* reboot system takes precedence over restart windows */
2997 if (psInfo->rebootSystem)
2998 result = ID_PSREBOOTSYSTEM;
2999
3000 if (psInfo->isModeless)
3001 psInfo->activeValid = FALSE;
3002 else
3003 EndDialog(hwnd, result);
3004 }
3005 else
3006 EnableWindow(hwndApplyBtn, FALSE);
3007
3008 break;
3009 }
3010
3011 case IDC_BACK_BUTTON:
3012 PROPSHEET_Back(hwnd);
3013 break;
3014
3015 case IDC_NEXT_BUTTON:
3016 PROPSHEET_Next(hwnd);
3017 break;
3018
3019 case IDC_FINISH_BUTTON:
3020 PROPSHEET_Finish(hwnd);
3021 break;
3022
3023 case IDCANCEL:
3024 PROPSHEET_Cancel(hwnd, 0);
3025 break;
3026
3027 case IDHELP:
3028 PROPSHEET_Help(hwnd);
3029 break;
3030
3031 default:
3032 return FALSE;
3033 }
3034
3035 return TRUE;
3036 }
3037
3038 /******************************************************************************
3039 * PROPSHEET_Paint
3040 */
3041 static LRESULT PROPSHEET_Paint(HWND hwnd)
3042 {
3043 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd, PropSheetInfoStr);
3044 PAINTSTRUCT ps;
3045 HDC hdc, hdcSrc;
3046 BITMAP bm;
3047 HBITMAP hbmp;
3048 HPALETTE hOldPal = 0;
3049 int offsety = 0;
3050 HBRUSH hbr;
3051 RECT r;
3052 LPCPROPSHEETPAGEW ppshpage;
3053 WCHAR szBuffer[256];
3054 int nLength;
3055
3056 hdc = BeginPaint(hwnd, &ps);
3057 if (!hdc) return 1;
3058
3059 hdcSrc = CreateCompatibleDC(0);
3060 ppshpage = (LPCPROPSHEETPAGEW)psInfo->proppage[psInfo->active_page].hpage;
3061
3062 if (psInfo->ppshheader.dwFlags & PSH_USEHPLWATERMARK)
3063 hOldPal = SelectPalette(hdc, psInfo->ppshheader.hplWatermark, FALSE);
3064
3065 if ( (!(ppshpage->dwFlags & PSP_HIDEHEADER)) &&
3066 (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW)) &&
3067 (psInfo->ppshheader.dwFlags & PSH_HEADER) )
3068 {
3069 RECT rzone;
3070 HWND hwndLineHeader = GetDlgItem(hwnd, IDC_SUNKEN_LINEHEADER);
3071 HFONT hOldFont;
3072 COLORREF clrOld = 0;
3073 int oldBkMode = 0;
3074
3075 hbmp = SelectObject(hdcSrc, psInfo->ppshheader.u5.hbmHeader);
3076 hOldFont = SelectObject(hdc, psInfo->hFontBold);
3077
3078 GetClientRect(hwndLineHeader, &r);
3079 MapWindowPoints(hwndLineHeader, hwnd, (LPPOINT) &r, 2);
3080 SetRect(&rzone, 0, 0, r.right + 1, r.top - 1);
3081
3082 GetObjectA(psInfo->ppshheader.u5.hbmHeader, sizeof(BITMAP), (LPVOID)&bm);
3083
3084 if (psInfo->ppshheader.dwFlags & PSH_WIZARD97_OLD)
3085 {
3086 /* Fill the unoccupied part of the header with color of the
3087 * left-top pixel, but do it only when needed.
3088 */
3089 if (bm.bmWidth < r.right || bm.bmHeight < r.bottom)
3090 {
3091 hbr = CreateSolidBrush(GetPixel(hdcSrc, 0, 0));
3092 CopyRect(&r, &rzone);
3093 if (bm.bmWidth < r.right)
3094 {
3095 r.left = bm.bmWidth;
3096 FillRect(hdc, &r, hbr);
3097 }
3098 if (bm.bmHeight < r.bottom)
3099 {
3100 r.left = 0;
3101 r.top = bm.bmHeight;
3102 FillRect(hdc, &r, hbr);
3103 }
3104 DeleteObject(hbr);
3105 }
3106
3107 /* Draw the header itself. */
3108 BitBlt(hdc, 0, 0,
3109 bm.bmWidth, min(bm.bmHeight, rzone.bottom),
3110 hdcSrc, 0, 0, SRCCOPY);
3111 }
3112 else
3113 {
3114 hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
3115 FillRect(hdc, &rzone, hbr);
3116 DeleteObject(hbr);
3117
3118 /* Draw the header bitmap. It's always centered like a
3119 * common 49 x 49 bitmap. */
3120 BitBlt(hdc, rzone.right - 49 - ((rzone.bottom - 49) / 2),
3121 (rzone.bottom - 49) / 2,
3122 bm.bmWidth, bm.bmHeight,
3123 hdcSrc, 0, 0, SRCCOPY);
3124
3125 /* NOTE: Native COMCTL32 draws a white stripe over the bitmap
3126 * if its height is smaller than 49 pixels. Because the reason
3127 * for this bug is unknown the current code doesn't try to
3128 * replicate it. */
3129 }
3130
3131 clrOld = SetTextColor (hdc, 0x00000000);
3132 oldBkMode = SetBkMode (hdc, TRANSPARENT);
3133
3134 if (ppshpage->dwFlags & PSP_USEHEADERTITLE) {
3135 SetRect(&r, 20, 10, 0, 0);
3136 if (HIWORD(ppshpage->pszHeaderTitle))
3137 {
3138 if (psInfo->unicode)
3139 DrawTextW(hdc, (LPWSTR)ppshpage->pszHeaderTitle,
3140 -1, &r, DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
3141 else
3142 DrawTextA(hdc, (LPCSTR)ppshpage->pszHeaderTitle,
3143 -1, &r, DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
3144 }
3145 else
3146 {
3147 nLength = LoadStringW(ppshpage->hInstance, (UINT)ppshpage->pszHeaderTitle,
3148 szBuffer, 256);
3149 if (nLength != 0)
3150 {
3151 DrawTextW(hdc, szBuffer, nLength,
3152 &r, DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
3153 }
3154 }
3155 }
3156
3157 if (ppshpage->dwFlags & PSP_USEHEADERSUBTITLE) {
3158 SelectObject(hdc, psInfo->hFont);
3159 SetRect(&r, 40, 25, 0, 0);
3160 if (HIWORD(ppshpage->pszHeaderTitle))
3161 {
3162 if (psInfo->unicode)
3163 DrawTextW(hdc, (LPWSTR)ppshpage->pszHeaderSubTitle,
3164 -1, &r, DT_LEFT | DT_SINGLELINE);
3165 else
3166 DrawTextA(hdc, (LPCSTR)ppshpage->pszHeaderSubTitle,
3167 -1, &r, DT_LEFT | DT_SINGLELINE);
3168 }
3169 else
3170 {
3171 nLength = LoadStringW(ppshpage->hInstance, (UINT)ppshpage->pszHeaderSubTitle,
3172 szBuffer, 256);
3173 if (nLength != 0)
3174 {
3175 DrawTextW(hdc, szBuffer, nLength,
3176 &r, DT_LEFT | DT_SINGLELINE | DT_NOCLIP);
3177 }
3178 }
3179 }
3180
3181 offsety = rzone.bottom + 2;
3182
3183 SetTextColor(hdc, clrOld);
3184 SetBkMode(hdc, oldBkMode);
3185 SelectObject(hdc, hOldFont);
3186 SelectObject(hdcSrc, hbmp);
3187 }
3188
3189 if ( (ppshpage->dwFlags & PSP_HIDEHEADER) &&
3190 (psInfo->ppshheader.dwFlags & (PSH_WIZARD97_OLD | PSH_WIZARD97_NEW)) &&
3191 (psInfo->ppshheader.dwFlags & PSH_WATERMARK) )
3192 {
3193 HWND hwndLine = GetDlgItem(hwnd, IDC_SUNKEN_LINE);
3194
3195 GetClientRect(hwndLine, &r);
3196 MapWindowPoints(hwndLine, hwnd, (LPPOINT) &r, 2);
3197
3198 GetObjectA(psInfo->ppshheader.u4.hbmWatermark, sizeof(BITMAP), (LPVOID)&bm);
3199 hbmp = SelectObject(hdcSrc, psInfo->ppshheader.u4.hbmWatermark);
3200
3201 BitBlt(hdc, 0, offsety, min(bm.bmWidth, r.right),
3202 min(bm.bmHeight, r.bottom), hdcSrc, 0, 0, SRCCOPY);
3203
3204 /* If the bitmap is not big enough, fill the remaining area
3205 with the color of pixel (0,0) of bitmap - see MSDN */
3206 if (r.top > bm.bmHeight) {
3207 r.bottom = r.top - 1;
3208 r.top = bm.bmHeight;
3209 r.left = 0;
3210 r.right = bm.bmWidth;
3211 hbr = CreateSolidBrush(GetPixel(hdcSrc, 0, 0));
3212 FillRect(hdc, &r, hbr);
3213 DeleteObject(hbr);
3214 }
3215
3216 SelectObject(hdcSrc, hbmp);
3217 }
3218
3219 if (psInfo->ppshheader.dwFlags & PSH_USEHPLWATERMARK)
3220 SelectPalette(hdc, hOldPal, FALSE);
3221
3222 DeleteDC(hdcSrc);
3223
3224 EndPaint(hwnd, &ps);
3225
3226 return 0;
3227 }
3228
3229 /******************************************************************************
3230 * PROPSHEET_DialogProc
3231 */
3232 INT_PTR CALLBACK
3233 PROPSHEET_DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
3234 {
3235 TRACE("hwnd=%p msg=0x%04x wparam=%x lparam=%lx\n",
3236 hwnd, uMsg, wParam, lParam);
3237
3238 switch (uMsg)
3239 {
3240 case WM_INITDIALOG:
3241 {
3242 PropSheetInfo* psInfo = (PropSheetInfo*) lParam;
3243 WCHAR* strCaption = (WCHAR*)Alloc(MAX_CAPTION_LENGTH*sizeof(WCHAR));
3244 HWND hwndTabCtrl = GetDlgItem(hwnd, IDC_TABCONTROL);
3245 LPCPROPSHEETPAGEW ppshpage;
3246 int idx;
3247 LOGFONTA logFont;
3248
3249 /* Using PropSheetInfoStr to store extra data doesn't match the native
3250 * common control: native uses TCM_[GS]ETITEM
3251 */
3252 SetPropW(hwnd, PropSheetInfoStr, (HANDLE)psInfo);
3253
3254 /*
3255 * psInfo->hwnd is not being used by WINE code - it exists
3256 * for compatibility with "real" Windoze. The same about
3257 * SetWindowLongPtr - WINE is only using the PropSheetInfoStr
3258 * property.
3259 */
3260 psInfo->hwnd = hwnd;
3261 SetWindowLongPtrW(hwnd, DWLP_USER, (DWORD_PTR)psInfo);
3262
3263 /* set up the Next and Back buttons by default */
3264 PROPSHEET_SetWizButtons(hwnd, PSWIZB_BACK|PSWIZB_NEXT);
3265
3266 /* Set up fonts */
3267 SystemParametersInfoA (SPI_GETICONTITLELOGFONT, 0, &logFont, 0);
3268 psInfo->hFont = CreateFontIndirectA (&logFont);
3269 logFont.lfWeight = FW_BOLD;
3270 psInfo->hFontBold = CreateFontIndirectA (&logFont);
3271
3272 /*
3273 * Small icon in the title bar.
3274 */
3275 if ((psInfo->ppshheader.dwFlags & PSH_USEICONID) ||
3276 (psInfo->ppshheader.dwFlags & PSH_USEHICON))
3277 {
3278 HICON hIcon;
3279 int icon_cx = GetSystemMetrics(SM_CXSMICON);
3280 int icon_cy = GetSystemMetrics(SM_CYSMICON);
3281
3282 if (psInfo->ppshheader.dwFlags & PSH_USEICONID)
3283 hIcon = LoadImageW(psInfo->ppshheader.hInstance,
3284 psInfo->ppshheader.u.pszIcon,
3285 IMAGE_ICON,
3286 icon_cx, icon_cy,
3287 LR_DEFAULTCOLOR);
3288 else
3289 hIcon = psInfo->ppshheader.u.hIcon;
3290
3291 SendMessageW(hwnd, WM_SETICON, 0, (LPARAM)hIcon);
3292 }
3293
3294 if (psInfo->ppshheader.dwFlags & PSH_USEHICON)
3295 SendMessageW(hwnd, WM_SETICON, 0, (LPARAM)psInfo->ppshheader.u.hIcon);
3296
3297 psInfo->strPropertiesFor = strCaption;
3298
3299 GetWindowTextW(hwnd, psInfo->strPropertiesFor, MAX_CAPTION_LENGTH);
3300
3301 PROPSHEET_CreateTabControl(hwnd, psInfo);
3302
3303 PROPSHEET_LoadWizardBitmaps(psInfo);
3304
3305 if (psInfo->ppshheader.dwFlags & INTRNL_ANY_WIZARD)
3306 {
3307 ShowWindow(hwndTabCtrl, SW_HIDE);
3308 if (PROPSHEET_IsTooSmallWizard(hwnd, psInfo))
3309 {
3310 PROPSHEET_AdjustSizeWizard(hwnd, psInfo);
3311 PROPSHEET_AdjustButtonsWizard(hwnd, psInfo);
3312 }
3313 }
3314 else
3315 {
3316 if (PROPSHEET_SizeMismatch(hwnd, psInfo))
3317 {
3318 PROPSHEET_AdjustSize(hwnd, psInfo);
3319 PROPSHEET_AdjustButtons(hwnd, psInfo);
3320 }
3321 }
3322
3323 if (psInfo->useCallback)
3324 (*(psInfo->ppshheader.pfnCallback))(hwnd,
3325 PSCB_INITIALIZED, (LPARAM)0);
3326
3327 idx = psInfo->active_page;
3328 ppshpage = (LPCPROPSHEETPAGEW)psInfo->proppage[idx].hpage;
3329 psInfo->active_page = -1;
3330
3331 PROPSHEET_SetCurSel(hwnd, idx, 1, psInfo->proppage[idx].hpage);
3332
3333 /* doing TCM_SETCURSEL seems to be needed even in case of PSH_WIZARD,
3334 * as some programs call TCM_GETCURSEL to get the current selection
3335 * from which to switch to the next page */
3336 SendMessageW(hwndTabCtrl, TCM_SETCURSEL, psInfo->active_page, 0);
3337
3338 if (!HIWORD(psInfo->ppshheader.pszCaption) &&
3339 psInfo->ppshheader.hInstance)
3340 {
3341 WCHAR szText[256];
3342
3343 if (LoadStringW(psInfo->ppshheader.hInstance,
3344 (UINT)psInfo->ppshheader.pszCaption, szText, 255))
3345 PROPSHEET_SetTitleW(hwnd, psInfo->ppshheader.dwFlags, szText);
3346 }
3347 else
3348 {
3349 PROPSHEET_SetTitleW(hwnd, psInfo->ppshheader.dwFlags,
3350 psInfo->ppshheader.pszCaption);
3351 }
3352
3353 return TRUE;
3354 }
3355
3356 case WM_PAINT:
3357 PROPSHEET_Paint(hwnd);
3358 return TRUE;
3359
3360 case WM_DESTROY:
3361 PROPSHEET_CleanUp(hwnd);
3362 return TRUE;
3363
3364 case WM_CLOSE:
3365 PROPSHEET_Cancel(hwnd, 1);
3366 return TRUE;
3367
3368 case WM_COMMAND:
3369 if (!PROPSHEET_DoCommand(hwnd, LOWORD(wParam)))
3370 {
3371 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd, PropSheetInfoStr);
3372
3373 /* No default handler, forward notification to active page */
3374 if (psInfo->activeValid && psInfo->active_page != -1)
3375 {
3376 HWND hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
3377 SendMessageW(hwndPage, WM_COMMAND, wParam, lParam);
3378 }
3379 }
3380 return TRUE;
3381
3382 case WM_NOTIFY:
3383 {
3384 NMHDR* pnmh = (LPNMHDR) lParam;
3385
3386 if (pnmh->code == TCN_SELCHANGE)
3387 {
3388 int index = SendMessageW(pnmh->hwndFrom, TCM_GETCURSEL, 0, 0);
3389 PROPSHEET_SetCurSel(hwnd, index, 1, 0);
3390 }
3391
3392 if(pnmh->code == TCN_SELCHANGING)
3393 {
3394 BOOL bRet = PROPSHEET_CanSetCurSel(hwnd);
3395 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, !bRet);
3396 return TRUE;
3397 }
3398
3399 return FALSE;
3400 }
3401
3402 case PSM_GETCURRENTPAGEHWND:
3403 {
3404 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd,
3405 PropSheetInfoStr);
3406 HWND hwndPage = 0;
3407
3408 if (psInfo->activeValid && psInfo->active_page != -1)
3409 hwndPage = psInfo->proppage[psInfo->active_page].hwndPage;
3410
3411 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (DWORD_PTR)hwndPage);
3412
3413 return TRUE;
3414 }
3415
3416 case PSM_CHANGED:
3417 PROPSHEET_Changed(hwnd, (HWND)wParam);
3418 return TRUE;
3419
3420 case PSM_UNCHANGED:
3421 PROPSHEET_UnChanged(hwnd, (HWND)wParam);
3422 return TRUE;
3423
3424 case PSM_GETTABCONTROL:
3425 {
3426 HWND hwndTabCtrl = GetDlgItem(hwnd, IDC_TABCONTROL);
3427
3428 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, (DWORD_PTR)hwndTabCtrl);
3429
3430 return TRUE;
3431 }
3432
3433 case PSM_SETCURSEL:
3434 {
3435 BOOL msgResult;
3436
3437 msgResult = PROPSHEET_CanSetCurSel(hwnd);
3438 if(msgResult != FALSE)
3439 {
3440 msgResult = PROPSHEET_SetCurSel(hwnd,
3441 (int)wParam,
3442 1,
3443 (HPROPSHEETPAGE)lParam);
3444 }
3445
3446 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3447
3448 return TRUE;
3449 }
3450
3451 case PSM_CANCELTOCLOSE:
3452 {
3453 WCHAR buf[MAX_BUTTONTEXT_LENGTH];
3454 HWND hwndOK = GetDlgItem(hwnd, IDOK);
3455 HWND hwndCancel = GetDlgItem(hwnd, IDCANCEL);
3456
3457 EnableWindow(hwndCancel, FALSE);
3458 if (LoadStringW(COMCTL32_hModule, IDS_CLOSE, buf, sizeof(buf)))
3459 SetWindowTextW(hwndOK, buf);
3460
3461 return FALSE;
3462 }
3463
3464 case PSM_RESTARTWINDOWS:
3465 {
3466 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd,
3467 PropSheetInfoStr);
3468
3469 psInfo->restartWindows = TRUE;
3470 return TRUE;
3471 }
3472
3473 case PSM_REBOOTSYSTEM:
3474 {
3475 PropSheetInfo* psInfo = (PropSheetInfo*) GetPropW(hwnd,
3476 PropSheetInfoStr);
3477
3478 psInfo->rebootSystem = TRUE;
3479 return TRUE;
3480 }
3481
3482 case PSM_SETTITLEA:
3483 PROPSHEET_SetTitleA(hwnd, (DWORD) wParam, (LPCSTR) lParam);
3484 return TRUE;
3485
3486 case PSM_SETTITLEW:
3487 PROPSHEET_SetTitleW(hwnd, (DWORD) wParam, (LPCWSTR) lParam);
3488 return TRUE;
3489
3490 case PSM_APPLY:
3491 {
3492 BOOL msgResult = PROPSHEET_Apply(hwnd, 0);
3493
3494 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3495
3496 return TRUE;
3497 }
3498
3499 case PSM_QUERYSIBLINGS:
3500 {
3501 LRESULT msgResult = PROPSHEET_QuerySiblings(hwnd, wParam, lParam);
3502
3503 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3504
3505 return TRUE;
3506 }
3507
3508 case PSM_ADDPAGE:
3509 {
3510 /*
3511 * Note: MSVC++ 6.0 documentation says that PSM_ADDPAGE does not have
3512 * a return value. This is not true. PSM_ADDPAGE returns TRUE
3513 * on success or FALSE otherwise, as specified on MSDN Online.
3514 * Also see the MFC code for
3515 * CPropertySheet::AddPage(CPropertyPage* pPage).
3516 */
3517
3518 BOOL msgResult = PROPSHEET_AddPage(hwnd, (HPROPSHEETPAGE)lParam);
3519
3520 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3521
3522 return TRUE;
3523 }
3524
3525 case PSM_REMOVEPAGE:
3526 PROPSHEET_RemovePage(hwnd, (int)wParam, (HPROPSHEETPAGE)lParam);
3527 return TRUE;
3528
3529 case PSM_ISDIALOGMESSAGE:
3530 {
3531 BOOL msgResult = PROPSHEET_IsDialogMessage(hwnd, (LPMSG)lParam);
3532 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3533 return TRUE;
3534 }
3535
3536 case PSM_PRESSBUTTON:
3537 PROPSHEET_PressButton(hwnd, (int)wParam);
3538 return TRUE;
3539
3540 case PSM_SETFINISHTEXTA:
3541 PROPSHEET_SetFinishTextA(hwnd, (LPCSTR) lParam);
3542 return TRUE;
3543
3544 case PSM_SETWIZBUTTONS:
3545 PROPSHEET_SetWizButtons(hwnd, (DWORD)lParam);
3546 return TRUE;
3547
3548 case PSM_SETCURSELID:
3549 PROPSHEET_SetCurSelId(hwnd, (int)lParam);
3550 return TRUE;
3551
3552 case PSM_SETFINISHTEXTW:
3553 PROPSHEET_SetFinishTextW(hwnd, (LPCWSTR) lParam);
3554 return FALSE;
3555
3556 case PSM_INSERTPAGE:
3557 {
3558 BOOL msgResult = PROPSHEET_InsertPage(hwnd, (HPROPSHEETPAGE)wParam, (HPROPSHEETPAGE)lParam);
3559 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3560 return TRUE;
3561 }
3562
3563 case PSM_SETHEADERTITLEW:
3564 PROPSHEET_SetHeaderTitleW(hwnd, (int)wParam, (LPCWSTR)lParam);
3565 return TRUE;
3566
3567 case PSM_SETHEADERTITLEA:
3568 PROPSHEET_SetHeaderTitleA(hwnd, (int)wParam, (LPCSTR)lParam);
3569 return TRUE;
3570
3571 case PSM_SETHEADERSUBTITLEW:
3572 PROPSHEET_SetHeaderSubTitleW(hwnd, (int)wParam, (LPCWSTR)lParam);
3573 return TRUE;
3574
3575 case PSM_SETHEADERSUBTITLEA:
3576 PROPSHEET_SetHeaderSubTitleA(hwnd, (int)wParam, (LPCSTR)lParam);
3577 return TRUE;
3578
3579 case PSM_HWNDTOINDEX:
3580 {
3581 LRESULT msgResult = PROPSHEET_HwndToIndex(hwnd, (HWND)wParam);
3582 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3583 return TRUE;
3584 }
3585
3586 case PSM_INDEXTOHWND:
3587 {
3588 LRESULT msgResult = PROPSHEET_IndexToHwnd(hwnd, (int)wParam);
3589 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3590 return TRUE;
3591 }
3592
3593 case PSM_PAGETOINDEX:
3594 {
3595 LRESULT msgResult = PROPSHEET_PageToIndex(hwnd, (HPROPSHEETPAGE)wParam);
3596 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3597 return TRUE;
3598 }
3599
3600 case PSM_INDEXTOPAGE:
3601 {
3602 LRESULT msgResult = PROPSHEET_IndexToPage(hwnd, (int)wParam);
3603 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3604 return TRUE;
3605 }
3606
3607 case PSM_IDTOINDEX:
3608 {
3609 LRESULT msgResult = PROPSHEET_IdToIndex(hwnd, (int)lParam);
3610 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3611 return TRUE;
3612 }
3613
3614 case PSM_INDEXTOID:
3615 {
3616 LRESULT msgResult = PROPSHEET_IndexToId(hwnd, (int)wParam);
3617 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3618 return TRUE;
3619 }
3620
3621 case PSM_GETRESULT:
3622 {
3623 LRESULT msgResult = PROPSHEET_GetResult(hwnd);
3624 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3625 return TRUE;
3626 }
3627
3628 case PSM_RECALCPAGESIZES:
3629 {
3630 LRESULT msgResult = PROPSHEET_RecalcPageSizes(hwnd);
3631 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, msgResult);
3632 return TRUE;
3633 }
3634
3635 default:
3636 return FALSE;
3637 }
3638
3639 return FALSE;
3640 }
Maarten's multimedia branch