source: trunk/src/comctl32/propsheet.c@ 9425

Last change on this file since 9425 was 9425, checked in by sandervl, 23 years ago

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