git.oblomov.eu Git - wine/blob - dlls/comctl32/propsheet.c

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