5503 lines
180 KiB
C
5503 lines
180 KiB
C
#include "ctlspriv.h"
|
|
#include "help.h" // Help IDs
|
|
#include "prshti.h"
|
|
|
|
#include "dlgcvt.h"
|
|
|
|
#ifdef WX86
|
|
#include <wx86ofl.h>
|
|
#endif
|
|
|
|
#define FLAG_CHANGED 0x0001
|
|
#define DEFAULTHEADERHEIGHT 58 // in pixels
|
|
#define DEFAULTTEXTDIVIDERGAP 5
|
|
#define DEFAULTCTRLWIDTH 501 // page list window in new wizard style
|
|
#define DEFAULTCTRLHEIGHT 253 // page list window in new wizard style
|
|
#define TITLEX 22
|
|
#define TITLEY 10
|
|
#define SUBTITLEX 44
|
|
#define SUBTITLEY 25
|
|
|
|
// fixed sizes for the bitmap painted in the header section
|
|
#define HEADERBITMAP_Y 5
|
|
#define HEADERBITMAP_WIDTH 49
|
|
#define HEADERBITMAP_CXBACK (5 + HEADERBITMAP_WIDTH)
|
|
#define HEADERBITMAP_HEIGHT 49
|
|
#define HEADERSUBTITLE_WRAPOFFSET 10
|
|
|
|
// Fixed sizes for the watermark bitmap (Wizard97IE5 style)
|
|
#define BITMAP_WIDTH 164
|
|
#define BITMAP_HEIGHT 312
|
|
|
|
#define DRAWTEXT_WIZARD97FLAGS (DT_LEFT | DT_WORDBREAK | DT_NOPREFIX | DT_EDITCONTROL)
|
|
|
|
LPVOID WINAPI MapSLFix(HANDLE);
|
|
VOID WINAPI UnMapSLFixArray(int, HANDLE *);
|
|
|
|
LRESULT CALLBACK WizardWndProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam, UINT_PTR uID, ULONG_PTR dwRefData);
|
|
|
|
#if !defined(WIN32)
|
|
#ifdef FE_IME
|
|
typedef void *PVOID;
|
|
DWORD WINAPI GetCurrentThreadID(VOID);
|
|
DWORD WINAPI GetCurrentProcessID(VOID);
|
|
PVOID WINAPI ImmFindThreadLink(DWORD dwThreadID);
|
|
BOOL WINAPI ImmCreateThreadLink(DWORD dwPid, DWORD dwTid);
|
|
#endif
|
|
#endif
|
|
|
|
void ResetWizButtons(LPPROPDATA ppd);
|
|
|
|
typedef struct // tie
|
|
{
|
|
TC_ITEMHEADER tci;
|
|
HWND hwndPage;
|
|
UINT state;
|
|
} TC_ITEMEXTRA;
|
|
|
|
#define CB_ITEMEXTRA (sizeof(TC_ITEMEXTRA) - sizeof(TC_ITEMHEADER))
|
|
#define IS_WIZARDPSH(psh) ((psh).dwFlags & (PSH_WIZARD | PSH_WIZARD97 | PSH_WIZARD_LITE))
|
|
#define IS_WIZARD(ppd) IS_WIZARDPSH(ppd->psh)
|
|
|
|
void PageChange(LPPROPDATA ppd, int iAutoAdj);
|
|
void RemovePropPageData(LPPROPDATA ppd, int nPage);
|
|
HRESULT GetPageLanguage(PISP pisp, WORD *pwLang);
|
|
UINT GetDefaultCharsetFromLang(LANGID wLang);
|
|
LANGID NT5_GetUserDefaultUILanguage(void);
|
|
|
|
//
|
|
// IMPORTANT: The IDHELP ID should always be LAST since we just subtract
|
|
// 1 from the number of IDs if no help in the page.
|
|
// IDD_APPLYNOW should always be the FIRST ID for standard IDs since it
|
|
// is sometimes not displayed and we'll start with index 1.
|
|
//
|
|
const static int IDs[] = {IDOK, IDCANCEL, IDD_APPLYNOW, IDHELP};
|
|
const static int WizIDs[] = {IDD_BACK, IDD_NEXT, IDD_FINISH, IDCANCEL, IDHELP};
|
|
const static WORD wIgnoreIDs[] = {IDD_PAGELIST, IDD_DIVIDER, IDD_TOPDIVIDER};
|
|
|
|
// Prsht_PrepareTemplate action matrix. Please do not change without contacting [msadek]...
|
|
|
|
const PSPT_ACTION g_PSPT_Action [PSPT_TYPE_MAX][PSPT_OS_MAX][PSPT_OVERRIDE_MAX]={
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_MIRRORED, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_MIRRORED, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_WIN9XCOMPAT, // PSPT_TYPE_MIRRORED, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_WIN9XCOMPAT, // PSPT_TYPE_MIRRORED, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_MIRRORED, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_MIRRORED, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_MIRRORED, PSPT_OS_WINNT5, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_MIRRORED, PSPT_OS_WINNT5, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_MIRRORED, PSPT_OS_OTHER, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOMIRRORING, // PSPT_TYPE_MIRRORED, PSPT_OS_OTHER, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENABLED, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENABLED, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WINNT5, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENABLED, PSPT_OS_WINNT5, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENABLED, PSPT_OS_OTHER, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOMIRRORING, // PSPT_TYPE_ENABLED, PSPT_OS_OTHER, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENGLISH, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENGLISH, PSPT_OS_WIN95_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_LOADENGLISH, // PSPT_TYPE_ENGLISH, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENGLISH, PSPT_OS_WIN98_BIDI, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENGLISH, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENGLISH, PSPT_OS_WINNT4_ENA, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_LOADENGLISH, // PSPT_TYPE_ENGLISH, PSPT_OS_WINNT5, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_FLIP, // PSPT_TYPE_ENGLISH, PSPT_OS_WINNT5, PSPT_OVERRIDE_USEPAGELANG
|
|
PSPT_ACTION_NOACTION, // PSPT_TYPE_ENGLISH, PSPT_OS_OTHER, PSPT_OVERRIDE_NOOVERRIDE
|
|
PSPT_ACTION_NOMIRRORING, // PSPT_TYPE_ENGLISH, PSPT_OS_OTHER, PSPT_OVERRIDE_USEPAGELANG
|
|
};
|
|
|
|
// HACK FOR HIJAAK 95!
|
|
//
|
|
// Instead of creating
|
|
// property sheet pages with CreatePropertySheetPage, they merely
|
|
// take a pointer to a PROPSHEETPAGE structure and cast it to
|
|
// HPROPSHEETPAGE. They got away with this on Win95 because Win95's
|
|
// HPROPSHEETPAGE actually was 95% identical to a PROPSHEETPAGE.
|
|
// (The missing 5% causes RIPs at property sheet destruction, which
|
|
// Hijaak no doubt ignored.)
|
|
//
|
|
// On NT and IE5, this coincidence is not true.
|
|
//
|
|
// So validate that what we have is really a property sheet
|
|
// structure by checking if it's on the heap at the
|
|
// right place. If not, then make one.
|
|
//
|
|
|
|
HPROPSHEETPAGE WINAPI _Hijaak95Hack(LPPROPDATA ppd, HPROPSHEETPAGE hpage)
|
|
{
|
|
if (hpage && !LocalSize(PropSheetBase(hpage))) {
|
|
// SLACKERS! Have to call CreatePropertySheetPage for them
|
|
RIPMSG(0, "App passed HPROPSHEETPAGE not created by us; trying to cope");
|
|
hpage = _CreatePropertySheetPage((LPCPROPSHEETPAGE)hpage,
|
|
ppd->fFlags & PD_NEEDSHADOW,
|
|
ppd->fFlags & PD_WX86);
|
|
}
|
|
return hpage;
|
|
}
|
|
|
|
void _SetTitle(HWND hDlg, LPPROPDATA ppd)
|
|
{
|
|
TCHAR szFormat[50];
|
|
TCHAR szTitle[128];
|
|
TCHAR szTemp[128 + 50];
|
|
LPCTSTR pCaption = ppd->psh.pszCaption;
|
|
|
|
if (IS_INTRESOURCE(pCaption)) {
|
|
LoadString(ppd->psh.hInstance, (UINT)LOWORD(pCaption), szTitle, ARRAYSIZE(szTitle));
|
|
pCaption = (LPCTSTR)szTitle;
|
|
}
|
|
|
|
if (ppd->psh.dwFlags & PSH_PROPTITLE) {
|
|
if (*pCaption == 0)
|
|
{
|
|
// Hey, no title, we need a different resource for localization
|
|
LocalizedLoadString(IDS_PROPERTIES, szTemp, ARRAYSIZE(szTemp));
|
|
pCaption = szTemp;
|
|
}
|
|
else
|
|
{
|
|
LocalizedLoadString(IDS_PROPERTIESFOR, szFormat, ARRAYSIZE(szFormat));
|
|
if ((lstrlen(pCaption) + 1 + lstrlen(szFormat) + 1) < ARRAYSIZE(szTemp)) {
|
|
wsprintf(szTemp, szFormat, pCaption);
|
|
pCaption = szTemp;
|
|
}
|
|
}
|
|
}
|
|
#ifdef WINDOWS_ME
|
|
if(ppd->psh.dwFlags & PSH_RTLREADING) {
|
|
SetWindowLong(hDlg, GWL_EXSTYLE, GetWindowLong(hDlg, GWL_EXSTYLE) | WS_EX_RTLREADING);
|
|
}
|
|
#endif // WINDOWS_ME
|
|
SetWindowText(hDlg, pCaption);
|
|
}
|
|
|
|
BOOL _SetHeaderFonts(HWND hDlg, LPPROPDATA ppd)
|
|
{
|
|
HFONT hFont;
|
|
LOGFONT LogFont;
|
|
|
|
GetObject(GetWindowFont(hDlg), sizeof(LogFont), &LogFont);
|
|
|
|
CCAdjustForBold(&LogFont);
|
|
if ((hFont = CreateFontIndirect(&LogFont)) == NULL)
|
|
{
|
|
ppd->hFontBold = NULL;
|
|
return FALSE;
|
|
}
|
|
ppd->hFontBold = hFont;
|
|
// Save the font as a window prop so we can delete it later
|
|
return TRUE;
|
|
}
|
|
|
|
int _WriteHeaderTitle(LPPROPDATA ppd, HDC hdc, LPRECT prc, LPCTSTR pszTitle, BOOL bTitle, DWORD dwDrawFlags)
|
|
{
|
|
LPCTSTR pszOut;
|
|
int cch;
|
|
int cx, cy;
|
|
TCHAR szTitle[MAX_PATH*4];
|
|
HFONT hFontOld = NULL;
|
|
HFONT hFont;
|
|
int yDrawHeight = 0;
|
|
|
|
if (IS_INTRESOURCE(pszTitle))
|
|
{
|
|
LoadString(GETPPSP(ppd, ppd->nCurItem)->hInstance, (UINT)LOWORD(pszTitle), szTitle, ARRAYSIZE(szTitle));
|
|
pszOut = szTitle;
|
|
}
|
|
else
|
|
pszOut = pszTitle;
|
|
|
|
cch = lstrlen(pszOut);
|
|
|
|
if (bTitle && ppd->hFontBold)
|
|
hFont = ppd->hFontBold;
|
|
else
|
|
hFont = GetWindowFont(ppd->hDlg);
|
|
|
|
hFontOld = SelectObject(hdc, hFont);
|
|
|
|
if (bTitle)
|
|
{
|
|
cx = TITLEX;
|
|
cy = TITLEY;
|
|
ExtTextOut(hdc, cx, cy, 0, prc, pszOut, cch, NULL);
|
|
}
|
|
else
|
|
{
|
|
RECT rcWrap;
|
|
CopyRect(&rcWrap, prc);
|
|
|
|
rcWrap.left = SUBTITLEX;
|
|
rcWrap.top = ppd->ySubTitle;
|
|
yDrawHeight = DrawText(hdc, pszOut, cch, &rcWrap, dwDrawFlags);
|
|
}
|
|
|
|
if (hFontOld)
|
|
SelectObject(hdc, hFontOld);
|
|
|
|
return yDrawHeight;
|
|
}
|
|
|
|
// In Wizard97 only:
|
|
// The subtitles user passed in could be larger than the two line spaces we give
|
|
// them, especially in localization cases. So here we go through all subtitles and
|
|
// compute the max space they need and set the header height so that no text is clipped
|
|
int _ComputeHeaderHeight(LPPROPDATA ppd, int dxMax)
|
|
{
|
|
int dyHeaderHeight;
|
|
int dyTextDividerGap;
|
|
HDC hdc;
|
|
dyHeaderHeight = DEFAULTHEADERHEIGHT;
|
|
hdc = GetDC(ppd->hDlg);
|
|
|
|
// First, let's get the correct text height and spacing, this can be used
|
|
// as the title height and the between-lastline-and-divider spacing.
|
|
{
|
|
HFONT hFont, hFontOld;
|
|
TEXTMETRIC tm;
|
|
if (ppd->hFontBold)
|
|
hFont = ppd->hFontBold;
|
|
else
|
|
hFont = GetWindowFont(ppd->hDlg);
|
|
|
|
hFontOld = SelectObject(hdc, hFont);
|
|
if (GetTextMetrics(hdc, &tm))
|
|
{
|
|
dyTextDividerGap = tm.tmExternalLeading;
|
|
ppd->ySubTitle = max ((tm.tmHeight + tm.tmExternalLeading + TITLEY), SUBTITLEY);
|
|
}
|
|
else
|
|
{
|
|
dyTextDividerGap = DEFAULTTEXTDIVIDERGAP;
|
|
ppd->ySubTitle = SUBTITLEY;
|
|
}
|
|
|
|
if (hFontOld)
|
|
SelectObject(hdc, hFontOld);
|
|
}
|
|
|
|
// Second, get the subtitle text block height
|
|
// should make into a function if shared
|
|
{
|
|
RECT rcWrap;
|
|
UINT uPages;
|
|
|
|
//
|
|
// WIZARD97IE5 subtracts out the space used by the header bitmap.
|
|
// WIZARD97IE4 uses the full width since the header bitmap
|
|
// in IE4 is a watermark and occupies no space.
|
|
//
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
rcWrap.right = dxMax;
|
|
else
|
|
rcWrap.right = dxMax - HEADERBITMAP_CXBACK - HEADERSUBTITLE_WRAPOFFSET;
|
|
for (uPages = 0; uPages < ppd->psh.nPages; uPages++)
|
|
{
|
|
PROPSHEETPAGE *ppsp = GETPPSP(ppd, uPages);
|
|
if (!(ppsp->dwFlags & PSP_HIDEHEADER) &&
|
|
(ppsp->dwFlags & PSP_USEHEADERSUBTITLE))
|
|
{
|
|
int iSubHeaderHeight = _WriteHeaderTitle(ppd, hdc, &rcWrap, ppsp->pszHeaderSubTitle,
|
|
FALSE, DT_CALCRECT | DRAWTEXT_WIZARD97FLAGS);
|
|
if ((iSubHeaderHeight + ppd->ySubTitle) > dyHeaderHeight)
|
|
dyHeaderHeight = iSubHeaderHeight + ppd->ySubTitle;
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the header height has been recomputed, set the correct gap between
|
|
// the text and the divider.
|
|
if (dyHeaderHeight != DEFAULTHEADERHEIGHT)
|
|
{
|
|
ASSERT(dyHeaderHeight > DEFAULTHEADERHEIGHT);
|
|
dyHeaderHeight += dyTextDividerGap;
|
|
}
|
|
|
|
ReleaseDC(ppd->hDlg, hdc);
|
|
return dyHeaderHeight;
|
|
}
|
|
|
|
void MoveAllButtons(HWND hDlg, const int *pids, int idLast, int dx, int dy)
|
|
{
|
|
do {
|
|
HWND hCtrl;
|
|
RECT rcCtrl;
|
|
|
|
int iCtrl = *pids;
|
|
hCtrl = GetDlgItem(hDlg, iCtrl);
|
|
GetWindowRect(hCtrl, &rcCtrl);
|
|
|
|
//
|
|
// If the dialog wizard window is mirrored, then rcl.right
|
|
// in terms of screen coord is the near edge (lead). [samera]
|
|
//
|
|
if (IS_WINDOW_RTL_MIRRORED(hDlg))
|
|
rcCtrl.left = rcCtrl.right;
|
|
|
|
ScreenToClient(hDlg, (LPPOINT)&rcCtrl);
|
|
SetWindowPos(hCtrl, NULL, rcCtrl.left + dx,
|
|
rcCtrl.top + dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
} while(*(pids++) != idLast);
|
|
}
|
|
|
|
void RemoveButton(HWND hDlg, int idRemove, const int *pids)
|
|
{
|
|
int idPrev = 0;
|
|
HWND hRemove = NULL;
|
|
HWND hPrev;
|
|
RECT rcRemove, rcPrev;
|
|
int iWidth = 0;
|
|
const int *pidRemove;
|
|
|
|
// get the previous id
|
|
for (pidRemove = pids; *pidRemove != idRemove; pidRemove++)
|
|
idPrev = *pidRemove;
|
|
|
|
|
|
if (idPrev) {
|
|
hRemove = GetDlgItem(hDlg, idRemove);
|
|
hPrev = GetDlgItem(hDlg, idPrev);
|
|
GetWindowRect(hRemove, &rcRemove);
|
|
GetWindowRect(hPrev, &rcPrev);
|
|
|
|
//
|
|
// If the dialog window is mirrored, then the prev button
|
|
// will be ahead (to the right) of the button-to-be-removed.
|
|
// As a result, the subtraction will be definitely negative,
|
|
// so let's convert it to be positive. [samera]
|
|
//
|
|
if (IS_WINDOW_RTL_MIRRORED(hDlg))
|
|
iWidth = rcPrev.right - rcRemove.right;
|
|
else
|
|
iWidth = rcRemove.right - rcPrev.right;
|
|
}
|
|
|
|
MoveAllButtons(hDlg, pids, idRemove, iWidth, 0);
|
|
|
|
if (hRemove)
|
|
ShowWindow(hRemove, SW_HIDE);
|
|
|
|
// Cannot disable the window; see Prsht_ButtonSubclassProc for explanation.
|
|
// WRONG - EnableWindow(hRemove, FALSE);
|
|
}
|
|
|
|
typedef struct LOGPALETTE256 {
|
|
WORD palVersion;
|
|
WORD palNumEntries;
|
|
union {
|
|
PALETTEENTRY rgpal[256];
|
|
RGBQUAD rgq[256];
|
|
} u;
|
|
} LOGPALETTE256;
|
|
|
|
HPALETTE PaletteFromBmp(HBITMAP hbm)
|
|
{
|
|
LOGPALETTE256 pal;
|
|
int i,n;
|
|
HDC hdc;
|
|
HPALETTE hpl;
|
|
|
|
hdc = CreateCompatibleDC(NULL);
|
|
SelectObject(hdc, hbm);
|
|
n = GetDIBColorTable(hdc, 0, 256, pal.u.rgq);
|
|
|
|
if (n) // DIB section with color table
|
|
{
|
|
// Palettes are such a hassle. GetDIBColorTable returns RGBQUADs, whereas
|
|
// LOGPALETTE wants PALETTEENTRYss, and the two are reverse-endian
|
|
// of each other.
|
|
for (i= 0 ; i < n; i++)
|
|
{
|
|
PALETTEENTRY pe;
|
|
pe.peRed = pal.u.rgq[i].rgbRed;
|
|
pe.peGreen = pal.u.rgq[i].rgbGreen;
|
|
pe.peBlue = pal.u.rgq[i].rgbBlue;
|
|
pe.peFlags = 0;
|
|
pal.u.rgpal[i] = pe;
|
|
}
|
|
|
|
pal.palVersion = 0x0300;
|
|
pal.palNumEntries = (WORD)n;
|
|
|
|
hpl = CreatePalette((LPLOGPALETTE)&pal);
|
|
}
|
|
else // Not a DIB section or no color table
|
|
{
|
|
hpl = CreateHalftonePalette(hdc);
|
|
}
|
|
|
|
DeleteDC(hdc);
|
|
return hpl;
|
|
}
|
|
|
|
// -------------- stolen from user code -------------------------------------
|
|
//
|
|
// GetCharDimensions(hDC, psiz)
|
|
//
|
|
// This function loads the Textmetrics of the font currently selected into
|
|
// the given hDC and saves the height and Average char width of the font
|
|
// (NOTE: the
|
|
// AveCharWidth value returned by the text metrics call is wrong for
|
|
// proportional fonts -- so, we compute them).
|
|
//
|
|
// -------------- stolen from user code --------------------------------------
|
|
TCHAR AveCharWidthData[52+1] = TEXT("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
|
|
void GetCharDimensions(HDC hDC, SIZE *psiz)
|
|
{
|
|
TEXTMETRIC tm;
|
|
|
|
// Store the System Font metrics info.
|
|
GetTextMetrics(hDC, &tm);
|
|
|
|
if (!(tm.tmPitchAndFamily & TMPF_FIXED_PITCH)) // the name is opposite:)
|
|
psiz->cx = tm.tmAveCharWidth;
|
|
else
|
|
{
|
|
// Change from tmAveCharWidth. We will calculate a true average as
|
|
// opposed to the one returned by tmAveCharWidth. This works better
|
|
// when dealing with proportional spaced fonts. -- ROUND UP
|
|
if (GetTextExtentPoint32(hDC, AveCharWidthData, 52, psiz) == TRUE)
|
|
{
|
|
psiz->cx = ((psiz->cx / 26) + 1) / 2;
|
|
}
|
|
else
|
|
psiz->cx = tm.tmAveCharWidth;
|
|
}
|
|
|
|
psiz->cy = tm.tmHeight;
|
|
}
|
|
|
|
//
|
|
// It is a feature that USER considers keyboard accelerators live even if
|
|
// the control is hidden. This lets you put a hidden static in front of
|
|
// a custom control to get an accelerator attached to the custom control.
|
|
//
|
|
// Unfortunately, it means that the &F accelerator for "Finish" activates
|
|
// the Finish button even when the Finish button is hidden. The normal
|
|
// workaround for this is to disable the control, but that doesn't work
|
|
// because Microsoft PhotoDraw runs around and secretly hides and shows
|
|
// buttons without going through PSM_SETWIZBUTTONS, so they end up showing
|
|
// a disabled window and their wizard stops working.
|
|
//
|
|
// So instead, we subclass the buttons and customize their WM_GETDLGCODE
|
|
// so that when the control is hidden, they disable their accelerators.
|
|
//
|
|
LRESULT CALLBACK Prsht_ButtonSubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp, UINT_PTR uID, ULONG_PTR dwRefData)
|
|
{
|
|
LRESULT lres;
|
|
|
|
|
|
switch (wm)
|
|
{
|
|
|
|
case WM_GETDLGCODE:
|
|
lres = DefSubclassProc(hwnd, wm, wp, lp);
|
|
if (!IsWindowVisible(hwnd))
|
|
{
|
|
// To remove yourself from the mnemonic search, you have to
|
|
// return DLGC_WANTCHAR if you are give a NULL LPMSG pointer.
|
|
// Normally, the dialog manager sends a real LPMSG containing
|
|
// the message that just got received, but when it's poking
|
|
// around looking for accelerators, it doesn't give you a
|
|
// message at all. It is in that case that you want to
|
|
// say, "Hey, I will process the (nonexistent) message".
|
|
// This tricks USER into thinking you're an edit control, so
|
|
// it won't scan your for mnemonics.
|
|
if ((LPMSG)lp == NULL)
|
|
lres |= DLGC_WANTCHARS;
|
|
|
|
}
|
|
break;
|
|
|
|
case WM_NCDESTROY:
|
|
// Clean up subclass
|
|
RemoveWindowSubclass(hwnd, Prsht_ButtonSubclassProc, 0);
|
|
lres = DefSubclassProc(hwnd, wm, wp, lp);
|
|
break;
|
|
|
|
default:
|
|
lres = DefSubclassProc(hwnd, wm, wp, lp);
|
|
break;
|
|
}
|
|
|
|
return lres;
|
|
}
|
|
|
|
void Prsht_SubclassButton(HWND hDlg, UINT idd)
|
|
{
|
|
SetWindowSubclass(GetDlgItem(hDlg, idd), Prsht_ButtonSubclassProc, 0, 0);
|
|
}
|
|
|
|
BOOL CompareFontFaceW(LPCWSTR lpwz1, LPCWSTR lpwz2, BOOL fBitCmp)
|
|
{
|
|
return lstrcmpiW(lpwz1, lpwz2);
|
|
}
|
|
|
|
//
|
|
// GetPageFontMetrics
|
|
//
|
|
// synopsis:
|
|
//
|
|
// Get the real font metrics from PAGEFONTDATA. Used in InitPropSheetDlg() to
|
|
// calculate the physical page size based on the font specified in page templates
|
|
//
|
|
// fML is set if we are in here because of an ML scenario, in which case the
|
|
// font names need to be mapped.
|
|
//
|
|
|
|
BOOL GetPageFontMetrics(LPPROPDATA ppd, PPAGEFONTDATA ppfd, BOOL fML)
|
|
{
|
|
LOGFONT lf = {0};
|
|
HFONT hFont;
|
|
HRESULT fRc = FALSE;
|
|
HDC hdc;
|
|
|
|
if (ppfd && (ppfd->PointSize > 0) && ppfd->szFace[0])
|
|
{
|
|
|
|
// font name mapping
|
|
// should be done only for the platform less than NT5
|
|
// NT5 is supposed to work with native typeface on any system locale.
|
|
//
|
|
if (!staticIsOS(OS_WIN2000ORGREATER) && fML)
|
|
{
|
|
// replace native font face name to single byte name for non-native platform
|
|
typedef struct tagFontFace
|
|
{
|
|
BOOL fBitCmp;
|
|
LPCWSTR lpEnglish;
|
|
LPCWSTR lpNative;
|
|
} FONTFACE, *LPFONTFACE;
|
|
|
|
const static FONTFACE s_FontTbl[] =
|
|
{
|
|
{ FALSE, L"MS Gothic", L"MS UI Gothic" },
|
|
{ TRUE, L"MS Gothic", L"\xff2d\xff33 \xff30\x30b4\x30b7\x30c3\x30af" },
|
|
{ TRUE, L"GulimChe", L"\xad74\xb9bc" },
|
|
{ TRUE, L"MS Song", L"\x5b8b\x4f53" },
|
|
{ TRUE, L"MingLiU", L"\x65b0\x7d30\x660e\x9ad4" }
|
|
};
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAYSIZE(s_FontTbl); i++)
|
|
{
|
|
if (!CompareFontFaceW(ppfd->szFace, s_FontTbl[i].lpNative, s_FontTbl[i].fBitCmp))
|
|
{
|
|
lstrcpynW(lf.lfFaceName, s_FontTbl[i].lpEnglish, ARRAYSIZE(lf.lfFaceName));
|
|
break;
|
|
}
|
|
}
|
|
if (i >= ARRAYSIZE(s_FontTbl))
|
|
lstrcpynW(lf.lfFaceName, ppfd->szFace, ARRAYSIZE(lf.lfFaceName));
|
|
}
|
|
else
|
|
lstrcpynW(lf.lfFaceName, ppfd->szFace, ARRAYSIZE(lf.lfFaceName));
|
|
|
|
// Try to use the cache
|
|
if (ppfd->iCharset == ppd->pfdCache.iCharset &&
|
|
ppfd->bItalic == ppd->pfdCache.bItalic &&
|
|
ppfd->PointSize == ppd->pfdCache.PointSize &&
|
|
lstrcmpiW(ppfd->szFace, ppd->pfdCache.szFace) == 0) {
|
|
fRc = TRUE;
|
|
} else {
|
|
if (hdc = GetDC(ppd->hDlg))
|
|
{
|
|
lf.lfHeight = -MulDiv(ppfd->PointSize, GetDeviceCaps(hdc,LOGPIXELSY), 72);
|
|
lf.lfCharSet = (BYTE)ppfd->iCharset;
|
|
lf.lfItalic = (BYTE)ppfd->bItalic;
|
|
lf.lfWeight = FW_NORMAL;
|
|
|
|
hFont = CreateFontIndirectW(&lf);
|
|
if (hFont)
|
|
{
|
|
HFONT hFontOld = SelectObject(hdc, hFont);
|
|
|
|
GetCharDimensions(hdc, &ppd->sizCache);
|
|
if (hFontOld)
|
|
SelectObject(hdc, hFontOld);
|
|
|
|
DeleteObject(hFont);
|
|
|
|
// Save these font metrics into the cache
|
|
ppd->pfdCache = *ppfd;
|
|
fRc = TRUE;
|
|
}
|
|
ReleaseDC(ppd->hDlg, hdc);
|
|
|
|
}
|
|
}
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
//
|
|
// The "ideal page size" of a property sheet is the maximum size of all
|
|
// pages.
|
|
//
|
|
// GIPS_SKIPINTERIOR97HEIGHT and GIPS_SKIPEXTERIOR97HEIGHT selective
|
|
// exclude Wiz97 pages from the height computation. They are important
|
|
// because interior pages are shorter than exterior pages by
|
|
// ppd->cyHeaderHeight.
|
|
//
|
|
|
|
#define GIPS_SKIPINTERIOR97HEIGHT 1
|
|
#define GIPS_SKIPEXTERIOR97HEIGHT 2
|
|
|
|
void Prsht_GetIdealPageSize(LPPROPDATA ppd, PSIZE psiz, UINT flags)
|
|
{
|
|
UINT uPages;
|
|
|
|
*psiz = ppd->sizMin;
|
|
|
|
for (uPages = 0; uPages < ppd->psh.nPages; uPages++)
|
|
{
|
|
PISP pisp = GETPISP(ppd, uPages);
|
|
int cy = pisp->_pfx.siz.cy;
|
|
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
if (pisp->_psp.dwFlags & PSP_HIDEHEADER)
|
|
{
|
|
if (flags & GIPS_SKIPEXTERIOR97HEIGHT) goto skip;
|
|
}
|
|
else
|
|
{
|
|
if (flags & GIPS_SKIPINTERIOR97HEIGHT) goto skip;
|
|
}
|
|
}
|
|
|
|
if (psiz->cy < cy)
|
|
psiz->cy = cy;
|
|
|
|
skip:;
|
|
if (psiz->cx < pisp->_pfx.siz.cx)
|
|
psiz->cx = pisp->_pfx.siz.cx;
|
|
}
|
|
|
|
}
|
|
|
|
#define IsMSShellDlgMapped(langid) (PRIMARYLANGID(langid) == LANG_JAPANESE)
|
|
|
|
//
|
|
// Given a page, decide what size it wants to be and save it in the
|
|
// pisp->_pfx.siz.
|
|
//
|
|
void Prsht_ComputeIdealPageSize(LPPROPDATA ppd, PISP pisp, PAGEINFOEX *ppi)
|
|
{
|
|
BOOL fUsePageFont;
|
|
|
|
// pressume page and frame dialog are in same character set
|
|
LANGID wPageLang = ppd->wFrameLang;
|
|
int iPageCharset = DEFAULT_CHARSET;
|
|
|
|
if (SUCCEEDED(GetPageLanguage(pisp, &wPageLang)))
|
|
{
|
|
// GetPageLanguage fails if page is marked PSP_DLGINDIRECT;
|
|
// we'll try to recover from that later. For now,
|
|
// we leave pagelang to DEFAULT_CHARSET and see if we can take
|
|
// the charset info from template EX.
|
|
//
|
|
// if PSH_USEPAGELANG is specified, we can assume that
|
|
// page charset == frame charset and no need for ML adjustment
|
|
// *except for* the case of NT Japanese version that replaces
|
|
// frame's MS Shell Dlg to their native font. We handle this
|
|
// exception later where we set up fUsePageFont;
|
|
//
|
|
if (!(ppd->psh.dwFlags & PSH_USEPAGELANG)
|
|
&& wPageLang != ppd->wFrameLang)
|
|
{
|
|
iPageCharset = GetDefaultCharsetFromLang(wPageLang);
|
|
}
|
|
else
|
|
iPageCharset = ppd->iFrameCharset;
|
|
}
|
|
|
|
// Use the font in the page if any of these conditions are met:
|
|
//
|
|
// A) It's a SHELLFONT page. Do this even if the font is not
|
|
// "MS Shell Dlg 2". This gives apps a way to specify that
|
|
// their custom-font page should be measured against the
|
|
// font in the page rather than in the frame font.
|
|
//
|
|
// B) ML scenario - complicated original comment below...
|
|
//
|
|
// 1) we've detected lang in the caller's resource and
|
|
// it's different from the frame dialog
|
|
// 2) the caller's page doesn't have lang info or we've
|
|
// failed to get it (iPageCharset == DEFAULT_CHARSET),
|
|
// then we find the page is described with DLGTEMPLATEEX
|
|
// and has meaningful charset specified (!= defaultcharset)
|
|
// *and* the charset is different from frame's
|
|
// 3) the exception for NT Japanese platform that maps
|
|
// MS Shell Dlg to their native font. For US Apps to
|
|
// work on these platforms they typically specify
|
|
// PSH_USEPAGELANG to get English buttons on frame
|
|
// but they still need to get the frame sized based on
|
|
// page font
|
|
//
|
|
// Otherwise, IE4 compat **requires** that we use the frame font.
|
|
// ISVs have hacked around this historical bug by having large
|
|
// dialog templates with extra space in them.
|
|
//
|
|
fUsePageFont =
|
|
/* --- A) It's a SHELLFONT page --- */
|
|
IsPageInfoSHELLFONT(ppi) ||
|
|
/* --- B) ML scenario --- */
|
|
((ppd->psh.dwFlags & PSH_USEPAGELANG)
|
|
&& IsMSShellDlgMapped(NT5_GetUserDefaultUILanguage())) ||
|
|
(ppd->iFrameCharset != iPageCharset
|
|
&& (iPageCharset != DEFAULT_CHARSET
|
|
|| (ppi->pfd.iCharset != DEFAULT_CHARSET
|
|
&& ppi->pfd.iCharset != ppd->iFrameCharset)));
|
|
|
|
if (fUsePageFont &&
|
|
GetPageFontMetrics(ppd, &ppi->pfd, MLIsMLHInstance(pisp->_psp.hInstance)))
|
|
{
|
|
// Compute Real Dialog Unit for the page
|
|
pisp->_pfx.siz.cx = MulDiv(ppi->pt.x, ppd->sizCache.cx, 4);
|
|
pisp->_pfx.siz.cy = MulDiv(ppi->pt.y, ppd->sizCache.cy, 8);
|
|
} else {
|
|
RECT rcT;
|
|
// IE4 compat - Use the frame font
|
|
rcT.top = rcT.left = 0; // Win95 will fault if these are uninit
|
|
rcT.right = ppi->pt.x;
|
|
rcT.bottom = ppi->pt.y;
|
|
MapDialogRect(ppd->hDlg, &rcT);
|
|
pisp->_pfx.siz.cx = rcT.right;
|
|
pisp->_pfx.siz.cy = rcT.bottom;
|
|
|
|
//
|
|
// If this is PSP_DLGINDIRECT but the character set and face name
|
|
// say this is a "generic" property sheet, then take the frame
|
|
// font or the page font, whichever is bigger.
|
|
//
|
|
// This fixes the Chinese MingLiu font, which is not as tall as
|
|
// the English MS Sans Serif font. Without this fix, we would
|
|
// use MingLui (the frame font), and then your MS Shell Dlg pages
|
|
// would get truncated.
|
|
//
|
|
// (Truncated property sheets is what you got in NT4, but I guess
|
|
// looking pretty is more important than bug-for-bug compatibility.
|
|
// Who knows what apps will be broken by this change.)
|
|
//
|
|
if ((pisp->_psp.dwFlags & PSP_DLGINDIRECT) &&
|
|
ppi->pfd.iCharset == DEFAULT_CHARSET &&
|
|
lstrcmpiW(ppi->pfd.szFace, L"MS Shell Dlg") == 0)
|
|
{
|
|
int i;
|
|
GetPageFontMetrics(ppd, &ppi->pfd, FALSE);
|
|
i = MulDiv(ppi->pt.x, ppd->sizCache.cx, 4);
|
|
if (pisp->_pfx.siz.cx < i)
|
|
pisp->_pfx.siz.cx = i;
|
|
i = MulDiv(ppi->pt.y, ppd->sizCache.cy, 8);
|
|
if (pisp->_pfx.siz.cy < i)
|
|
pisp->_pfx.siz.cy = i;
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void InitPropSheetDlg(HWND hDlg, LPPROPDATA ppd)
|
|
{
|
|
PAGEINFOEX pi;
|
|
int dxDlg, dyDlg, dyGrow, dxGrow;
|
|
RECT rcMinSize, rcDlg, rcPage, rcOrigTabs;
|
|
UINT uPages;
|
|
HIMAGELIST himl = NULL;
|
|
TC_ITEMEXTRA tie;
|
|
TCHAR szStartPage[128];
|
|
LPCTSTR pStartPage = NULL;
|
|
UINT nStartPage;
|
|
BOOL fPrematurePages = FALSE;
|
|
#ifdef DEBUG
|
|
BOOL fStartPageFound = FALSE;
|
|
#endif
|
|
LANGID langidMUI;
|
|
MONITORINFO mMonitorInfo;
|
|
HMONITOR hMonitor;
|
|
BOOL bMirrored = FALSE;
|
|
// set our instance data pointer
|
|
SetWindowLongPtr(hDlg, DWLP_USER, (LONG_PTR)ppd);
|
|
|
|
// Make sure this gets inited early on.
|
|
ppd->nCurItem = 0;
|
|
|
|
// By default we allow the "Apply" button to be enabled
|
|
ppd->fAllowApply = TRUE;
|
|
|
|
if (IS_WIZARD(ppd)) {
|
|
// Subclass our buttons so their mnemonics won't mess up applications
|
|
// that run around hiding and showing the buttons behind our back.
|
|
Prsht_SubclassButton(hDlg, IDD_BACK);
|
|
Prsht_SubclassButton(hDlg, IDD_NEXT);
|
|
Prsht_SubclassButton(hDlg, IDD_FINISH);
|
|
} else
|
|
_SetTitle(hDlg, ppd);
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEICONID)
|
|
{
|
|
ppd->psh.H_hIcon = LoadImage(ppd->psh.hInstance, ppd->psh.H_pszIcon, IMAGE_ICON, g_cxSmIcon, g_cySmIcon, LR_DEFAULTCOLOR);
|
|
}
|
|
|
|
if ((ppd->psh.dwFlags & (PSH_USEICONID | PSH_USEHICON)) && ppd->psh.H_hIcon)
|
|
SendMessage(hDlg, WM_SETICON, FALSE, (LPARAM)(UINT_PTR)ppd->psh.H_hIcon);
|
|
|
|
ppd->hDlg = hDlg;
|
|
|
|
// IDD_PAGELIST should definitely exist
|
|
ppd->hwndTabs = GetDlgItem(hDlg, IDD_PAGELIST);
|
|
ASSERT(ppd->hwndTabs);
|
|
TabCtrl_SetItemExtra(ppd->hwndTabs, CB_ITEMEXTRA);
|
|
|
|
// nStartPage is either ppd->psh.H_nStartPage or the page pStartPage
|
|
nStartPage = ppd->psh.H_nStartPage;
|
|
if (ppd->psh.dwFlags & PSH_USEPSTARTPAGE)
|
|
{
|
|
nStartPage = 0; // Assume we don't find the page
|
|
pStartPage = ppd->psh.H_pStartPage;
|
|
|
|
if (IS_INTRESOURCE(pStartPage))
|
|
{
|
|
szStartPage[0] = TEXT('\0');
|
|
LoadString(ppd->psh.hInstance, (UINT)LOWORD(pStartPage),
|
|
szStartPage, ARRAYSIZE(szStartPage));
|
|
pStartPage = szStartPage;
|
|
}
|
|
}
|
|
|
|
#ifndef WINDOWS_ME
|
|
tie.tci.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
|
|
#endif
|
|
tie.hwndPage = NULL;
|
|
tie.tci.pszText = pi.szCaption;
|
|
tie.state = 0;
|
|
|
|
SendMessage(ppd->hwndTabs, WM_SETREDRAW, FALSE, 0L);
|
|
|
|
// load langid we chose for frame dialog template
|
|
ppd->wFrameLang = LANGIDFROMLCID(CCGetProperThreadLocale(NULL));
|
|
|
|
// it's charset that really matters to font
|
|
ppd->iFrameCharset = GetDefaultCharsetFromLang(ppd->wFrameLang);
|
|
|
|
langidMUI = GetMUILanguage();
|
|
|
|
for (uPages = 0; uPages < ppd->psh.nPages; uPages++)
|
|
{
|
|
PISP pisp = GETPISP(ppd, uPages);
|
|
|
|
if (GetPageInfoEx(ppd, pisp, &pi, langidMUI, GPI_ALL))
|
|
{
|
|
Prsht_ComputeIdealPageSize(ppd, pisp, &pi);
|
|
|
|
// Add the page to the end of the tab list
|
|
|
|
tie.tci.iImage = -1;
|
|
#ifdef WINDOWS_ME
|
|
tie.tci.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE | (pi.bRTL ? TCIF_RTLREADING : 0);
|
|
#endif
|
|
if (pi.hIcon) {
|
|
if (!himl) {
|
|
UINT flags = ILC_MASK;
|
|
if(IS_WINDOW_RTL_MIRRORED(ppd->hwndTabs)) {
|
|
flags |= ILC_MIRROR;
|
|
}
|
|
himl = ImageList_Create(g_cxSmIcon, g_cySmIcon, flags, 8, 4);
|
|
TabCtrl_SetImageList(ppd->hwndTabs, himl);
|
|
}
|
|
|
|
tie.tci.iImage = ImageList_AddIcon(himl, pi.hIcon);
|
|
// QUESTION raymondc - we always destroy even if PSP_USEHICON?
|
|
DestroyIcon(pi.hIcon);
|
|
}
|
|
|
|
// QUESTION? What if this fails? Do we want to destroy the page?
|
|
if (TabCtrl_InsertItem(ppd->hwndTabs, 1000, &tie.tci) >= 0)
|
|
{
|
|
// Nothing to do; all the code that was here got moved elsewhere
|
|
}
|
|
|
|
// remember if any page wants premature init
|
|
if (pisp->_psp.dwFlags & PSP_PREMATURE)
|
|
fPrematurePages = TRUE;
|
|
|
|
// if the user is specifying the startpage via title, check it here
|
|
if ((ppd->psh.dwFlags & PSH_USEPSTARTPAGE) &&
|
|
!lstrcmpi(pStartPage, pi.szCaption))
|
|
{
|
|
nStartPage = uPages;
|
|
#ifdef DEBUG
|
|
fStartPageFound = TRUE;
|
|
#endif
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("PropertySheet failed to GetPageInfo"));
|
|
RemovePropPageData(ppd, uPages--);
|
|
}
|
|
}
|
|
|
|
SendMessage(ppd->hwndTabs, WM_SETREDRAW, TRUE, 0L);
|
|
|
|
if (ppd->psh.pfnCallback) {
|
|
#ifdef WX86
|
|
if (ppd->fFlags & PD_WX86)
|
|
Wx86Callback(ppd->psh.pfnCallback, hDlg, PSCB_INITIALIZED, 0);
|
|
else
|
|
#endif
|
|
ppd->psh.pfnCallback(hDlg, PSCB_INITIALIZED, 0);
|
|
}
|
|
|
|
//
|
|
// Now compute the size of the tab control.
|
|
//
|
|
|
|
// First get the rectangle for the whole dialog
|
|
GetWindowRect(hDlg, &rcDlg);
|
|
|
|
// For WIZARD_LITE style wizards, we stretch the tabs page and sunken divider
|
|
// to cover the whole wizard (without the border)
|
|
if (ppd->psh.dwFlags & PSH_WIZARD_LITE)
|
|
{
|
|
// Stretch the divider to the whole width of the wizard
|
|
RECT rcDiv, rcDlgClient;
|
|
HWND hDiv;
|
|
|
|
// we allow both PSH_WIZARD and PSH_WIZARD_LITE to be set
|
|
// it's exactly the same as setting just PSH_WIZARD_LITE
|
|
RIPMSG(!(ppd->psh.dwFlags & PSH_WIZARD97),
|
|
"Cannot combine PSH_WIZARD_LITE with PSH_WIZARD97");
|
|
|
|
// but some people do it anyway, so turn off
|
|
ppd->psh.dwFlags &= ~PSH_WIZARD97;
|
|
|
|
// NOTE: GetDlgItemRect returns a rectangle relative to hDlg
|
|
hDiv = GetDlgItemRect(hDlg, IDD_DIVIDER, &rcDiv);
|
|
if (hDiv)
|
|
SetWindowPos(hDiv, NULL, 0, rcDiv.top, RECTWIDTH(rcDlg),
|
|
RECTHEIGHT(rcDiv), SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
GetClientRect(hDlg, &rcDlgClient);
|
|
|
|
// Stretch the page list control to cover the whole wizard client area above
|
|
// the divider
|
|
SetWindowPos(ppd->hwndTabs, NULL, 0, 0, RECTWIDTH(rcDlgClient),
|
|
rcDiv.top, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
//
|
|
// While we're thinking about it, don't let people set both
|
|
// WIZARD97IE4 *and* WIZARD97IE5. That's just way too strange.
|
|
//
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
ppd->psh.dwFlags &= ~PSH_WIZARD97IE5;
|
|
|
|
// Get the rectangle of the pagelist control in pixels.
|
|
GetClientRect(ppd->hwndTabs, &rcOrigTabs);
|
|
ppd->sizMin.cx = rcOrigTabs.right;
|
|
ppd->sizMin.cy = rcOrigTabs.bottom;
|
|
|
|
// Compute rcPage = Size of page area in pixels
|
|
// For now, we only care about interior pages; we'll deal with exterior
|
|
// pages later.
|
|
rcPage.left = rcPage.top = 0;
|
|
Prsht_GetIdealPageSize(ppd, (SIZE *)&rcPage.right, GIPS_SKIPEXTERIOR97HEIGHT);
|
|
|
|
//
|
|
// IE4's Wizard97 assumed that all exterior pages were exactly
|
|
// DEFAULTHEADERHEIGHT dlu's taller than interior pages. That's
|
|
// right, DEFAULTHEADERHEIGHT is a pixel count, but IE4 messed up
|
|
// and used it as a dlu count here.
|
|
//
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
{
|
|
SIZE sizT;
|
|
SetRect(&rcMinSize, 0, 0, 0, DEFAULTHEADERHEIGHT);
|
|
MapDialogRect(hDlg, &rcMinSize);
|
|
Prsht_GetIdealPageSize(ppd, &sizT, GIPS_SKIPINTERIOR97HEIGHT);
|
|
if (rcPage.bottom < sizT.cy - rcMinSize.bottom)
|
|
rcPage.bottom = sizT.cy - rcMinSize.bottom;
|
|
}
|
|
|
|
// Now compute the minimum size for the page region
|
|
rcMinSize = rcPage;
|
|
|
|
//
|
|
// If this is a wizard then set the size of the page area to the entire
|
|
// size of the control. If it is a normal property sheet then adjust for
|
|
// the tabs, resize the control, and then compute the size of the page
|
|
// region only.
|
|
//
|
|
if (IS_WIZARD(ppd))
|
|
// initialize
|
|
rcPage = rcMinSize;
|
|
else
|
|
{
|
|
int i;
|
|
RECT rcAdjSize;
|
|
|
|
// initialize
|
|
|
|
for (i = 0; i < 2; i++) {
|
|
rcAdjSize = rcMinSize;
|
|
TabCtrl_AdjustRect(ppd->hwndTabs, TRUE, &rcAdjSize);
|
|
|
|
rcAdjSize.right -= rcAdjSize.left;
|
|
rcAdjSize.bottom -= rcAdjSize.top;
|
|
rcAdjSize.left = rcAdjSize.top = 0;
|
|
|
|
if (rcAdjSize.right < rcMinSize.right)
|
|
rcAdjSize.right = rcMinSize.right;
|
|
if (rcAdjSize.bottom < rcMinSize.bottom)
|
|
rcAdjSize.bottom = rcMinSize.bottom;
|
|
|
|
SetWindowPos(ppd->hwndTabs, NULL, 0,0, rcAdjSize.right, rcAdjSize.bottom,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
rcPage = rcMinSize = rcAdjSize;
|
|
TabCtrl_AdjustRect(ppd->hwndTabs, FALSE, &rcPage);
|
|
}
|
|
//
|
|
// rcMinSize now contains the size of the control, including the tabs, and
|
|
// rcPage is the rect containing the page portion (without the tabs).
|
|
//
|
|
|
|
// For wizard97:
|
|
// Now we have the correct width for our wizard, let's compute the
|
|
// header height based on that, shift the tab window and the pages
|
|
// window down accordingly.
|
|
//
|
|
dyGrow = 0;
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
RECT rcTabs;
|
|
SIZE sizT;
|
|
|
|
// NOTE: we don't directly use rcPage because the verticle position for
|
|
// ppd->hwndTabs is not determined, yet, even though the horizontal is
|
|
// already computed. Therefore, we can only use rcPageCopy.right not
|
|
// rcPageCopy.bottom in the following code.
|
|
RECT rcTemp;
|
|
CopyRect(&rcTemp, &rcPage);
|
|
MapWindowPoints(ppd->hwndTabs, hDlg, (LPPOINT)&rcTemp, 2);
|
|
|
|
GetWindowRect(ppd->hwndTabs, &rcTabs);
|
|
MapWindowRect(NULL, hDlg, &rcTabs);
|
|
|
|
// Set the header fonts first because we need to use the bold font
|
|
// to compute the title height
|
|
_SetHeaderFonts(hDlg, ppd);
|
|
|
|
// Adjust the header height
|
|
ppd->cyHeaderHeight = _ComputeHeaderHeight(ppd, rcTemp.right);
|
|
|
|
// Since the app can change the subheader text on the fly,
|
|
// our computation of the header height might end up wrong later.
|
|
// Allow ISVs to precompensate for that by setting their exterior
|
|
// pages larger than the interior pages by the amount they want
|
|
// to reserve.
|
|
// So if the largest external page is larger than the largest internal
|
|
// page, then expand to enclose the external pages too.
|
|
// IE4 Wizard97 didn't do this and MFC relies on the bug.
|
|
|
|
if (!(ppd->psh.dwFlags & PSH_WIZARD97IE4))
|
|
{
|
|
// A margin of 7dlu's is placed above the page, and another
|
|
// margin of 7 dlu's is placed below.
|
|
SetRect(&rcTemp, 0, 0, 0, 7+7);
|
|
MapDialogRect(hDlg, &rcTemp);
|
|
|
|
Prsht_GetIdealPageSize(ppd, &sizT, GIPS_SKIPINTERIOR97HEIGHT);
|
|
|
|
if (ppd->cyHeaderHeight < sizT.cy - RECTHEIGHT(rcPage) - rcTemp.bottom)
|
|
ppd->cyHeaderHeight = sizT.cy - RECTHEIGHT(rcPage) - rcTemp.bottom;
|
|
}
|
|
|
|
// Move the tab window right under the header
|
|
dyGrow += ppd->cyHeaderHeight;
|
|
SetWindowPos(ppd->hwndTabs, NULL, rcTabs.left, rcTabs.top + dyGrow,
|
|
RECTWIDTH(rcTabs), RECTHEIGHT(rcTabs), SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
//
|
|
// Resize the dialog to make room for the control's new size. This can
|
|
// only grow the size.
|
|
//
|
|
dxGrow = rcMinSize.right - rcOrigTabs.right;
|
|
dxDlg = rcDlg.right - rcDlg.left + dxGrow;
|
|
dyGrow += rcMinSize.bottom - rcOrigTabs.bottom;
|
|
dyDlg = rcDlg.bottom - rcDlg.top + dyGrow;
|
|
|
|
//
|
|
// Cascade property sheet windows (only for comctl32 and commctrl)
|
|
//
|
|
|
|
//
|
|
// HACK: Putting CW_USEDEFAULT in dialog template does not work because
|
|
// CreateWindowEx ignores it unless the window has WS_OVERLAPPED, which
|
|
// is not appropriate for a property sheet.
|
|
//
|
|
{
|
|
const TCHAR c_szStatic[] = TEXT("Static");
|
|
UINT swp = SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE;
|
|
if (!IsWindow(ppd->psh.hwndParent)) {
|
|
HWND hwndT = CreateWindowEx(0, c_szStatic, NULL,
|
|
WS_OVERLAPPED, CW_USEDEFAULT, CW_USEDEFAULT,
|
|
0, 0, NULL, NULL, HINST_THISDLL, NULL);
|
|
if (hwndT) {
|
|
GetWindowRect(hwndT, &rcDlg);
|
|
swp = SWP_NOZORDER | SWP_NOACTIVATE;
|
|
DestroyWindow(hwndT);
|
|
}
|
|
} else {
|
|
GetWindowRect(ppd->psh.hwndParent, &rcDlg);
|
|
if (IsWindowVisible(ppd->psh.hwndParent)) {
|
|
bMirrored = IS_WINDOW_RTL_MIRRORED(ppd->psh.hwndParent);
|
|
|
|
rcDlg.top += g_cySmIcon;
|
|
if(bMirrored)
|
|
{
|
|
rcDlg.left = rcDlg.right - g_cxSmIcon - dxDlg;
|
|
}
|
|
else
|
|
{
|
|
rcDlg.left += g_cxSmIcon;
|
|
}
|
|
}
|
|
swp = SWP_NOZORDER | SWP_NOACTIVATE;
|
|
}
|
|
hMonitor = MonitorFromWindow(hDlg, MONITOR_DEFAULTTONEAREST);
|
|
mMonitorInfo.cbSize = sizeof(MONITORINFO);
|
|
if (GetMonitorInfo(hMonitor, &mMonitorInfo))
|
|
{
|
|
if (mMonitorInfo.rcMonitor.right < (rcDlg.left + dxDlg))
|
|
{
|
|
// Move the Window left.
|
|
rcDlg.left = mMonitorInfo.rcMonitor.right - dxDlg;
|
|
}
|
|
if (mMonitorInfo.rcMonitor.left > rcDlg.left)
|
|
{
|
|
// Move the Window Right.
|
|
rcDlg.left = mMonitorInfo.rcMonitor.left;
|
|
}
|
|
if (mMonitorInfo.rcMonitor.bottom < (rcDlg.top + dyDlg))
|
|
{
|
|
// Move the Window Up.
|
|
rcDlg.top = mMonitorInfo.rcMonitor.bottom - dyDlg;
|
|
}
|
|
if (mMonitorInfo.rcMonitor.top > rcDlg.top)
|
|
{
|
|
// Move the Window Down.
|
|
rcDlg.top = mMonitorInfo.rcMonitor.top;
|
|
}
|
|
}
|
|
SetWindowPos(hDlg, NULL, rcDlg.left, rcDlg.top, dxDlg, dyDlg, swp);
|
|
}
|
|
|
|
// Now we'll figure out where the page needs to start relative
|
|
// to the bottom of the tabs.
|
|
MapWindowRect(ppd->hwndTabs, hDlg, &rcPage);
|
|
|
|
ppd->xSubDlg = rcPage.left;
|
|
ppd->ySubDlg = rcPage.top;
|
|
ppd->cxSubDlg = rcPage.right - rcPage.left;
|
|
ppd->cySubDlg = rcPage.bottom - rcPage.top;
|
|
|
|
//
|
|
// move all the buttons down as needed and turn on appropriate buttons
|
|
// for a wizard.
|
|
//
|
|
{
|
|
RECT rcCtrl;
|
|
HWND hCtrl;
|
|
const int *pids;
|
|
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
hCtrl = GetDlgItemRect(hDlg, IDD_TOPDIVIDER, &rcCtrl);
|
|
if (hCtrl)
|
|
SetWindowPos(hCtrl, NULL, rcCtrl.left, ppd->cyHeaderHeight,
|
|
RECTWIDTH(rcCtrl) + dxGrow, RECTHEIGHT(rcCtrl), SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
if (IS_WIZARD(ppd)) {
|
|
pids = WizIDs;
|
|
|
|
hCtrl = GetDlgItemRect(hDlg, IDD_DIVIDER, &rcCtrl);
|
|
if (hCtrl)
|
|
SetWindowPos(hCtrl, NULL, rcCtrl.left, rcCtrl.top + dyGrow,
|
|
RECTWIDTH(rcCtrl) + dxGrow, RECTHEIGHT(rcCtrl),
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
EnableWindow(GetDlgItem(hDlg, IDD_BACK), TRUE);
|
|
ppd->idDefaultFallback = IDD_NEXT;
|
|
} else {
|
|
pids = IDs;
|
|
ppd->idDefaultFallback = IDOK;
|
|
}
|
|
|
|
|
|
// first move everything over by the same amount that
|
|
// the dialog grew by.
|
|
|
|
// If we flipped the buttons, it should be aligned to the left
|
|
// No move needed
|
|
MoveAllButtons(hDlg, pids, IDHELP, ppd->fFlipped ? 0 : dxGrow, dyGrow);
|
|
|
|
|
|
// If there's no help, then remove the help button.
|
|
if (!(ppd->psh.dwFlags & PSH_HASHELP)) {
|
|
RemoveButton(hDlg, IDHELP, pids);
|
|
}
|
|
|
|
// If we are not a wizard, and we should NOT show apply now
|
|
if ((ppd->psh.dwFlags & PSH_NOAPPLYNOW) &&
|
|
!IS_WIZARD(ppd))
|
|
{
|
|
RemoveButton(hDlg, IDD_APPLYNOW, pids);
|
|
}
|
|
|
|
if (IS_WIZARD(ppd) &&
|
|
(!(ppd->psh.dwFlags & PSH_WIZARDHASFINISH)))
|
|
{
|
|
DWORD dwStyle=0;
|
|
|
|
RemoveButton(hDlg, IDD_FINISH, pids);
|
|
|
|
// if there's no finish button showing, we need to place it where
|
|
// the next button is
|
|
GetWindowRect(GetDlgItem(hDlg, IDD_NEXT), &rcCtrl);
|
|
MapWindowPoints(HWND_DESKTOP, hDlg, (LPPOINT)&rcCtrl, 2);
|
|
SetWindowPos(GetDlgItem(hDlg, IDD_FINISH), NULL, rcCtrl.left, rcCtrl.top,
|
|
RECTWIDTH(rcCtrl), RECTHEIGHT(rcCtrl), SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
}
|
|
|
|
// (dli) compute the Pattern Brush for the watermark
|
|
// Note: This is done here because we need to know the size of the big dialog in
|
|
// case the user wants to stretch the bitmap
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
int cx, cy;
|
|
ASSERT(ppd->hbmHeader == NULL);
|
|
ASSERT(ppd->hbmWatermark == NULL);
|
|
|
|
//
|
|
// WIZARD97IE4 disabled the watermark and header bitmap
|
|
// if high contrast was turned on.
|
|
//
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4) {
|
|
HIGHCONTRAST hc = {sizeof(hc)};
|
|
if (SystemParametersInfo(SPI_GETHIGHCONTRAST, sizeof(hc), &hc, 0) &&
|
|
(hc.dwFlags & HCF_HIGHCONTRASTON)) {
|
|
ppd->psh.dwFlags &= ~(PSH_WATERMARK | PSH_USEHBMWATERMARK |
|
|
PSH_USEHPLWATERMARK |
|
|
PSH_HEADER | PSH_USEHBMHEADER);
|
|
}
|
|
}
|
|
|
|
if ((ppd->psh.dwFlags & PSH_WATERMARK) && ppd->psh.H_hbmWatermark)
|
|
{
|
|
// Compute dimensions of final bitmap, which may be slightly
|
|
// goofy due to stretching
|
|
|
|
cx = cy = 0; // Assume no stretching
|
|
if (ppd->psh.dwFlags & PSH_STRETCHWATERMARK) {
|
|
RECT rc;
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4) {
|
|
// The WIZARD97IE4 watermark covers the entire dialog
|
|
if (GetDlgItemRect(hDlg, IDD_DIVIDER, &rc)) {
|
|
cx = dxDlg;
|
|
cy = rc.top;
|
|
}
|
|
} else {
|
|
// The WIZARD97IE5 watermark does not stretch
|
|
// (Too many people passed this flag when converting
|
|
// from WIZARD97IE4 to WIZARD97IE5 and relied on
|
|
// the nonstretchability.)
|
|
}
|
|
}
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEHBMWATERMARK)
|
|
{
|
|
// LR_COPYRETURNORG means "If no stretching was needed,
|
|
// then just return the original bitmap unaltered."
|
|
// Note that we need special cleanup if a stretch occurred.
|
|
ppd->hbmWatermark = (HBITMAP)CopyImage(ppd->psh.H_hbmWatermark,
|
|
IMAGE_BITMAP, cx, cy, LR_COPYRETURNORG);
|
|
}
|
|
else
|
|
{
|
|
ppd->hbmWatermark = (HBITMAP)LoadImage(ppd->psh.hInstance,
|
|
ppd->psh.H_pszbmWatermark,
|
|
IMAGE_BITMAP, cx, cy, LR_CREATEDIBSECTION);
|
|
}
|
|
|
|
if (ppd->hbmWatermark)
|
|
{
|
|
// If app provides custom palette, then use it,
|
|
// else create one based on the bmp. (And if the bmp
|
|
// doesn't have a palette, PaletteFromBmp will use the
|
|
// halftone palette.)
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEHPLWATERMARK)
|
|
ppd->hplWatermark = ppd->psh.hplWatermark;
|
|
else
|
|
ppd->hplWatermark = PaletteFromBmp(ppd->hbmWatermark);
|
|
|
|
// And WIZARD97IE4 needs to turn it into a bitmap brush.
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
ppd->hbrWatermark = CreatePatternBrush(ppd->hbmWatermark);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((ppd->psh.dwFlags & PSH_HEADER) && ppd->psh.H_hbmHeader)
|
|
{
|
|
cx = cy = 0; // Assume no stretching
|
|
if (ppd->psh.dwFlags & PSH_STRETCHWATERMARK) {
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4) {
|
|
// The WIZARD97IE4 header covers the entire header
|
|
cx = dxDlg;
|
|
cy = ppd->cyHeaderHeight;
|
|
} else {
|
|
// The WIZARD97IE5 header does not stretch
|
|
// (Too many people passed this flag when converting
|
|
// from WIZARD97IE4 to WIZARD97IE5 and relied on
|
|
// the nonstretchability.)
|
|
}
|
|
}
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEHBMHEADER)
|
|
{
|
|
// LR_COPYRETURNORG means "If no stretching was needed,
|
|
// then just return the original bitmap unaltered."
|
|
// Note that we need special cleanup if a stretch occurred.
|
|
ppd->hbmHeader = (HBITMAP)CopyImage(ppd->psh.H_hbmHeader,
|
|
IMAGE_BITMAP, cx, cy, LR_COPYRETURNORG);
|
|
}
|
|
else
|
|
{
|
|
ppd->hbmHeader = (HBITMAP)LoadImage(ppd->psh.hInstance,
|
|
ppd->psh.H_pszbmHeader,
|
|
IMAGE_BITMAP, cx, cy, LR_CREATEDIBSECTION);
|
|
}
|
|
|
|
// And WIZARD97IE4 needs to turn it into a bitmap brush.
|
|
if (ppd->hbmHeader && (ppd->psh.dwFlags & PSH_WIZARD97IE4))
|
|
ppd->hbrHeader = CreatePatternBrush(ppd->hbmHeader);
|
|
|
|
}
|
|
else
|
|
{
|
|
// In case the user does not specify a header bitmap
|
|
// use the top portion of the watermark
|
|
ppd->hbmHeader = ppd->hbmWatermark;
|
|
ppd->hbrHeader = ppd->hbrWatermark;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// force the dialog to reposition itself based on its new size
|
|
|
|
SendMessage(hDlg, DM_REPOSITION, 0, 0L);
|
|
|
|
// do this here instead of using DS_SETFOREGROUND so we don't hose
|
|
// pages that do things that want to set the foreground window
|
|
SetForegroundWindow(hDlg);
|
|
|
|
// We set this to 1 if the user saves any changes.
|
|
// do this before initting or switching to any pages
|
|
ppd->nReturn = 0;
|
|
|
|
// AppHack - Some people forgot to initialize nStartPage, and they were
|
|
// lucky that the garbage value on the stack was zero. Lucky no longer.
|
|
if (nStartPage >= ppd->psh.nPages) {
|
|
RIPMSG(0, "App forgot to initialize PROPSHEETHEADER.nStartPage field, assuming zero");
|
|
nStartPage = 0;
|
|
}
|
|
|
|
// Now attempt to select the starting page.
|
|
TabCtrl_SetCurSel(ppd->hwndTabs, nStartPage);
|
|
PageChange(ppd, 1);
|
|
|
|
// Now init any other pages that require it
|
|
if (fPrematurePages)
|
|
{
|
|
int nPage;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
for (nPage = 0; nPage < (int)ppd->psh.nPages; nPage++)
|
|
{
|
|
PISP pisp = GETPISP(ppd, nPage);
|
|
|
|
if (!(pisp->_psp.dwFlags & PSP_PREMATURE))
|
|
continue;
|
|
|
|
TabCtrl_GetItem(ppd->hwndTabs, nPage, &tie.tci);
|
|
|
|
if (tie.hwndPage)
|
|
continue;
|
|
|
|
if ((tie.hwndPage = _CreatePage(ppd, pisp, hDlg, langidMUI)) == NULL)
|
|
{
|
|
RemovePropPageData(ppd, nPage--);
|
|
continue;
|
|
}
|
|
|
|
TabCtrl_SetItem(ppd->hwndTabs, nPage, &tie.tci);
|
|
}
|
|
}
|
|
}
|
|
|
|
HWND _Ppd_GetPage(LPPROPDATA ppd, int nItem)
|
|
{
|
|
if (ppd->hwndTabs)
|
|
{
|
|
TC_ITEMEXTRA tie;
|
|
tie.tci.mask = TCIF_PARAM;
|
|
TabCtrl_GetItem(ppd->hwndTabs, nItem, &tie.tci);
|
|
return tie.hwndPage;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL _Ppd_IsPageHidden(LPPROPDATA ppd, int nItem)
|
|
{
|
|
if (ppd->hwndTabs)
|
|
{
|
|
TCITEM tci;
|
|
tci.mask = TCIF_STATE;
|
|
tci.dwStateMask = TCIS_HIDDEN;
|
|
if (TabCtrl_GetItem(ppd->hwndTabs, nItem, &tci))
|
|
return tci.dwState;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LRESULT _Ppd_SendNotify(LPPROPDATA ppd, int nItem, int code, LPARAM lParam)
|
|
{
|
|
PSHNOTIFY pshn;
|
|
|
|
pshn.lParam = lParam;
|
|
return SendNotifyEx(_Ppd_GetPage(ppd,nItem), ppd->hDlg, code, (LPNMHDR)&pshn, FALSE);
|
|
}
|
|
|
|
//
|
|
// dwFind = 0 means just move to the current item + iAutoAdjust
|
|
// dwFind != 0 means it's a dialog resource identifier we should look for
|
|
//
|
|
int FindPageIndex(LPPROPDATA ppd, int nCurItem, ULONG_PTR dwFind, LONG_PTR iAutoAdj)
|
|
{
|
|
LRESULT nActivate;
|
|
|
|
if (dwFind == 0) {
|
|
nActivate = nCurItem + iAutoAdj;
|
|
if (((UINT)nActivate) <= ppd->psh.nPages) {
|
|
return((int)nActivate);
|
|
}
|
|
} else {
|
|
for (nActivate = 0; (UINT)nActivate < ppd->psh.nPages; nActivate++) {
|
|
if ((DWORD_PTR)GETPPSP(ppd, nActivate)->P_pszTemplate == dwFind) {
|
|
return((int)nActivate);
|
|
}
|
|
}
|
|
}
|
|
return(-1);
|
|
}
|
|
|
|
//
|
|
// If hpage != NULL, then return the index of the page which matches it,
|
|
// or -1 on failure.
|
|
//
|
|
int FindPageIndexByHpage(LPPROPDATA ppd, HPROPSHEETPAGE hpage)
|
|
{
|
|
int i;
|
|
|
|
//
|
|
// Notice that we explicitly do not do a InternalizeHPROPSHEETPAGE,
|
|
// because the app might be passing us garbage. We just want to
|
|
// say "Nope, can't find garbage here, sorry."
|
|
//
|
|
|
|
for (i = ppd->psh.nPages - 1; i >= 0; i--) {
|
|
if (hpage == GETHPAGE(ppd, i))
|
|
break;
|
|
}
|
|
return i;
|
|
}
|
|
|
|
|
|
// This WM_NEXTDLGCTL stuff works, except for ACT!4.0 which faults randomly
|
|
// I don't know why. The USER people said that removing a
|
|
// SetFocus(NULL) call from SetDlgFocus works, but I tried that
|
|
// and the app merely faulted in a different place. so I'm going
|
|
// back to the old IE4 way, which means that there are scenarios
|
|
// where the DEFID can get out of sync with reality.
|
|
#undef WM_NEXTDLGCTL_WORKS
|
|
|
|
#ifdef WM_NEXTDLGCTL_WORKS
|
|
|
|
//
|
|
// Helper function that manages dialog box focus in a manner that keeps
|
|
// USER in the loop, so we don't get "two buttons both with the bold
|
|
// defpushbutton border" problems.
|
|
//
|
|
// We have to use WM_NEXTDLGCTL to fix defid problems, such as this one:
|
|
//
|
|
// Right-click My Computer, Properties.
|
|
// Go to Advanced tab. Click Environment Variables.
|
|
// Click New. Type a name for a new dummy environment variable.
|
|
// Click OK.
|
|
//
|
|
// At this point (with the old code), the "New" button is a DEFPUSHBUTTON,
|
|
// but the DEFID is IDOK. The USER folks said I should use WM_NEXTDLGCTL
|
|
// to avoid this problem. But using WM_NEXTDLGCTL introduces its own big
|
|
// hairy mess of problems. All the code in this function aside from the
|
|
// SendMessage(WM_NEXTDLGCTL) are to work around "quirks" in WM_NEXTDLGCTL
|
|
// or workarounds for app bugs.
|
|
//
|
|
// THIS CODE IS SUBTLE AND QUICK TO ANGER!
|
|
//
|
|
void SetDlgFocus(LPPROPDATA ppd, HWND hwndFocus)
|
|
{
|
|
//
|
|
// HACK! It's possible that by the time we get around to changing
|
|
// the dialog focus, the dialog box doesn't have focus any more!
|
|
// This happens because PSM_SETWIZBUTTONS is a posted message, so
|
|
// it can arrive *after* focus has moved elsewhere (e.g., to a
|
|
// MessageBox).
|
|
//
|
|
// There is no way to update the dialog box focus without
|
|
// letting it change the real focus (another "quirk" of
|
|
// WM_NEXTDLGCTL), so instead we remember who used to have the
|
|
// focus, let the dialog box do its focus goo, and then restore
|
|
// the focus as necessary.
|
|
//
|
|
HWND hwndFocusPrev = GetFocus();
|
|
|
|
// If focus belonged to a window within our property sheet, then
|
|
// let the dialog box code push the focus around. Otherwise,
|
|
// focus belonged to somebody outside our property sheet, so
|
|
// remember to restore it after we're done.
|
|
|
|
if (hwndFocusPrev && IsChild(ppd->hDlg, hwndFocusPrev))
|
|
hwndFocusPrev = NULL;
|
|
|
|
// USER forgot to revalidate hwndOldFocus at this point, so we have
|
|
// to exit USER (by returning to comctl32) then re-enter USER
|
|
// (in the SendMessage below) so parameter validation will happen
|
|
// again. Sigh.
|
|
|
|
//
|
|
// Bug in Win9x and NT: WM_NEXTDLGCTL will crash if the previous
|
|
// focus window destroys itself in response to WM_KILLFOCUS.
|
|
// (WebTurbo by NetMetrics does this.) There's a missed
|
|
// revalidation so USER ends up using a window handle after
|
|
// it has been destroyed. Oops.
|
|
//
|
|
// (The NT folks consider this "Won't fix, because the system stays
|
|
// up; just the app crashes". The 9x folks will try to get the fix
|
|
// into Win98 OSR.)
|
|
//
|
|
|
|
//
|
|
// Do a manual SetFocus here to make the old focus (if any)
|
|
// do all its WM_KILLFOCUS stuff, and possibly destroy itself (grrr).
|
|
//
|
|
// We have to SetFocus to NULL because some apps (e.g.,
|
|
// Visual C 6.0 setup) do funky things on SetFocus, and our early
|
|
// SetFocus interferes with the EM_SETSEL that WM_NEXTDLGCTL will
|
|
// do later.
|
|
//
|
|
// APP HACK 2: But not if the target focus is the same as the
|
|
// curreng focus, because ACT!4.0 crashes if it receives a
|
|
// WM_KILLFOCUS when it is not expecting one.
|
|
|
|
if (hwndFocus != GetFocus())
|
|
SetFocus(NULL);
|
|
|
|
//
|
|
// Note that by manually shoving the focus around, we
|
|
// have gotten focus and DEFPUSHBUTTON and DEFID all out
|
|
// of sync, which is exactly the problem we're trying to
|
|
// avoid! Fortunately, USER also contains special
|
|
// recovery code to handle the case where somebody "mistakenly" called
|
|
// SetFocus() to change the focus. (I put "mistakenly" in quotes because
|
|
// in this case, we did it on purpose.)
|
|
//
|
|
|
|
SendMessage(ppd->hDlg, WM_NEXTDLGCTL, (WPARAM)hwndFocus, MAKELPARAM(TRUE, 0));
|
|
|
|
//
|
|
// If WM_NEXTDLGCTL damaged the focus, fix it.
|
|
//
|
|
if (hwndFocusPrev)
|
|
SetFocus(hwndFocusPrev);
|
|
}
|
|
#endif
|
|
|
|
void SetNewDefID(LPPROPDATA ppd)
|
|
{
|
|
HWND hDlg = ppd->hDlg;
|
|
HWND hwndFocus;
|
|
hwndFocus = GetNextDlgTabItem(ppd->hwndCurPage, NULL, FALSE);
|
|
ASSERT(hwndFocus);
|
|
if (hwndFocus) {
|
|
#ifndef WM_NEXTDLGCTL_WORKS
|
|
int id;
|
|
if (((DWORD)SendMessage(hwndFocus, WM_GETDLGCODE, 0, 0L)) & DLGC_HASSETSEL)
|
|
{
|
|
// select the text
|
|
Edit_SetSel(hwndFocus, 0, -1);
|
|
}
|
|
|
|
id = GetDlgCtrlID(hwndFocus);
|
|
#endif
|
|
|
|
//
|
|
// See if the handle give to us by GetNextDlgTabItem was any good.
|
|
// (For compatibility reasons, if the dialog contains no tabstops,
|
|
// it returns the first item.)
|
|
//
|
|
if ((GetWindowLong(hwndFocus, GWL_STYLE) & (WS_VISIBLE | WS_DISABLED | WS_TABSTOP)) == (WS_VISIBLE | WS_TABSTOP))
|
|
{
|
|
//
|
|
// Give the page a chance to change the default focus.
|
|
//
|
|
HWND hwndT = (HWND)_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_QUERYINITIALFOCUS, (LPARAM)hwndFocus);
|
|
|
|
// The window had better be valid and a child of the page.
|
|
if (hwndT && IsWindow(hwndT) && IsChild(ppd->hwndCurPage, hwndT))
|
|
{
|
|
hwndFocus = hwndT;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// in prop sheet mode, focus on tabs,
|
|
// in wizard mode, tabs aren't visible, go to idDefFallback
|
|
if (IS_WIZARD(ppd))
|
|
hwndFocus = GetDlgItem(hDlg, ppd->idDefaultFallback);
|
|
else
|
|
hwndFocus = ppd->hwndTabs;
|
|
}
|
|
|
|
#ifdef WM_NEXTDLGCTL_WORKS
|
|
//
|
|
// Aw-right. Go for it.
|
|
//
|
|
SetDlgFocus(ppd, hwndFocus);
|
|
|
|
//
|
|
// Hack for MFC: MFC relies on DM_SETDEFID to know when to
|
|
// update its wizard buttons.
|
|
//
|
|
SendMessage(hDlg, DM_SETDEFID, SendMessage(hDlg, DM_GETDEFID, 0, 0), 0);
|
|
#else
|
|
SetFocus(hwndFocus);
|
|
ResetWizButtons(ppd);
|
|
if (SendDlgItemMessage(ppd->hwndCurPage, id, WM_GETDLGCODE, 0, 0L) & DLGC_UNDEFPUSHBUTTON)
|
|
SendMessage(ppd->hwndCurPage, DM_SETDEFID, id, 0);
|
|
else {
|
|
SendMessage(hDlg, DM_SETDEFID, ppd->idDefaultFallback, 0);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** we are about to change pages. what a nice chance to let the current
|
|
** page validate itself before we go away. if the page decides not
|
|
** to be de-activated, then this'll cancel the page change.
|
|
**
|
|
** return TRUE iff this page failed validation
|
|
*/
|
|
BOOL PageChanging(LPPROPDATA ppd)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
if (ppd && ppd->hwndCurPage)
|
|
{
|
|
bRet = BOOLFROMPTR(_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_KILLACTIVE, 0));
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
void PageChange(LPPROPDATA ppd, int iAutoAdj)
|
|
{
|
|
HWND hwndCurPage;
|
|
HWND hwndCurFocus;
|
|
int nItem;
|
|
HWND hDlg, hwndTabs;
|
|
|
|
TC_ITEMEXTRA tie;
|
|
UINT FlailCount = 0;
|
|
LRESULT lres;
|
|
|
|
if (!ppd)
|
|
{
|
|
return;
|
|
}
|
|
|
|
hDlg = ppd->hDlg;
|
|
hwndTabs = ppd->hwndTabs;
|
|
|
|
// NOTE: the page was already validated (PSN_KILLACTIVE) before
|
|
// the actual page change.
|
|
|
|
hwndCurFocus = GetFocus();
|
|
|
|
TryAgain:
|
|
FlailCount++;
|
|
if (FlailCount > ppd->psh.nPages)
|
|
{
|
|
DebugMsg(DM_TRACE, TEXT("PropSheet PageChange attempt to set activation more than 10 times."));
|
|
return;
|
|
}
|
|
|
|
nItem = TabCtrl_GetCurSel(hwndTabs);
|
|
if (nItem < 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
|
|
TabCtrl_GetItem(hwndTabs, nItem, &tie.tci);
|
|
hwndCurPage = tie.hwndPage;
|
|
|
|
if (!hwndCurPage)
|
|
{
|
|
if ((hwndCurPage = _CreatePage(ppd, GETPISP(ppd, nItem), hDlg, GetMUILanguage())) == NULL)
|
|
{
|
|
/* Should we put up some sort of error message here?
|
|
*/
|
|
RemovePropPageData(ppd, nItem);
|
|
TabCtrl_SetCurSel(hwndTabs, 0);
|
|
goto TryAgain;
|
|
}
|
|
|
|
// tie.tci.mask = TCIF_PARAM;
|
|
tie.hwndPage = hwndCurPage;
|
|
TabCtrl_SetItem(hwndTabs, nItem, &tie.tci);
|
|
|
|
if (HIDEWIZ97HEADER(ppd, nItem))
|
|
// Subclass for back ground watermark painting.
|
|
SetWindowSubclass(hwndCurPage, WizardWndProc, 0, (DWORD_PTR)ppd);
|
|
}
|
|
|
|
// THI WAS REMOVED as part of the fix for bug 18327. The problem is we need to
|
|
// send a SETACTIVE message to a page if it is being activated.
|
|
// if (ppd->hwndCurPage == hwndCurPage)
|
|
// {
|
|
// /* we should be done at this point.
|
|
// */
|
|
// return;
|
|
// }
|
|
|
|
/* Size the dialog and move it to the top of the list before showing
|
|
** it in case there is size specific initializing to be done in the
|
|
** GETACTIVE message.
|
|
*/
|
|
|
|
if (IS_WIZARD(ppd))
|
|
{
|
|
HWND hwndTopDivider= GetDlgItem(hDlg, IDD_TOPDIVIDER);
|
|
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
HWND hwndDivider;
|
|
RECT rcDlg, rcDivider;
|
|
GetClientRect(hDlg, &rcDlg);
|
|
|
|
hwndDivider = GetDlgItemRect(hDlg, IDD_DIVIDER, &rcDivider);
|
|
if (hwndDivider)
|
|
SetWindowPos(hwndDivider, NULL, rcDlg.left, rcDivider.top,
|
|
RECTWIDTH(rcDlg), RECTHEIGHT(rcDivider),
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
|
|
if (GETPPSP(ppd, nItem)->dwFlags & PSP_HIDEHEADER)
|
|
{
|
|
// In this case, we give the whole dialog box except for the portion under the
|
|
// Bottom divider to the property page
|
|
RECT rcTopDivider;
|
|
ShowWindow(hwndTopDivider, SW_HIDE);
|
|
ShowWindow(ppd->hwndTabs, SW_HIDE);
|
|
|
|
hwndTopDivider = GetDlgItemRect(hDlg, IDD_DIVIDER, &rcTopDivider);
|
|
SetWindowPos(hwndCurPage, HWND_TOP, rcDlg.left, rcDlg.top, RECTWIDTH(rcDlg), rcTopDivider.top - rcDlg.top, 0);
|
|
}
|
|
else
|
|
{
|
|
ShowWindow(hwndTopDivider, SW_SHOW);
|
|
ShowWindow(ppd->hwndTabs, SW_SHOW);
|
|
SetWindowPos(hwndCurPage, HWND_TOP, ppd->xSubDlg, ppd->ySubDlg, ppd->cxSubDlg, ppd->cySubDlg, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ShowWindow(hwndTopDivider, SW_HIDE);
|
|
SetWindowPos(hwndCurPage, HWND_TOP, ppd->xSubDlg, ppd->ySubDlg, ppd->cxSubDlg, ppd->cySubDlg, 0);
|
|
}
|
|
} else {
|
|
RECT rcPage;
|
|
GetClientRect(ppd->hwndTabs, &rcPage);
|
|
TabCtrl_AdjustRect(ppd->hwndTabs, FALSE, &rcPage);
|
|
MapWindowPoints(ppd->hwndTabs, hDlg, (LPPOINT)&rcPage, 2);
|
|
SetWindowPos(hwndCurPage, HWND_TOP, rcPage.left, rcPage.top,
|
|
rcPage.right - rcPage.left, rcPage.bottom - rcPage.top, 0);
|
|
}
|
|
|
|
/* We want to send the SETACTIVE message before the window is visible
|
|
** to minimize on flicker if it needs to update fields.
|
|
*/
|
|
|
|
//
|
|
// If the page returns non-zero from the PSN_SETACTIVE call then
|
|
// we will set the activation to the resource ID returned from
|
|
// the call and set activation to it. This is mainly used by wizards
|
|
// to skip a step.
|
|
//
|
|
lres = _Ppd_SendNotify(ppd, nItem, PSN_SETACTIVE, 0);
|
|
|
|
if (lres) {
|
|
int iPageIndex = FindPageIndex(ppd, nItem,
|
|
(lres == -1) ? 0 : lres, iAutoAdj);
|
|
|
|
|
|
if ((lres == -1) &&
|
|
(nItem == iPageIndex || iPageIndex >= TabCtrl_GetItemCount(hwndTabs))) {
|
|
iPageIndex = ppd->nCurItem;
|
|
}
|
|
|
|
if (iPageIndex != -1) {
|
|
TabCtrl_SetCurSel(hwndTabs, iPageIndex);
|
|
ShowWindow(hwndCurPage, SW_HIDE);
|
|
goto TryAgain;
|
|
}
|
|
}
|
|
|
|
if (ppd->psh.dwFlags & PSH_HASHELP) {
|
|
// PSH_HASHELP controls the "Help" button at the bottom
|
|
// PSH_NOCONTEXTHELP controls the caption "?" button
|
|
Button_Enable(GetDlgItem(hDlg, IDHELP),
|
|
(BOOL)(GETPPSP(ppd, nItem)->dwFlags & PSP_HASHELP));
|
|
}
|
|
|
|
//
|
|
// If this is a wizard then we'll set the dialog's title to the tab
|
|
// title.
|
|
//
|
|
if (IS_WIZARD(ppd)) {
|
|
TC_ITEMEXTRA tie;
|
|
TCHAR szTemp[128 + 50];
|
|
szTemp[0] = 0;
|
|
|
|
tie.tci.mask = TCIF_TEXT;
|
|
tie.tci.pszText = szTemp;
|
|
tie.tci.cchTextMax = ARRAYSIZE(szTemp);
|
|
if (TabCtrl_GetItem(hwndTabs, nItem, &tie.tci))
|
|
{
|
|
#ifdef WINDOWS_ME
|
|
tie.tci.mask = TCIF_RTLREADING;
|
|
tie.tci.cchTextMax = 0;
|
|
// hack, use cchTextMax to query tab item reading order
|
|
TabCtrl_GetItem(hwndTabs, nItem, &tie.tci);
|
|
if( (ppd->psh.dwFlags & PSH_RTLREADING) || (tie.tci.cchTextMax))
|
|
SetWindowLong(hDlg, GWL_EXSTYLE, GetWindowLong(hDlg, GWL_EXSTYLE) | WS_EX_RTLREADING);
|
|
else
|
|
SetWindowLong(hDlg, GWL_EXSTYLE, GetWindowLong(hDlg, GWL_EXSTYLE) & ~WS_EX_RTLREADING);
|
|
#endif // WINDOWS_ME
|
|
|
|
if (szTemp[0])
|
|
SetWindowText(hDlg, szTemp);
|
|
}
|
|
}
|
|
|
|
/* Disable all erasebkgnd messages that come through because windows
|
|
** are getting shuffled. Note that we need to call ShowWindow (and
|
|
** not show the window in some other way) because DavidDs is counting
|
|
** on the correct parameters to the WM_SHOWWINDOW message, and we may
|
|
** document how to keep your page from flashing.
|
|
*/
|
|
ppd->fFlags |= PD_NOERASE;
|
|
ShowWindow(hwndCurPage, SW_SHOW);
|
|
if (ppd->hwndCurPage && (ppd->hwndCurPage != hwndCurPage))
|
|
{
|
|
ShowWindow(ppd->hwndCurPage, SW_HIDE);
|
|
}
|
|
ppd->fFlags &= ~PD_NOERASE;
|
|
|
|
ppd->hwndCurPage = hwndCurPage;
|
|
ppd->nCurItem = nItem;
|
|
|
|
/* Newly created dialogs seem to steal the focus, so we steal it back
|
|
** to the page list, which must have had the focus to get to this
|
|
** point. If this is a wizard then set the focus to the dialog of
|
|
** the page. Otherwise, set the focus to the tabs.
|
|
*/
|
|
if (hwndCurFocus != hwndTabs)
|
|
{
|
|
SetNewDefID(ppd);
|
|
}
|
|
else
|
|
{
|
|
// The focus may have been stolen from us, bring it back
|
|
SendMessage(hDlg, WM_NEXTDLGCTL, (WPARAM)hwndTabs, (LPARAM)TRUE);
|
|
}
|
|
|
|
// make sure the header is repaint
|
|
if ((ppd->psh.dwFlags & PSH_WIZARD97) && (!(GETPPSP(ppd, nItem)->dwFlags & PSP_HIDEHEADER)))
|
|
InvalidateRect(hDlg, NULL,TRUE);
|
|
}
|
|
|
|
#define DECLAREWAITCURSOR HCURSOR hcursor_wait_cursor_save
|
|
#define SetWaitCursor() hcursor_wait_cursor_save = SetCursor(LoadCursor(NULL, IDC_WAIT))
|
|
#define ResetWaitCursor() SetCursor(hcursor_wait_cursor_save)
|
|
|
|
//
|
|
// HACKHACK (reinerf)
|
|
//
|
|
// This function sends the PSN_LASTCHANCEAPPLY right after the property sheets have had "ok"
|
|
// pressed. This allows the "General" tab on the file/folder properties to do a rename, so that
|
|
// it wont rename the file out from under the other pages, and have them barf when they go to
|
|
// persist their info.
|
|
//
|
|
void SendLastChanceApply(LPPROPDATA ppd)
|
|
{
|
|
TC_ITEMEXTRA tie;
|
|
int nItem;
|
|
int nItems = TabCtrl_GetItemCount(ppd->hwndTabs);
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
|
|
// we start with the last tab and count towards the first. This ensures
|
|
// that the more important tabs (such as the "General" tab) will be the last
|
|
// to recieve the PSN_LASTCHANCEAPPLY message.
|
|
for (nItem = nItems - 1; nItem >= 0; nItem--)
|
|
{
|
|
TabCtrl_GetItem(ppd->hwndTabs, nItem, &tie.tci);
|
|
|
|
if (tie.hwndPage)
|
|
{
|
|
// we ignore the return vale from the PSN_LASTCHANCEAPPLY message since
|
|
// there are probably prop sheet extensions that return both TRUE and
|
|
// FALSE for messages that they dont process...(sigh)
|
|
_Ppd_SendNotify(ppd, nItem, PSN_LASTCHANCEAPPLY, (LPARAM)TRUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef MAINWIN
|
|
EXTERN_C HKEY HKEY_ROOT;
|
|
#endif
|
|
|
|
// return TRUE iff all sheets successfully handle the notification
|
|
BOOL ButtonPushed(LPPROPDATA ppd, WPARAM wParam)
|
|
{
|
|
HWND hwndTabs;
|
|
int nItems, nItem;
|
|
int nNotify;
|
|
TC_ITEMEXTRA tie;
|
|
BOOL bExit = FALSE;
|
|
int nReturnNew = ppd->nReturn;
|
|
int fSuccess = TRUE;
|
|
DECLAREWAITCURSOR;
|
|
LRESULT lres = 0;
|
|
LPARAM lParam = FALSE;
|
|
LPARAM nButtonPressed = 0;
|
|
|
|
switch (wParam)
|
|
{
|
|
case IDOK:
|
|
nButtonPressed = PSBTN_OK;
|
|
lParam = TRUE;
|
|
bExit = TRUE;
|
|
// Fall through...
|
|
|
|
case IDD_APPLYNOW:
|
|
if (IDD_APPLYNOW == wParam)
|
|
{
|
|
nButtonPressed = PSBTN_APPLYNOW;
|
|
}
|
|
|
|
// First allow the current dialog to validate itself.
|
|
if (_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_KILLACTIVE, 0))
|
|
return FALSE;
|
|
|
|
nReturnNew = 1;
|
|
|
|
nNotify = PSN_APPLY;
|
|
break;
|
|
|
|
case IDCLOSE:
|
|
nButtonPressed = PSBTN_FINISH;
|
|
lParam = TRUE;
|
|
// fall through
|
|
case IDCANCEL:
|
|
if (IDCANCEL == wParam)
|
|
{
|
|
nButtonPressed = PSBTN_CANCEL;
|
|
}
|
|
bExit = TRUE;
|
|
nNotify = PSN_RESET;
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
if (ppd && ppd->psh.pfnCallback && nButtonPressed)
|
|
{
|
|
ppd->psh.pfnCallback(NULL, PSCB_BUTTONPRESSED, nButtonPressed);
|
|
}
|
|
|
|
SetWaitCursor();
|
|
|
|
hwndTabs = ppd->hwndTabs;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
|
|
nItems = TabCtrl_GetItemCount(hwndTabs);
|
|
for (nItem = 0; nItem < nItems; ++nItem)
|
|
{
|
|
|
|
TabCtrl_GetItem(hwndTabs, nItem, &tie.tci);
|
|
|
|
if (tie.hwndPage)
|
|
{
|
|
/* If the dialog fails a PSN_APPY call (by returning TRUE),
|
|
** then it has invalid information on it (should be verified
|
|
** on the PSN_KILLACTIVE, but that is not always possible)
|
|
** and we want to abort the notifications. We select the failed
|
|
** page below.
|
|
*/
|
|
lres = _Ppd_SendNotify(ppd, nItem, nNotify, lParam);
|
|
|
|
if (lres)
|
|
{
|
|
fSuccess = FALSE;
|
|
bExit = FALSE;
|
|
break;
|
|
} else {
|
|
// if we need a restart (Apply or OK), then this is an exit
|
|
if ((nNotify == PSN_APPLY) && !bExit && ppd->nRestart) {
|
|
DebugMsg(DM_TRACE, TEXT("PropertySheet: restart flags force close"));
|
|
bExit = TRUE;
|
|
}
|
|
}
|
|
|
|
/* We have either reset or applied, so everything is
|
|
** up to date.
|
|
*/
|
|
tie.state &= ~FLAG_CHANGED;
|
|
// tie.tci.mask = TCIF_PARAM; // already set
|
|
TabCtrl_SetItem(hwndTabs, nItem, &tie.tci);
|
|
}
|
|
}
|
|
|
|
#ifdef MAINWIN
|
|
// This is a temporary solution for saving the
|
|
// registry options incase IE doesnot shutdown
|
|
// normaly.
|
|
if( nNotify == PSN_APPLY )
|
|
RegSaveKey(HKEY_ROOT, NULL, NULL);
|
|
#endif
|
|
|
|
/* If we leave ppd->hwndCurPage as NULL, it will tell the main
|
|
** loop to exit.
|
|
*/
|
|
if (fSuccess)
|
|
{
|
|
ppd->hwndCurPage = NULL;
|
|
}
|
|
else if (lres != PSNRET_INVALID_NOCHANGEPAGE)
|
|
{
|
|
// Need to change to the page that caused the failure.
|
|
// if lres == PSN_INVALID_NOCHANGEPAGE, then assume sheet has already
|
|
// changed to the page with the invalid information on it
|
|
TabCtrl_SetCurSel(hwndTabs, nItem);
|
|
}
|
|
|
|
if (fSuccess)
|
|
{
|
|
// Set to the cached value
|
|
ppd->nReturn = nReturnNew;
|
|
}
|
|
|
|
if (!bExit)
|
|
{
|
|
// before PageChange, so ApplyNow gets disabled faster.
|
|
if (fSuccess)
|
|
{
|
|
TCHAR szOK[30];
|
|
HWND hwndApply;
|
|
|
|
if (!IS_WIZARD(ppd)) {
|
|
// The ApplyNow button should always be disabled after
|
|
// a successfull apply/cancel, since no change has been made yet.
|
|
hwndApply = GetDlgItem(ppd->hDlg, IDD_APPLYNOW);
|
|
Button_SetStyle(hwndApply, BS_PUSHBUTTON, TRUE);
|
|
EnableWindow(hwndApply, FALSE);
|
|
ResetWizButtons(ppd);
|
|
SendMessage(ppd->hDlg, DM_SETDEFID, IDOK, 0);
|
|
ppd->idDefaultFallback = IDOK;
|
|
}
|
|
|
|
// Undo PSM_CANCELTOCLOSE for the same reasons.
|
|
if (ppd->fFlags & PD_CANCELTOCLOSE)
|
|
{
|
|
ppd->fFlags &= ~PD_CANCELTOCLOSE;
|
|
LocalizedLoadString(IDS_OK, szOK, ARRAYSIZE(szOK));
|
|
SetDlgItemText(ppd->hDlg, IDOK, szOK);
|
|
EnableWindow(GetDlgItem(ppd->hDlg, IDCANCEL), TRUE);
|
|
}
|
|
}
|
|
|
|
/* Re-"select" the current item and get the whole list to
|
|
** repaint.
|
|
*/
|
|
if (lres != PSNRET_INVALID_NOCHANGEPAGE)
|
|
PageChange(ppd, 1);
|
|
}
|
|
|
|
ResetWaitCursor();
|
|
|
|
return(fSuccess);
|
|
}
|
|
|
|
// Win3.1 USER didn't handle DM_SETDEFID very well-- it's very possible to get
|
|
// multiple buttons with the default button style look. This has been fixed
|
|
// for Win95, but the Setup wizard needs this hack when running from 3.1.
|
|
|
|
// it seems win95 doesn't handle it well either..
|
|
void ResetWizButtons(LPPROPDATA ppd)
|
|
{
|
|
int id;
|
|
|
|
if (IS_WIZARD(ppd)) {
|
|
|
|
for (id = 0; id < ARRAYSIZE(WizIDs); id++)
|
|
SendDlgItemMessage(ppd->hDlg, WizIDs[id], BM_SETSTYLE, BS_PUSHBUTTON, TRUE);
|
|
}
|
|
}
|
|
|
|
void SetWizButtons(LPPROPDATA ppd, LPARAM lParam)
|
|
{
|
|
int idDef;
|
|
int iShowID = IDD_NEXT;
|
|
int iHideID = IDD_FINISH;
|
|
BOOL bEnabled;
|
|
BOOL bResetFocus;
|
|
HWND hwndShow;
|
|
HWND hwndFocus = GetFocus();
|
|
HWND hwndHide;
|
|
HWND hwndBack;
|
|
HWND hDlg = ppd->hDlg;
|
|
|
|
idDef = (int)LOWORD(SendMessage(hDlg, DM_GETDEFID, 0, 0));
|
|
|
|
// Enable/Disable the IDD_BACK button
|
|
hwndBack = GetDlgItem(hDlg, IDD_BACK);
|
|
bEnabled = (lParam & PSWIZB_BACK) != 0;
|
|
EnableWindow(hwndBack, bEnabled);
|
|
|
|
// Enable/Disable the IDD_NEXT button, and Next gets shown by default
|
|
// bEnabled remembers whether hwndShow should be enabled or not
|
|
hwndShow = GetDlgItem(hDlg, IDD_NEXT);
|
|
bEnabled = (lParam & PSWIZB_NEXT) != 0;
|
|
EnableWindow(hwndShow, bEnabled);
|
|
|
|
// Enable/Disable Show/Hide the IDD_FINISH button
|
|
if (lParam & (PSWIZB_FINISH | PSWIZB_DISABLEDFINISH)) {
|
|
iShowID = IDD_FINISH; // If Finish is being shown
|
|
iHideID = IDD_NEXT; // then Next isn't
|
|
|
|
hwndShow = GetDlgItem(hDlg, IDD_FINISH);
|
|
bEnabled = (lParam & PSWIZB_FINISH) != 0;
|
|
EnableWindow(hwndShow, bEnabled);
|
|
}
|
|
|
|
if (!(ppd->psh.dwFlags & PSH_WIZARDHASFINISH)) {
|
|
hwndHide = GetDlgItem(hDlg, iHideID);
|
|
ShowWindow(hwndHide, SW_HIDE);
|
|
// Cannot disable the window; see Prsht_ButtonSubclassProc for explanation.
|
|
// WRONG - EnableWindow(hwndHide, FALSE);
|
|
|
|
hwndShow = GetDlgItem(hDlg, iShowID);
|
|
// Cannot disable the window; see Prsht_ButtonSubclassProc for explanation.
|
|
// WRONG - EnableWindow(hwndShow, bEnabled);
|
|
ShowWindow(hwndShow, SW_SHOW);
|
|
}
|
|
|
|
|
|
// bResetFocus keeps track of whether or not we need to set Focus to our button
|
|
bResetFocus = FALSE;
|
|
if (hwndFocus)
|
|
{
|
|
// if the dude that has focus is a button, we want to steal focus away
|
|
// so users can just press enter all the way through a property sheet,
|
|
// getting the default as they go. this also catches the case
|
|
// of where focus is on one of our buttons which was turned off.
|
|
if (SendMessage(hwndFocus, WM_GETDLGCODE, 0, 0L) & (DLGC_UNDEFPUSHBUTTON|DLGC_DEFPUSHBUTTON))
|
|
bResetFocus = TRUE;
|
|
}
|
|
if (!bResetFocus)
|
|
{
|
|
// if there is no focus or we're focused on an invisible/disabled
|
|
// item on the sheet, grab focus.
|
|
bResetFocus = !hwndFocus || !IsWindowVisible(hwndFocus) || !IsWindowEnabled(hwndFocus) ;
|
|
}
|
|
|
|
// We used to do this code only if we nuked a button which had default
|
|
// or if bResetFocus. Unfortunately, some wizards turn off BACK+NEXT
|
|
// and then when they turn them back on, they want DEFID on NEXT.
|
|
// So now we always reset DEFID.
|
|
{
|
|
static const int ids[4] = { IDD_NEXT, IDD_FINISH, IDD_BACK, IDCANCEL };
|
|
int i;
|
|
HWND hwndNewFocus = NULL;
|
|
|
|
for (i = 0; i < ARRAYSIZE(ids); i++) {
|
|
hwndNewFocus = GetDlgItem(hDlg, ids[i]);
|
|
|
|
// can't do IsVisible because we may be doing this
|
|
// before the prop sheet as a whole is shown
|
|
if ((GetWindowLong(hwndNewFocus, GWL_STYLE) & WS_VISIBLE) &&
|
|
IsWindowEnabled(hwndNewFocus)) {
|
|
hwndFocus = hwndNewFocus;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ppd->idDefaultFallback = ids[i];
|
|
if (bResetFocus) {
|
|
if (!hwndNewFocus)
|
|
hwndNewFocus = hDlg;
|
|
#ifdef WM_NEXTDLGCTL_WORKS
|
|
SetDlgFocus(ppd, hwndNewFocus);
|
|
#else
|
|
// 337614 - Since PSM_SETWIZBUTTONS is often a posted message,
|
|
// we may end up here when we don't even have focus at all
|
|
// (caller went on and called MessageBox or something before
|
|
// we got a chance to set the buttons). So do this only if
|
|
// focus belongs to our dialog box (or if it's nowhere).
|
|
hwndFocus = GetFocus();
|
|
if (!hwndFocus || (ppd->hDlg == hwndFocus || IsChild(ppd->hDlg, hwndFocus)))
|
|
SetFocus(hwndNewFocus);
|
|
#endif
|
|
}
|
|
ResetWizButtons(ppd);
|
|
SendMessage(hDlg, DM_SETDEFID, ids[i], 0);
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// lptie = NULL means "I don't care about the other goop, just give me
|
|
// the index."
|
|
//
|
|
int FindItem(HWND hwndTabs, HWND hwndPage, TC_ITEMEXTRA * lptie)
|
|
{
|
|
int i;
|
|
TC_ITEMEXTRA tie;
|
|
|
|
if (!lptie)
|
|
{
|
|
tie.tci.mask = TCIF_PARAM;
|
|
lptie = &tie;
|
|
}
|
|
|
|
for (i = TabCtrl_GetItemCount(hwndTabs) - 1; i >= 0; --i)
|
|
{
|
|
TabCtrl_GetItem(hwndTabs, i, &lptie->tci);
|
|
|
|
if (lptie->hwndPage == hwndPage)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//this will be -1 if the for loop falls out.
|
|
return i;
|
|
}
|
|
|
|
// a page is telling us that something on it has changed and thus
|
|
// "Apply Now" should be enabled
|
|
|
|
void PageInfoChange(LPPROPDATA ppd, HWND hwndPage)
|
|
{
|
|
int i;
|
|
TC_ITEMEXTRA tie;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
i = FindItem(ppd->hwndTabs, hwndPage, &tie);
|
|
|
|
if (i == -1)
|
|
return;
|
|
|
|
if (!(tie.state & FLAG_CHANGED))
|
|
{
|
|
// tie.tci.mask = TCIF_PARAM; // already set
|
|
tie.state |= FLAG_CHANGED;
|
|
TabCtrl_SetItem(ppd->hwndTabs, i, &tie.tci);
|
|
}
|
|
|
|
if (ppd->fAllowApply)
|
|
EnableWindow(GetDlgItem(ppd->hDlg, IDD_APPLYNOW), TRUE);
|
|
}
|
|
|
|
// a page is telling us that everything has reverted to its last
|
|
// saved state.
|
|
|
|
void PageInfoUnChange(LPPROPDATA ppd, HWND hwndPage)
|
|
{
|
|
int i;
|
|
TC_ITEMEXTRA tie;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
i = FindItem(ppd->hwndTabs, hwndPage, &tie);
|
|
|
|
if (i == -1)
|
|
return;
|
|
|
|
if (tie.state & FLAG_CHANGED)
|
|
{
|
|
tie.state &= ~FLAG_CHANGED;
|
|
TabCtrl_SetItem(ppd->hwndTabs, i, &tie.tci);
|
|
}
|
|
|
|
// check all the pages, if none are FLAG_CHANGED, disable IDD_APLYNOW
|
|
for (i = ppd->psh.nPages-1 ; i >= 0 ; i--)
|
|
{
|
|
if (!TabCtrl_GetItem(ppd->hwndTabs, i, &tie.tci))
|
|
break;
|
|
if (tie.state & FLAG_CHANGED)
|
|
break;
|
|
}
|
|
if (i<0)
|
|
EnableWindow(GetDlgItem(ppd->hDlg, IDD_APPLYNOW), FALSE);
|
|
}
|
|
|
|
HDWP Prsht_RepositionControl(LPPROPDATA ppd, HWND hwnd, HDWP hdwp,
|
|
int dxMove, int dyMove, int dxSize, int dySize)
|
|
{
|
|
if (hwnd) {
|
|
RECT rc;
|
|
GetWindowRect(hwnd, &rc);
|
|
MapWindowRect(HWND_DESKTOP, ppd->hDlg, &rc);
|
|
hdwp = DeferWindowPos(hdwp, hwnd, NULL,
|
|
rc.left + dxMove, rc.top + dyMove,
|
|
RECTWIDTH(rc) + dxSize, RECTHEIGHT(rc) + dySize,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
return hdwp;
|
|
}
|
|
|
|
//
|
|
// dxSize/(dySize+dyMove) is the amount by which to resize the tab control.
|
|
// dxSize/dySize controls how much the dialog should be grown.
|
|
// Buttons move by (dxSize, dySize+dyMove).
|
|
//
|
|
|
|
BOOL Prsht_ResizeDialog(LPPROPDATA ppd, int dxSize, int dySize, int dyMove)
|
|
{
|
|
BOOL fChanged = dxSize || dySize || dyMove;
|
|
if (fChanged)
|
|
{
|
|
int dxMove = 0; // To make the code more symmetric in x and y
|
|
int dxAll = dxSize + dxMove;
|
|
int dyAll = dySize + dyMove;
|
|
RECT rc;
|
|
UINT i;
|
|
const int *rgid;
|
|
UINT cid;
|
|
HDWP hdwp;
|
|
HWND hwnd;
|
|
|
|
// Use DeferWindowPos to avoid flickering. We expect to move
|
|
// the tab control, up to five buttons, two possible dividers,
|
|
// plus the current page. (And a partridge in a pear tree.)
|
|
//
|
|
|
|
hdwp = BeginDeferWindowPos(1 + 5 + 2 + 1);
|
|
|
|
// The tab control just sizes.
|
|
hdwp = Prsht_RepositionControl(ppd, ppd->hwndTabs, hdwp,
|
|
0, 0, dxAll, dyAll);
|
|
|
|
//
|
|
// Move and size the current page. We can't trust its location
|
|
// or size, since PageChange shoves it around without updating
|
|
// ppd->ySubDlg.
|
|
//
|
|
if (ppd->hwndCurPage) {
|
|
hdwp = DeferWindowPos(hdwp, ppd->hwndCurPage, NULL,
|
|
ppd->xSubDlg, ppd->ySubDlg,
|
|
ppd->cxSubDlg, ppd->cySubDlg,
|
|
SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
//
|
|
// And our buttons just move by both the size and move (since they
|
|
// lie below both the tabs and the pages).
|
|
//
|
|
if (IS_WIZARD(ppd)) {
|
|
//
|
|
// Ooh, wait, reposition the separator lines, too.
|
|
// Moves vertically but resizes horizontally.
|
|
//
|
|
hwnd = GetDlgItem(ppd->hDlg, IDD_DIVIDER);
|
|
hdwp = Prsht_RepositionControl(ppd, hwnd, hdwp,
|
|
0, dyAll, dxAll, 0);
|
|
|
|
//
|
|
// The top divider does not move vertically since it lies
|
|
// above the area that is changing.
|
|
//
|
|
hwnd = GetDlgItem(ppd->hDlg, IDD_TOPDIVIDER);
|
|
hdwp = Prsht_RepositionControl(ppd, hwnd, hdwp,
|
|
0, 0, dxAll, 0);
|
|
|
|
rgid = WizIDs;
|
|
cid = ARRAYSIZE(WizIDs);
|
|
} else {
|
|
rgid = IDs;
|
|
cid = ARRAYSIZE(IDs);
|
|
}
|
|
|
|
for (i = 0 ; i < cid; i++)
|
|
{
|
|
hwnd = GetDlgItem(ppd->hDlg, rgid[i]);
|
|
hdwp = Prsht_RepositionControl(ppd, hwnd, hdwp,
|
|
dxAll, dyAll, 0, 0);
|
|
}
|
|
|
|
// All finished sizing and moving. Let 'er rip!
|
|
if (hdwp)
|
|
EndDeferWindowPos(hdwp);
|
|
|
|
// Grow ourselves as well
|
|
GetWindowRect(ppd->hDlg, &rc);
|
|
SetWindowPos(ppd->hDlg, NULL, 0, 0,
|
|
RECTWIDTH(rc) + dxAll, RECTHEIGHT(rc) + dyAll,
|
|
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
return fChanged;
|
|
}
|
|
|
|
BOOL Prsht_RecalcPageSizes(LPPROPDATA ppd)
|
|
{
|
|
SIZE siz;
|
|
int dxSize = 0, dySize = 0, dyMove = 0;
|
|
|
|
// After inserting or removing a page, the tab control may have
|
|
// changed height. If so, then we need to resize ourselves to
|
|
// accomodate the growth or shrinkage, so that all the tabs remain
|
|
// visible.
|
|
//
|
|
// APP COMPAT! We cannot do this by default because Jamba 1.1
|
|
// **FAULTS** if the property sheet changes size after creation.
|
|
// Grrrrrr...
|
|
|
|
// Wizards don't have a visible tab control,
|
|
// so do this only for non-wizards
|
|
if (!IS_WIZARD(ppd))
|
|
{
|
|
RECT rc;
|
|
|
|
// Get the client rect of the tab control in dialog coords
|
|
GetClientRect(ppd->hwndTabs, &rc);
|
|
MapWindowRect(ppd->hwndTabs, ppd->hDlg, &rc);
|
|
|
|
// See how many rows there are now
|
|
TabCtrl_AdjustRect(ppd->hwndTabs, FALSE, &rc);
|
|
|
|
// rc.top is the new ySubDlg. Compute the amount we have to move.
|
|
dyMove = rc.top - ppd->ySubDlg;
|
|
ppd->ySubDlg = rc.top;
|
|
}
|
|
|
|
Prsht_GetIdealPageSize(ppd, &siz, GIPS_SKIPEXTERIOR97HEIGHT);
|
|
dxSize = siz.cx - ppd->cxSubDlg;
|
|
dySize = siz.cy - ppd->cySubDlg;
|
|
ppd->cxSubDlg = siz.cx;
|
|
ppd->cySubDlg = siz.cy;
|
|
return Prsht_ResizeDialog(ppd, dxSize, dySize, dyMove);
|
|
}
|
|
|
|
//
|
|
// InsertPropPage
|
|
//
|
|
// hpage is the page being inserted.
|
|
//
|
|
// hpageInsertAfter described where it should be inserted.
|
|
//
|
|
// hpageInsertAfter can be...
|
|
//
|
|
// MAKEINTRESOURCE(index) to insert at a specific index.
|
|
//
|
|
// NULL to insert at the beginning
|
|
//
|
|
// an HPROPSHEETPAGE to insert *after* that page
|
|
//
|
|
BOOL InsertPropPage(LPPROPDATA ppd, PSP * hpageInsertAfter,
|
|
PSP * hpage)
|
|
{
|
|
TC_ITEMEXTRA tie;
|
|
int nPage;
|
|
HIMAGELIST himl;
|
|
PAGEINFOEX pi;
|
|
PISP pisp;
|
|
int idx;
|
|
|
|
hpage = _Hijaak95Hack(ppd, hpage);
|
|
|
|
if (!hpage)
|
|
return FALSE;
|
|
|
|
if (ppd->psh.nPages >= MAXPROPPAGES)
|
|
return FALSE; // we're full
|
|
|
|
if (IS_INTRESOURCE(hpageInsertAfter))
|
|
{
|
|
// Inserting by index
|
|
idx = (int) PtrToLong(hpageInsertAfter);
|
|
|
|
// Attempting to insert past the end is the same as appending.
|
|
if (idx > (int)ppd->psh.nPages)
|
|
idx = (int)ppd->psh.nPages;
|
|
}
|
|
else
|
|
{
|
|
// Inserting by hpageInsertAfter.
|
|
for (idx = 0; idx < (int)(ppd->psh.nPages); idx++) {
|
|
if (hpageInsertAfter == GETHPAGE(ppd, idx))
|
|
break;
|
|
}
|
|
|
|
if (idx >= (int)(ppd->psh.nPages))
|
|
return FALSE; // hpageInsertAfter not found
|
|
|
|
idx++; // idx Points to the insertion location (to the right of hpageInsertAfter)
|
|
ASSERT(hpageInsertAfter == GETHPAGE(ppd, idx-1));
|
|
}
|
|
|
|
ASSERT(idx <= (int)(ppd->psh.nPages+1));
|
|
|
|
// Shift all pages adjacent to the insertion point to the right
|
|
for (nPage=ppd->psh.nPages - 1; nPage >= idx; nPage--)
|
|
SETPISP(ppd, nPage+1, GETPISP(ppd, nPage));
|
|
|
|
// Insert the new page
|
|
pisp = InternalizeHPROPSHEETPAGE(hpage);
|
|
SETPISP(ppd, idx, pisp);
|
|
|
|
ppd->psh.nPages++;
|
|
|
|
himl = TabCtrl_GetImageList(ppd->hwndTabs);
|
|
|
|
if (!GetPageInfoEx(ppd, pisp, &pi, GetMUILanguage(),
|
|
GPI_ICON | GPI_BRTL | GPI_CAPTION | GPI_FONT | GPI_DIALOGEX))
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("InsertPropPage: GetPageInfo failed"));
|
|
goto bogus;
|
|
}
|
|
|
|
Prsht_ComputeIdealPageSize(ppd, pisp, &pi);
|
|
|
|
#ifndef WINDOWS_ME
|
|
tie.tci.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE;
|
|
#else
|
|
tie.tci.mask = TCIF_TEXT | TCIF_PARAM | TCIF_IMAGE | (pi.bRTL ? TCIF_RTLREADING : 0);
|
|
#endif
|
|
tie.hwndPage = NULL;
|
|
tie.tci.pszText = pi.szCaption;
|
|
tie.state = 0;
|
|
|
|
|
|
if (pi.hIcon) {
|
|
if (himl)
|
|
tie.tci.iImage = ImageList_AddIcon(himl, pi.hIcon);
|
|
DestroyIcon(pi.hIcon);
|
|
} else {
|
|
tie.tci.iImage = -1;
|
|
}
|
|
|
|
// Insert the page into the tab list
|
|
TabCtrl_InsertItem(ppd->hwndTabs, idx, &tie.tci);
|
|
|
|
// If this page wants premature initialization then init it
|
|
// do this last so pages can rely on "being there" at init time
|
|
if (pisp->_psp.dwFlags & PSP_PREMATURE)
|
|
{
|
|
if ((tie.hwndPage = _CreatePage(ppd, pisp, ppd->hDlg, GetMUILanguage())) == NULL)
|
|
{
|
|
TabCtrl_DeleteItem(ppd->hwndTabs, idx);
|
|
// don't free the pisp here let the caller do it
|
|
// REARCHITECT raymondc - but caller doesn't know if hIcon has been destroyed
|
|
goto bogus;
|
|
}
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
TabCtrl_SetItem(ppd->hwndTabs, idx, &tie.tci);
|
|
}
|
|
|
|
// Adjust the internally track current item if it is to the right of our insertion point
|
|
if (ppd->nCurItem >= idx)
|
|
ppd->nCurItem++;
|
|
|
|
return TRUE;
|
|
|
|
bogus:
|
|
// Shift everything back
|
|
for (nPage=idx; nPage < (int)(ppd->psh.nPages-1); nPage++)
|
|
SETPISP(ppd, nPage, GETPISP(ppd, nPage+1));
|
|
|
|
ppd->psh.nPages--;
|
|
return FALSE;
|
|
}
|
|
|
|
#define AddPropPage(ppd, hpage) InsertPropPage(ppd, (LPVOID)MAKEINTRESOURCE(-1), hpage)
|
|
|
|
// removes property sheet hpage (index if NULL)
|
|
void RemovePropPage(LPPROPDATA ppd, int index, HPROPSHEETPAGE hpage)
|
|
{
|
|
int i = -1;
|
|
BOOL fReturn = TRUE;
|
|
TC_ITEMEXTRA tie;
|
|
|
|
//
|
|
// Notice that we explicitly do not do a InternalizeHPROPSHEETPAGE,
|
|
// because the app might be passing us garbage. We just want to
|
|
// say "Nope, can't find garbage here, sorry."
|
|
//
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
if (hpage) {
|
|
i = FindPageIndexByHpage(ppd, hpage);
|
|
}
|
|
if (i == -1) {
|
|
i = index;
|
|
|
|
// this catches i < 0 && i >= (int)(ppd->psh.nPages)
|
|
if ((UINT)i >= ppd->psh.nPages)
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("RemovePropPage: invalid page"));
|
|
return;
|
|
}
|
|
}
|
|
|
|
index = TabCtrl_GetCurSel(ppd->hwndTabs);
|
|
if (i == index) {
|
|
// if we're removing the current page, select another (don't worry
|
|
// about this page having invalid information on it -- we're nuking it)
|
|
PageChanging(ppd);
|
|
|
|
if (index == 0)
|
|
index++;
|
|
else
|
|
index--;
|
|
|
|
if (SendMessage(ppd->hwndTabs, TCM_SETCURSEL, index, 0L) == -1) {
|
|
// if we couldn't select (find) the new one, punt to 0th
|
|
SendMessage(ppd->hwndTabs, TCM_SETCURSEL, 0, 0L);
|
|
}
|
|
PageChange(ppd, 1);
|
|
}
|
|
|
|
// REARCHITECT if removing a page below ppd->nCurItem, need to update
|
|
// nCurItem to prevent it from getting out of sync with hwndCurPage?
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
TabCtrl_GetItem(ppd->hwndTabs, i, &tie.tci);
|
|
if (tie.hwndPage) {
|
|
if (ppd->hwndCurPage == tie.hwndPage)
|
|
ppd->hwndCurPage = NULL;
|
|
DestroyWindow(tie.hwndPage);
|
|
}
|
|
|
|
RemovePropPageData(ppd, i);
|
|
}
|
|
|
|
void RemovePropPageData(LPPROPDATA ppd, int nPage)
|
|
{
|
|
ULONG_PTR dw = PropPageActivateContext(ppd, GETPISP(ppd, nPage));
|
|
TabCtrl_DeleteItem(ppd->hwndTabs, nPage);
|
|
DestroyPropertySheetPage(GETHPAGE(ppd, nPage));
|
|
PropPageDeactivateContext(dw);
|
|
|
|
//
|
|
// Delete the HPROPSHEETPAGE from our table and slide everybody down.
|
|
//
|
|
ppd->psh.nPages--;
|
|
hmemcpy(&ppd->psh.H_phpage[nPage], &ppd->psh.H_phpage[nPage + 1],
|
|
sizeof(ppd->psh.H_phpage[0]) * (ppd->psh.nPages - nPage));
|
|
}
|
|
|
|
// returns TRUE iff the page was successfully set to index/hpage
|
|
// Note: The iAutoAdj should be set to 1 or -1. This value is used
|
|
// by PageChange if a page refuses a SETACTIVE to either increment
|
|
// or decrement the page index.
|
|
BOOL PageSetSelection(LPPROPDATA ppd, int index, HPROPSHEETPAGE hpage,
|
|
int iAutoAdj)
|
|
{
|
|
int i = -1;
|
|
BOOL fReturn = FALSE;
|
|
TC_ITEMEXTRA tie;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
if (hpage) {
|
|
for (i = ppd->psh.nPages - 1; i >= 0; i--) {
|
|
if (hpage == GETHPAGE(ppd, i))
|
|
break;
|
|
}
|
|
}
|
|
if (i == -1) {
|
|
if (index == -1)
|
|
return FALSE;
|
|
|
|
i = index;
|
|
}
|
|
if (i >= MAXPROPPAGES)
|
|
{
|
|
// don't go off the end of our HPROPSHEETPAGE array
|
|
return FALSE;
|
|
}
|
|
|
|
fReturn = !PageChanging(ppd);
|
|
if (fReturn)
|
|
{
|
|
index = TabCtrl_GetCurSel(ppd->hwndTabs);
|
|
if (SendMessage(ppd->hwndTabs, TCM_SETCURSEL, i, 0L) == -1) {
|
|
// if we couldn't select (find) the new one, fail out
|
|
// and restore the old one
|
|
SendMessage(ppd->hwndTabs, TCM_SETCURSEL, index, 0L);
|
|
fReturn = FALSE;
|
|
}
|
|
PageChange(ppd, iAutoAdj);
|
|
}
|
|
return fReturn;
|
|
}
|
|
|
|
LRESULT QuerySiblings(LPPROPDATA ppd, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UINT i;
|
|
for (i = 0 ; i < ppd->psh.nPages ; i++)
|
|
{
|
|
HWND hwndSibling = _Ppd_GetPage(ppd, i);
|
|
if (hwndSibling)
|
|
{
|
|
LRESULT lres = SendMessage(hwndSibling, PSM_QUERYSIBLINGS, wParam, lParam);
|
|
if (lres)
|
|
return lres;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
// REVIEW HACK This gets round the problem of having a hotkey control
|
|
// up and trying to enter the hotkey that is already in use by a window.
|
|
BOOL HandleHotkey(LPARAM lparam)
|
|
{
|
|
WORD wHotkey;
|
|
TCHAR szClass[32];
|
|
HWND hwnd;
|
|
|
|
// What hotkey did the user type hit?
|
|
wHotkey = (WORD)SendMessage((HWND)lparam, WM_GETHOTKEY, 0, 0);
|
|
// Were they typing in a hotkey window?
|
|
hwnd = GetFocus();
|
|
GetClassName(hwnd, szClass, ARRAYSIZE(szClass));
|
|
if (lstrcmp(szClass, HOTKEY_CLASS) == 0)
|
|
{
|
|
// Yes.
|
|
SendMessage(hwnd, HKM_SETHOTKEY, wHotkey, 0);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Function handles Next and Back functions for wizards. The code will
|
|
// be either PSN_WIZNEXT or PSN_WIZBACK
|
|
//
|
|
BOOL WizNextBack(LPPROPDATA ppd, int code)
|
|
{
|
|
LRESULT dwFind;
|
|
int iPageIndex;
|
|
int iAutoAdj = (code == PSN_WIZNEXT) ? 1 : -1;
|
|
|
|
dwFind = _Ppd_SendNotify(ppd, ppd->nCurItem, code, 0);
|
|
|
|
if (dwFind == -1) {
|
|
return(FALSE);
|
|
}
|
|
|
|
iPageIndex = FindPageIndex(ppd, ppd->nCurItem, dwFind, iAutoAdj);
|
|
|
|
if (iPageIndex == -1) {
|
|
return(FALSE);
|
|
}
|
|
|
|
return(PageSetSelection(ppd, iPageIndex, NULL, iAutoAdj));
|
|
}
|
|
|
|
BOOL Prsht_OnCommand(LPPROPDATA ppd, int id, HWND hwndCtrl, UINT codeNotify)
|
|
{
|
|
|
|
//
|
|
// There's a bug in USER that when the user highlights a defpushbutton
|
|
// and presses ENTER, the WM_COMMAND is sent to the top-level dialog
|
|
// (i.e., the property sheet) instead of to the parent of the button.
|
|
// So if a property sheet page has a control whose ID coincidentally
|
|
// matches any of our own, we will think it's ours instead of theirs.
|
|
if (hwndCtrl && GetParent(hwndCtrl) != ppd->hDlg)
|
|
goto Forward;
|
|
|
|
if (!hwndCtrl)
|
|
hwndCtrl = GetDlgItem(ppd->hDlg, id);
|
|
|
|
switch (id) {
|
|
|
|
case IDCLOSE:
|
|
case IDCANCEL:
|
|
if (_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_QUERYCANCEL, 0) == 0) {
|
|
ButtonPushed(ppd, id);
|
|
}
|
|
break;
|
|
|
|
case IDD_APPLYNOW:
|
|
case IDOK:
|
|
if (!IS_WIZARD(ppd)) {
|
|
|
|
//ButtonPushed returns true if and only if all pages have processed PSN_LASTCHANCEAPPLY
|
|
if (ButtonPushed(ppd, id))
|
|
{
|
|
|
|
//Everyone has processed the PSN_APPLY Message. Now send PSN_LASTCHANCEAPPLY message.
|
|
|
|
//
|
|
// HACKHACK (reinerF)
|
|
//
|
|
// We send out a private PSN_LASTCHANCEAPPLY message telling all the pages
|
|
// that everyone is done w/ the apply. This is needed for pages who have to do
|
|
// something after every other page has applied. Currently, the "General" tab
|
|
// of the file properties needs a last-chance to rename files as well as new print
|
|
// dialog in comdlg32.dll.
|
|
SendLastChanceApply(ppd);
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case IDHELP:
|
|
if (IsWindowEnabled(hwndCtrl))
|
|
{
|
|
_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_HELP, 0);
|
|
}
|
|
break;
|
|
|
|
case IDD_FINISH:
|
|
{
|
|
HWND hwndNewFocus;
|
|
EnableWindow(ppd->hDlg, FALSE);
|
|
hwndNewFocus = (HWND)_Ppd_SendNotify(ppd, ppd->nCurItem, PSN_WIZFINISH, 0);
|
|
// b#11346 - dont let multiple clicks on FINISH.
|
|
if (!hwndNewFocus)
|
|
{
|
|
ppd->hwndCurPage = NULL;
|
|
ppd->nReturn = 1;
|
|
}
|
|
else
|
|
{
|
|
EnableWindow(ppd->hDlg, TRUE);
|
|
if (IsWindow(hwndNewFocus) && IsChild(ppd->hDlg, hwndNewFocus))
|
|
#ifdef WM_NEXTDLGCTL_WORKS
|
|
SetDlgFocus(ppd, hwndNewFocus);
|
|
#else
|
|
SetFocus(hwndNewFocus);
|
|
#endif
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDD_NEXT:
|
|
case IDD_BACK:
|
|
ppd->idDefaultFallback = id;
|
|
WizNextBack(ppd, id == IDD_NEXT ? PSN_WIZNEXT : PSN_WIZBACK);
|
|
break;
|
|
|
|
default:
|
|
Forward:
|
|
FORWARD_WM_COMMAND(_Ppd_GetPage(ppd, ppd->nCurItem), id, hwndCtrl, codeNotify, SendMessage);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL Prop_IsDialogMessage(LPPROPDATA ppd, LPMSG32 pmsg32)
|
|
{
|
|
// Don't fault if we don't have a pointer...
|
|
if (!pmsg32)
|
|
return FALSE;
|
|
|
|
if ((pmsg32->message == WM_KEYDOWN) && (GetKeyState(VK_CONTROL) < 0))
|
|
{
|
|
BOOL bBack = FALSE;
|
|
|
|
switch (pmsg32->wParam) {
|
|
case VK_TAB:
|
|
bBack = GetKeyState(VK_SHIFT) < 0;
|
|
break;
|
|
|
|
case VK_PRIOR: // VK_PAGE_UP
|
|
case VK_NEXT: // VK_PAGE_DOWN
|
|
bBack = (pmsg32->wParam == VK_PRIOR);
|
|
break;
|
|
|
|
default:
|
|
goto NoKeys;
|
|
}
|
|
|
|
//notify of navigation key usage
|
|
SendMessage(ppd->hDlg, WM_CHANGEUISTATE,
|
|
MAKELONG(UIS_CLEAR, UISF_HIDEFOCUS | UISF_HIDEACCEL), 0);
|
|
|
|
if (IS_WIZARD(ppd))
|
|
{
|
|
int idWiz;
|
|
int idDlg;
|
|
HWND hwnd;
|
|
|
|
if (bBack) {
|
|
idWiz = PSN_WIZBACK;
|
|
idDlg = IDD_BACK;
|
|
} else {
|
|
idWiz = PSN_WIZNEXT;
|
|
idDlg = IDD_NEXT;
|
|
}
|
|
|
|
hwnd = GetDlgItem(ppd->hDlg, idDlg);
|
|
if (IsWindowVisible(hwnd) && IsWindowEnabled(hwnd))
|
|
WizNextBack(ppd, idWiz);
|
|
}
|
|
else
|
|
{
|
|
int iStart = TabCtrl_GetCurSel(ppd->hwndTabs);
|
|
int iCur;
|
|
|
|
//
|
|
// Skip over hidden tabs, but don't go into an infinite loop.
|
|
//
|
|
iCur = iStart;
|
|
do {
|
|
// tab in reverse if shift is down
|
|
if (bBack)
|
|
iCur += (ppd->psh.nPages - 1);
|
|
else
|
|
iCur++;
|
|
|
|
iCur %= ppd->psh.nPages;
|
|
} while (_Ppd_IsPageHidden(ppd, iCur) && iCur != iStart);
|
|
PageSetSelection(ppd, iCur, NULL, 1);
|
|
}
|
|
return TRUE;
|
|
}
|
|
NoKeys:
|
|
|
|
//
|
|
// Since we now send out a PSN_TRANSLATEACCELERATOR, add a
|
|
// short-circuit so we don't do all this work for things
|
|
// that can't possibly be accelerators.
|
|
//
|
|
if (pmsg32->message >= WM_KEYFIRST && pmsg32->message <= WM_KEYLAST &&
|
|
|
|
// And there had better be a target window...
|
|
|
|
pmsg32->hwnd &&
|
|
|
|
// and the target window must live either outside the propsheet
|
|
// altogether or completely inside the propsheet page.
|
|
// (This is so that the propsheet can display its own popup dialog,
|
|
// but can't futz with the tab control or OK/Cancel buttons.)
|
|
|
|
(!IsChild(ppd->hDlg, pmsg32->hwnd) ||
|
|
IsChild(ppd->hwndCurPage, pmsg32->hwnd)) &&
|
|
|
|
// Then ask the propsheet if he wants to eat it.
|
|
_Ppd_SendNotify(ppd, ppd->nCurItem,
|
|
PSN_TRANSLATEACCELERATOR, (LPARAM)pmsg32) == PSNRET_MESSAGEHANDLED)
|
|
return TRUE;
|
|
|
|
if (IsDialogMessage32(ppd->hDlg, pmsg32, TRUE))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT Prsht_GetObject (LPPROPDATA ppd, HWND hDlg, int iItem, const IID *piid, void **pObject)
|
|
{
|
|
TC_ITEMEXTRA tie;
|
|
NMOBJECTNOTIFY non;
|
|
PISP pisp = GETPISP(ppd, iItem);
|
|
*pObject = NULL;
|
|
|
|
tie.tci.mask = TCIF_PARAM;
|
|
TabCtrl_GetItem(ppd->hwndTabs, iItem, &tie.tci);
|
|
if (!tie.hwndPage && ((tie.hwndPage = _CreatePage(ppd, pisp, hDlg, GetMUILanguage())) == NULL))
|
|
{
|
|
RemovePropPageData(ppd, iItem);
|
|
return E_UNEXPECTED;
|
|
}
|
|
TabCtrl_SetItem(ppd->hwndTabs, iItem, &tie.tci);
|
|
|
|
non.iItem = -1;
|
|
non.piid = piid;
|
|
non.pObject = NULL;
|
|
non.hResult = E_NOINTERFACE;
|
|
non.dwFlags = 0;
|
|
|
|
SendNotifyEx (tie.hwndPage, ppd->hwndTabs, PSN_GETOBJECT,
|
|
&non.hdr,
|
|
TRUE
|
|
);
|
|
if (SUCCEEDED (non.hResult))
|
|
{
|
|
*pObject = non.pObject;
|
|
if (pObject == NULL)
|
|
non.hResult = E_UNEXPECTED;
|
|
}
|
|
else if (non.pObject)
|
|
{
|
|
((LPDROPTARGET) non.pObject)->lpVtbl->Release ((LPDROPTARGET) non.pObject);
|
|
non.pObject = NULL;
|
|
}
|
|
return non.hResult;
|
|
}
|
|
|
|
//
|
|
// We would not normally need IDD_PAGELIST except that DefWindowProc() and
|
|
// WinHelp() do hit-testing differently. DefWindowProc() will do cool
|
|
// things like checking against the SetWindowRgn and skipping over windows
|
|
// that return HTTRANSPARENT. WinHelp() on the other hand
|
|
// ignores window regions and transparency. So what happens is if you
|
|
// click on the transparent part of a tab control, DefWindowProc() says
|
|
// (correctly) "He clicked on the dialog background". We then say, "Okay,
|
|
// WinHelp(), go display context help for the dialog background", and it
|
|
// says, "Hey, I found a tab control. I'm going to display help for the
|
|
// tab control now." To keep a bogus context menu from appearing, we
|
|
// explicitly tell WinHelp that "If you found a tab control (IDD_PAGELIST),
|
|
// then ignore it (NO_HELP)."
|
|
//
|
|
const static DWORD aPropHelpIDs[] = { // Context Help IDs
|
|
IDD_APPLYNOW, IDH_COMM_APPLYNOW,
|
|
IDD_PAGELIST, NO_HELP,
|
|
0, 0
|
|
};
|
|
|
|
|
|
void HandlePaletteChange(LPPROPDATA ppd, UINT uMessage, HWND hDlg)
|
|
{
|
|
HDC hdc;
|
|
hdc = GetDC(hDlg);
|
|
if (hdc)
|
|
{
|
|
BOOL fRepaint;
|
|
SelectPalette(hdc,ppd->hplWatermark,(uMessage == WM_PALETTECHANGED));
|
|
fRepaint = RealizePalette(hdc);
|
|
if (fRepaint)
|
|
InvalidateRect(hDlg,NULL,TRUE);
|
|
}
|
|
ReleaseDC(hDlg,hdc);
|
|
}
|
|
|
|
//
|
|
// Paint a rectangle with the specified brush and palette.
|
|
//
|
|
void PaintWithPaletteBrush(HDC hdc, LPRECT lprc, HPALETTE hplPaint, HBRUSH hbrPaint)
|
|
{
|
|
HBRUSH hbrPrev = SelectBrush(hdc, hbrPaint);
|
|
UnrealizeObject(hbrPaint);
|
|
if (hplPaint)
|
|
{
|
|
SelectPalette(hdc, hplPaint, FALSE);
|
|
RealizePalette(hdc);
|
|
}
|
|
FillRect(hdc, lprc, hbrPaint);
|
|
SelectBrush(hdc, hbrPrev);
|
|
}
|
|
|
|
//
|
|
// lprc is the target rectangle.
|
|
// Use as much of the bitmap as will fit into the target rectangle.
|
|
// If the bitmap is smaller than the target rectangle, then fill the rest with
|
|
// the pixel in the upper left corner of the hbmpPaint.
|
|
//
|
|
void PaintWithPaletteBitmap(HDC hdc, LPRECT lprc, HPALETTE hplPaint, HBITMAP hbmpPaint)
|
|
{
|
|
HDC hdcBmp;
|
|
BITMAP bm;
|
|
int cxRect, cyRect, cxBmp, cyBmp;
|
|
|
|
GetObject(hbmpPaint, sizeof(BITMAP), &bm);
|
|
hdcBmp = CreateCompatibleDC(hdc);
|
|
SelectObject(hdcBmp, hbmpPaint);
|
|
|
|
if (hplPaint)
|
|
{
|
|
SelectPalette(hdc, hplPaint, FALSE);
|
|
RealizePalette(hdc);
|
|
}
|
|
|
|
cxRect = RECTWIDTH(*lprc);
|
|
cyRect = RECTHEIGHT(*lprc);
|
|
|
|
// Never use more pixels from the bmp as we have room in the rect.
|
|
cxBmp = min(bm.bmWidth, cxRect);
|
|
cyBmp = min(bm.bmHeight, cyRect);
|
|
|
|
BitBlt(hdc, lprc->left, lprc->top, cxBmp, cyBmp, hdcBmp, 0, 0, SRCCOPY);
|
|
|
|
// If bitmap is too narrow, then StretchBlt to fill the width.
|
|
if (cxBmp < cxRect)
|
|
StretchBlt(hdc, lprc->left + cxBmp, lprc->top,
|
|
cxRect - cxBmp, cyBmp,
|
|
hdcBmp, 0, 0, 1, 1, SRCCOPY);
|
|
|
|
// If bitmap is to short, then StretchBlt to fill the height.
|
|
if (cyBmp < cyRect)
|
|
StretchBlt(hdc, lprc->left, cyBmp,
|
|
cxRect, cyRect - cyBmp,
|
|
hdcBmp, 0, 0, 1, 1, SRCCOPY);
|
|
|
|
DeleteDC(hdcBmp);
|
|
}
|
|
|
|
void _SetHeaderTitles(HWND hDlg, LPPROPDATA ppd, UINT uPage, LPCTSTR pszNewTitle, BOOL bTitle)
|
|
{
|
|
PISP pisp = NULL;
|
|
|
|
// Must be for wizard97
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
// Page number must be within range
|
|
if (uPage < ppd->psh.nPages)
|
|
{
|
|
// Get the page structure
|
|
pisp = GETPISP(ppd, uPage);
|
|
|
|
// We should have this page if it's within range
|
|
ASSERT(pisp);
|
|
|
|
// Do this only if this page has header.
|
|
if (!(pisp->_psp.dwFlags & PSP_HIDEHEADER))
|
|
{
|
|
LPCTSTR pszOldTitle = bTitle ? pisp->_psp.pszHeaderTitle : pisp->_psp.pszHeaderSubTitle;
|
|
|
|
if (!IS_INTRESOURCE(pszOldTitle))
|
|
LocalFree((LPVOID)pszOldTitle);
|
|
|
|
// Set the new title
|
|
if (bTitle)
|
|
pisp->_psp.pszHeaderTitle = pszNewTitle;
|
|
else
|
|
pisp->_psp.pszHeaderSubTitle = pszNewTitle;
|
|
|
|
// set pszNewTitle to NULL here so that we don't free it later
|
|
pszNewTitle = NULL;
|
|
|
|
// set the correct flags
|
|
pisp->_psp.dwFlags |= bTitle ? PSP_USEHEADERTITLE : PSP_USEHEADERSUBTITLE;
|
|
|
|
// force redrawing of the titles
|
|
if (uPage == (UINT)ppd->nCurItem)
|
|
{
|
|
RECT rcHeader;
|
|
GetClientRect(hDlg, &rcHeader);
|
|
rcHeader.bottom = ppd->cyHeaderHeight;
|
|
|
|
InvalidateRect(hDlg, &rcHeader, FALSE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pszNewTitle)
|
|
LocalFree((LPVOID)pszNewTitle);
|
|
}
|
|
|
|
void PropSheetPaintHeader(LPPROPDATA ppd, PISP pisp, HWND hDlg, HDC hdc)
|
|
{
|
|
RECT rcHeader;
|
|
|
|
GetClientRect(hDlg, &rcHeader);
|
|
if ((rcHeader.right > 0) && (rcHeader.bottom > 0))
|
|
{
|
|
RECT rcHeaderBitmap;
|
|
|
|
rcHeader.bottom = ppd->cyHeaderHeight;
|
|
|
|
// do we need to paint the header?
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
{
|
|
// Do it the WIZARD97IE4 way
|
|
|
|
// Bug-for-bug compatibility: WIZARD97IE4 tested the wrong flag here
|
|
if ((ppd->psh.dwFlags & PSH_WATERMARK) && (ppd->hbrWatermark))
|
|
PaintWithPaletteBrush(hdc, &rcHeader, ppd->hplWatermark, ppd->hbrHeader);
|
|
SetBkMode(hdc, TRANSPARENT);
|
|
}
|
|
else
|
|
{
|
|
// Do it the WIZARD97IE5 way
|
|
if ((ppd->psh.dwFlags & PSH_HEADER) && (ppd->hbmHeader))
|
|
{
|
|
// compute the rectangle for the bitmap depending on the size of the header
|
|
int bx = RECTWIDTH(rcHeader) - HEADERBITMAP_CXBACK;
|
|
ASSERT(bx > 0);
|
|
FillRect(hdc, &rcHeader, g_hbrWindow);
|
|
SetRect(&rcHeaderBitmap, bx, HEADERBITMAP_Y, bx + HEADERBITMAP_WIDTH, HEADERBITMAP_Y + HEADERBITMAP_HEIGHT);
|
|
PaintWithPaletteBitmap(hdc, &rcHeaderBitmap, ppd->hplWatermark, ppd->hbmHeader);
|
|
SetBkColor(hdc, g_clrWindow);
|
|
SetTextColor(hdc, g_clrWindowText);
|
|
}
|
|
else
|
|
{
|
|
SendMessage(hDlg, WM_CTLCOLORSTATIC, (WPARAM)hdc, (LPARAM)hDlg);
|
|
}
|
|
}
|
|
|
|
//
|
|
// WIZARD97IE5 subtracts out the space used by the header bitmap.
|
|
// WIZARD97IE4 uses the full width since the header bitmap
|
|
// in IE4 is a watermark and occupies no space.
|
|
//
|
|
if (!(ppd->psh.dwFlags & PSH_WIZARD97IE4))
|
|
{
|
|
rcHeader.right -= HEADERBITMAP_CXBACK + HEADERSUBTITLE_WRAPOFFSET;
|
|
}
|
|
|
|
ASSERT(rcHeader.right);
|
|
|
|
if (HASHEADERTITLE(pisp))
|
|
{
|
|
_WriteHeaderTitle(ppd, hdc, &rcHeader, pisp->_psp.pszHeaderTitle,
|
|
TRUE, DRAWTEXT_WIZARD97FLAGS);
|
|
}
|
|
|
|
if (HASHEADERSUBTITLE(pisp))
|
|
{
|
|
_WriteHeaderTitle(ppd, hdc, &rcHeader, pisp->_psp.pszHeaderSubTitle,
|
|
FALSE, DRAWTEXT_WIZARD97FLAGS);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free the title if we need to
|
|
void Prsht_FreeTitle(LPPROPDATA ppd)
|
|
{
|
|
if (ppd->fFlags & PD_FREETITLE) {
|
|
ppd->fFlags &= ~PD_FREETITLE;
|
|
if (!IS_INTRESOURCE(ppd->psh.pszCaption)) {
|
|
LocalFree((LPVOID)ppd->psh.pszCaption);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// pfnStrDup is the function that converts lParam into a native character
|
|
// set string. (Either StrDup or StrDup_AtoW).
|
|
//
|
|
void Prsht_OnSetTitle(LPPROPDATA ppd, WPARAM wParam, LPARAM lParam, STRDUPPROC pfnStrDup)
|
|
{
|
|
LPTSTR pszTitle;
|
|
|
|
//
|
|
// The ppd->psh.pszCaption is not normally LocalAlloc()d; it's
|
|
// just a pointer copy. But if the app does a PSM_SETTITLE,
|
|
// then all of a sudden it got LocalAlloc()d and needs to be
|
|
// freed. PD_FREETITLE is the flag that tell us that this has
|
|
// happened.
|
|
//
|
|
|
|
if (IS_INTRESOURCE(lParam)) {
|
|
pszTitle = (LPTSTR)lParam;
|
|
} else {
|
|
pszTitle = pfnStrDup((LPTSTR)lParam);
|
|
}
|
|
|
|
if (pszTitle) {
|
|
Prsht_FreeTitle(ppd); // Free old title if necessary
|
|
|
|
ppd->psh.pszCaption = pszTitle;
|
|
ppd->fFlags |= PD_FREETITLE; // Need to free this
|
|
|
|
ppd->psh.dwFlags = ((((DWORD)wParam) & PSH_PROPTITLE) | (ppd->psh.dwFlags & ~PSH_PROPTITLE));
|
|
_SetTitle(ppd->hDlg, ppd);
|
|
}
|
|
}
|
|
|
|
BOOL_PTR CALLBACK PropSheetDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HWND hwndT;
|
|
LPPROPDATA ppd = (LPPROPDATA)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
LRESULT lres;
|
|
|
|
if (!ppd && (uMessage != WM_INITDIALOG))
|
|
return FALSE;
|
|
|
|
switch (uMessage)
|
|
{
|
|
case WM_INITDIALOG:
|
|
InitPropSheetDlg(hDlg, (LPPROPDATA)lParam);
|
|
return FALSE;
|
|
|
|
case WM_SYSCOMMAND:
|
|
if (wParam == SC_HOTKEY)
|
|
return HandleHotkey(lParam);
|
|
else if (wParam == SC_CLOSE)
|
|
{
|
|
UINT id = IDCLOSE;
|
|
|
|
if (IS_WIZARD(ppd))
|
|
id = IDCANCEL;
|
|
else if (ppd->fFlags & PD_CANCELTOCLOSE)
|
|
id = IDOK;
|
|
|
|
// system menu close should be IDCANCEL, but if we're in the
|
|
// PSM_CANCELTOCLOSE state, treat it as an IDOK (ie, "Close").
|
|
return Prsht_OnCommand(ppd, id, NULL, 0);
|
|
}
|
|
|
|
return FALSE; // Let default process happen
|
|
|
|
case WM_NCDESTROY:
|
|
{
|
|
int iPage;
|
|
|
|
ASSERT(GetDlgItem(hDlg, IDD_PAGELIST) == NULL);
|
|
|
|
ppd->hwndTabs = NULL;
|
|
|
|
// NOTE: all of the hwnds for the pages must be destroyed by now!
|
|
|
|
// Release all page objects in REVERSE ORDER so we can have
|
|
// pages that are dependant on eachother based on the initial
|
|
// order of those pages
|
|
//
|
|
for (iPage = ppd->psh.nPages - 1; iPage >= 0; iPage--)
|
|
{
|
|
ULONG_PTR dw = PropPageActivateContext(ppd, GETPISP(ppd, iPage));
|
|
DestroyPropertySheetPage(GETHPAGE(ppd, iPage));
|
|
PropPageDeactivateContext(dw);
|
|
}
|
|
// hwndCurPage is no longer valid from here on
|
|
ppd->hwndCurPage = NULL;
|
|
|
|
if (ppd->hActCtxInit)
|
|
ReleaseActCtx(ppd->hActCtxInit);
|
|
|
|
// If we are modeless, we need to free our ppd. If we are modal,
|
|
// we let _RealPropertySheet free it since one of our pages may
|
|
// set the restart flag during DestroyPropertySheetPage above.
|
|
if (ppd->psh.dwFlags & PSH_MODELESS)
|
|
{
|
|
LocalFree(ppd);
|
|
}
|
|
}
|
|
//
|
|
// NOTES:
|
|
// Must return FALSE to avoid DS leak!!!
|
|
//
|
|
return FALSE;
|
|
|
|
case WM_DESTROY:
|
|
{
|
|
int i;
|
|
HIMAGELIST himl;
|
|
int c = TabCtrl_GetItemCount(ppd->hwndTabs);
|
|
|
|
for (i = 0; i < c; i++)
|
|
{
|
|
EnableThemeDialogTexture(_Ppd_GetPage(ppd, i), ETDT_DISABLE);
|
|
}
|
|
|
|
// Destroy the image list we created during our init call.
|
|
himl = TabCtrl_GetImageList(ppd->hwndTabs);
|
|
if (himl)
|
|
ImageList_Destroy(himl);
|
|
|
|
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97)
|
|
{
|
|
|
|
// Even if the PSH_USEHBMxxxxxx flag is set, we might
|
|
// need to delete the bitmap if we had to create a
|
|
// stretched copy.
|
|
|
|
if (ppd->psh.dwFlags & PSH_WATERMARK)
|
|
{
|
|
if ((!(ppd->psh.dwFlags & PSH_USEHBMWATERMARK) ||
|
|
ppd->hbmWatermark != ppd->psh.H_hbmWatermark) &&
|
|
ppd->hbmWatermark)
|
|
DeleteObject(ppd->hbmWatermark);
|
|
|
|
if (!(ppd->psh.dwFlags & PSH_USEHPLWATERMARK) &&
|
|
ppd->hplWatermark)
|
|
DeleteObject(ppd->hplWatermark);
|
|
|
|
if (ppd->hbrWatermark)
|
|
DeleteObject(ppd->hbrWatermark);
|
|
}
|
|
|
|
if ((ppd->psh.dwFlags & PSH_HEADER) && ppd->psh.H_hbmHeader)
|
|
{
|
|
if ((!(ppd->psh.dwFlags & PSH_USEHBMHEADER) ||
|
|
ppd->hbmHeader != ppd->psh.H_hbmHeader) &&
|
|
ppd->hbmHeader)
|
|
{
|
|
ASSERT(ppd->hbmHeader != ppd->hbmWatermark);
|
|
DeleteObject(ppd->hbmHeader);
|
|
}
|
|
|
|
if (ppd->hbrHeader)
|
|
{
|
|
ASSERT(ppd->hbrHeader != ppd->hbrWatermark);
|
|
DeleteObject(ppd->hbrHeader);
|
|
}
|
|
}
|
|
|
|
if (ppd->hFontBold)
|
|
DeleteObject(ppd->hFontBold);
|
|
}
|
|
|
|
if ((ppd->psh.dwFlags & PSH_USEICONID) && ppd->psh.H_hIcon)
|
|
DestroyIcon(ppd->psh.H_hIcon);
|
|
|
|
Prsht_FreeTitle(ppd);
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_ERASEBKGND:
|
|
return ppd->fFlags & PD_NOERASE;
|
|
break;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hdc;
|
|
PISP pisp;
|
|
|
|
hdc = BeginPaint(hDlg, &ps);
|
|
|
|
// only paint if the invalid rect has a non-zero widht or height
|
|
if (((ps.rcPaint.bottom - ps.rcPaint.top) > 0) &&
|
|
((ps.rcPaint.right - ps.rcPaint.left) > 0))
|
|
{
|
|
// (dli) paint the header
|
|
if ((ppd->psh.dwFlags & PSH_WIZARD97) &&
|
|
(!((pisp = GETPISP(ppd, ppd->nCurItem))->_psp.dwFlags & PSP_HIDEHEADER)))
|
|
{
|
|
PropSheetPaintHeader(ppd, pisp, hDlg, hdc);
|
|
}
|
|
|
|
if (ps.fErase) {
|
|
SendMessage (hDlg, WM_ERASEBKGND, (WPARAM) hdc, 0);
|
|
}
|
|
}
|
|
|
|
EndPaint(hDlg, &ps);
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
// Cannot use HANDLE_WM_COMMAND, because we want to pass a result!
|
|
return Prsht_OnCommand(ppd, GET_WM_COMMAND_ID(wParam, lParam),
|
|
GET_WM_COMMAND_HWND(wParam, lParam),
|
|
GET_WM_COMMAND_CMD(wParam, lParam));
|
|
|
|
case WM_NOTIFY:
|
|
switch (((NMHDR *)lParam)->code)
|
|
{
|
|
case TCN_SELCHANGE:
|
|
PageChange(ppd, 1);
|
|
break;
|
|
|
|
case TCN_SELCHANGING:
|
|
{
|
|
lres = PageChanging(ppd);
|
|
if (!lres) {
|
|
SetWindowPos(ppd->hwndCurPage, HWND_BOTTOM, 0,0,0,0, SWP_NOACTIVATE | SWP_NOSIZE |SWP_NOMOVE);
|
|
}
|
|
goto ReturnLres;
|
|
}
|
|
break;
|
|
|
|
case TCN_GETOBJECT:
|
|
{
|
|
LPNMOBJECTNOTIFY lpnmon = (LPNMOBJECTNOTIFY)lParam;
|
|
|
|
lpnmon->hResult = Prsht_GetObject(ppd, hDlg, lpnmon->iItem,
|
|
lpnmon->piid, &lpnmon->pObject);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
|
|
case PSM_SETWIZBUTTONS:
|
|
SetWizButtons(ppd, lParam);
|
|
break;
|
|
|
|
case PSM_SETFINISHTEXTA:
|
|
case PSM_SETFINISHTEXT:
|
|
{
|
|
HWND hFinish = GetDlgItem(hDlg, IDD_FINISH);
|
|
HWND hwndFocus = GetFocus();
|
|
HWND hwnd;
|
|
BOOL fSetFocus = FALSE;
|
|
|
|
if (!(ppd->psh.dwFlags & PSH_WIZARDHASFINISH)) {
|
|
hwnd = GetDlgItem(hDlg, IDD_NEXT);
|
|
if (hwnd == hwndFocus)
|
|
fSetFocus = TRUE;
|
|
ShowWindow(hwnd, SW_HIDE);
|
|
}
|
|
|
|
hwnd = GetDlgItem(hDlg, IDD_BACK);
|
|
if (hwnd == hwndFocus)
|
|
fSetFocus = TRUE;
|
|
ShowWindow(hwnd, SW_HIDE);
|
|
|
|
if (lParam)
|
|
{
|
|
if (uMessage == PSM_SETFINISHTEXTA)
|
|
{
|
|
SetWindowTextA(hFinish, (LPSTR)lParam);
|
|
}
|
|
else
|
|
Button_SetText(hFinish, (LPTSTR)lParam);
|
|
}
|
|
ShowWindow(hFinish, SW_SHOW);
|
|
Button_Enable(hFinish, TRUE);
|
|
ResetWizButtons(ppd);
|
|
SendMessage(hDlg, DM_SETDEFID, IDD_FINISH, 0);
|
|
ppd->idDefaultFallback = IDD_FINISH;
|
|
if (fSetFocus)
|
|
#ifdef WM_NEXTDLGCTL_WORKS
|
|
SetDlgFocus(ppd, hFinish);
|
|
#else
|
|
SetFocus(hFinish);
|
|
#endif
|
|
}
|
|
break;
|
|
|
|
case PSM_SETTITLEA:
|
|
Prsht_OnSetTitle(ppd, wParam, lParam, StrDup_AtoW);
|
|
break;
|
|
|
|
case PSM_SETTITLE:
|
|
Prsht_OnSetTitle(ppd, wParam, lParam, StrDup);
|
|
break;
|
|
|
|
case PSM_SETHEADERTITLEA:
|
|
{
|
|
LPWSTR lpHeaderTitle = (lParam && HIWORD(lParam)) ?
|
|
ProduceWFromA(CP_ACP, (LPCSTR)lParam) : StrDupW((LPWSTR)lParam);
|
|
if (lpHeaderTitle)
|
|
_SetHeaderTitles(hDlg, ppd, (UINT)wParam, lpHeaderTitle, TRUE);
|
|
}
|
|
break;
|
|
|
|
case PSM_SETHEADERTITLE:
|
|
{
|
|
LPTSTR lpHeaderTitle = StrDup((LPCTSTR)lParam);
|
|
if (lpHeaderTitle)
|
|
_SetHeaderTitles(hDlg, ppd, (UINT)wParam, lpHeaderTitle, TRUE);
|
|
}
|
|
break;
|
|
|
|
case PSM_SETHEADERSUBTITLEA:
|
|
{
|
|
LPWSTR lpHeaderSubTitle = (lParam && HIWORD(lParam)) ?
|
|
ProduceWFromA(CP_ACP, (LPCSTR)lParam) : StrDupW((LPWSTR)lParam);
|
|
if (lpHeaderSubTitle)
|
|
_SetHeaderTitles(hDlg, ppd, (UINT)wParam, lpHeaderSubTitle, FALSE);
|
|
}
|
|
break;
|
|
|
|
case PSM_SETHEADERSUBTITLE:
|
|
{
|
|
LPTSTR lpHeaderSubTitle = StrDup((LPCTSTR)lParam);
|
|
if (lpHeaderSubTitle)
|
|
_SetHeaderTitles(hDlg, ppd, (UINT)wParam, lpHeaderSubTitle, FALSE);
|
|
}
|
|
break;
|
|
|
|
case PSM_CHANGED:
|
|
PageInfoChange(ppd, (HWND)wParam);
|
|
break;
|
|
|
|
case PSM_RESTARTWINDOWS:
|
|
ppd->nRestart |= ID_PSRESTARTWINDOWS;
|
|
break;
|
|
|
|
case PSM_REBOOTSYSTEM:
|
|
ppd->nRestart |= ID_PSREBOOTSYSTEM;
|
|
break;
|
|
|
|
case PSM_DISABLEAPPLY:
|
|
// the page is asking us to gray the "Apply" button and not let
|
|
// anyone else re-enable it
|
|
if (ppd->fAllowApply)
|
|
{
|
|
ppd->fAllowApply = FALSE;
|
|
EnableWindow(GetDlgItem(ppd->hDlg, IDD_APPLYNOW), FALSE);
|
|
}
|
|
break;
|
|
|
|
case PSM_ENABLEAPPLY:
|
|
// the page is asking us to allow the the "Apply" button to be
|
|
// once again enabled
|
|
if (!ppd->fAllowApply)
|
|
ppd->fAllowApply = TRUE;
|
|
// REARCHITECT - raymondc - shouldn't we call EnableWindow?
|
|
break;
|
|
|
|
case PSM_CANCELTOCLOSE:
|
|
if (!(ppd->fFlags & PD_CANCELTOCLOSE))
|
|
{
|
|
TCHAR szClose[20];
|
|
ppd->fFlags |= PD_CANCELTOCLOSE;
|
|
LocalizedLoadString(IDS_CLOSE, szClose, ARRAYSIZE(szClose));
|
|
SetDlgItemText(hDlg, IDOK, szClose);
|
|
EnableWindow(GetDlgItem(hDlg, IDCANCEL), FALSE);
|
|
}
|
|
break;
|
|
|
|
case PSM_SETCURSEL:
|
|
lres = PageSetSelection(ppd, (int)wParam, (HPROPSHEETPAGE)lParam, 1);
|
|
goto ReturnLres;
|
|
|
|
case PSM_SETCURSELID:
|
|
{
|
|
int iPageIndex;
|
|
|
|
iPageIndex = FindPageIndex(ppd, ppd->nCurItem, (DWORD)lParam, 1);
|
|
|
|
if (iPageIndex == -1)
|
|
lres = 0;
|
|
else
|
|
lres = PageSetSelection(ppd, iPageIndex, NULL, 1);
|
|
goto ReturnLres;
|
|
}
|
|
break;
|
|
|
|
case PSM_REMOVEPAGE:
|
|
RemovePropPage(ppd, (int)wParam, (HPROPSHEETPAGE)lParam);
|
|
break;
|
|
|
|
case PSM_ADDPAGE:
|
|
lres = AddPropPage(ppd,(HPROPSHEETPAGE)lParam);
|
|
goto ReturnLres;
|
|
|
|
case PSM_INSERTPAGE:
|
|
lres = InsertPropPage(ppd, (HPROPSHEETPAGE)wParam, (HPROPSHEETPAGE)lParam);
|
|
goto ReturnLres;
|
|
|
|
case PSM_QUERYSIBLINGS:
|
|
lres = QuerySiblings(ppd, wParam, lParam);
|
|
goto ReturnLres;
|
|
|
|
case PSM_UNCHANGED:
|
|
PageInfoUnChange(ppd, (HWND)wParam);
|
|
break;
|
|
|
|
case PSM_APPLY:
|
|
// a page is asking us to simulate an "Apply Now".
|
|
// let the page know if we're successful
|
|
lres = ButtonPushed(ppd, IDD_APPLYNOW);
|
|
goto ReturnLres;
|
|
|
|
case PSM_GETTABCONTROL:
|
|
lres = (LRESULT)ppd->hwndTabs;
|
|
goto ReturnLres;
|
|
|
|
case PSM_GETCURRENTPAGEHWND:
|
|
lres = (LRESULT)ppd->hwndCurPage;
|
|
goto ReturnLres;
|
|
|
|
case PSM_PRESSBUTTON:
|
|
if (wParam <= PSBTN_MAX)
|
|
{
|
|
const static int IndexToID[] = {IDD_BACK, IDD_NEXT, IDD_FINISH, IDOK,
|
|
IDD_APPLYNOW, IDCANCEL, IDHELP};
|
|
Prsht_OnCommand(ppd, IndexToID[wParam], NULL, 0);
|
|
}
|
|
break;
|
|
|
|
case PSM_ISDIALOGMESSAGE:
|
|
// returning TRUE means we handled it, do a continue
|
|
// FALSE do standard translate/dispatch
|
|
lres = Prop_IsDialogMessage(ppd, (LPMSG32)lParam);
|
|
goto ReturnLres;
|
|
|
|
case PSM_HWNDTOINDEX:
|
|
lres = FindItem(ppd->hwndTabs, (HWND)wParam, NULL);
|
|
goto ReturnLres;
|
|
|
|
case PSM_INDEXTOHWND:
|
|
if ((UINT)wParam < ppd->psh.nPages)
|
|
lres = (LRESULT)_Ppd_GetPage(ppd, (int)wParam);
|
|
else
|
|
lres = 0;
|
|
goto ReturnLres;
|
|
|
|
case PSM_PAGETOINDEX:
|
|
lres = FindPageIndexByHpage(ppd, (HPROPSHEETPAGE)lParam);
|
|
goto ReturnLres;
|
|
|
|
case PSM_INDEXTOPAGE:
|
|
if ((UINT)wParam < ppd->psh.nPages)
|
|
lres = (LRESULT)GETHPAGE(ppd, wParam);
|
|
else
|
|
lres = 0;
|
|
goto ReturnLres;
|
|
|
|
case PSM_INDEXTOID:
|
|
if ((UINT)wParam < ppd->psh.nPages)
|
|
{
|
|
lres = (LRESULT)GETPPSP(ppd, wParam)->P_pszTemplate;
|
|
|
|
// Need to be careful -- return a value only if pszTemplate
|
|
// is an ID. Don't return out our internal pointers!
|
|
if (!IS_INTRESOURCE(lres))
|
|
lres = 0;
|
|
}
|
|
else
|
|
lres = 0;
|
|
goto ReturnLres;
|
|
|
|
case PSM_IDTOINDEX:
|
|
lres = FindPageIndex(ppd, ppd->nCurItem, (DWORD)lParam, 0);
|
|
goto ReturnLres;
|
|
|
|
case PSM_GETRESULT:
|
|
// This is valid only after the property sheet is gone
|
|
if (ppd->hwndCurPage)
|
|
{
|
|
lres = -1; // you shouldn't be calling me yet
|
|
} else {
|
|
lres = ppd->nReturn;
|
|
if (lres > 0 && ppd->nRestart)
|
|
lres = ppd->nRestart;
|
|
}
|
|
goto ReturnLres;
|
|
break;
|
|
|
|
case PSM_RECALCPAGESIZES:
|
|
lres = Prsht_RecalcPageSizes(ppd);
|
|
goto ReturnLres;
|
|
|
|
// these should be relayed to all created dialogs
|
|
case WM_WININICHANGE:
|
|
case WM_SYSCOLORCHANGE:
|
|
case WM_DISPLAYCHANGE:
|
|
{
|
|
int nItem, nItems = TabCtrl_GetItemCount(ppd->hwndTabs);
|
|
for (nItem = 0; nItem < nItems; ++nItem)
|
|
{
|
|
|
|
hwndT = _Ppd_GetPage(ppd, nItem);
|
|
if (hwndT)
|
|
SendMessage(hwndT, uMessage, wParam, lParam);
|
|
}
|
|
SendMessage(ppd->hwndTabs, uMessage, wParam, lParam);
|
|
}
|
|
break;
|
|
|
|
//
|
|
// send toplevel messages to the current page and tab control
|
|
//
|
|
case WM_PALETTECHANGED:
|
|
//
|
|
// If this is our window we need to avoid selecting and realizing
|
|
// because doing so would cause an infinite loop between WM_QUERYNEWPALETTE
|
|
// and WM_PALETTECHANGED.
|
|
//
|
|
if((HWND)wParam == hDlg) {
|
|
return(FALSE);
|
|
}
|
|
//
|
|
// FALL THROUGH
|
|
//
|
|
|
|
case WM_QUERYNEWPALETTE:
|
|
// This is needed when another window which has different palette clips
|
|
// us
|
|
if ((ppd->psh.dwFlags & PSH_WIZARD97) &&
|
|
(ppd->psh.dwFlags & PSH_WATERMARK) &&
|
|
(ppd->psh.hplWatermark))
|
|
HandlePaletteChange(ppd, uMessage, hDlg);
|
|
|
|
//
|
|
// FALL THROUGH
|
|
//
|
|
|
|
case WM_ENABLE:
|
|
case WM_DEVICECHANGE:
|
|
case WM_QUERYENDSESSION:
|
|
case WM_ENDSESSION:
|
|
if (ppd->hwndTabs)
|
|
SendMessage(ppd->hwndTabs, uMessage, wParam, lParam);
|
|
//
|
|
// FALL THROUGH
|
|
//
|
|
|
|
case WM_ACTIVATEAPP:
|
|
case WM_ACTIVATE:
|
|
{
|
|
hwndT = _Ppd_GetPage(ppd, ppd->nCurItem);
|
|
if (hwndT && IsWindow(hwndT))
|
|
{
|
|
//
|
|
// By doing this, we are "handling" the message. Therefore
|
|
// we must set the dialog return value to whatever the child
|
|
// wanted.
|
|
//
|
|
lres = SendMessage(hwndT, uMessage, wParam, lParam);
|
|
goto ReturnLres;
|
|
}
|
|
}
|
|
|
|
if ((uMessage == WM_PALETTECHANGED) || (uMessage == WM_QUERYNEWPALETTE))
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
|
|
case WM_CONTEXTMENU:
|
|
// ppd->hwndTabs is handled by aPropHelpIDs to work around a USER bug.
|
|
// See aPropHelpIDs for gory details.
|
|
if ((ppd->hwndCurPage != (HWND)wParam) && (!IS_WIZARD(ppd)))
|
|
WinHelp((HWND)wParam, NULL, HELP_CONTEXTMENU, (ULONG_PTR)(LPVOID) aPropHelpIDs);
|
|
break;
|
|
|
|
case WM_HELP:
|
|
hwndT = (HWND)((LPHELPINFO)lParam)->hItemHandle;
|
|
if ((GetParent(hwndT) == hDlg) && (hwndT != ppd->hwndTabs))
|
|
WinHelp(hwndT, NULL, HELP_WM_HELP, (ULONG_PTR)(LPVOID) aPropHelpIDs);
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
|
|
ReturnLres:
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, lres);
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
//
|
|
// Draw the background for wizard pages.
|
|
//
|
|
BOOL Prsht_EraseWizBkgnd(LPPROPDATA ppd, HDC hdc)
|
|
{
|
|
RECT rc;
|
|
BOOL fPainted = FALSE;
|
|
GetClientRect(ppd->hDlg, &rc);
|
|
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
{
|
|
if (ppd->hbrWatermark)
|
|
{
|
|
PaintWithPaletteBrush(hdc, &rc, ppd->hplWatermark, ppd->hbrWatermark);
|
|
fPainted = TRUE;
|
|
}
|
|
}
|
|
else // PSH_WIZARD97IE5
|
|
{
|
|
if (ppd->hbmWatermark)
|
|
{
|
|
// Right-hand side gets g_hbrWindow.
|
|
rc.left = BITMAP_WIDTH;
|
|
FillRect(hdc, &rc, g_hbrWindow);
|
|
|
|
// Left-hand side gets watermark in top portion with autofill...
|
|
rc.right = rc.left;
|
|
rc.left = 0;
|
|
PaintWithPaletteBitmap(hdc, &rc, ppd->hplWatermark, ppd->hbmWatermark);
|
|
fPainted = TRUE;
|
|
}
|
|
}
|
|
return fPainted;
|
|
}
|
|
|
|
LRESULT CALLBACK WizardWndProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam, UINT_PTR uID, ULONG_PTR dwRefData)
|
|
{
|
|
LPPROPDATA ppd = (LPPROPDATA)dwRefData;
|
|
switch (uMessage)
|
|
{
|
|
case WM_ERASEBKGND:
|
|
if (Prsht_EraseWizBkgnd(ppd, (HDC)wParam))
|
|
return TRUE;
|
|
break;
|
|
|
|
// Only PSH_WIZARD97IE4 cares about these messages
|
|
case WM_CTLCOLOREDIT:
|
|
case WM_CTLCOLORDLG:
|
|
if (!(ppd->psh.dwFlags & PSH_WIZARD97IE4))
|
|
break;
|
|
// fall through
|
|
|
|
case WM_CTLCOLOR:
|
|
case WM_CTLCOLORMSGBOX:
|
|
case WM_CTLCOLORLISTBOX:
|
|
case WM_CTLCOLORBTN:
|
|
case WM_CTLCOLORSCROLLBAR:
|
|
case WM_CTLCOLORSTATIC:
|
|
if (ppd->psh.dwFlags & PSH_WIZARD97IE4)
|
|
{
|
|
if (ppd->hbrWatermark) {
|
|
POINT pt;
|
|
// Bug-for-bug compatibility: TRANSPARENT messes up edit
|
|
// controls when they scroll, but that's what IE4 did.
|
|
SetBkMode((HDC)wParam, TRANSPARENT);
|
|
|
|
if (ppd->hplWatermark)
|
|
{
|
|
SelectPalette((HDC)wParam, ppd->hplWatermark, FALSE);
|
|
RealizePalette((HDC)wParam);
|
|
}
|
|
UnrealizeObject(ppd->hbrWatermark);
|
|
GetDCOrgEx((HDC)wParam, &pt);
|
|
// Bug-for-bug compatibility: We shouldn't use GetParent
|
|
// because the notification might be forwarded up from an
|
|
// embedded dialog child, but that's what IE4 did.
|
|
ScreenToClient(GetParent((HWND)lParam), &pt);
|
|
SetBrushOrgEx((HDC)wParam, -pt.x, -pt.y, NULL);
|
|
return (LRESULT)(HBRUSH)ppd->hbrWatermark;
|
|
}
|
|
}
|
|
else // PSH_WIZARD97IE5
|
|
{
|
|
if (ppd->hbmWatermark)
|
|
{
|
|
LRESULT lRet = DefWindowProc(hDlg, uMessage, wParam, lParam);
|
|
if (lRet == DefSubclassProc(hDlg, uMessage, wParam, lParam))
|
|
{
|
|
SetTextColor((HDC)wParam, GetSysColor(COLOR_WINDOWTEXT));
|
|
SetBkColor((HDC)wParam, GetSysColor(COLOR_WINDOW));
|
|
return (LRESULT)g_hbrWindow;
|
|
}
|
|
else
|
|
return lRet;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_PALETTECHANGED:
|
|
if((HWND)wParam == hDlg)
|
|
return(FALSE);
|
|
|
|
case WM_QUERYNEWPALETTE:
|
|
HandlePaletteChange(ppd, uMessage, hDlg);
|
|
return TRUE;
|
|
|
|
case WM_DESTROY:
|
|
// Clean up subclass
|
|
RemoveWindowSubclass(hDlg, WizardWndProc, 0);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return DefSubclassProc(hDlg, uMessage, wParam, lParam);
|
|
}
|
|
|
|
//
|
|
// EnumResLangProc
|
|
//
|
|
// purpose: a callback function for EnumResourceLanguages().
|
|
// look into the type passed in and if it is RT_DIALOG
|
|
// copy the lang of the first resource to our buffer
|
|
// this also counts # of lang if more than one of them
|
|
// are passed in
|
|
//
|
|
//
|
|
typedef struct {
|
|
WORD wLang;
|
|
BOOL fFoundLang;
|
|
LPCTSTR lpszType;
|
|
} ENUMLANGDATA;
|
|
|
|
BOOL CALLBACK EnumResLangProc(HINSTANCE hinst, LPCTSTR lpszType, LPCTSTR lpszName, WORD wIdLang, LPARAM lparam)
|
|
{
|
|
ENUMLANGDATA *pel = (ENUMLANGDATA *)lparam;
|
|
BOOL fContinue = TRUE;
|
|
|
|
ASSERT(pel);
|
|
|
|
if (lpszType == pel->lpszType)
|
|
{
|
|
// When comctl's been initialized with a particular MUI language,
|
|
// we pass in the langid to GetPageLanguage(), then it's given to this proc.
|
|
// we want to look for a template that matches to the langid,
|
|
// and if it's not found, we have to use the first instance of templates.
|
|
//
|
|
if (pel->wLang == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL)
|
|
|| (pel->wLang == wIdLang))
|
|
{
|
|
pel->wLang = wIdLang;
|
|
pel->fFoundLang = TRUE;
|
|
fContinue = FALSE;
|
|
}
|
|
}
|
|
return fContinue; // continue until we get langs...
|
|
}
|
|
|
|
// GetPageLanguage
|
|
//
|
|
// purpose: tries to retrieve language information out of
|
|
// given page's dialog template. We get the first language
|
|
// in which the template is localized in.
|
|
// currently doesn't support PSP_DLGINDIRECT case
|
|
//
|
|
// we luck out with browselc since there's only one lang per resid,
|
|
// we should cache the langid we loaded up front and pull it out here.
|
|
//
|
|
HRESULT GetPageLanguage(PISP pisp, WORD *pwLang)
|
|
{
|
|
if (pisp && pwLang)
|
|
{
|
|
if (pisp->_psp.dwFlags & PSP_DLGINDIRECT)
|
|
{
|
|
// try something other than dialog
|
|
return E_FAIL; // not supported yet.
|
|
}
|
|
else
|
|
{
|
|
ENUMLANGDATA el;
|
|
|
|
// the caller passes-in the langid with which we're initialized
|
|
//
|
|
el.wLang = *pwLang;
|
|
el.fFoundLang = FALSE;
|
|
el.lpszType = RT_DIALOG;
|
|
// check with the dialog template specified
|
|
EnumResourceLanguages(pisp->_psp.hInstance, RT_DIALOG, pisp->_psp.P_pszTemplate, EnumResLangProc, (LPARAM)&el);
|
|
if (!el.fFoundLang)
|
|
{
|
|
// we couldn't find a matching lang in the given page's resource
|
|
// so we'll take the first one
|
|
el.wLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
|
|
// it doesn't matter if this fails, because we'll then end up with
|
|
// the neutral langid, which is the best guess here after failing
|
|
// to get any page lang.
|
|
//
|
|
EnumResourceLanguages(pisp->_psp.hInstance, RT_DIALOG,
|
|
pisp->_psp.P_pszTemplate, EnumResLangProc, (LPARAM)&el);
|
|
}
|
|
*pwLang = el.wLang;
|
|
}
|
|
return S_OK;
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
//
|
|
// FindResourceExRetry
|
|
//
|
|
// Just like FindResourceEx, except that if we can't find the resource,
|
|
// we try again with MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL).
|
|
//
|
|
HRSRC FindResourceExRetry(HMODULE hmod, LPCTSTR lpType, LPCTSTR lpName, WORD wLang)
|
|
{
|
|
HRSRC hrsrc = FindResourceEx(hmod, lpType, lpName, wLang);
|
|
|
|
// if failed because we couldn't find the resouce in requested lang
|
|
// and requested lang wasn't neutral, then try neutral.
|
|
if (!hrsrc && wLang != MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL))
|
|
{
|
|
wLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
hrsrc = FindResourceEx(hmod, lpType, lpName, wLang);
|
|
}
|
|
|
|
|
|
return hrsrc;
|
|
}
|
|
|
|
|
|
WORD GetShellResourceLangID(void);
|
|
|
|
// NT5_GetUserDefaultUILanguage
|
|
//
|
|
// NT5 has a new function GetUserDefaultUILanguage which returns the
|
|
// language the user as selected for UI.
|
|
//
|
|
// If the function is not available (e.g., NT4), then use the
|
|
// shell resource language ID.
|
|
//
|
|
|
|
typedef LANGID (CALLBACK* GETUSERDEFAULTUILANGUAGE)(void);
|
|
|
|
GETUSERDEFAULTUILANGUAGE _GetUserDefaultUILanguage;
|
|
|
|
LANGID NT5_GetUserDefaultUILanguage(void)
|
|
{
|
|
if (_GetUserDefaultUILanguage == NULL)
|
|
{
|
|
HMODULE hmod = GetModuleHandle(TEXT("KERNEL32"));
|
|
|
|
//
|
|
// Must keep in a local to avoid thread races.
|
|
//
|
|
GETUSERDEFAULTUILANGUAGE pfn = NULL;
|
|
|
|
if (hmod)
|
|
pfn = (GETUSERDEFAULTUILANGUAGE)
|
|
GetProcAddress(hmod, "GetUserDefaultUILanguage");
|
|
|
|
//
|
|
// If function is not available, then use our fallback
|
|
//
|
|
if (pfn == NULL)
|
|
pfn = GetShellResourceLangID;
|
|
|
|
ASSERT(pfn != NULL);
|
|
_GetUserDefaultUILanguage = pfn;
|
|
}
|
|
|
|
return _GetUserDefaultUILanguage();
|
|
}
|
|
|
|
|
|
LCID CCGetSystemDefaultThreadLocale(LCID iLcidThreadOrig)
|
|
{
|
|
UINT uLangThread, uLangThreadOrig;
|
|
|
|
uLangThreadOrig = LANGIDFROMLCID(iLcidThreadOrig);
|
|
|
|
|
|
|
|
// uLangThread is the language we think we want to use
|
|
uLangThread = uLangThreadOrig;
|
|
|
|
if (staticIsOS(OS_NT4ORGREATER) && !staticIsOS(OS_WIN2000ORGREATER))
|
|
{
|
|
int iLcidUserDefault = GetUserDefaultLCID();
|
|
UINT uLangUD = LANGIDFROMLCID(iLcidUserDefault);
|
|
|
|
//
|
|
// If we are running on Enabled Arabic NT4, we should always
|
|
// display the US English resources (since the UI is English), however NT4
|
|
// Resource Loader will look for the current Thread Locale (which is Arabic).
|
|
// This is no problem in NT5 since the Resource Loader will check for
|
|
// the UI Language (newly introduced) when loading such resources. To
|
|
// fix this, we will change the thread locale to US English
|
|
// and restore it back to Arabic/Hebrew if we are running on an Enabled Arabic/Hebrew NT4.
|
|
// The check is done to make sure we are running within a Araic/Hebrew user locale
|
|
// and the thread locale is still Arabic/Hebrew (i.e. nobody tried to SetThreadLocale).
|
|
// [samera]
|
|
//
|
|
if( ((PRIMARYLANGID(uLangUD ) == LANG_ARABIC) &&
|
|
(PRIMARYLANGID(uLangThread) == LANG_ARABIC)) ||
|
|
((PRIMARYLANGID(uLangUD ) == LANG_HEBREW) &&
|
|
(PRIMARYLANGID(uLangThread) == LANG_HEBREW)))
|
|
{
|
|
uLangThread = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make locale match UI locale if not otherwise overridden.
|
|
//
|
|
if (uLangThread == uLangThreadOrig)
|
|
{
|
|
uLangThread = NT5_GetUserDefaultUILanguage();
|
|
}
|
|
|
|
//
|
|
// Now see if we actually changed the thread language.
|
|
//
|
|
if (uLangThread == uLangThreadOrig)
|
|
{
|
|
// No change, return the original locale, including sort stuff
|
|
return iLcidThreadOrig;
|
|
}
|
|
else
|
|
{
|
|
// It changed, return a generic sort order, since we don't use
|
|
// this information for sorting.
|
|
return MAKELCID(uLangThread, SORT_DEFAULT);
|
|
}
|
|
}
|
|
|
|
//
|
|
// GetAltFontLangId
|
|
//
|
|
// used to detect "MS UI Gothic" on Jpn localized non NT5 platforms
|
|
// the font is shipped with IE5 for the language but comctl can't
|
|
// always assume the font so we have a fake sublang id assigned to
|
|
// the secondary resource file for the language
|
|
//
|
|
int CALLBACK FontEnumProc(
|
|
ENUMLOGFONTEX *lpelfe,
|
|
NEWTEXTMETRICEX *lpntme,
|
|
int FontType,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
if (lParam)
|
|
{
|
|
*(BOOL *)lParam = TRUE;
|
|
}
|
|
return 0; // stop at the first callback
|
|
}
|
|
UINT GetDefaultCharsetFromLang(LANGID wLang)
|
|
{
|
|
TCHAR szData[6+1]; // 6 chars are max allowed for this lctype
|
|
UINT uiRet = DEFAULT_CHARSET;
|
|
|
|
// JPN hack here: GetLocaleInfo() DOES return > 0 for Jpn altfont langid,
|
|
// but doesn't get us any useful info. So for JPN, we ripout the SUBLANG
|
|
// portion of id. we can't do this for other langs since sublang can affect
|
|
// charset (ex. chinese)
|
|
//
|
|
if(PRIMARYLANGID(wLang) == LANG_JAPANESE)
|
|
wLang = MAKELANGID(PRIMARYLANGID(wLang), SUBLANG_NEUTRAL);
|
|
|
|
if (GetLocaleInfo(MAKELCID(wLang, SORT_DEFAULT),
|
|
LOCALE_IDEFAULTANSICODEPAGE,
|
|
szData, ARRAYSIZE(szData)) > 0)
|
|
{
|
|
|
|
UINT uiCp = StrToInt(szData);
|
|
CHARSETINFO csinfo;
|
|
|
|
if (TranslateCharsetInfo(IntToPtr_(DWORD *, uiCp), &csinfo, TCI_SRCCODEPAGE))
|
|
uiRet = csinfo.ciCharset;
|
|
}
|
|
|
|
return uiRet;
|
|
}
|
|
BOOL IsFontInstalled(LANGID wLang, LPCTSTR szFace)
|
|
{
|
|
BOOL fInstalled = FALSE;
|
|
HDC hdc;
|
|
LOGFONT lf = {0};
|
|
|
|
lstrcpyn(lf.lfFaceName, szFace, ARRAYSIZE(lf.lfFaceName));
|
|
|
|
// retrieve charset from given language
|
|
lf.lfCharSet = (BYTE)GetDefaultCharsetFromLang(wLang);
|
|
|
|
// then see if we can enumrate the font
|
|
hdc = GetDC(NULL);
|
|
if (hdc)
|
|
{
|
|
EnumFontFamiliesEx(hdc, &lf, (FONTENUMPROC)FontEnumProc, (LPARAM)&fInstalled, 0);
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
return fInstalled;
|
|
}
|
|
|
|
LANGID GetAltFontLangId(LANGID wLang)
|
|
{
|
|
LPCTSTR pszTypeFace = NULL;
|
|
USHORT usAltSubLang = SUBLANG_NEUTRAL;
|
|
const static TCHAR s_szUIGothic[] = TEXT("MS UI Gothic");
|
|
static int iPrimaryFontInstalled = -1;
|
|
|
|
// most of the case we return the lang just as is
|
|
switch(PRIMARYLANGID(wLang))
|
|
{
|
|
case LANG_JAPANESE:
|
|
pszTypeFace = s_szUIGothic;
|
|
usAltSubLang = SUBLANG_JAPANESE_ALTFONT;
|
|
break;
|
|
// add code here to handle any other cases like Jpn
|
|
default:
|
|
return wLang;
|
|
}
|
|
|
|
// check existence of the font if we haven't
|
|
if (iPrimaryFontInstalled < 0 && pszTypeFace)
|
|
{
|
|
iPrimaryFontInstalled = IsFontInstalled(wLang, pszTypeFace);
|
|
}
|
|
|
|
// return secondary lang id if our alternative font *is* installed
|
|
if (iPrimaryFontInstalled == 1)
|
|
wLang = MAKELANGID(PRIMARYLANGID(wLang), usAltSubLang);
|
|
|
|
return wLang;
|
|
}
|
|
// GetShellResourceLangID
|
|
//
|
|
// On NT4, we want to match our ML resource to the one that OS is localized.
|
|
// this is to prevent general UI (buttons) from changing along with regional
|
|
// setting change.
|
|
// Win95 won't change system default locale, NT5 will load from matching satelite
|
|
// resource dll automatically so this won't be needed on these platforms.
|
|
// This function finds shell32.dll and gets the language in which the dll is
|
|
// localized, then cache the lcid so we won't have to detect it again.
|
|
//
|
|
WORD GetShellResourceLangID(void)
|
|
{
|
|
static WORD langRes = 0L;
|
|
|
|
// we do this only once
|
|
if (langRes == 0L)
|
|
{
|
|
HINSTANCE hinstShell;
|
|
ENUMLANGDATA el = {MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), FALSE, RT_DIALOG};
|
|
|
|
hinstShell = LoadLibrary(TEXT("shell32.dll"));
|
|
if (hinstShell)
|
|
{
|
|
EnumResourceLanguages(hinstShell, RT_DIALOG, MAKEINTRESOURCE(DLG_EXITWINDOWS), EnumResLangProc, (LPARAM)&el);
|
|
|
|
FreeLibrary(hinstShell);
|
|
}
|
|
|
|
if (PRIMARYLANGID(el.wLang) == LANG_CHINESE
|
|
|| PRIMARYLANGID(el.wLang) == LANG_PORTUGUESE )
|
|
{
|
|
// these two languages need special handling
|
|
langRes = el.wLang;
|
|
}
|
|
else
|
|
{
|
|
// otherwise we use only primary langid.
|
|
langRes = MAKELANGID(PRIMARYLANGID(el.wLang), SUBLANG_NEUTRAL);
|
|
}
|
|
}
|
|
return langRes;
|
|
}
|
|
|
|
//
|
|
// CCGetProperThreadLocale
|
|
//
|
|
// This function computes its brains out and tries to decide
|
|
// which thread locale we should use for our UI components.
|
|
//
|
|
// Returns the desired locale.
|
|
//
|
|
// Adjustment - For Arabic / Hebrew - NT4 Only
|
|
//
|
|
// Converts the thread locale to US, so that neutral resources
|
|
// loaded by the thread will be the US-English one, if available.
|
|
// This is used when the locale is Arabic/Hebrew and the system is
|
|
// NT4 enabled ( There was no localized NT4), as a result we need
|
|
// always to see the English resources on NT4 Arabic/Hebrew.
|
|
// [samera]
|
|
//
|
|
// Adjustment - For all languages - NT4 Only
|
|
//
|
|
// Convert the thread locale to the shell locale if not otherwise
|
|
// altered by previous adjustments.
|
|
//
|
|
// Adjustment - For all languages - NT5 Only
|
|
//
|
|
// Always use the default UI language. If that fails, then use the
|
|
// shell locale.
|
|
//
|
|
// The last two adjustments are handled in a common function, because
|
|
// the NT5 fallback turns out to be equal to the NT4 algorithm.
|
|
//
|
|
LCID CCGetProperThreadLocale(OPTIONAL LCID *plcidPrev)
|
|
{
|
|
LANGID uLangAlt, uLangMUI;
|
|
LCID lcidRet, iLcidThreadOrig;
|
|
|
|
iLcidThreadOrig = GetThreadLocale();
|
|
if (plcidPrev)
|
|
*plcidPrev = iLcidThreadOrig;
|
|
|
|
uLangMUI = GetMUILanguage();
|
|
if ( uLangMUI == MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL))
|
|
{
|
|
// return adjusted system default locale if MUI isn't initialized
|
|
//
|
|
lcidRet = CCGetSystemDefaultThreadLocale(iLcidThreadOrig);
|
|
}
|
|
else
|
|
{
|
|
// our host has initialized us with prefered MUI language
|
|
//
|
|
lcidRet = MAKELCID(uLangMUI, SORT_DEFAULT);
|
|
}
|
|
|
|
uLangAlt = GetAltFontLangId(LANGIDFROMLCID(lcidRet));
|
|
if (uLangAlt != LANGIDFROMLCID(lcidRet))
|
|
{
|
|
// use secondary resource for the language
|
|
// if the platform *does* have the alternative font
|
|
lcidRet = MAKELCID(uLangAlt, SORTIDFROMLCID(lcidRet));
|
|
}
|
|
|
|
return lcidRet;
|
|
}
|
|
|
|
//
|
|
// CCLoadStringEx
|
|
//
|
|
// Just like LoadString, except you can specify the language, too.
|
|
//
|
|
// This is harder than you think, because NT5 changed the way strings
|
|
// are loaded. Quote:
|
|
//
|
|
// We changed the resource loader in NT5, to only load resources
|
|
// in the language of the thread locale, if the thread locale is
|
|
// different to the user locale. The reasoning behind this was
|
|
// the "random" loading of the language of the user locale in
|
|
// the UI. This breaks if you do a SetThreadLocale to the User
|
|
// Locale, because then the whole step is ignored and the
|
|
// InstallLanguage of the system is loaded.
|
|
//
|
|
// Therefore, we have to use FindResourceEx.
|
|
//
|
|
//
|
|
int CCLoadStringEx(UINT uID, LPWSTR lpBuffer, int nBufferMax, WORD wLang)
|
|
{
|
|
return CCLoadStringExInternal(HINST_THISDLL, uID, lpBuffer, nBufferMax, wLang);
|
|
}
|
|
|
|
int CCLoadStringExInternal(HINSTANCE hInst, UINT uID, LPWSTR lpBuffer, int nBufferMax, WORD wLang)
|
|
{
|
|
PWCHAR pwch;
|
|
HRSRC hrsrc;
|
|
int cwch = 0;
|
|
|
|
if (nBufferMax <= 0) return 0; // sanity check
|
|
|
|
/*
|
|
* String tables are broken up into "bundles" of 16 strings each.
|
|
*/
|
|
|
|
hrsrc = FindResourceExRetry(hInst, RT_STRING,
|
|
(LPCTSTR)(LONG_PTR)(1 + (USHORT)uID / 16),
|
|
wLang);
|
|
if (hrsrc) {
|
|
pwch = (PWCHAR)LoadResource(hInst, hrsrc);
|
|
if (pwch) {
|
|
/*
|
|
* Now skip over the strings in the resource until we
|
|
* hit the one we want. Each entry is a counted string,
|
|
* just like Pascal.
|
|
*/
|
|
for (uID %= 16; uID; uID--) {
|
|
pwch += *pwch + 1;
|
|
}
|
|
cwch = min(*pwch, nBufferMax - 1);
|
|
memcpy(lpBuffer, pwch+1, cwch * sizeof(WCHAR)); /* Copy the goo */
|
|
}
|
|
}
|
|
lpBuffer[cwch] = L'\0'; /* Terminate the string */
|
|
return cwch;
|
|
}
|
|
|
|
|
|
//
|
|
// LocalizedLoadString
|
|
//
|
|
// Loads a string from our resources, using the correct language.
|
|
//
|
|
|
|
int LocalizedLoadString(UINT uID, LPWSTR lpBuffer, int nBufferMax)
|
|
{
|
|
return CCLoadStringEx(uID, lpBuffer, nBufferMax,
|
|
LANGIDFROMLCID(CCGetProperThreadLocale(NULL)));
|
|
}
|
|
|
|
//
|
|
// Determine if the prop sheet frame should use the new
|
|
// "MS Shell Dlg 2" font. To do this, we examine each page's dlg template.
|
|
// If all pages have SHELLFONT enabled, then
|
|
// we want to use the new font.
|
|
//
|
|
BOOL ShouldUseMSShellDlg2Font(LPPROPDATA ppd)
|
|
{
|
|
UINT iPage;
|
|
PAGEINFOEX pi;
|
|
LANGID langidMUI;
|
|
|
|
if (!staticIsOS(OS_WIN2000ORGREATER))
|
|
return FALSE;
|
|
|
|
langidMUI = GetMUILanguage();
|
|
for (iPage = 0; iPage < ppd->psh.nPages; iPage++)
|
|
{
|
|
if (GetPageInfoEx(ppd, GETPISP(ppd, iPage), &pi, langidMUI, GPI_DIALOGEX))
|
|
{
|
|
if (!IsPageInfoSHELLFONT(&pi))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
PSPT_OS Prsht_GetOS()
|
|
{
|
|
static PSPT_OS pspt_os = (PSPT_OS)-1;
|
|
int iIsOSBiDiEnabled = 0;
|
|
|
|
if (pspt_os != (PSPT_OS)-1)
|
|
{
|
|
return pspt_os;
|
|
}
|
|
|
|
|
|
iIsOSBiDiEnabled = GetSystemMetrics(SM_MIDEASTENABLED);
|
|
|
|
if (staticIsOS(OS_WIN2000ORGREATER))
|
|
{
|
|
pspt_os = PSPT_OS_WINNT5;
|
|
}
|
|
else if (iIsOSBiDiEnabled && staticIsOS(OS_NT4ORGREATER) && (!staticIsOS(OS_WIN2000ORGREATER)))
|
|
{
|
|
pspt_os = PSPT_OS_WINNT4_ENA;
|
|
}
|
|
else if (iIsOSBiDiEnabled && staticIsOS(OS_WIN95ORGREATER) && (!staticIsOS(OS_WIN98)))
|
|
{
|
|
pspt_os = PSPT_OS_WIN95_BIDI;
|
|
}
|
|
else if (iIsOSBiDiEnabled && staticIsOS(OS_WIN98))
|
|
{
|
|
pspt_os = PSPT_OS_WIN98_BIDI;
|
|
}
|
|
else
|
|
{
|
|
pspt_os = PSPT_OS_OTHER;
|
|
}
|
|
|
|
return pspt_os;
|
|
}
|
|
|
|
PSPT_OVERRIDE Prsht_GetOverrideState(LPPROPDATA ppd)
|
|
{
|
|
// if passed bad argument, assume no override
|
|
if(!ppd)
|
|
return PSPT_OVERRIDE_NOOVERRIDE;
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEPAGELANG)
|
|
return PSPT_OVERRIDE_USEPAGELANG;
|
|
|
|
return PSPT_OVERRIDE_NOOVERRIDE;
|
|
}
|
|
|
|
PSPT_TYPE Prsht_GetType(LPPROPDATA ppd, WORD wLang)
|
|
{
|
|
|
|
PISP pisp = NULL;
|
|
// if passed bad argument, give it the english resources
|
|
if(!ppd)
|
|
return PSPT_TYPE_ENGLISH;
|
|
|
|
pisp = GETPISP(ppd, 0);
|
|
if(pisp)
|
|
{
|
|
PAGEINFOEX pi = {0};
|
|
|
|
if ((IS_PROCESS_RTL_MIRRORED()) ||
|
|
(GetPageInfoEx(ppd, pisp, &pi, wLang, GPI_BMIRROR) && pi.bMirrored))
|
|
return PSPT_TYPE_MIRRORED;
|
|
|
|
else
|
|
{
|
|
WORD wLang = LANGIDFROMLCID(CCGetProperThreadLocale(NULL));
|
|
|
|
GetPageLanguage(pisp,&wLang);
|
|
if((PRIMARYLANGID(wLang) == LANG_ARABIC) || (PRIMARYLANGID(wLang) == LANG_HEBREW))
|
|
return PSPT_TYPE_ENABLED;
|
|
}
|
|
}
|
|
|
|
return PSPT_TYPE_ENGLISH;
|
|
}
|
|
|
|
PSPT_ACTION Prsht_GetAction(PSPT_TYPE pspt_type, PSPT_OS pspt_os, PSPT_OVERRIDE pspt_override)
|
|
{
|
|
if ((pspt_type < 0) || (pspt_type >= PSPT_TYPE_MAX)
|
|
|| (pspt_os < 0) || (pspt_os >= PSPT_OS_MAX)
|
|
|| (pspt_override < 0) || (pspt_override >= PSPT_OVERRIDE_MAX))
|
|
return PSPT_ACTION_NOACTION;
|
|
|
|
return g_PSPT_Action[pspt_type][pspt_os][pspt_override];
|
|
|
|
}
|
|
|
|
void Prsht_PrepareTemplate(LPPROPDATA ppd, HINSTANCE hInst, HGLOBAL *phDlgTemplate, HRSRC *phResInfo,
|
|
LPCSTR lpName, HWND hWndOwner, LPWORD lpwLangID)
|
|
{
|
|
|
|
|
|
LPDLGTEMPLATE pDlgTemplate = NULL;
|
|
PSPT_ACTION pspt_action;
|
|
|
|
if (pDlgTemplate = (LPDLGTEMPLATE)LockResource(*phDlgTemplate))
|
|
{
|
|
|
|
// We save BiDi templates as DIALOG (not DIALOGEX)
|
|
// If we got an extended template then it is not ours
|
|
|
|
if (((LPDLGTEMPLATEEX)pDlgTemplate)->wSignature == 0xFFFF)
|
|
return;
|
|
|
|
// Cut it short to save time
|
|
//
|
|
if (!(pDlgTemplate->dwExtendedStyle & (RTL_MIRRORED_WINDOW | RTL_NOINHERITLAYOUT)))
|
|
return;
|
|
}
|
|
|
|
pspt_action = Prsht_GetAction(Prsht_GetType(ppd, *lpwLangID), Prsht_GetOS(),
|
|
Prsht_GetOverrideState(ppd));
|
|
|
|
switch(pspt_action)
|
|
{
|
|
case PSPT_ACTION_NOACTION:
|
|
return;
|
|
|
|
case PSPT_ACTION_NOMIRRORING:
|
|
{
|
|
if (pDlgTemplate)
|
|
{
|
|
EditBiDiDLGTemplate(pDlgTemplate, EBDT_NOMIRROR, NULL, 0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PSPT_ACTION_FLIP:
|
|
{
|
|
if (pDlgTemplate)
|
|
{
|
|
EditBiDiDLGTemplate(pDlgTemplate, EBDT_NOMIRROR, NULL, 0);
|
|
EditBiDiDLGTemplate(pDlgTemplate, EBDT_FLIP, (PWORD)&wIgnoreIDs, ARRAYSIZE(wIgnoreIDs));
|
|
ppd->fFlipped = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PSPT_ACTION_LOADENGLISH:
|
|
{
|
|
HGLOBAL hDlgTemplateTemp = NULL;
|
|
HRSRC hResInfoTemp;
|
|
|
|
//
|
|
//Try to load an English resource.
|
|
//
|
|
*lpwLangID = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
|
|
|
|
if ((hResInfoTemp = FindResourceExA( hInst, (LPCSTR)RT_DIALOG, lpName, *lpwLangID)))
|
|
{
|
|
hDlgTemplateTemp = LoadResource(hInst, hResInfoTemp);
|
|
}
|
|
if (hDlgTemplateTemp)
|
|
{
|
|
//
|
|
//And return it to the caller to use it.
|
|
// Since we loaeded a new template, we should copy it to a local memory
|
|
// in case there is a callback.
|
|
//
|
|
|
|
DWORD cbTemplate = SizeofResource(hInst, hResInfoTemp);
|
|
LPVOID pTemplateMod;
|
|
|
|
pTemplateMod = (LPVOID)LocalAlloc(LPTR, cbTemplate * 2);
|
|
if (pTemplateMod)
|
|
{
|
|
memmove(pTemplateMod, hDlgTemplateTemp, cbTemplate);
|
|
LocalFree(*phDlgTemplate);
|
|
*phResInfo = hResInfoTemp;
|
|
*phDlgTemplate = pTemplateMod;
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
|
|
case PSPT_ACTION_WIN9XCOMPAT:
|
|
{
|
|
if (pDlgTemplate)
|
|
{
|
|
pDlgTemplate->style |= DS_BIDI_RTL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
INT_PTR _RealPropertySheet(LPPROPDATA ppd)
|
|
{
|
|
HWND hwndMain;
|
|
MSG32 msg32;
|
|
HWND hwndTopOwner;
|
|
int nReturn = -1;
|
|
HWND hwndOriginalFocus;
|
|
WORD wLang, wUserLang;
|
|
LCID iLcidThread=0L;
|
|
HRSRC hrsrc = 0;
|
|
LPVOID pTemplate, pTemplateMod;
|
|
LPTSTR lpDlgId;
|
|
if (ppd->psh.nPages == 0)
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("no pages for prop sheet"));
|
|
goto FreePpdAndReturn;
|
|
}
|
|
|
|
ppd->hwndCurPage = NULL;
|
|
ppd->nReturn = -1;
|
|
ppd->nRestart = 0;
|
|
|
|
hwndTopOwner = ppd->psh.hwndParent;
|
|
hwndOriginalFocus = GetFocus();
|
|
|
|
#ifdef DEBUG
|
|
if (GetAsyncKeyState(VK_CONTROL) < 0) {
|
|
|
|
ppd->psh.dwFlags |= PSH_WIZARDHASFINISH;
|
|
}
|
|
#endif
|
|
|
|
if (!(ppd->psh.dwFlags & PSH_MODELESS))
|
|
{
|
|
//
|
|
// Like dialog boxes, we only want to disable top level windows.
|
|
// NB The mail guys would like us to be more like a regular
|
|
// dialog box and disable the parent before putting up the sheet.
|
|
if (hwndTopOwner)
|
|
{
|
|
while (GetWindowLong(hwndTopOwner, GWL_STYLE) & WS_CHILD)
|
|
hwndTopOwner = GetParent(hwndTopOwner);
|
|
|
|
ASSERT(hwndTopOwner); // Should never get this!
|
|
if ((hwndTopOwner == GetDesktopWindow()) ||
|
|
(EnableWindow(hwndTopOwner, FALSE)))
|
|
{
|
|
//
|
|
// If the window was the desktop window, then don't disable
|
|
// it now and don't reenable it later.
|
|
// Also, if the window was already disabled, then don't
|
|
// enable it later.
|
|
//
|
|
hwndTopOwner = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if !defined(WIN32)
|
|
#ifdef FE_IME
|
|
// Win95d-B#754
|
|
// When PCMCIA gets detected, NETDI calls DiCallClassInstaller().
|
|
// The class installer of setupx calls PropertySheet() for msgsrv32.
|
|
// We usually don't prepare thread link info in imm for that process as
|
|
// it won't use IME normaly but we need to treat this case as special.
|
|
//
|
|
if (!ImmFindThreadLink(GetCurrentThreadID()))
|
|
{
|
|
ImmCreateThreadLink(GetCurrentProcessID(),GetCurrentThreadID());
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
//
|
|
// WARNING! WARNING! WARNING! WARNING!
|
|
//
|
|
// Before you mess with any language stuff, be aware that MFC loads
|
|
// resources directly out of comctl32.dll, so if you change the
|
|
// way we choose the proper resource, you may break MFC apps.
|
|
// See NT bug 302959.
|
|
|
|
//
|
|
// Support PSH_USEPAGELANG
|
|
//
|
|
|
|
// Presume we load our template based on thread lang id.
|
|
wLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
wUserLang= MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
|
|
if (ppd->psh.dwFlags & PSH_USEPAGELANG)
|
|
{
|
|
// Get callers language version. We know we have at least one page
|
|
if (FAILED(GetPageLanguage(GETPISP(ppd, 0), &wLang)))
|
|
{
|
|
// failed to get langid out of caller's resource
|
|
// just pretend nothing happened.
|
|
wLang = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL);
|
|
}
|
|
wUserLang = wLang;
|
|
}
|
|
else
|
|
wLang = LANGIDFROMLCID(CCGetProperThreadLocale(NULL));
|
|
|
|
//
|
|
// The only thing we need the thread locale for is to locate the
|
|
// correct dialog template. We don't want it to affect page
|
|
// initialization or anything else like that, so get the template
|
|
// and quickly set the locale back before anyone notices.
|
|
//
|
|
// If we can't get the requested language, retry with the neutral
|
|
// language.
|
|
//
|
|
|
|
|
|
// We have seperate dialog templates for Win95 BiDi localized
|
|
// The code used to check to see if we are running on Win98 BiDi localized
|
|
// and load this template.
|
|
// We have a special case when running Office2000 with Arabic/Hebrew SKU on
|
|
// BiDi win95 Enabled where we need to load this template as well
|
|
if(Prsht_GetOS() == PSPT_OS_WIN95_BIDI)
|
|
{
|
|
lpDlgId = MAKEINTRESOURCE(IS_WIZARD(ppd) ? DLG_WIZARD95 : DLG_PROPSHEET95);
|
|
hrsrc = FindResourceEx(
|
|
HINST_THISDLL, RT_DIALOG,
|
|
lpDlgId,
|
|
wLang );
|
|
// we only have DLG_WIZARD95 and DLG_PROPSHEET95 in Arabic & Hebrew language
|
|
// if we got any other language we will fail
|
|
// In this case, let's use the normal templates
|
|
if(hrsrc)
|
|
{
|
|
ppd->fFlipped = TRUE;
|
|
}
|
|
else
|
|
{
|
|
lpDlgId = MAKEINTRESOURCE(IS_WIZARD(ppd) ? DLG_WIZARD : DLG_PROPSHEET);
|
|
hrsrc = FindResourceExRetry(
|
|
HINST_THISDLL, RT_DIALOG,
|
|
lpDlgId,
|
|
wLang );
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
lpDlgId = MAKEINTRESOURCE(IS_WIZARD(ppd) ? DLG_WIZARD : DLG_PROPSHEET);
|
|
|
|
hrsrc = FindResourceExRetry(
|
|
HINST_THISDLL, RT_DIALOG,
|
|
lpDlgId,
|
|
wLang );
|
|
}
|
|
// Setup for failure
|
|
hwndMain = NULL;
|
|
|
|
if (hrsrc &&
|
|
(pTemplate = (LPVOID)LoadResource(HINST_THISDLL, hrsrc)))
|
|
{
|
|
DWORD cbTemplate;
|
|
|
|
cbTemplate = SizeofResource(HINST_THISDLL, hrsrc);
|
|
|
|
pTemplateMod = (LPVOID)LocalAlloc(LPTR, cbTemplate * 2); //double it to give some play leeway
|
|
|
|
if (pTemplateMod)
|
|
{
|
|
hmemcpy(pTemplateMod, pTemplate, cbTemplate);
|
|
//Check the direction of this dialog and change it if it does not match the owner.
|
|
Prsht_PrepareTemplate(ppd, HINST_THISDLL, &pTemplateMod, (HRSRC *)&hrsrc,
|
|
(LPSTR)lpDlgId,ppd->psh.hwndParent, &wUserLang);
|
|
}
|
|
else
|
|
{
|
|
pTemplateMod = pTemplate; // no modifications
|
|
}
|
|
|
|
//
|
|
// Template editing and callbacks happen only if we were able
|
|
// to create a copy for modifying.
|
|
//
|
|
if (pTemplateMod != pTemplate)
|
|
{
|
|
if (ppd->psh.dwFlags & PSH_NOCONTEXTHELP)
|
|
{
|
|
if (((LPDLGTEMPLATEEX)pTemplateMod)->wSignature == 0xFFFF){
|
|
((LPDLGTEMPLATEEX)pTemplateMod)->dwStyle &= ~DS_CONTEXTHELP;
|
|
} else {
|
|
((LPDLGTEMPLATE)pTemplateMod)->style &= ~DS_CONTEXTHELP;
|
|
}
|
|
}
|
|
|
|
if (IS_WIZARD(ppd) &&
|
|
(ppd->psh.dwFlags & PSH_WIZARDCONTEXTHELP)) {
|
|
|
|
if (((LPDLGTEMPLATEEX)pTemplateMod)->wSignature == 0xFFFF){
|
|
((LPDLGTEMPLATEEX)pTemplateMod)->dwStyle |= DS_CONTEXTHELP;
|
|
} else {
|
|
((LPDLGTEMPLATE)pTemplateMod)->style |= DS_CONTEXTHELP;
|
|
}
|
|
}
|
|
|
|
// extra check for PSH_USEPAGELANG case
|
|
if (ppd->psh.pfnCallback)
|
|
{
|
|
#ifdef WX86
|
|
if (ppd->fFlags & PD_WX86)
|
|
Wx86Callback(ppd->psh.pfnCallback, NULL, PSCB_PRECREATE, (LPARAM)(LPVOID)pTemplateMod);
|
|
else
|
|
#endif
|
|
ppd->psh.pfnCallback(NULL, PSCB_PRECREATE, (LPARAM)(LPVOID)pTemplateMod);
|
|
}
|
|
}
|
|
|
|
|
|
if (pTemplateMod)
|
|
{
|
|
//
|
|
// For NT, we want to use MS Shell Dlg 2 font in the prop sheet if
|
|
// all of the pages in the sheet use MS Shell Dlg 2.
|
|
// To do this, we ensure the template is DIALOGEX and that the
|
|
// DS_SHELLFONT style bits (DS_SHELLFONT | DS_FIXEDSYS) are set.
|
|
//
|
|
if (ShouldUseMSShellDlg2Font(ppd))
|
|
{
|
|
if (((LPDLGTEMPLATEEX)pTemplateMod)->wSignature != 0xFFFF)
|
|
{
|
|
//
|
|
// Convert DLGTEMPLATE to DLGTEMPLATEEX.
|
|
//
|
|
LPVOID pTemplateCvtEx;
|
|
int iCharset = GetDefaultCharsetFromLang(wLang);
|
|
if (SUCCEEDED(CvtDlgToDlgEx(pTemplateMod, (LPDLGTEMPLATEEX *)&pTemplateCvtEx, iCharset)))
|
|
{
|
|
LocalFree(pTemplateMod);
|
|
pTemplateMod = pTemplateCvtEx;
|
|
} else {
|
|
// Unable to convert to ShellFont; oh well
|
|
goto NotShellFont;
|
|
}
|
|
}
|
|
//
|
|
// Set DS_SHELLFONT style bits so we get "MS Shell Dlg2" font.
|
|
//
|
|
((LPDLGTEMPLATEEX)pTemplateMod)->dwStyle |= DS_SHELLFONT;
|
|
ppd->fFlags |= PD_SHELLFONT;
|
|
NotShellFont:;
|
|
}
|
|
|
|
// pTemplateMod is always unicode, even for the A function - no need to thunk
|
|
hwndMain = CreateDialogIndirectParam(HINST_THISDLL, pTemplateMod,
|
|
ppd->psh.hwndParent, PropSheetDlgProc, (LPARAM)(LPPROPDATA)ppd);
|
|
|
|
// WORK AROUND WOW/USER BUG: Even though InitPropSheetDlg sets
|
|
// ppd->hDlg, in the WOW scenario, the incoming hDlg is WRONG!
|
|
// The USER guys say "Tough. You have to work around it."
|
|
ppd->hDlg = hwndMain;
|
|
}
|
|
if (pTemplateMod != pTemplate)
|
|
LocalFree(pTemplateMod);
|
|
}
|
|
|
|
if (!hwndMain)
|
|
{
|
|
int iPage;
|
|
|
|
DebugMsg(DM_ERROR, TEXT("PropertySheet: unable to create main dialog"));
|
|
|
|
if (hwndTopOwner && !(ppd->psh.dwFlags & PSH_MODELESS))
|
|
EnableWindow(hwndTopOwner, TRUE);
|
|
|
|
// Release all page objects in REVERSE ORDER so we can have
|
|
// pages that are dependant on eachother based on the initial
|
|
// order of those pages
|
|
//
|
|
for (iPage = (int)ppd->psh.nPages - 1; iPage >= 0; iPage--)
|
|
{
|
|
ULONG_PTR dw = PropPageActivateContext(ppd, GETPISP(ppd, iPage));
|
|
DestroyPropertySheetPage(GETHPAGE(ppd, iPage));
|
|
PropPageDeactivateContext(dw);
|
|
}
|
|
|
|
goto FreePpdAndReturn;
|
|
}
|
|
|
|
if (ppd->psh.dwFlags & PSH_MODELESS)
|
|
return (INT_PTR)hwndMain;
|
|
|
|
while( ppd->hwndCurPage && GetMessage32(&msg32, NULL, 0, 0, TRUE) )
|
|
{
|
|
// if (PropSheet_IsDialogMessage(ppd->hDlg, (LPMSG)&msg32))
|
|
if (Prop_IsDialogMessage(ppd, &msg32))
|
|
continue;
|
|
|
|
TranslateMessage32(&msg32, TRUE);
|
|
DispatchMessage32(&msg32, TRUE);
|
|
}
|
|
|
|
if( ppd->hwndCurPage )
|
|
{
|
|
// GetMessage returned FALSE (WM_QUIT)
|
|
DebugMsg( DM_TRACE, TEXT("PropertySheet: bailing in response to WM_QUIT (and reposting quit)") );
|
|
ButtonPushed( ppd, IDCANCEL ); // nuke ourselves
|
|
PostQuitMessage( (int) msg32.wParam ); // repost quit for next enclosing loop
|
|
}
|
|
|
|
// don't let this get mangled during destroy processing
|
|
nReturn = ppd->nReturn ;
|
|
|
|
if (ppd->psh.hwndParent && (GetActiveWindow() == hwndMain)) {
|
|
DebugMsg(DM_TRACE, TEXT("Passing activation up"));
|
|
SetActiveWindow(ppd->psh.hwndParent);
|
|
}
|
|
|
|
if (hwndTopOwner)
|
|
EnableWindow(hwndTopOwner, TRUE);
|
|
|
|
if (IsWindow(hwndOriginalFocus)) {
|
|
SetFocus(hwndOriginalFocus);
|
|
}
|
|
|
|
DestroyWindow(hwndMain);
|
|
|
|
// do pickup any PSM_REBOOTSYSTEM or PSM_RESTARTWINDOWS sent during destroy
|
|
if ((nReturn > 0) && ppd->nRestart)
|
|
nReturn = ppd->nRestart;
|
|
|
|
FreePpdAndReturn:
|
|
|
|
#ifdef WIN32
|
|
LocalFree((HLOCAL)ppd);
|
|
#else
|
|
LocalFree((HLOCAL)LOWORD(ppd));
|
|
#endif
|
|
|
|
return nReturn;
|
|
}
|
|
|
|
|
|
|
|
|
|
HPROPSHEETPAGE WINAPI CreateProxyPage(HPROPSHEETPAGE hpage16, HINSTANCE hinst16)
|
|
{
|
|
SetLastErrorEx(ERROR_CALL_NOT_IMPLEMENTED, SLE_WARNING);
|
|
return NULL;
|
|
}
|
|
|
|
// DestroyPropsheetPageArray
|
|
//
|
|
// Helper function used during error handling. It destroys the
|
|
// incoming property sheet pages.
|
|
|
|
void DestroyPropsheetPageArray(LPCPROPSHEETHEADER ppsh)
|
|
{
|
|
int iPage;
|
|
|
|
if (!(ppsh->dwFlags & PSH_PROPSHEETPAGE))
|
|
{
|
|
// Release all page objects in REVERSE ORDER so we can have
|
|
// pages that are dependant on eachother based on the initial
|
|
// order of those pages
|
|
|
|
for (iPage = (int)ppsh->nPages - 1; iPage >= 0; iPage--)
|
|
{
|
|
DestroyPropertySheetPage(ppsh->H_phpage[iPage]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// PropertySheet API
|
|
//
|
|
// This function displays the property sheet described by ppsh.
|
|
//
|
|
// Since I don't expect anyone to ever check the return value
|
|
// (we certainly don't), we need to make sure any provided phpage array
|
|
// is always freed with DestroyPropertySheetPage, even if an error occurs.
|
|
//
|
|
//
|
|
// The fNeedShadow parameter means "The incoming LPCPROPSHEETHEADER is in the
|
|
// opposite character set from what you implement natively".
|
|
//
|
|
// If we are compiling UNICODE, then fNeedShadow is TRUE if the incoming
|
|
// LPCPROPSHEETHEADER is really an ANSI property sheet page.
|
|
//
|
|
// If we are compiling ANSI-only, then fNeedShadow is always FALSE because
|
|
// we don't support UNICODE in the ANSI-only version.
|
|
//
|
|
|
|
INT_PTR WINAPI _PropertySheet(LPCPROPSHEETHEADER ppsh, BOOL fNeedShadow)
|
|
{
|
|
PROPDATA *ppd;
|
|
int iPage;
|
|
|
|
//
|
|
// validate header
|
|
//
|
|
ASSERT(IsValidPROPSHEETHEADERSIZE(sizeof(PROPSHEETHEADER)));
|
|
|
|
if (!IsValidPROPSHEETHEADERSIZE(ppsh->dwSize))
|
|
{
|
|
DebugMsg( DM_ERROR, TEXT("PropertySheet: dwSize is not correct") );
|
|
goto invalid_call;
|
|
}
|
|
|
|
if (ppsh->dwFlags & ~PSH_ALL)
|
|
{
|
|
DebugMsg( DM_ERROR, TEXT("PropertySheet: invalid flags") );
|
|
goto invalid_call;
|
|
}
|
|
|
|
if (ppsh->nPages >= MAXPROPPAGES)
|
|
{
|
|
DebugMsg( DM_ERROR, TEXT("PropertySheet: too many pages ( use MAXPROPPAGES )") );
|
|
goto invalid_call;
|
|
}
|
|
|
|
ppd = (PROPDATA *)LocalAlloc(LPTR, sizeof(PROPDATA));
|
|
if (ppd == NULL)
|
|
{
|
|
DebugMsg(DM_ERROR, TEXT("failed to alloc property page data"));
|
|
|
|
invalid_call:
|
|
DestroyPropsheetPageArray(ppsh);
|
|
return -1;
|
|
}
|
|
|
|
// Initialize the flags.
|
|
ppd->fFlags = FALSE;
|
|
|
|
#ifdef WX86
|
|
//
|
|
// If Wx86 is calling, set the flag that thunks the callbacks.
|
|
//
|
|
|
|
if ( Wx86IsCallThunked() ) {
|
|
ppd->fFlags |= PD_WX86;
|
|
}
|
|
#endif
|
|
|
|
if (fNeedShadow)
|
|
ppd->fFlags |= PD_NEEDSHADOW;
|
|
|
|
// make a copy of the header so we can party on it
|
|
hmemcpy(&ppd->psh, ppsh, ppsh->dwSize);
|
|
|
|
// so we don't have to check later...
|
|
if (!(ppd->psh.dwFlags & PSH_USECALLBACK))
|
|
ppd->psh.pfnCallback = NULL;
|
|
|
|
// fix up the page pointer to point to our copy of the page array
|
|
ppd->psh.H_phpage = ppd->rghpage;
|
|
|
|
GetCurrentActCtx(&ppd->hActCtxInit);
|
|
|
|
if (ppd->psh.dwFlags & PSH_PROPSHEETPAGE)
|
|
{
|
|
// for lazy clients convert PROPSHEETPAGE structures into page handles
|
|
LPCPROPSHEETPAGE ppsp = ppsh->H_ppsp;
|
|
|
|
for (iPage = 0; iPage < (int)ppd->psh.nPages; iPage++)
|
|
{
|
|
ppd->psh.H_phpage[iPage] = _CreatePropertySheetPage(ppsp, fNeedShadow,
|
|
ppd->fFlags & PD_WX86);
|
|
if (!ppd->psh.H_phpage[iPage])
|
|
{
|
|
iPage--;
|
|
ppd->psh.nPages--;
|
|
}
|
|
|
|
ppsp = (LPCPROPSHEETPAGE)((LPBYTE)ppsp + ppsp->dwSize); // next PROPSHEETPAGE structure
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The UNICODE build needs to hack around Hijaak 95.
|
|
//
|
|
ppd->psh.nPages = 0;
|
|
for (iPage = 0; iPage < (int)ppsh->nPages; iPage++)
|
|
{
|
|
ppd->psh.H_phpage[ppd->psh.nPages] = _Hijaak95Hack(ppd, ppsh->H_phpage[iPage]);
|
|
if (ppd->psh.H_phpage[ppd->psh.nPages])
|
|
{
|
|
ppd->psh.nPages++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Everybody else assumes that the HPROPSHEETPAGEs have been
|
|
// internalized, so let's do that before anybody notices.
|
|
//
|
|
for (iPage = 0; iPage < (int)ppd->psh.nPages; iPage++)
|
|
{
|
|
SETPISP(ppd, iPage, InternalizeHPROPSHEETPAGE(ppd->psh.H_phpage[iPage]));
|
|
}
|
|
|
|
//
|
|
// Walk all pages to see if any have help and if so, set the PSH_HASHELP
|
|
// flag in the header.
|
|
//
|
|
if (!(ppd->psh.dwFlags & PSH_HASHELP))
|
|
{
|
|
for (iPage = 0; iPage < (int)ppd->psh.nPages; iPage++)
|
|
{
|
|
if (GETPPSP(ppd, iPage)->dwFlags & PSP_HASHELP)
|
|
{
|
|
ppd->psh.dwFlags |= PSH_HASHELP;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return _RealPropertySheet(ppd);
|
|
}
|
|
|
|
INT_PTR WINAPI PropertySheetW(LPCPROPSHEETHEADERW ppsh)
|
|
{
|
|
return _PropertySheet(ppsh, FALSE);
|
|
}
|
|
|
|
INT_PTR WINAPI PropertySheetA(LPCPROPSHEETHEADERA ppsh)
|
|
{
|
|
PROPSHEETHEADERW pshW;
|
|
INT_PTR iResult;
|
|
|
|
//
|
|
// Most validation is done by _PropertySheet, but we need
|
|
// to validate the header size, or we won't survive the thunk.
|
|
//
|
|
if (!IsValidPROPSHEETHEADERSIZE(ppsh->dwSize))
|
|
{
|
|
DebugMsg( DM_ERROR, TEXT("PropertySheet: dwSize is not correct") );
|
|
goto Error;
|
|
}
|
|
|
|
if (!ThunkPropSheetHeaderAtoW(ppsh, &pshW))
|
|
goto Error;
|
|
|
|
iResult = _PropertySheet(&pshW, TRUE);
|
|
|
|
FreePropSheetHeaderW(&pshW);
|
|
|
|
return iResult;
|
|
|
|
Error:
|
|
DestroyPropsheetPageArray((LPCPROPSHEETHEADER)ppsh);
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// CopyPropertyPageStrings
|
|
//
|
|
// We have a PROPSHEETPAGE structure that contains pointers to strings.
|
|
// For each string, create a copy and smash the pointer-to-copy in the
|
|
// place where the original static pointer used to be.
|
|
//
|
|
// The method of copying varies depending on what kind of copy we want
|
|
// to make, so we use a callback procedure.
|
|
//
|
|
// UNICODE-to-UNICODE: StrDupW
|
|
// ANSI-to-UNICODE: StrDup_AtoW
|
|
// ANSI-to-ANSI: StrDupA
|
|
//
|
|
// On failure, all strings that did not get properly duplicated are set
|
|
// to NULL. You still have to call FreePropertyPageStrings to clear
|
|
// them out. Notice that when we fail to allocate, we merely make a note
|
|
// of the fact and continue onward. This ensures that all string fields
|
|
// are set to NULL if they could not be dup'd.
|
|
//
|
|
// ppsp - A pointer to either a PROPSHEETPAGEA or PROPSHEETPAGEW.
|
|
// The two structures are laid out identically, so it doesn't matter.
|
|
//
|
|
// pfnStrDup - function that will make the appropriate copy.
|
|
//
|
|
|
|
BOOL CopyPropertyPageStrings(LPPROPSHEETPAGE ppsp, STRDUPPROC pfnStrDup)
|
|
{
|
|
BOOL fSuccess = TRUE;
|
|
|
|
if (!(ppsp->dwFlags & PSP_DLGINDIRECT) && !IS_INTRESOURCE(ppsp->P_pszTemplate))
|
|
{
|
|
ppsp->P_pszTemplate = pfnStrDup(ppsp->P_pszTemplate);
|
|
if (!ppsp->P_pszTemplate)
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
if ((ppsp->dwFlags & PSP_USEICONID) && !IS_INTRESOURCE(ppsp->P_pszIcon))
|
|
{
|
|
ppsp->P_pszIcon = pfnStrDup(ppsp->P_pszIcon);
|
|
if (!ppsp->P_pszIcon)
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
if ((ppsp->dwFlags & PSP_USETITLE) && !IS_INTRESOURCE(ppsp->pszTitle))
|
|
{
|
|
ppsp->pszTitle = pfnStrDup(ppsp->pszTitle);
|
|
if (!ppsp->pszTitle)
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
if ((ppsp->dwFlags & PSP_USEHEADERTITLE) && !IS_INTRESOURCE(ppsp->pszHeaderTitle))
|
|
{
|
|
ppsp->pszHeaderTitle = pfnStrDup(ppsp->pszHeaderTitle);
|
|
if (!ppsp->pszHeaderTitle)
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
if ((ppsp->dwFlags & PSP_USEHEADERSUBTITLE) && !IS_INTRESOURCE(ppsp->pszHeaderSubTitle))
|
|
{
|
|
ppsp->pszHeaderSubTitle = pfnStrDup(ppsp->pszHeaderSubTitle);
|
|
if (!ppsp->pszHeaderSubTitle)
|
|
fSuccess = FALSE;
|
|
}
|
|
|
|
return fSuccess;
|
|
}
|
|
|
|
//
|
|
// FreePropertyPageStrings
|
|
//
|
|
// Free the strings that live inside a property sheet page structure.
|
|
//
|
|
// ppsp - A pointer to either a PROPSHEETPAGEA or PROPSHEETPAGEW.
|
|
// The two structures are laid out identically, so it doesn't matter.
|
|
//
|
|
|
|
void FreePropertyPageStrings(LPCPROPSHEETPAGE ppsp)
|
|
{
|
|
if (!(ppsp->dwFlags & PSP_DLGINDIRECT) && !IS_INTRESOURCE(ppsp->P_pszTemplate))
|
|
LocalFree((LPVOID)ppsp->P_pszTemplate);
|
|
|
|
if ((ppsp->dwFlags & PSP_USEICONID) && !IS_INTRESOURCE(ppsp->P_pszIcon))
|
|
LocalFree((LPVOID)ppsp->P_pszIcon);
|
|
|
|
if ((ppsp->dwFlags & PSP_USETITLE) && !IS_INTRESOURCE(ppsp->pszTitle))
|
|
LocalFree((LPVOID)ppsp->pszTitle);
|
|
|
|
if ((ppsp->dwFlags & PSP_USEHEADERTITLE) && !IS_INTRESOURCE(ppsp->pszHeaderTitle))
|
|
LocalFree((LPVOID)ppsp->pszHeaderTitle);
|
|
|
|
if ((ppsp->dwFlags & PSP_USEHEADERSUBTITLE) && !IS_INTRESOURCE(ppsp->pszHeaderSubTitle))
|
|
LocalFree((LPVOID)ppsp->pszHeaderSubTitle);
|
|
}
|
|
|
|
//*************************************************************
|
|
//
|
|
// ThunkPropSheetHeaderAtoW ()
|
|
//
|
|
// Purpose: Thunks the Ansi version of PROPSHEETHEADER to
|
|
// Unicode.
|
|
//
|
|
// Note that the H_phpage / H_ppsp field is not thunked.
|
|
// We'll deal with that separately.
|
|
//
|
|
//*************************************************************
|
|
|
|
BOOL ThunkPropSheetHeaderAtoW (LPCPROPSHEETHEADERA ppshA,
|
|
LPPROPSHEETHEADERW ppsh)
|
|
{
|
|
//
|
|
// Deciding whether an item should be freed or not is tricky, so we
|
|
// keep a private array of all the pointers we've allocated, so we
|
|
// know what to free when we fail.
|
|
//
|
|
LPTSTR Alloced[5] = { 0 };
|
|
|
|
ASSERT(IsValidPROPSHEETHEADERSIZE(ppshA->dwSize));
|
|
|
|
hmemcpy(ppsh, ppshA, ppshA->dwSize);
|
|
|
|
ppsh->dwFlags |= PSH_THUNKED;
|
|
if ((ppsh->dwFlags & PSH_USEICONID) && !IS_INTRESOURCE(ppsh->H_pszIcon))
|
|
{
|
|
ppsh->H_pszIcon = Alloced[0] = StrDup_AtoW(ppsh->H_pszIcon);
|
|
if (!ppsh->H_pszIcon)
|
|
goto ExitIcon;
|
|
}
|
|
|
|
if (!IS_WIZARDPSH(*ppsh) && !IS_INTRESOURCE(ppsh->pszCaption))
|
|
{
|
|
ppsh->pszCaption = Alloced[1] = StrDup_AtoW(ppsh->pszCaption);
|
|
if (!ppsh->pszCaption)
|
|
goto ExitCaption;
|
|
}
|
|
|
|
if ((ppsh->dwFlags & PSH_USEPSTARTPAGE) && !IS_INTRESOURCE(ppsh->H_pStartPage))
|
|
{
|
|
ppsh->H_pStartPage = Alloced[2] = StrDup_AtoW(ppsh->H_pStartPage);
|
|
if (!ppsh->H_pStartPage)
|
|
goto ExitStartPage;
|
|
}
|
|
|
|
if (ppsh->dwFlags & PSH_WIZARD97)
|
|
{
|
|
if ((ppsh->dwFlags & PSH_WATERMARK) &&
|
|
!(ppsh->dwFlags & PSH_USEHBMWATERMARK) &&
|
|
!IS_INTRESOURCE(ppsh->H_pszbmWatermark))
|
|
{
|
|
ppsh->H_pszbmWatermark = Alloced[3] = StrDup_AtoW(ppsh->H_pszbmWatermark);
|
|
if (!ppsh->H_pszbmWatermark)
|
|
goto ExitWatermark;
|
|
}
|
|
|
|
if ((ppsh->dwFlags & PSH_HEADER) &&
|
|
!(ppsh->dwFlags & PSH_USEHBMHEADER) &&
|
|
!IS_INTRESOURCE(ppsh->H_pszbmHeader))
|
|
{
|
|
ppsh->H_pszbmHeader = Alloced[4] = StrDup_AtoW(ppsh->H_pszbmHeader);
|
|
if (!ppsh->H_pszbmHeader)
|
|
goto ExitHeader;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
ExitHeader:
|
|
if (Alloced[3]) LocalFree(Alloced[3]);
|
|
ExitWatermark:
|
|
if (Alloced[2]) LocalFree(Alloced[2]);
|
|
ExitStartPage:
|
|
if (Alloced[1]) LocalFree(Alloced[1]);
|
|
ExitCaption:
|
|
if (Alloced[0]) LocalFree(Alloced[0]);
|
|
ExitIcon:
|
|
return FALSE;
|
|
}
|
|
|
|
void FreePropSheetHeaderW(LPPROPSHEETHEADERW ppsh)
|
|
{
|
|
if ((ppsh->dwFlags & PSH_USEICONID) && !IS_INTRESOURCE(ppsh->H_pszIcon))
|
|
LocalFree((LPVOID)ppsh->H_pszIcon);
|
|
|
|
if (!IS_WIZARDPSH(*ppsh) && !IS_INTRESOURCE(ppsh->pszCaption))
|
|
LocalFree((LPVOID)ppsh->pszCaption);
|
|
|
|
if ((ppsh->dwFlags & PSH_USEPSTARTPAGE) && !IS_INTRESOURCE(ppsh->H_pStartPage))
|
|
LocalFree((LPVOID)ppsh->H_pStartPage);
|
|
|
|
if (ppsh->dwFlags & PSH_WIZARD97)
|
|
{
|
|
if ((ppsh->dwFlags & PSH_WATERMARK) &&
|
|
!(ppsh->dwFlags & PSH_USEHBMWATERMARK) &&
|
|
!IS_INTRESOURCE(ppsh->H_pszbmWatermark))
|
|
LocalFree((LPVOID)ppsh->H_pszbmWatermark);
|
|
|
|
if ((ppsh->dwFlags & PSH_HEADER) &&
|
|
!(ppsh->dwFlags & PSH_USEHBMHEADER) &&
|
|
!IS_INTRESOURCE(ppsh->H_pszbmHeader))
|
|
LocalFree((LPVOID)ppsh->H_pszbmHeader);
|
|
}
|
|
}
|