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