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