You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2129 lines
61 KiB
2129 lines
61 KiB
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
DWORD OptionsDlgContextHelp[] = { IDC_MAKELOCALSOURCEFROMCD, IDH_MAKELOCALSOURCEFROMCD,
|
|
IDC_USEFLOPPIES , IDH_USEFLOPPIES,
|
|
IDC_SYSPARTDRIVE , IDH_SYSPARTDRIVE,
|
|
IDT_SYSPARTTEXT , IDH_SYSPARTDRIVE,
|
|
IDC_CHOOSE_INSTALLPART , IDH_CHOOSE_INSTALLPART,
|
|
IDC_INSTALL_DIR , IDH_INSTALL_DIR,
|
|
0 , 0
|
|
};
|
|
|
|
typedef struct _LOCALE_ENTRY {
|
|
LPTSTR Lcid;
|
|
LPTSTR Description;
|
|
LPTSTR LanguageGroup1;
|
|
LPTSTR LanguageGroup2;
|
|
} LOCALE_ENTRY, *PLOCALE_ENTRY;
|
|
|
|
typedef struct _LANGUAGE_GROUP_ENTRY {
|
|
LPTSTR Id;
|
|
LPTSTR Description;
|
|
LPTSTR Directory;
|
|
BOOL Selected;
|
|
} LANGUAGE_GROUP_ENTRY, *PLANGUAGE_GROUP_ENTRY;
|
|
|
|
BOOL IntlInfProcessed = FALSE;
|
|
DWORD LocaleCount = 0;
|
|
PLOCALE_ENTRY LocaleList;
|
|
DWORD PrimaryLocale;
|
|
DWORD LanguageGroupsCount = 0;
|
|
PLANGUAGE_GROUP_ENTRY LanguageGroups;
|
|
BOOL NTFSConversionChanged;
|
|
|
|
//
|
|
// Headless settings.
|
|
//
|
|
TCHAR HeadlessSelection[MAX_PATH];
|
|
ULONG HeadlessBaudRate = 0;
|
|
#define DEFAULT_HEADLESS_SETTING TEXT("COM1")
|
|
|
|
BOOL
|
|
(*Kernel32IsValidLanguageGroup)(
|
|
IN LGRPID LanguageGroup,
|
|
IN DWORD dwFlags);
|
|
|
|
// Only used for amd64/X86 case.
|
|
BOOL ForceFloppyless = FALSE;
|
|
UINT g_Boot16 = BOOT16_NO;
|
|
|
|
|
|
INT_PTR
|
|
OptionsDlgProc(
|
|
IN HWND hdlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL b;
|
|
TCHAR Text[MAX_PATH];
|
|
|
|
switch(msg) {
|
|
|
|
case WM_INITDIALOG:
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
if (RemoteBoot) {
|
|
|
|
//
|
|
// For remote boot client upgrade, uncheck and disable the
|
|
// "copy files from CD-ROM to hard drive" checkbox.
|
|
//
|
|
CheckDlgButton(hdlg,IDC_MAKELOCALSOURCEFROMCD,BST_UNCHECKED);
|
|
EnableWindow(GetDlgItem(hdlg,IDC_MAKELOCALSOURCEFROMCD),FALSE);
|
|
ShowWindow(GetDlgItem(hdlg, IDC_MAKELOCALSOURCEFROMCD), SW_HIDE);
|
|
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
|
|
if (!IsArc()) {
|
|
//
|
|
// Set initial state of "copy files from CD-ROM to hard drive"
|
|
// checkbox. Note that that control might be disabled.
|
|
//
|
|
CheckDlgButton(hdlg,
|
|
IDC_MAKELOCALSOURCEFROMCD,
|
|
MakeLocalSource ? BST_CHECKED : BST_UNCHECKED);
|
|
|
|
if(!RunFromCD) {
|
|
//
|
|
// Not run from CD, disable the control. The box won't be checked.
|
|
// But MakeLocalSource is probably TRUE.
|
|
//
|
|
EnableWindow(GetDlgItem(hdlg,IDC_MAKELOCALSOURCEFROMCD),FALSE);
|
|
}
|
|
} else {
|
|
//
|
|
// On ARC machines the files are always copied to the hard drive
|
|
//
|
|
ShowWindow(GetDlgItem(hdlg, IDC_MAKELOCALSOURCEFROMCD), SW_HIDE);
|
|
} // if (!IsArc())
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Disable system partition controls?
|
|
//
|
|
#if defined _IA64_
|
|
EnableWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),FALSE);
|
|
ShowWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),SW_HIDE);
|
|
ShowWindow(GetDlgItem(hdlg,IDT_SYSPARTTEXT),SW_HIDE);
|
|
#else
|
|
if( !IsArc()) {
|
|
EnableWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),FALSE);
|
|
ShowWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),SW_HIDE);
|
|
ShowWindow(GetDlgItem(hdlg,IDT_SYSPARTTEXT),SW_HIDE);
|
|
} else {
|
|
EnableWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),SystemPartitionDriveLetter != 0);
|
|
ShowWindow(GetDlgItem(hdlg,IDC_SYSPARTDRIVE),SystemPartitionDriveLetter ? SW_SHOW : SW_HIDE);
|
|
ShowWindow(GetDlgItem(hdlg,IDT_SYSPARTTEXT),SystemPartitionDriveLetter ? SW_SHOW : SW_HIDE);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
if (Upgrade && !ISNT()) {
|
|
//
|
|
// Populate the Boot16 value.
|
|
//
|
|
SendDlgItemMessage(hdlg,IDC_BOOT16_1,BM_SETCHECK, (g_Boot16 == BOOT16_AUTOMATIC) ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(hdlg,IDC_BOOT16_2,BM_SETCHECK, (g_Boot16 == BOOT16_YES ) ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
SendDlgItemMessage(hdlg,IDC_BOOT16_3,BM_SETCHECK, (g_Boot16 == BOOT16_NO ) ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
}
|
|
|
|
//
|
|
// Set floppyless control.
|
|
//
|
|
#if defined(REMOTE_BOOT)
|
|
if (RemoteBoot) {
|
|
//
|
|
// For remote boot client upgrade, this is always unchecked and disabled.
|
|
//
|
|
CheckDlgButton(hdlg,IDC_USEFLOPPIES,BST_UNCHECKED);
|
|
EnableWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),FALSE);
|
|
ShowWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),SW_HIDE);
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
CheckDlgButton(hdlg,IDC_USEFLOPPIES,Floppyless ? BST_UNCHECKED : BST_CHECKED);
|
|
if(ForceFloppyless) {
|
|
EnableWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),FALSE);
|
|
}
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
//
|
|
// Get rid of floppy-related controls.
|
|
//
|
|
EnableWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),FALSE);
|
|
ShowWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),SW_HIDE);
|
|
|
|
//
|
|
// Populate the system partition combobox.
|
|
//
|
|
if (SystemPartitionDriveLetter)
|
|
{
|
|
PWCHAR p;
|
|
WCHAR x[3];
|
|
|
|
x[1] = L':';
|
|
x[2] = 0;
|
|
|
|
for(p=SystemPartitionDriveLetters; *p; p++) {
|
|
|
|
x[0] = *p;
|
|
|
|
SendDlgItemMessage(hdlg,IDC_SYSPARTDRIVE,CB_ADDSTRING,0,(LPARAM)x);
|
|
}
|
|
|
|
x[0] = SystemPartitionDriveLetter;
|
|
SendDlgItemMessage(hdlg,IDC_SYSPARTDRIVE,CB_SELECTSTRING,(WPARAM)(-1),(LPARAM)x);
|
|
}
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
|
|
//
|
|
// Set text in edit controls, and configure the control a little.
|
|
//
|
|
SetDlgItemText(hdlg,IDC_SOURCE,InfName);
|
|
SendDlgItemMessage(hdlg,IDC_SOURCE,EM_LIMITTEXT,MAX_PATH,0);
|
|
|
|
if(SourceCount == 1) {
|
|
EnableWindow(GetDlgItem(hdlg,IDC_SOURCE2),TRUE);
|
|
SetDlgItemText(hdlg,IDC_SOURCE2,NativeSourcePaths[0]);
|
|
} else {
|
|
LoadString(hInst,IDS_MULTIPLE,Text,sizeof(Text)/sizeof(TCHAR));
|
|
SetDlgItemText(hdlg,IDC_SOURCE2,Text);
|
|
EnableWindow(GetDlgItem(hdlg,IDC_SOURCE2),FALSE);
|
|
}
|
|
SendDlgItemMessage(hdlg,IDC_SOURCE2,EM_LIMITTEXT,MAX_PATH-1,0);
|
|
|
|
SetDlgItemText(hdlg,IDC_INSTALL_DIR,InstallDir);
|
|
//
|
|
// limit the path to the same value as textmode setup (50 TCHARS)
|
|
//
|
|
|
|
#define MAX_NT_DIR_LEN 50
|
|
|
|
SendDlgItemMessage(hdlg,IDC_INSTALL_DIR,EM_LIMITTEXT,MAX_NT_DIR_LEN,0);
|
|
|
|
CheckDlgButton(hdlg,IDC_CHOOSE_INSTALLPART,ChoosePartition ? BST_CHECKED : BST_UNCHECKED);
|
|
|
|
if (Upgrade) {
|
|
TCHAR Text[MAX_PATH];
|
|
|
|
//
|
|
// Set the installation directory to the current Windows directory,
|
|
// then disable the user's ability to edit it.
|
|
//
|
|
MyGetWindowsDirectory(Text,MAX_PATH);
|
|
SetDlgItemText(hdlg,IDC_INSTALL_DIR,Text+3);
|
|
SendDlgItemMessage(hdlg,IDC_INSTALL_DIR,EM_LIMITTEXT,MAX_PATH,0);
|
|
|
|
EnableWindow(GetDlgItem(hdlg,IDC_INSTALL_DIR),FALSE);
|
|
EnableWindow(GetDlgItem(hdlg,IDC_CHOOSE_INSTALLPART),FALSE);
|
|
}
|
|
|
|
//
|
|
// On server installs, don't all the user to modify the
|
|
// install partition selection state
|
|
//
|
|
if (Server) {
|
|
EnableWindow( GetDlgItem(hdlg,IDC_CHOOSE_INSTALLPART), FALSE );
|
|
}
|
|
|
|
//
|
|
// Set focus to Cancel button.
|
|
//
|
|
SetFocus(GetDlgItem(hdlg,IDCANCEL));
|
|
b = FALSE;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
b = FALSE;
|
|
|
|
switch(LOWORD(wParam)) {
|
|
|
|
case IDOK:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
#if defined(REMOTE_BOOT)
|
|
if (RemoteBoot) {
|
|
MakeLocalSource = FALSE;
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
if(RunFromCD) {
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_)
|
|
MakeLocalSource = TRUE;
|
|
UserSpecifiedMakeLocalSource = TRUE;
|
|
|
|
#endif // defined(_AMD64_)
|
|
|
|
#if defined(_X86_)
|
|
MakeLocalSource = (IsDlgButtonChecked(hdlg,IDC_MAKELOCALSOURCEFROMCD) == BST_CHECKED);
|
|
UserSpecifiedMakeLocalSource = (IsDlgButtonChecked(hdlg,IDC_MAKELOCALSOURCEFROMCD) == BST_CHECKED);
|
|
#endif // defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
MakeLocalSource = TRUE;
|
|
UserSpecifiedMakeLocalSource = TRUE;
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
}
|
|
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
#if defined(REMOTE_BOOT)
|
|
if (RemoteBoot) {
|
|
MakeBootMedia = FALSE;
|
|
Floppyless = TRUE;
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
Floppyless = (IsDlgButtonChecked(hdlg,IDC_USEFLOPPIES) == BST_UNCHECKED);
|
|
}
|
|
#endif // defined(_AMD64_) || defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
WCHAR x[3];
|
|
|
|
GetDlgItemText(hdlg,IDC_SYSPARTDRIVE,x,3);
|
|
SystemPartitionDriveLetter = x[0];
|
|
LocalBootDirectory[0] = x[0];
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
|
|
GetDlgItemText(hdlg,IDC_SOURCE,InfName,MAX_PATH);
|
|
|
|
if(SourceCount == 1) {
|
|
GetDlgItemText(hdlg,IDC_SOURCE2,NativeSourcePaths[0],MAX_PATH);
|
|
}
|
|
|
|
|
|
{
|
|
TCHAR tmp[MAX_PATH];
|
|
BOOL bSelectedChoosePartition;
|
|
|
|
bSelectedChoosePartition = (IsDlgButtonChecked(hdlg, IDC_CHOOSE_INSTALLPART) == BST_CHECKED);
|
|
|
|
GetDlgItemText(hdlg,IDC_INSTALL_DIR,tmp,MAX_PATH);
|
|
if (tmp[0] == 0) {
|
|
InstallDir[0] = 0;
|
|
} else if (tmp[1] == L':' && tmp[2] == L'\\')
|
|
{
|
|
// User included a drive letter.
|
|
// remove it and assume they selected to choose the installation
|
|
// partition in textmode.
|
|
lstrcpy( InstallDir, &tmp[2] );
|
|
bSelectedChoosePartition = TRUE;
|
|
} else {
|
|
if (tmp[0] == L'\\') {
|
|
lstrcpy( InstallDir, tmp );
|
|
} else {
|
|
InstallDir[0] = L'\\';
|
|
lstrcpy( &InstallDir[1], tmp );
|
|
}
|
|
}
|
|
//
|
|
// if user selected any of the accessibility options, warn about choosing the partition installation
|
|
//
|
|
if(bSelectedChoosePartition &&
|
|
(AccessibleMagnifier || AccessibleKeyboard || AccessibleVoice || AccessibleReader) &&
|
|
IDYES != MessageBoxFromMessage(hdlg, MSG_WARNING_ACCESSIBILITY, FALSE, AppTitleStringId, MB_YESNO | MB_ICONEXCLAMATION)) {
|
|
b = TRUE;
|
|
break;
|
|
}
|
|
|
|
ChoosePartition = bSelectedChoosePartition;
|
|
}
|
|
|
|
//
|
|
// warn the user if their install dir is > 8 characters, since it will be truncated
|
|
//
|
|
if (!IsValid8Dot3(InstallDir) && IsWindowEnabled(GetDlgItem(hdlg,IDC_INSTALL_DIR ))) {
|
|
InstallDir[0] = 0;
|
|
MessageBoxFromMessage(
|
|
hdlg,
|
|
MSG_WRN_TRUNC_WINDIR,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONEXCLAMATION
|
|
);
|
|
SetFocus(GetDlgItem(hdlg,IDC_INSTALL_DIR));
|
|
b = FALSE;
|
|
|
|
} else {
|
|
|
|
EndDialog(hdlg,TRUE);
|
|
b = TRUE;
|
|
}
|
|
|
|
|
|
#ifdef _X86_
|
|
{
|
|
if ((SendDlgItemMessage (hdlg, IDC_BOOT16_1, BM_GETSTATE, 0, 0) & 0x0003) == BST_CHECKED) {
|
|
g_Boot16 = BOOT16_AUTOMATIC;
|
|
}
|
|
else
|
|
if ((SendDlgItemMessage (hdlg, IDC_BOOT16_2, BM_GETSTATE, 0, 0) & 0x0003) == BST_CHECKED) {
|
|
g_Boot16 = BOOT16_YES;
|
|
}
|
|
else
|
|
if ((SendDlgItemMessage (hdlg, IDC_BOOT16_3, BM_GETSTATE, 0, 0) & 0x0003) == BST_CHECKED) {
|
|
g_Boot16 = BOOT16_NO;
|
|
}
|
|
else {
|
|
g_Boot16 = BOOT16_AUTOMATIC;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
//
|
|
// Now take care of the headless settings.
|
|
//
|
|
if( IsDlgButtonChecked( hdlg, IDC_ENABLE_HEADLESS) == BST_CHECKED ) {
|
|
|
|
//
|
|
// He wants to run setup, and the resulting installation
|
|
// through a headless port. Got figure out which headless
|
|
// port he wants to use.
|
|
//
|
|
GetDlgItemText( hdlg,
|
|
IDC_HEADLESS_PORT,
|
|
HeadlessSelection,
|
|
MAX_PATH );
|
|
|
|
if( (HeadlessSelection[0] == 0) ||
|
|
(lstrcmpi( HeadlessSelection, TEXT("usebiossettings"))) ||
|
|
(_tcsnicmp( HeadlessSelection, TEXT("com"), 3)) ) {
|
|
|
|
//
|
|
// He gave us something that's invalid.
|
|
//
|
|
MessageBoxFromMessage( hdlg,
|
|
MSG_INVALID_HEADLESS_SETTING,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONEXCLAMATION );
|
|
|
|
_tcscpy( HeadlessSelection, DEFAULT_HEADLESS_SETTING );
|
|
SetDlgItemText( hdlg,
|
|
IDC_HEADLESS_PORT,
|
|
HeadlessSelection );
|
|
|
|
SetFocus(GetDlgItem(hdlg,IDC_HEADLESS_PORT));
|
|
b = FALSE;
|
|
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
EndDialog(hdlg,FALSE);
|
|
b = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDC_ENABLE_HEADLESS:
|
|
|
|
if( HIWORD(wParam) == BN_CLICKED ) {
|
|
|
|
if( IsDlgButtonChecked(hdlg, IDC_ENABLE_HEADLESS) ) {
|
|
|
|
//
|
|
// Make sure the headless settings box is enabled.
|
|
//
|
|
EnableWindow( GetDlgItem(hdlg, IDC_HEADLESS_PORT), TRUE );
|
|
ShowWindow( GetDlgItem(hdlg, IDC_HEADLESS_PORT), SW_SHOW );
|
|
if( HeadlessSelection[0] == TEXT('\0') ) {
|
|
|
|
//
|
|
// This is the first time the user has asked
|
|
// us to enable Headless. Suggest the use of
|
|
// se the default COM port.
|
|
//
|
|
_tcscpy( HeadlessSelection, DEFAULT_HEADLESS_SETTING );
|
|
|
|
}
|
|
SetDlgItemText( hdlg,
|
|
IDC_HEADLESS_PORT,
|
|
HeadlessSelection );
|
|
|
|
SetFocus(GetDlgItem(hdlg,IDC_HEADLESS_PORT));
|
|
|
|
} else {
|
|
|
|
//
|
|
// Disable the headless settings box since the
|
|
// user has chosen not to use headless.
|
|
//
|
|
HeadlessSelection[0] = TEXT('\0');
|
|
EnableWindow( GetDlgItem(hdlg, IDC_HEADLESS_PORT), FALSE );
|
|
ShowWindow( GetDlgItem(hdlg, IDC_HEADLESS_PORT), SW_HIDE );
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IDC_HEADLESS_PORT:
|
|
|
|
if( HIWORD(wParam) == EN_CHANGE) {
|
|
|
|
EnableWindow( GetDlgItem(hdlg, IDOK),
|
|
SendDlgItemMessage(hdlg, IDC_HEADLESS_PORT,WM_GETTEXTLENGTH,0,0) ? TRUE : FALSE );
|
|
}
|
|
break;
|
|
|
|
case IDC_SOURCE:
|
|
|
|
if(HIWORD(wParam) == EN_CHANGE) {
|
|
|
|
EnableWindow(
|
|
GetDlgItem(hdlg,IDOK),
|
|
SendDlgItemMessage(hdlg,IDC_SOURCE,WM_GETTEXTLENGTH,0,0) ? TRUE : FALSE
|
|
);
|
|
}
|
|
break;
|
|
|
|
case IDC_SOURCE2:
|
|
|
|
if(HIWORD(wParam) == EN_CHANGE) {
|
|
|
|
EnableWindow(
|
|
GetDlgItem(hdlg,IDOK),
|
|
SendDlgItemMessage(hdlg,IDC_SOURCE2,WM_GETTEXTLENGTH,0,0) ? TRUE : FALSE
|
|
);
|
|
}
|
|
break;
|
|
|
|
case IDB_BROWSE:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
TCHAR InitialPath[MAX_PATH];
|
|
TCHAR NewPath[MAX_PATH];
|
|
|
|
GetDlgItemText(hdlg,IDC_SOURCE2,InitialPath,MAX_PATH);
|
|
if(BrowseForDosnetInf(hdlg,InitialPath,NewPath)) {
|
|
SetDlgItemText(hdlg,IDC_SOURCE2,NewPath);
|
|
}
|
|
b = TRUE;
|
|
}
|
|
break;
|
|
|
|
#if defined(_AMD64_) || defined(_X86_)
|
|
case IDC_USEFLOPPIES:
|
|
|
|
b = FALSE;
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
|
|
MEDIA_TYPE MediaType;
|
|
|
|
// switch(MediaType = GetMediaType(TEXT('A'), NULL)) {
|
|
switch(MediaType = GetMediaType(FirstFloppyDriveLetter, NULL)) {
|
|
|
|
case Unknown:
|
|
case F5_1Pt2_512:
|
|
case F3_720_512:
|
|
case F5_360_512:
|
|
case F5_320_512:
|
|
case F5_320_1024:
|
|
case F5_180_512:
|
|
case F5_160_512:
|
|
case RemovableMedia:
|
|
case FixedMedia:
|
|
//
|
|
// None of these are acceptable.
|
|
//
|
|
MessageBoxFromMessage(
|
|
hdlg,
|
|
MSG_EVIL_FLOPPY_DRIVE,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR
|
|
);
|
|
|
|
CheckDlgButton(hdlg,IDC_USEFLOPPIES,BST_UNCHECKED);
|
|
EnableWindow(GetDlgItem(hdlg,IDC_USEFLOPPIES),FALSE);
|
|
Floppyless = TRUE;
|
|
ForceFloppyless = TRUE;
|
|
b = TRUE;
|
|
break;
|
|
|
|
case F3_1Pt44_512:
|
|
case F3_2Pt88_512:
|
|
case F3_20Pt8_512:
|
|
case F3_120M_512:
|
|
default:
|
|
//
|
|
// Allow these -- nothing to do here.
|
|
// Note that this includes types we don't know about,
|
|
// since new types could appear after we ship and we assume
|
|
// they'll be big enough.
|
|
//
|
|
break;
|
|
}
|
|
// } -to match commented out switch above.
|
|
}
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_HELP:
|
|
|
|
MyWinHelp(((HELPINFO *)lParam)->hItemHandle,HELP_WM_HELP,(ULONG_PTR)OptionsDlgContextHelp);
|
|
b = TRUE;
|
|
break;
|
|
|
|
case WM_CONTEXTMENU:
|
|
|
|
MyWinHelp((HWND)wParam,HELP_CONTEXTMENU,(ULONG_PTR)OptionsDlgContextHelp);
|
|
b = TRUE;
|
|
break;
|
|
|
|
default:
|
|
b = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
VOID
|
|
DoOptions(
|
|
IN HWND Parent
|
|
)
|
|
{
|
|
INT_PTR i;
|
|
|
|
if (Upgrade && !ISNT()) {
|
|
i = DialogBox(hInst,MAKEINTRESOURCE(IDD_ADVANCED3),Parent,OptionsDlgProc);
|
|
}
|
|
else {
|
|
i = DialogBox(hInst,MAKEINTRESOURCE(IDD_ADVANCED),Parent,OptionsDlgProc);
|
|
}
|
|
|
|
if(i == -1) {
|
|
MessageBoxFromMessage(
|
|
Parent,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR
|
|
);
|
|
}
|
|
}
|
|
|
|
VOID
|
|
SaveLanguageDirs(
|
|
)
|
|
{
|
|
DWORD ItemNo;
|
|
HMODULE hKernel32 = NULL;
|
|
LGRPID LangGroupId;
|
|
PTSTR p;
|
|
|
|
p = NULL;
|
|
Kernel32IsValidLanguageGroup = NULL;
|
|
|
|
//
|
|
// Get IsValidLanguageGroup if we can
|
|
//
|
|
if (Upgrade && ISNT() && (BuildNumber >= NT50B3)) {
|
|
|
|
hKernel32 = LoadLibrary(TEXT("KERNEL32"));
|
|
if (hKernel32) {
|
|
(FARPROC)Kernel32IsValidLanguageGroup =
|
|
GetProcAddress( hKernel32, "IsValidLanguageGroup" );
|
|
}
|
|
}
|
|
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
|
|
//
|
|
// When upgrading from NT 5, select any languages which are already
|
|
// installed, to make sure they get upgraded.
|
|
//
|
|
LangGroupId = _tcstoul( LanguageGroups[ItemNo].Id, NULL, 10 );
|
|
if (Kernel32IsValidLanguageGroup && LangGroupId &&
|
|
Kernel32IsValidLanguageGroup( LangGroupId, LGRPID_INSTALLED )
|
|
) {
|
|
|
|
LanguageGroups[ItemNo].Selected = TRUE;
|
|
}
|
|
|
|
//
|
|
// Install any languages required by the primary locale.
|
|
//
|
|
if (!lstrcmp( LanguageGroups[ItemNo].Id, LocaleList[PrimaryLocale].LanguageGroup1 ) ||
|
|
!lstrcmp( LanguageGroups[ItemNo].Id, LocaleList[PrimaryLocale].LanguageGroup2 )
|
|
) {
|
|
|
|
LanguageGroups[ItemNo].Selected = TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Make sure the necessary optional directories get copied for all
|
|
// selected language groups.
|
|
//
|
|
if( LanguageGroups[ItemNo].Selected ) {
|
|
|
|
TCHAR TempString[MAX_PATH];
|
|
|
|
if( LanguageGroups[ItemNo].Directory &&
|
|
LanguageGroups[ItemNo].Directory[0]
|
|
) {
|
|
RememberOptionalDir(
|
|
LanguageGroups[ItemNo].Directory,
|
|
OPTDIR_TEMPONLY | OPTDIR_ADDSRCARCH
|
|
);
|
|
#if defined(_WIN64)
|
|
|
|
//Add the i386\lang folder if needed
|
|
|
|
StringCchCopy( TempString, ARRAYSIZE(TempString), TEXT("\\I386\\"));
|
|
StringCchCat( TempString, ARRAYSIZE(TempString), LanguageGroups[ItemNo].Directory );
|
|
|
|
|
|
RememberOptionalDir(
|
|
TempString,
|
|
OPTDIR_TEMPONLY | OPTDIR_PLATFORM_INDEP
|
|
);
|
|
|
|
|
|
#endif
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef _X86_
|
|
|
|
|
|
//
|
|
// If this is a win9xupg, we need to get any optional directories they need for installed languages.
|
|
//
|
|
if (Upgrade && !ISNT()) {
|
|
|
|
p = UpgradeSupport.OptionalDirsRoutine ();
|
|
|
|
while (p && *p) {
|
|
|
|
RememberOptionalDir (p, OPTDIR_TEMPONLY | OPTDIR_ADDSRCARCH);
|
|
p = _tcschr (p, 0) + 1;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
BOOL
|
|
SaveLanguageParams(
|
|
IN LPCTSTR FileName
|
|
)
|
|
{
|
|
BOOL b;
|
|
DWORD ItemNo;
|
|
LPCTSTR WinntLangSection = WINNT_REGIONALSETTINGS;
|
|
PTSTR LanguageString = NULL;
|
|
UINT LanguageLength = 0;
|
|
LPTSTR p;
|
|
|
|
|
|
if( !IntlInfProcessed ) {
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// If this is a win9x upgrade, let the upgrade .dll take care
|
|
// of writing these parameters.
|
|
//
|
|
if (Upgrade && !ISNT()) {
|
|
return TRUE;
|
|
}
|
|
|
|
b = WritePrivateProfileString(
|
|
WinntLangSection,
|
|
WINNT_D_LANGUAGE,
|
|
LocaleList[PrimaryLocale].Lcid,
|
|
FileName
|
|
);
|
|
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
|
|
if( LanguageGroups[ItemNo].Selected ) {
|
|
|
|
if(LanguageString) {
|
|
p = REALLOC(
|
|
LanguageString,
|
|
(lstrlen( LanguageGroups[ItemNo].Id) + 2 + LanguageLength ) * sizeof(TCHAR)
|
|
);
|
|
} else {
|
|
p = MALLOC((lstrlen(LanguageGroups[ItemNo].Id)+2)*sizeof(TCHAR));
|
|
}
|
|
|
|
if(!p) {
|
|
if( LanguageString ) {
|
|
FREE( LanguageString );
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
LanguageString = p;
|
|
|
|
if( LanguageLength ) {
|
|
lstrcat( LanguageString, LanguageGroups[ItemNo].Id );
|
|
} else {
|
|
lstrcpy( LanguageString, LanguageGroups[ItemNo].Id );
|
|
}
|
|
|
|
lstrcat( LanguageString, TEXT(",") );
|
|
LanguageLength = lstrlen( LanguageString );
|
|
}
|
|
}
|
|
|
|
if( LanguageString ) {
|
|
//
|
|
// Remove trailing "," if any
|
|
//
|
|
if( LanguageLength && (LanguageString[LanguageLength-1] == TEXT(','))) {
|
|
LanguageString[LanguageLength-1] = 0;
|
|
}
|
|
|
|
b = b && WritePrivateProfileString(
|
|
WinntLangSection,
|
|
WINNT_D_LANGUAGE_GROUP,
|
|
LanguageString,
|
|
FileName
|
|
);
|
|
|
|
FREE( LanguageString );
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
VOID
|
|
FreeLanguageData(
|
|
)
|
|
{
|
|
DWORD ItemNo;
|
|
|
|
|
|
//
|
|
// Free all the data allocated for the language options data
|
|
//
|
|
for( ItemNo=0; ItemNo<LocaleCount; ItemNo++ ) {
|
|
FREE( LocaleList[ItemNo].Lcid );
|
|
FREE( LocaleList[ItemNo].Description );
|
|
FREE( LocaleList[ItemNo].LanguageGroup1 );
|
|
FREE( LocaleList[ItemNo].LanguageGroup2 );
|
|
}
|
|
LocaleCount = 0;
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
FREE( LanguageGroups[ItemNo].Id );
|
|
FREE( LanguageGroups[ItemNo].Description );
|
|
FREE( LanguageGroups[ItemNo].Directory );
|
|
}
|
|
LanguageGroupsCount = 0;
|
|
if( LocaleList ) {
|
|
FREE( LocaleList );
|
|
}
|
|
if( LanguageGroups ) {
|
|
FREE( LanguageGroups );
|
|
}
|
|
IntlInfProcessed = FALSE;
|
|
}
|
|
|
|
|
|
int
|
|
__cdecl
|
|
LocaleCompare(
|
|
const void *arg1,
|
|
const void *arg2
|
|
)
|
|
{
|
|
return lstrcmp(
|
|
((PLOCALE_ENTRY)arg1)->Description,
|
|
((PLOCALE_ENTRY)arg2)->Description
|
|
);
|
|
}
|
|
|
|
|
|
int
|
|
__cdecl
|
|
LangGroupCompare(
|
|
const void *arg1,
|
|
const void *arg2
|
|
)
|
|
{
|
|
return lstrcmp(
|
|
((PLANGUAGE_GROUP_ENTRY)arg1)->Description,
|
|
((PLANGUAGE_GROUP_ENTRY)arg2)->Description
|
|
);
|
|
}
|
|
|
|
|
|
BOOL
|
|
ReadIntlInf(
|
|
IN HWND hdlg
|
|
)
|
|
{
|
|
HINF IntlInf;
|
|
TCHAR IntlInfName[MAX_PATH];
|
|
DWORD LineCount;
|
|
DWORD ItemNo, NeededSize = 0;
|
|
LPCTSTR SectionName;
|
|
INFCONTEXT InfContext;
|
|
LPCTSTR Language;
|
|
TCHAR CurrentLcid[9] = TEXT("\0");
|
|
TCHAR CurrentLcidEx[9] = TEXT("\0"); // for AUTO_LANGPACK
|
|
|
|
//
|
|
// For AUTO_LANGPACK - BEGIN
|
|
//
|
|
// The pieces that are enclosed with AUTO_LANGPACK are for easy
|
|
// installation of other LangPack rather than English.
|
|
//
|
|
// This is originally for globalization testing. You can erase it by
|
|
// deleting lines surrounded or marked by the keyword AUTO_LANGPACK.
|
|
//
|
|
// Contact: YuhongLi
|
|
//
|
|
|
|
//
|
|
// read "Locale" from an extra file INTLEX.INF to install
|
|
// the locale rather than English (United States) by default.
|
|
//
|
|
// Here is a sample of INTLEX.INF which specifies Japanese
|
|
// as the default. The file INTLEX.INF should be in Unicode.
|
|
//
|
|
// --- cut here ---
|
|
// [Version]
|
|
// Signature = $Chicago$
|
|
//
|
|
// [DefaultValues]
|
|
// Locale = "00000411"
|
|
// --- end of cut ---
|
|
//
|
|
// For German (Germany), Locale will be 00000407.
|
|
//
|
|
|
|
FindPathToInstallationFile( TEXT("intlex.inf"), IntlInfName, MAX_PATH);
|
|
IntlInf = SetupapiOpenInfFile( IntlInfName, NULL, INF_STYLE_WIN4, NULL );
|
|
if( IntlInf != INVALID_HANDLE_VALUE ) {
|
|
if( SetupapiFindFirstLine( IntlInf, TEXT("DefaultValues"), TEXT("Locale"), &InfContext ) ) {
|
|
SetupapiGetStringField( &InfContext, 1, CurrentLcidEx, (sizeof(CurrentLcidEx)/sizeof(TCHAR)), NULL );
|
|
}
|
|
SetupapiCloseInfFile( IntlInf );
|
|
}
|
|
//
|
|
// For AUTO_LANGPACK -- END
|
|
//
|
|
|
|
//
|
|
// Open the INF
|
|
//
|
|
|
|
FindPathToInstallationFile( TEXT("intl.inf"), IntlInfName, MAX_PATH);
|
|
IntlInf = SetupapiOpenInfFile( IntlInfName, NULL, INF_STYLE_WIN4, NULL );
|
|
if(IntlInf == INVALID_HANDLE_VALUE && hdlg) {
|
|
MessageBoxFromMessageAndSystemError(
|
|
hdlg,
|
|
MSG_INTLINF_NOT_FOUND,
|
|
GetLastError(),
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Figure out what the default locale should be.
|
|
//
|
|
if( Upgrade ) {
|
|
wsprintf( CurrentLcid, TEXT("%08x"), GetSystemDefaultLCID());
|
|
} else if ( CurrentLcidEx[0] ) { // for AUTO_LANGPACK
|
|
lstrcpy( CurrentLcid, CurrentLcidEx); // for AUTO_LANGPACK
|
|
} else if( SetupapiFindFirstLine( IntlInf, TEXT("DefaultValues"), TEXT("Locale"), &InfContext )) {
|
|
SetupapiGetStringField( &InfContext, 1, CurrentLcid, (sizeof(CurrentLcid)/sizeof(TCHAR)), NULL );
|
|
} else {
|
|
if (hdlg) {
|
|
MessageBoxFromMessage(
|
|
hdlg,
|
|
MSG_INTLINF_NOT_FOUND,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR | MB_TASKMODAL
|
|
);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Read the [Locales] section, sort it, and find the default value in the list.
|
|
//
|
|
SectionName = TEXT("Locales");
|
|
LocaleCount = SetupapiGetLineCount( IntlInf, SectionName );
|
|
LocaleList = MALLOC( LocaleCount*sizeof( LOCALE_ENTRY ) );
|
|
if(!LocaleList){
|
|
SetupapiCloseInfFile( IntlInf );
|
|
return FALSE;
|
|
}
|
|
memset(LocaleList, 0, LocaleCount*sizeof( LOCALE_ENTRY ) );
|
|
|
|
for( ItemNo=0; ItemNo<LocaleCount; ItemNo++ ) {
|
|
if( SetupapiGetLineByIndex( IntlInf, SectionName, ItemNo, &InfContext )) {
|
|
|
|
|
|
if( SetupapiGetStringField( &InfContext, 0, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LocaleList[ItemNo].Lcid = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 0, LocaleList[ItemNo].Lcid, NeededSize, NULL );
|
|
}
|
|
}
|
|
|
|
if( SetupapiGetStringField( &InfContext, 1, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LocaleList[ItemNo].Description = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 1, LocaleList[ItemNo].Description, NeededSize, NULL );
|
|
}
|
|
|
|
}
|
|
|
|
if( SetupapiGetStringField( &InfContext, 3, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LocaleList[ItemNo].LanguageGroup1 = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 3, LocaleList[ItemNo].LanguageGroup1, NeededSize, NULL );
|
|
}
|
|
}
|
|
|
|
if( SetupapiGetStringField( &InfContext, 4, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LocaleList[ItemNo].LanguageGroup2 = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 4, LocaleList[ItemNo].LanguageGroup2, NeededSize, NULL );
|
|
}
|
|
}
|
|
|
|
}
|
|
else {
|
|
SetupapiCloseInfFile( IntlInf );
|
|
free( LocaleList );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
qsort(
|
|
LocaleList,
|
|
LocaleCount,
|
|
sizeof(LOCALE_ENTRY),
|
|
LocaleCompare
|
|
);
|
|
|
|
for( ItemNo=0; ItemNo<LocaleCount; ItemNo++ ) {
|
|
if( LocaleList[ItemNo].Lcid && !lstrcmpi( CurrentLcid, LocaleList[ItemNo].Lcid)) {
|
|
PrimaryLocale = ItemNo;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Read the [LanguageGroups] section and sort it
|
|
//
|
|
SectionName = TEXT("LanguageGroups");
|
|
LanguageGroupsCount = SetupapiGetLineCount( IntlInf, SectionName );
|
|
LanguageGroups = MALLOC( LanguageGroupsCount*sizeof( LANGUAGE_GROUP_ENTRY ) );
|
|
if(!LanguageGroups){
|
|
SetupapiCloseInfFile( IntlInf );
|
|
return FALSE;
|
|
}
|
|
memset(LanguageGroups, 0, LanguageGroupsCount*sizeof( LANGUAGE_GROUP_ENTRY ) );
|
|
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
if( SetupapiGetLineByIndex( IntlInf, SectionName, ItemNo, &InfContext )) {
|
|
|
|
if( SetupapiGetStringField( &InfContext, 0, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LanguageGroups[ItemNo].Id = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 0, LanguageGroups[ItemNo].Id, NeededSize, NULL );
|
|
}
|
|
|
|
}
|
|
|
|
if( SetupapiGetStringField( &InfContext, 1, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LanguageGroups[ItemNo].Description = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 1, LanguageGroups[ItemNo].Description, NeededSize, NULL );
|
|
}
|
|
|
|
}
|
|
|
|
if( SetupapiGetStringField( &InfContext, 2, NULL, 0, &NeededSize )){
|
|
if( NeededSize && (LanguageGroups[ItemNo].Directory = MALLOC( NeededSize*sizeof(TCHAR) ))){
|
|
SetupapiGetStringField( &InfContext, 2, LanguageGroups[ItemNo].Directory, NeededSize, NULL );
|
|
}
|
|
|
|
}
|
|
|
|
LanguageGroups[ItemNo].Selected = FALSE;
|
|
//
|
|
// Handle Hong Kong upgrades as a special case: always install Language
|
|
// Groups 9 and 10.
|
|
//
|
|
|
|
if( (TargetNativeLangID == 0xc04) && Upgrade &&
|
|
(!lstrcmpi( LanguageGroups[ItemNo].Id, TEXT("9")) ||
|
|
!lstrcmpi( LanguageGroups[ItemNo].Id, TEXT("10"))) ) {
|
|
|
|
LanguageGroups[ItemNo].Selected = TRUE;
|
|
}
|
|
}
|
|
else {
|
|
SetupapiCloseInfFile( IntlInf );
|
|
free( LocaleList );
|
|
free( LanguageGroups );
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
qsort(
|
|
LanguageGroups,
|
|
LanguageGroupsCount,
|
|
sizeof(LANGUAGE_GROUP_ENTRY),
|
|
LangGroupCompare
|
|
);
|
|
|
|
// If the primary language is a Far East one, don't show the check box.
|
|
if (IsFarEastLanguage(PrimaryLocale))
|
|
{
|
|
ShowWindow(GetDlgItem(hdlg, IDC_FAREAST_LANG), SW_HIDE);
|
|
}
|
|
//
|
|
// Clean up
|
|
//
|
|
SetupapiCloseInfFile( IntlInf );
|
|
IntlInfProcessed = TRUE;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL InitLangControl(HWND hdlg, BOOL bFarEast)
|
|
{
|
|
DWORD ItemNo;
|
|
//
|
|
// Init primary language combo box
|
|
//
|
|
for( ItemNo=0; ItemNo<LocaleCount; ItemNo++ ) {
|
|
SendDlgItemMessage( hdlg, IDC_COMBO1, CB_ADDSTRING, 0, (LPARAM)LocaleList[ItemNo].Description );
|
|
}
|
|
SendDlgItemMessage( hdlg, IDC_COMBO1, CB_SETCURSEL, PrimaryLocale, 0 );
|
|
|
|
// if the running language or the to be installed language is a FarEast
|
|
// language, this check box is not visible, because we install the language folder anyway.
|
|
if (IsWindowVisible(GetDlgItem(hdlg,IDC_FAREAST_LANG)))
|
|
{
|
|
if (bFarEast || IsFarEastLanguage(PrimaryLocale))
|
|
{
|
|
CheckDlgButton(hdlg,IDC_FAREAST_LANG,BST_CHECKED);
|
|
}
|
|
else
|
|
{
|
|
CheckDlgButton(hdlg,IDC_FAREAST_LANG,BST_UNCHECKED);
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
LanguageDlgProc(
|
|
IN HWND hdlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL b;
|
|
DWORD ItemNo;
|
|
|
|
|
|
switch(msg) {
|
|
|
|
case WM_INITDIALOG:
|
|
|
|
if( !IntlInfProcessed ) {
|
|
EndDialog( hdlg, FALSE );
|
|
}
|
|
|
|
//
|
|
// Init locales
|
|
//
|
|
for( ItemNo=0; ItemNo<LocaleCount; ItemNo++ ) {
|
|
SendDlgItemMessage( hdlg, IDC_COMBO1, CB_ADDSTRING, 0, (LPARAM)LocaleList[ItemNo].Description );
|
|
}
|
|
SendDlgItemMessage( hdlg, IDC_COMBO1, CB_SETCURSEL, PrimaryLocale, 0 );
|
|
|
|
//
|
|
// Init language groups
|
|
//
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
SendDlgItemMessage( hdlg, IDC_LIST, LB_ADDSTRING, 0, (LPARAM)LanguageGroups[ItemNo].Description );
|
|
SendDlgItemMessage( hdlg, IDC_LIST, LB_SETSEL, LanguageGroups[ItemNo].Selected, ItemNo );
|
|
}
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
LanguageGroups[ItemNo].Selected = (int)SendDlgItemMessage( hdlg, IDC_LIST, LB_GETSEL, ItemNo, 0 );
|
|
}
|
|
|
|
//
|
|
// Set focus to Cancel button.
|
|
//
|
|
SetFocus(GetDlgItem(hdlg,IDCANCEL));
|
|
b = FALSE;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
b = FALSE;
|
|
|
|
switch(LOWORD(wParam)) {
|
|
|
|
case IDOK:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
PrimaryLocale = (DWORD)SendDlgItemMessage( hdlg, IDC_COMBO1, CB_GETCURSEL, 0, 0 );
|
|
for( ItemNo=0; ItemNo<LanguageGroupsCount; ItemNo++ ) {
|
|
LanguageGroups[ItemNo].Selected = (int)SendDlgItemMessage( hdlg, IDC_LIST, LB_GETSEL, ItemNo, 0 );
|
|
}
|
|
|
|
EndDialog(hdlg,TRUE);
|
|
b = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
EndDialog(hdlg,FALSE);
|
|
b = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
b = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
VOID
|
|
DoLanguage(
|
|
IN HWND Parent
|
|
)
|
|
{
|
|
INT_PTR i;
|
|
|
|
i = DialogBox(hInst,MAKEINTRESOURCE(IDD_LANGUAGE),Parent,LanguageDlgProc);
|
|
|
|
if(i == -1) {
|
|
MessageBoxFromMessage(
|
|
Parent,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
INT_PTR
|
|
AccessibilityDlgProc(
|
|
IN HWND hdlg,
|
|
IN UINT msg,
|
|
IN WPARAM wParam,
|
|
IN LPARAM lParam
|
|
)
|
|
{
|
|
BOOL b;
|
|
TCHAR VisibleNarrator[2];
|
|
|
|
|
|
switch(msg) {
|
|
|
|
case WM_INITDIALOG:
|
|
//
|
|
// Disable the narrator in locales that don't support it.
|
|
//
|
|
|
|
if (!LoadString(hInst,IDS_VISIBLE_NARRATOR_CONTROL,VisibleNarrator,sizeof(VisibleNarrator)/sizeof(TCHAR)) ||
|
|
lstrcmp(VisibleNarrator,TEXT("1"))) {
|
|
|
|
EnableWindow(GetDlgItem( hdlg, IDC_READER ), FALSE);
|
|
ShowWindow(GetDlgItem( hdlg, IDC_READER ), SW_HIDE);
|
|
EnableWindow(GetDlgItem( hdlg, IDC_READER_TEXT ), FALSE);
|
|
ShowWindow(GetDlgItem( hdlg, IDC_READER_TEXT ), SW_HIDE);
|
|
}
|
|
|
|
//
|
|
// check the target LCID and disable it for non-English locales
|
|
//
|
|
if (SourceNativeLangID) {
|
|
if (!(SourceNativeLangID == 0x0409 || SourceNativeLangID == 0x0809)) {
|
|
EnableWindow(GetDlgItem( hdlg, IDC_READER ), FALSE);
|
|
ShowWindow(GetDlgItem( hdlg, IDC_READER ), SW_HIDE);
|
|
EnableWindow(GetDlgItem( hdlg, IDC_READER_TEXT ), FALSE);
|
|
ShowWindow(GetDlgItem( hdlg, IDC_READER_TEXT ), SW_HIDE);
|
|
}
|
|
}
|
|
//
|
|
// Set the initial state of the check boxes.
|
|
//
|
|
CheckDlgButton(hdlg,IDC_MAGNIFIER,AccessibleMagnifier ?
|
|
BST_CHECKED : BST_UNCHECKED);
|
|
CheckDlgButton(hdlg,IDC_KEYBOARD,AccessibleKeyboard ?
|
|
BST_CHECKED : BST_UNCHECKED);
|
|
CheckDlgButton(hdlg,IDC_VOICE,AccessibleVoice ?
|
|
BST_CHECKED : BST_UNCHECKED);
|
|
CheckDlgButton(hdlg,IDC_READER,AccessibleReader ?
|
|
BST_CHECKED : BST_UNCHECKED);
|
|
|
|
//
|
|
// Set focus to Cancel button.
|
|
//
|
|
SetFocus(GetDlgItem(hdlg,IDCANCEL));
|
|
b = FALSE;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
|
|
b = FALSE;
|
|
|
|
switch(LOWORD(wParam)) {
|
|
|
|
case IDOK:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
BOOL bSelectedAccessibleMagnifier;
|
|
BOOL bSelectedAccessibleKeyboard;
|
|
BOOL bSelectedAccessibleVoice;
|
|
BOOL bSelectedAccessibleReader;
|
|
|
|
b = TRUE;
|
|
bSelectedAccessibleMagnifier = (IsDlgButtonChecked(hdlg,IDC_MAGNIFIER) == BST_CHECKED);
|
|
bSelectedAccessibleKeyboard = (IsDlgButtonChecked(hdlg,IDC_KEYBOARD) == BST_CHECKED);
|
|
bSelectedAccessibleVoice = (IsDlgButtonChecked(hdlg,IDC_VOICE) == BST_CHECKED);
|
|
bSelectedAccessibleReader = (IsDlgButtonChecked(hdlg,IDC_READER) == BST_CHECKED);
|
|
//
|
|
// if user selected any of the accessibility options, warn about choosing the partition installation
|
|
//
|
|
if(ChoosePartition &&
|
|
(bSelectedAccessibleMagnifier || bSelectedAccessibleKeyboard || bSelectedAccessibleVoice || bSelectedAccessibleReader) &&
|
|
IDYES != MessageBoxFromMessage(hdlg, MSG_WARNING_ACCESSIBILITY, FALSE, AppTitleStringId, MB_YESNO | MB_ICONEXCLAMATION)) {
|
|
break;
|
|
}
|
|
|
|
AccessibleMagnifier = bSelectedAccessibleMagnifier;
|
|
AccessibleKeyboard = bSelectedAccessibleKeyboard;
|
|
AccessibleVoice = bSelectedAccessibleVoice;
|
|
AccessibleReader = bSelectedAccessibleReader;
|
|
EndDialog(hdlg,TRUE);
|
|
}
|
|
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
|
|
if(HIWORD(wParam) == BN_CLICKED) {
|
|
EndDialog(hdlg,FALSE);
|
|
b = TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
b = FALSE;
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
VOID
|
|
DoAccessibility(
|
|
IN HWND Parent
|
|
)
|
|
{
|
|
INT_PTR i;
|
|
|
|
i = DialogBox(hInst,MAKEINTRESOURCE(IDD_ACCESSIBILITY),Parent,AccessibilityDlgProc);
|
|
|
|
if(i == -1) {
|
|
MessageBoxFromMessage(
|
|
Parent,
|
|
MSG_OUT_OF_MEMORY,
|
|
FALSE,
|
|
AppTitleStringId,
|
|
MB_OK | MB_ICONERROR
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
InitVariousOptions(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize options for program operation, including
|
|
|
|
- determining whether we were run from a CD
|
|
|
|
- whether we should create a local source
|
|
|
|
If we are being run from CD then there's no need to create
|
|
a local source since we assume we can get to the CD from NT.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
Global variables RunFromCD, MakeLocalSource filled in.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR Path[MAX_PATH];
|
|
|
|
|
|
//
|
|
// Assume not run from CD. In that case we need to create
|
|
// a local source. This is a global, and should be FALSE
|
|
// unless the user has sent us a /#R to force the RunFromCD.
|
|
//
|
|
// RunFromCD = FALSE;
|
|
|
|
#if defined(REMOTE_BOOT)
|
|
//
|
|
// If this is a remote boot client, MakeLocalSource is always false.
|
|
//
|
|
if (RemoteBoot) {
|
|
|
|
MakeLocalSource = FALSE;
|
|
MakeBootMedia = FALSE;
|
|
Floppyless = TRUE;
|
|
|
|
} else
|
|
#endif // defined(REMOTE_BOOT)
|
|
{
|
|
//
|
|
// Determine if we were run from CD.
|
|
//
|
|
if(MyGetModuleFileName(NULL,Path,MAX_PATH)) {
|
|
//
|
|
// For UNC paths this will do something bogus, but certainly
|
|
// won't return DRIVE_CDROM, so we don't care.
|
|
//
|
|
Path[3] = 0;
|
|
if(GetDriveType(Path) == DRIVE_CDROM) {
|
|
RunFromCD = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now determine if we should MakeLocalSource.
|
|
//
|
|
if (!IsArc()) {
|
|
#if defined(_AMD64_)
|
|
//
|
|
// on AMD64, always make local source.
|
|
//
|
|
MakeLocalSource = TRUE;
|
|
#endif // defined(_AMD64_)
|
|
|
|
#if defined(_X86_)
|
|
//
|
|
// MakeLocalSource is a global, so he
|
|
// will be FALSE by default, unless the
|
|
// user has sent winnt32.exe the /MakeLocalSource flag,
|
|
// in which case, the flag will already be set to true.
|
|
//
|
|
MakeLocalSource = (MakeLocalSource || (!RunFromCD));
|
|
#endif // defined(_X86_)
|
|
} else {
|
|
#ifdef UNICODE // Always true for ARC, never true for Win9x upgrade
|
|
//
|
|
// on ARC, always make local source.
|
|
//
|
|
MakeLocalSource = TRUE;
|
|
#endif // UNICODE
|
|
} // if (!IsArc())
|
|
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
BrowseForDosnetInf(
|
|
IN HWND hdlg,
|
|
IN LPCTSTR InitialPath,
|
|
OUT TCHAR NewPath[MAX_PATH]
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine invokes the standard win32 find file dialog for
|
|
dosnet.inf or whatever inf is currently selected to substitute for
|
|
dosnet.inf.
|
|
|
|
Arguments:
|
|
|
|
hdlg - supplies window handle of dialog to use as parent for
|
|
find file common dialog.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether the user browsed and successfully
|
|
located dosnet.inf (or substitute).
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL b;
|
|
OPENFILENAME Info;
|
|
TCHAR Filter[2*MAX_PATH];
|
|
TCHAR File[MAX_PATH];
|
|
TCHAR Path[MAX_PATH];
|
|
DWORD d;
|
|
TCHAR Title[150];
|
|
PVOID p;
|
|
TCHAR* lastWack;
|
|
|
|
ZeroMemory(Filter,sizeof(Filter));
|
|
|
|
p = InfName;
|
|
|
|
d = FormatMessage(
|
|
FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
hInst,
|
|
MSG_DOSNET_INF_DESC,
|
|
0,
|
|
Filter,
|
|
MAX_PATH,
|
|
(va_list *)&p
|
|
);
|
|
|
|
//
|
|
// This is ok, since Filter is 2*MAX_PATH tchars long.
|
|
//
|
|
lstrcpy(Filter+d+1,InfName);
|
|
|
|
//
|
|
// This is ok, since both buffers are of size MAX_PATH
|
|
//
|
|
lstrcpy(File,InfName);
|
|
|
|
StringCchCopy(Path, ARRAYSIZE(Path), InitialPath);
|
|
|
|
LoadString(hInst,IDS_FIND_NT_FILES,Title,sizeof(Title)/sizeof(TCHAR));
|
|
|
|
Info.lStructSize = sizeof(OPENFILENAME);
|
|
Info.hwndOwner = hdlg;
|
|
Info.hInstance = NULL; // unused because not using a template
|
|
Info.lpstrFilter = Filter;
|
|
Info.lpstrCustomFilter = NULL;
|
|
Info.nMaxCustFilter = 0; // unused because lpstrCustomFilter is NULL
|
|
Info.nFilterIndex = 1;
|
|
Info.lpstrFile = File;
|
|
Info.nMaxFile = MAX_PATH;
|
|
Info.lpstrFileTitle = NULL;
|
|
Info.nMaxFileTitle = 0; // unused because lpstrFileTitle is NULL
|
|
Info.lpstrInitialDir = Path;
|
|
Info.lpstrTitle = Title;
|
|
Info.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NODEREFERENCELINKS | OFN_PATHMUSTEXIST;
|
|
Info.nFileOffset = 0;
|
|
Info.nFileExtension = 0;
|
|
Info.lpstrDefExt = NULL;
|
|
Info.lCustData = 0; // unused because no hook is used
|
|
Info.lpfnHook = NULL; // unused because no hook is used
|
|
Info.lpTemplateName = NULL; // unused because no template is used
|
|
|
|
b = GetOpenFileName(&Info);
|
|
|
|
if(b) {
|
|
lstrcpy(NewPath,File);
|
|
|
|
lastWack = _tcsrchr(NewPath,TEXT('\\'));
|
|
|
|
if (lastWack) {
|
|
*lastWack = 0;
|
|
}
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
BOOL
|
|
IsValid8Dot3(
|
|
IN LPCTSTR Path
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Check whether a path is valid 8.3. The path may or may not start with
|
|
a backslash. Only backslashes are recognized as path separators.
|
|
Individual characters are not checked for validity (ie, * would not
|
|
invalidate the path). The path may or may not terminate with a backslash.
|
|
A component may have a dot without characters in the extension
|
|
(ie, a\b.\c is valid).
|
|
|
|
\ and "" are explicitly disallowed even though they fit the rules.
|
|
|
|
Stolen from textmode\kernel sptarget.c
|
|
|
|
Arguments:
|
|
|
|
Path - pointer to path to check.
|
|
|
|
Return Value:
|
|
|
|
TRUE if valid 8.3, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
UINT Count;
|
|
BOOLEAN DotSeen,FirstChar;
|
|
static LPCTSTR UsableChars = TEXT("_-ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
|
|
|
|
if((*Path == 0) || ((Path[0] == TEXT('\\')) && (Path[1] == 0))) {
|
|
return(FALSE);
|
|
}
|
|
|
|
DotSeen = FALSE;
|
|
FirstChar = TRUE;
|
|
Count = 0;
|
|
|
|
while(*Path) {
|
|
|
|
//
|
|
// Path points to start of current component (1 past the slash)
|
|
//
|
|
|
|
switch(*Path) {
|
|
|
|
case TEXT('.'):
|
|
if(FirstChar) {
|
|
return(FALSE);
|
|
}
|
|
if(DotSeen) {
|
|
return(FALSE);
|
|
}
|
|
|
|
Count = 0;
|
|
DotSeen = TRUE;
|
|
break;
|
|
|
|
case TEXT('\\'):
|
|
|
|
DotSeen = FALSE;
|
|
FirstChar = TRUE;
|
|
Count = 0;
|
|
|
|
if(*(++Path) == TEXT('\\')) {
|
|
|
|
// 2 slashes in a row
|
|
return(FALSE);
|
|
}
|
|
|
|
continue;
|
|
|
|
default:
|
|
|
|
Count++;
|
|
FirstChar = FALSE;
|
|
|
|
if((Count == 4) && DotSeen) {
|
|
return(FALSE);
|
|
}
|
|
|
|
if(Count == 9) {
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Make sure it's a printable, US character.
|
|
//
|
|
if( !_tcschr( UsableChars, *Path ) ) {
|
|
return( FALSE );
|
|
}
|
|
|
|
}
|
|
|
|
Path++;
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
BOOL
|
|
SaveLanguageOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
UINT u;
|
|
UINT rem;
|
|
PTSTR list;
|
|
TCHAR buf[32];
|
|
LPTSTR p;
|
|
DWORD len;
|
|
DWORD size;
|
|
|
|
if (IntlInfProcessed) {
|
|
|
|
if (!WritePrivateProfileString (
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("LangInf"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
|
|
wsprintf (buf, TEXT("%u"), PrimaryLocale);
|
|
if (!WritePrivateProfileString(
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("PrimaryLocaleIndex"),
|
|
buf,
|
|
AnswerFile
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
|
|
size = rem = 32;
|
|
list = MALLOC (size);
|
|
if (!list) {
|
|
return FALSE;
|
|
}
|
|
*list = 0;
|
|
for (u = 0; u < LanguageGroupsCount; u++) {
|
|
if (LanguageGroups[u].Selected) {
|
|
len = wsprintf (buf, TEXT("%u"), u);
|
|
while (len + 1 > rem) {
|
|
PTSTR listReallocated = NULL;
|
|
|
|
size *= 2;
|
|
|
|
listReallocated = REALLOC (list, size);
|
|
if (!listReallocated) {
|
|
FREE(list);
|
|
return FALSE;
|
|
}
|
|
|
|
list = listReallocated;
|
|
rem = size;
|
|
}
|
|
if (*list) {
|
|
lstrcat (list, TEXT(","));
|
|
rem--;
|
|
}
|
|
lstrcat (list, buf);
|
|
rem -= len;
|
|
}
|
|
}
|
|
|
|
if (*list) {
|
|
if (!WritePrivateProfileString(
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("Selected"),
|
|
list,
|
|
AnswerFile
|
|
)) {
|
|
FREE( list );
|
|
return FALSE;
|
|
}
|
|
}
|
|
FREE( list );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
LoadLanguageOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
PTSTR optDirs;
|
|
TCHAR buf[MAX_PATH];
|
|
PTSTR list = NULL;
|
|
PTSTR p, q;
|
|
DWORD size;
|
|
DWORD u;
|
|
|
|
if (!IntlInfProcessed) {
|
|
return FALSE;
|
|
}
|
|
|
|
GetPrivateProfileString (
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("LangInf"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
IntlInfProcessed = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
if (!IntlInfProcessed) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetPrivateProfileString(
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("PrimaryLocaleIndex"),
|
|
TEXT(""),
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
)) {
|
|
return FALSE;
|
|
}
|
|
PrimaryLocale = (DWORD) _ttol (buf);
|
|
|
|
size = 16;
|
|
do {
|
|
if (!list) {
|
|
list = MALLOC (size);
|
|
} else {
|
|
PTSTR listReallocated;
|
|
|
|
size *= 2;
|
|
listReallocated = REALLOC (list, size);
|
|
if(!listReallocated){
|
|
FREE(list);
|
|
}
|
|
list = listReallocated;
|
|
}
|
|
if (!list) {
|
|
return FALSE;
|
|
}
|
|
if (GetPrivateProfileString (
|
|
WINNT_REGIONALSETTINGS,
|
|
TEXT("Selected"),
|
|
TEXT(""),
|
|
list,
|
|
size / sizeof ( TCHAR ),
|
|
AnswerFile
|
|
) < size - 1) {
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
|
|
p = list;
|
|
do {
|
|
q = _tcschr (p, TEXT(','));
|
|
if (q) {
|
|
*q = 0;
|
|
}
|
|
u = _ttol (p);
|
|
if (u >= LanguageGroupsCount) {
|
|
FREE (list);
|
|
return FALSE;
|
|
}
|
|
LanguageGroups[u].Selected = TRUE;
|
|
if (q) {
|
|
p = q + 1;
|
|
}
|
|
} while (q);
|
|
|
|
FREE (list);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
SaveAdvancedOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
TCHAR buf[32];
|
|
|
|
return
|
|
(!MakeLocalSource ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("MakeLS"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!UserSpecifiedMakeLocalSource ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("UserMakeLS"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!Floppyless ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("Floppyless"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!SystemPartitionDriveLetter ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("SysPartDriveLetter"),
|
|
_ltot (SystemPartitionDriveLetter, buf, 10),
|
|
AnswerFile
|
|
)) &&
|
|
(!ChoosePartition ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("ChoosePartition"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!InstallDir[0] ||
|
|
WritePrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("InstallDir"),
|
|
InstallDir,
|
|
AnswerFile
|
|
));
|
|
}
|
|
|
|
BOOL
|
|
LoadAdvancedOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
TCHAR buf[MAX_PATH];
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("MakeLS"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
MakeLocalSource = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("UserMakeLS"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
UserSpecifiedMakeLocalSource = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("Floppyless"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
Floppyless = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
if (GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("SysPartDriveLetter"),
|
|
TEXT(""),
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
)) {
|
|
SystemPartitionDriveLetter = (TCHAR) _ttol (buf);
|
|
}
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("ChoosePartition"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
ChoosePartition = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AdvancedOptions"),
|
|
TEXT("InstallDir"),
|
|
TEXT(""),
|
|
InstallDir,
|
|
sizeof (InstallDir) / sizeof (TCHAR),
|
|
AnswerFile
|
|
);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
SaveAccessibilityOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
return
|
|
(!AccessibleMagnifier ||
|
|
WritePrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleMagnifier"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!AccessibleKeyboard ||
|
|
WritePrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleKeyboard"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!AccessibleVoice ||
|
|
WritePrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleVoice"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
)) &&
|
|
(!AccessibleReader ||
|
|
WritePrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleReader"),
|
|
WINNT_A_YES,
|
|
AnswerFile
|
|
));
|
|
}
|
|
|
|
BOOL
|
|
LoadAccessibilityOptions (
|
|
IN PCTSTR AnswerFile
|
|
)
|
|
{
|
|
TCHAR buf[MAX_PATH];
|
|
|
|
if (!AccessibleMagnifier)
|
|
{
|
|
GetPrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleMagnifier"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
AccessibleMagnifier = !lstrcmpi (buf, WINNT_A_YES);
|
|
}
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleKeyboard"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
AccessibleKeyboard = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleVoice"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
AccessibleVoice = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
GetPrivateProfileString (
|
|
TEXT("AccessibilityOptions"),
|
|
TEXT("AccessibleReader"),
|
|
WINNT_A_NO,
|
|
buf,
|
|
MAX_PATH,
|
|
AnswerFile
|
|
);
|
|
AccessibleReader = !lstrcmpi (buf, WINNT_A_YES);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL IsFarEastLanguage(DWORD LangIdx)
|
|
{
|
|
BOOL FarEastLang = FALSE;
|
|
DWORD LangGroup;
|
|
|
|
LangGroup = (DWORD) _ttol (LocaleList[LangIdx].LanguageGroup1);
|
|
if ((LangGroup >= 7) && (LangGroup <= 10))
|
|
{
|
|
FarEastLang = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (LocaleList[LangIdx].LanguageGroup2)
|
|
{
|
|
LangGroup = (DWORD) _ttol (LocaleList[LangIdx].LanguageGroup2);
|
|
if ((LangGroup >= 7) && (LangGroup <= 10))
|
|
{
|
|
FarEastLang = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FarEastLang;
|
|
}
|
|
|
|
BOOL SelectFarEastLangGroup (BOOL bSelect)
|
|
{
|
|
DWORD LangIdx;
|
|
|
|
for (LangIdx = 0; LangIdx < LanguageGroupsCount; LangIdx++)
|
|
{
|
|
// NOTE: Only FarEast Language should have a directory
|
|
// If this ever changes, this code need to change too.
|
|
if (LanguageGroups[LangIdx].Directory &&
|
|
LanguageGroups[LangIdx].Directory[0] )
|
|
{
|
|
LanguageGroups[LangIdx].Selected = bSelect;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|