1259 lines
32 KiB
C
1259 lines
32 KiB
C
//
|
|
// ConfOpt.C
|
|
//
|
|
// Copyright (C) Microsoft, 1994,1995 All Rights Reserved.
|
|
//
|
|
// History:
|
|
// ral 5/23/94 - First pass
|
|
// 3/20/95 [stevecat] - NT port & real clean up, unicode, etc.
|
|
//
|
|
//
|
|
#include "priv.h"
|
|
#include "appwiz.h"
|
|
|
|
#define MAX_CFG_FILE_SIZE 20000
|
|
#define MAX_DESC_SIZE 100
|
|
|
|
//
|
|
// Return codes for OptSelected
|
|
//
|
|
#define OPTSEL_YES 0
|
|
#define OPTSEL_NO 1
|
|
#define OPTSEL_NOTSUPP 2
|
|
|
|
//
|
|
// Define checkbox states for listview
|
|
//
|
|
#define LVIS_GCNOCHECK 0x1000
|
|
#define LVIS_GCCHECK 0x2000
|
|
|
|
//
|
|
// Character definitions
|
|
//
|
|
#define CR 13
|
|
#define LF 10
|
|
|
|
|
|
TCHAR const c_szCRLF[] = {CR, LF, 0};
|
|
TCHAR const c_szRegValAutoexec[] = REGSTR_VAL_AUTOEXEC;
|
|
TCHAR const c_szRegValConfigSys[] = REGSTR_VAL_CONFIGSYS;
|
|
TCHAR const c_szRegDosOptFlags[] = REGSTR_VAL_DOSOPTFLAGS;
|
|
TCHAR const c_szRegStandardOpt[] = REGSTR_VAL_STDDOSOPTION;
|
|
TCHAR const c_szRegDosOptTip[] = REGSTR_VAL_DOSOPTTIP;
|
|
TCHAR const c_szRegDosOptsPath[] = REGSTR_PATH_MSDOSOPTS;
|
|
TCHAR const c_szRegGlobalFlags[] = REGSTR_VAL_DOSOPTGLOBALFLAGS;
|
|
TCHAR const c_szRegShutdownKey[] = REGSTR_PATH_SHUTDOWN;
|
|
TCHAR const c_szForceRebootVal[] = REGSTR_VAL_FORCEREBOOT;
|
|
|
|
|
|
|
|
BOOL MustRebootSystem(void)
|
|
{
|
|
HKEY hk;
|
|
BOOL bMustReboot = FALSE;
|
|
|
|
if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szRegShutdownKey, &hk) == ERROR_SUCCESS)
|
|
{
|
|
bMustReboot = (RegQueryValueEx(hk, c_szForceRebootVal, NULL,
|
|
NULL, NULL, NULL) == ERROR_SUCCESS);
|
|
RegCloseKey(hk);
|
|
}
|
|
return(bMustReboot);
|
|
}
|
|
|
|
|
|
DWORD GetMSDOSOptGlobalFlags(LPWIZDATA lpwd)
|
|
{
|
|
if ((lpwd->dwFlags & WDFLAG_READOPTFLAGS) == 0)
|
|
{
|
|
HKEY hk;
|
|
|
|
lpwd->dwFlags |= WDFLAG_READOPTFLAGS;
|
|
|
|
if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szRegDosOptsPath, &hk)
|
|
== ERROR_SUCCESS)
|
|
{
|
|
UINT cb = sizeof(lpwd->dwDosOptGlobalFlags);
|
|
|
|
if (RegQueryValueEx(hk, c_szRegGlobalFlags, NULL, NULL,
|
|
(LPVOID)(&(lpwd->dwDosOptGlobalFlags)), &cb)
|
|
!= ERROR_SUCCESS)
|
|
{
|
|
lpwd->dwDosOptGlobalFlags = 0;
|
|
}
|
|
RegCloseKey(hk);
|
|
}
|
|
|
|
if (MustRebootSystem())
|
|
{
|
|
lpwd->dwDosOptGlobalFlags |= DOSOPTGF_DEFCLEAN;
|
|
}
|
|
}
|
|
return(lpwd->dwDosOptGlobalFlags);
|
|
}
|
|
|
|
|
|
//
|
|
// Structure used to store text for Autoexec.Bat and Config.Sys
|
|
//
|
|
|
|
typedef struct _TEXTDATA {
|
|
UINT cb;
|
|
LPTSTR lpszData;
|
|
} TEXTDATA, FAR * LPTEXTDATA;
|
|
|
|
|
|
//
|
|
// Gets a single value from the specified option index. If no data is
|
|
// found for the specified value name then a 0 DWORD is stored.
|
|
//
|
|
|
|
void GetOptVal(LPWIZDATA lpwd, int i, LPCTSTR lpszValName, LPVOID lpData, UINT cb)
|
|
{
|
|
if (RegQueryValueEx(lpwd->DosOpt[i].hk, lpszValName, NULL, NULL, lpData, &cb) != ERROR_SUCCESS)
|
|
{
|
|
*(LPDWORD)lpData = (DWORD)0;
|
|
}
|
|
}
|
|
|
|
|
|
BOOL FindDriver(int idFiles, int idLoadHigh, HKEY hk, LPCTSTR lpszRegVal,
|
|
LPCTSTR FAR dirs[])
|
|
{
|
|
TCHAR szFiles[MAX_PATH];
|
|
LPTSTR lpszCur, lpszFileName;
|
|
TCHAR szCommand[MAX_PATH+20];
|
|
|
|
LoadAndStrip(idFiles, szFiles, ARRAYSIZE(szFiles));
|
|
LoadString(g_hinst, idLoadHigh, szCommand, ARRAYSIZE(szCommand));
|
|
|
|
lpszFileName = &szCommand[lstrlen(szCommand)];
|
|
lpszCur = szFiles;
|
|
|
|
while (*lpszCur)
|
|
{
|
|
lstrcpy(lpszFileName, lpszCur);
|
|
if (PathResolve(lpszFileName, dirs, PRF_VERIFYEXISTS))
|
|
{
|
|
PathGetShortPath(lpszFileName);
|
|
|
|
RegSetValueEx(hk, lpszRegVal, 0, REG_SZ, (LPBYTE) szCommand,
|
|
(lstrlen(szCommand)+1)*sizeof(TCHAR));
|
|
|
|
return(TRUE);
|
|
}
|
|
lpszCur = SkipStr(lpszCur);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
BOOL SetUpMouse(LPWIZDATA lpwd, int i)
|
|
{
|
|
#define MOpt lpwd->DosOpt[i]
|
|
TCHAR szMouseEnv[64];
|
|
TCHAR szMouseDir[64];
|
|
LPCTSTR FAR dirs[] = {szMouseDir, NULL};
|
|
BOOL fRetVal;
|
|
|
|
if (!LoadString(g_hinst, IDS_MOUSEENV, szMouseEnv, ARRAYSIZE(szMouseEnv)))
|
|
{
|
|
fRetVal = FALSE;
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(szMouseDir, szMouseEnv);
|
|
|
|
DoEnvironmentSubst(szMouseDir, ARRAYSIZE(szMouseDir));
|
|
|
|
if (lstrcmp(szMouseDir, szMouseEnv) == 0)
|
|
{
|
|
dirs[0] = NULL;
|
|
}
|
|
|
|
if (FindDriver(IDS_MOUSETSRS, IDS_LOADHIGH,MOpt.hk, c_szRegValAutoexec, dirs) ||
|
|
FindDriver(IDS_MOUSEDRVS, IDS_DEVHIGH, MOpt.hk, c_szRegValConfigSys, dirs))
|
|
{
|
|
MOpt.dwFlags |= DOSOPTF_SUPPORTED;
|
|
TraceMsg(TF_ERROR, "%s", "Found real mode mouse driver");
|
|
}
|
|
|
|
MOpt.dwFlags &= ~DOSOPTF_NEEDSETUP;
|
|
RegSetValueEx(MOpt.hk, c_szRegDosOptFlags, 0, REG_DWORD,
|
|
(LPBYTE)&(MOpt.dwFlags), sizeof(MOpt.dwFlags));
|
|
fRetVal = TRUE;
|
|
}
|
|
|
|
return fRetVal;
|
|
#undef MOpt
|
|
}
|
|
|
|
|
|
//
|
|
// The option is not configured. Here's where to add code to set up any
|
|
// standard option. Currently, we only set up the mouse.
|
|
//
|
|
|
|
BOOL SetupOption(LPWIZDATA lpwd, int i)
|
|
{
|
|
BOOL fRetVal;
|
|
|
|
if (RMOPT_MOUSE == lpwd->DosOpt[i].dwStdOpt)
|
|
{
|
|
TraceMsg(TF_ERROR, "%s", "About to search for real mode mouse driver");
|
|
fRetVal = SetUpMouse(lpwd, i);
|
|
}
|
|
else
|
|
{
|
|
fRetVal = TRUE;
|
|
}
|
|
|
|
return fRetVal;
|
|
}
|
|
|
|
|
|
//
|
|
// Closes all open hkeys and frees the memory. NOTE: This function can
|
|
// be called any time, even if ReadRegInfo has not been called previously.
|
|
//
|
|
|
|
void FreeRegInfo(LPWIZDATA lpwd)
|
|
{
|
|
int i;
|
|
|
|
if (!lpwd->DosOpt)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < lpwd->NumOpts; i++)
|
|
{
|
|
RegCloseKey(lpwd->DosOpt[i].hk);
|
|
}
|
|
|
|
LocalFree(lpwd->DosOpt);
|
|
lpwd->DosOpt = NULL;
|
|
lpwd->NumOpts = 0;
|
|
}
|
|
|
|
|
|
//
|
|
// Initializes the option table in the wizard data header.
|
|
//
|
|
|
|
BOOL ReadRegInfo(LPWIZDATA lpwd)
|
|
{
|
|
HKEY hk;
|
|
BOOL bSuccess = FALSE;
|
|
int i;
|
|
|
|
if (lpwd->DosOpt)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
if (RegOpenKey(HKEY_LOCAL_MACHINE, c_szRegDosOptsPath, &hk) !=
|
|
ERROR_SUCCESS)
|
|
{
|
|
goto Exit;
|
|
}
|
|
|
|
if (RegQueryInfoKey(hk, NULL, NULL, NULL, &(lpwd->NumOpts),
|
|
NULL, NULL, NULL, NULL, NULL, NULL, NULL) !=
|
|
ERROR_SUCCESS)
|
|
{
|
|
goto ExitCloseKey;
|
|
}
|
|
|
|
lpwd->DosOpt = LocalAlloc(LPTR, lpwd->NumOpts * sizeof(DOSOPT));
|
|
|
|
if (!lpwd->DosOpt)
|
|
{
|
|
goto ExitCloseKey;
|
|
}
|
|
|
|
for (i = 0; i < lpwd->NumOpts; i++)
|
|
{
|
|
UINT cb;
|
|
TCHAR szOptKey[80];
|
|
HKEY hkOpt;
|
|
UINT uOrder = 0;
|
|
int InsPos;
|
|
|
|
cb = ARRAYSIZE(szOptKey);
|
|
|
|
if ((RegEnumKeyEx(hk, i, szOptKey, &cb, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) ||
|
|
(RegOpenKey(hk, szOptKey, &hkOpt) != ERROR_SUCCESS))
|
|
{
|
|
lpwd->NumOpts = i - 1;
|
|
FreeRegInfo(lpwd); // This frees the DosOpt memory
|
|
goto ExitCloseKey;
|
|
}
|
|
|
|
cb = sizeof(uOrder);
|
|
|
|
RegQueryValueEx(hkOpt, REGSTR_VAL_OPTORDER, NULL, NULL, (LPVOID)&uOrder, &cb);
|
|
|
|
for (InsPos = i;
|
|
(InsPos > 0) && (lpwd->DosOpt[InsPos-1].uOrder > uOrder);
|
|
InsPos--);
|
|
|
|
if (InsPos < i)
|
|
{
|
|
MoveMemory(&(lpwd->DosOpt[InsPos+1]), &(lpwd->DosOpt[InsPos]),
|
|
(i - InsPos) * sizeof(DOSOPT));
|
|
}
|
|
|
|
lpwd->DosOpt[InsPos].hk = hkOpt;
|
|
lpwd->DosOpt[InsPos].uOrder = uOrder;
|
|
|
|
GetOptVal(lpwd, InsPos, c_szRegDosOptFlags, &(lpwd->DosOpt[InsPos].dwFlags), sizeof(DWORD));
|
|
GetOptVal(lpwd, InsPos, c_szRegStandardOpt, &(lpwd->DosOpt[InsPos].dwStdOpt), sizeof(DWORD));
|
|
|
|
if (lpwd->DosOpt[InsPos].dwFlags & DOSOPTF_NEEDSETUP)
|
|
{
|
|
if (!SetupOption(lpwd, InsPos))
|
|
{
|
|
goto ExitCloseKey;
|
|
}
|
|
}
|
|
}
|
|
bSuccess = TRUE;
|
|
|
|
ExitCloseKey:
|
|
RegCloseKey(hk);
|
|
Exit:
|
|
return(bSuccess);
|
|
}
|
|
|
|
|
|
//
|
|
// Inserts a single column into the specified ListView.
|
|
//
|
|
|
|
void InitSingleColListView(HWND hLV)
|
|
{
|
|
LV_COLUMN col = {LVCF_FMT | LVCF_WIDTH, LVCFMT_LEFT};
|
|
RECT rc;
|
|
|
|
GetClientRect(hLV, &rc);
|
|
|
|
col.cx = rc.right - GetSystemMetrics(SM_CXVSCROLL)
|
|
- GetSystemMetrics(SM_CXSMICON)
|
|
- 2 * GetSystemMetrics(SM_CXEDGE);
|
|
|
|
ListView_InsertColumn(hLV, 0, &col);
|
|
}
|
|
|
|
|
|
//
|
|
// Initializes the listview with all available options
|
|
//
|
|
|
|
void ConfOptInit(HWND hDlg, LPPROPSHEETPAGE lpp)
|
|
{
|
|
HIMAGELIST himlState;
|
|
HWND hwndOptions = GetDlgItem(hDlg, IDC_OPTIONLIST);
|
|
LPWIZDATA lpwd = InitWizSheet(hDlg, (LPARAM)lpp, 0);
|
|
|
|
InitSingleColListView(hwndOptions);
|
|
|
|
//
|
|
// Lets load our bitmap as an imagelist
|
|
//
|
|
|
|
himlState = ImageList_LoadImage(g_hinst, MAKEINTRESOURCE(IDB_CHECKSTATES), 0, 2,
|
|
CLR_NONE, IMAGE_BITMAP, LR_LOADTRANSPARENT);
|
|
|
|
ListView_SetImageList(hwndOptions, himlState, LVSIL_STATE);
|
|
|
|
//
|
|
// Find all options for MS-DOS configs and set their approropriate state
|
|
// information
|
|
//
|
|
|
|
if (ReadRegInfo(lpwd))
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < lpwd->NumOpts; i++)
|
|
{
|
|
DWORD dwFlags = lpwd->DosOpt[i].dwFlags;
|
|
|
|
if ((dwFlags & DOSOPTF_SUPPORTED) &&
|
|
((dwFlags & DOSOPTF_ALWAYSUSE) == 0) &&
|
|
((dwFlags & DOSOPTF_USESPMODE) == 0 ||
|
|
(lpwd->dwFlags & WDFLAG_REALMODEONLY) == 0) &&
|
|
(lpwd->DosOpt[i].uOrder > 0))
|
|
{
|
|
TCHAR szDesc[MAX_DESC_SIZE];
|
|
LV_ITEM lvi;
|
|
|
|
GetOptVal(lpwd, i, NULL, szDesc, sizeof(szDesc));
|
|
|
|
lvi.mask = LVIF_TEXT | LVIF_STATE | LVIF_PARAM;
|
|
lvi.iItem = 0x7FFF;
|
|
lvi.iSubItem = 0;
|
|
|
|
//
|
|
///// REARCHITECT If program properties contains real mode flags, use them for defaults!
|
|
//
|
|
|
|
lvi.state = (dwFlags & DOSOPTF_DEFAULT) ? LVIS_GCCHECK : LVIS_GCNOCHECK;
|
|
lvi.stateMask = LVIS_ALL;
|
|
lvi.pszText = szDesc;
|
|
lvi.lParam = (LPARAM)i;
|
|
lvi.cchTextMax = 0;
|
|
|
|
ListView_InsertItem(hwndOptions, &lvi);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Toggles the state of the specified item in the list view.
|
|
//
|
|
|
|
void ToggleState(HWND hwndLV, int i)
|
|
{
|
|
UINT state = ListView_GetItemState(hwndLV, i, LVIS_STATEIMAGEMASK);
|
|
|
|
state = (state == LVIS_GCNOCHECK) ? LVIS_GCCHECK : LVIS_GCNOCHECK;
|
|
|
|
ListView_SetItemState(hwndLV, i, state, LVIS_STATEIMAGEMASK);
|
|
}
|
|
|
|
|
|
//
|
|
// Returns the path to the boot directory. If we can't find it in the
|
|
// registry then this function returns the default (drive that windows
|
|
// directory is on)
|
|
//
|
|
|
|
void GetBootDir(LPTSTR lpszBootDir, int cchBootDir)
|
|
{
|
|
HKEY hkSetup;
|
|
|
|
*lpszBootDir = 0;
|
|
|
|
if (RegOpenKey(HKEY_LOCAL_MACHINE, REGSTR_PATH_SETUP REGSTR_KEY_SETUP,
|
|
&hkSetup) == ERROR_SUCCESS)
|
|
{
|
|
UINT cb = cchBootDir * SIZEOF(TCHAR);
|
|
|
|
RegQueryValueEx(hkSetup, REGSTR_VAL_BOOTDIR, NULL,
|
|
NULL, (LPBYTE) lpszBootDir, &cb);
|
|
RegCloseKey(hkSetup);
|
|
}
|
|
|
|
if (*lpszBootDir == 0)
|
|
{
|
|
if (0 != GetWindowsDirectory(lpszBootDir, cchBootDir)
|
|
&& lpszBootDir[0] != TEXT('\0')
|
|
&& lpszBootDir[1] == TEXT(':')
|
|
&& lpszBootDir[2] == TEXT('\\'))
|
|
{
|
|
lpszBootDir[3] = TEXT('\0');
|
|
}
|
|
else
|
|
{
|
|
LoadString(g_hinst, IDS_DEFBOOTDIR, lpszBootDir, cchBootDir);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Process the clicks on the listview. do a hittest to see where the user
|
|
// clicked. If on one of the state bitmaps, toggle it.
|
|
//
|
|
|
|
void ConfOptClick(HWND hDlg, LPNMHDR pnmhdr)
|
|
{
|
|
//
|
|
// The user clicked on one the listview see where...
|
|
//
|
|
|
|
DWORD dwpos;
|
|
LV_HITTESTINFO lvhti;
|
|
|
|
dwpos = GetMessagePos();
|
|
lvhti.pt.x = GET_X_LPARAM(dwpos);
|
|
lvhti.pt.y = GET_Y_LPARAM(dwpos);
|
|
|
|
MapWindowPoints(HWND_DESKTOP, pnmhdr->hwndFrom, &lvhti.pt, 1);
|
|
|
|
ListView_HitTest(pnmhdr->hwndFrom, &lvhti);
|
|
|
|
if (lvhti.flags & LVHT_ONITEMSTATEICON)
|
|
{
|
|
ToggleState(pnmhdr->hwndFrom, lvhti.iItem);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// When the user hits the space bar, toggle the state of the selected item.
|
|
//
|
|
BOOL ConfOptKeyDown(HWND hDlg, LV_KEYDOWN *plvkd)
|
|
{
|
|
int iCursor;
|
|
|
|
if (plvkd->wVKey == VK_SPACE && !(GetAsyncKeyState(VK_MENU) < 0))
|
|
{
|
|
//
|
|
// Lets toggle the cursored item.
|
|
//
|
|
|
|
iCursor = ListView_GetNextItem(plvkd->hdr.hwndFrom, -1, LVNI_FOCUSED);
|
|
|
|
if (iCursor != -1)
|
|
{
|
|
ToggleState(plvkd->hdr.hwndFrom, iCursor);
|
|
}
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Item selection changed. Update tip.
|
|
//
|
|
|
|
void ItemChanged(LPWIZDATA lpwd, LPNM_LISTVIEW lpnmlv)
|
|
{
|
|
LV_ITEM lvi;
|
|
TCHAR szTip[200]; ///???
|
|
|
|
if ((lpnmlv->uNewState & LVIS_FOCUSED) &&
|
|
(!(lpnmlv->uOldState & LVIS_FOCUSED)))
|
|
{
|
|
lvi.iItem = lpnmlv->iItem;
|
|
lvi.iSubItem = 0;
|
|
lvi.mask = LVIF_PARAM;
|
|
|
|
ListView_GetItem(lpnmlv->hdr.hwndFrom, &lvi);
|
|
|
|
GetOptVal(lpwd, (int)lvi.lParam, c_szRegDosOptTip, szTip, sizeof(szTip));
|
|
|
|
Static_SetText(GetDlgItem(lpwd->hwnd, IDC_OPTIONTIP), szTip);
|
|
}
|
|
}
|
|
|
|
|
|
void _inline NoSupportMsg(LPWIZDATA lpwd, int iOpt)
|
|
{
|
|
LPTSTR lpszDesc = (LPTSTR)LocalAlloc(LMEM_FIXED, MAX_DESC_SIZE*sizeof(TCHAR));
|
|
|
|
if (lpszDesc)
|
|
{
|
|
LPTSTR lpszMsg = (LPTSTR)LocalAlloc(LMEM_FIXED, 512*sizeof(TCHAR)); // Max 2 resource size
|
|
|
|
if (lpszMsg)
|
|
{
|
|
GetOptVal(lpwd, iOpt, NULL, lpszDesc, MAX_DESC_SIZE*sizeof(TCHAR));
|
|
LoadString(g_hinst, IDS_NOSUPPORT1, lpszMsg, 512);
|
|
LoadString(g_hinst, IDS_NOSUPPORT2, lpszMsg+lstrlen(lpszMsg), 256);
|
|
ShellMessageBox(g_hinst, lpwd->hwnd,
|
|
lpszMsg, 0,
|
|
MB_OK | MB_ICONEXCLAMATION,
|
|
lpszDesc);
|
|
LocalFree(lpszMsg);
|
|
}
|
|
LocalFree(lpszDesc);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Returns OPTSEL_YES if the option indicated by i is selected in the list
|
|
// box, or, if hwndLV is NULL then OPTSEL_YES if option should be added,
|
|
// OPTSEL_NO if should not be added, and OPTSEL_NOTSUPP if the option is
|
|
// required but can't be added.
|
|
//
|
|
|
|
int OptSelected(LPWIZDATA lpwd, int i, HWND hwndLV)
|
|
{
|
|
BOOL bSelected = FALSE;
|
|
|
|
if (lpwd->DosOpt[i].dwFlags & DOSOPTF_ALWAYSUSE)
|
|
{
|
|
bSelected = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (hwndLV)
|
|
{
|
|
LV_ITEM lvi;
|
|
int NumItems = ListView_GetItemCount(hwndLV);
|
|
|
|
for (lvi.iItem = 0; lvi.iItem < NumItems; lvi.iItem++)
|
|
{
|
|
lvi.iSubItem = 0;
|
|
lvi.mask = LVIF_PARAM | LVIF_STATE;
|
|
lvi.stateMask = LVIS_STATEIMAGEMASK;
|
|
ListView_GetItem(hwndLV, &lvi);
|
|
if ((int)lvi.lParam == i)
|
|
{
|
|
bSelected = ((lvi.state & LVIS_STATEIMAGEMASK) == LVIS_GCCHECK);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL bSupported = lpwd->DosOpt[i].dwFlags & DOSOPTF_SUPPORTED;
|
|
|
|
if (lpwd->PropPrg.dwRealModeFlags & lpwd->DosOpt[i].dwStdOpt)
|
|
{
|
|
bSelected = TRUE;
|
|
|
|
if (!bSupported)
|
|
{
|
|
NoSupportMsg(lpwd, i);
|
|
return(OPTSEL_NOTSUPP);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bSupported)
|
|
{
|
|
bSelected = (lpwd->PropPrg.dwRealModeFlags & (lpwd->DosOpt[i].dwStdOpt >> 16));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bSelected)
|
|
{
|
|
return(OPTSEL_YES);
|
|
}
|
|
else
|
|
{
|
|
return(OPTSEL_NO);
|
|
}
|
|
}
|
|
|
|
|
|
void AppendStr(LPTEXTDATA lpTD, LPTSTR lpStr)
|
|
{
|
|
int cb = lstrlen(lpStr)*sizeof(TCHAR);
|
|
|
|
if ((lpTD->cb + cb + 2) <= MAX_CFG_FILE_SIZE*sizeof(TCHAR))
|
|
{
|
|
memcpy(lpTD->lpszData+lpTD->cb, lpStr, cb);
|
|
lpTD->cb += cb;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Appends the string+cr/lf to the TextData structure.
|
|
//
|
|
|
|
void AppendLine(LPTEXTDATA lpTD, LPTSTR lpStr)
|
|
{
|
|
AppendStr(lpTD, lpStr);
|
|
AppendStr(lpTD, (LPTSTR)c_szCRLF);
|
|
}
|
|
|
|
|
|
//
|
|
// Returns NULL if none of the strings in szKeys matches the first entry
|
|
// in the specified string.
|
|
//
|
|
|
|
LPTSTR MatchesKey(LPTSTR lpszStr, LPTSTR lpszKeys)
|
|
{
|
|
UINT cch = lstrlen(lpszStr);
|
|
TCHAR szUpLine[20];
|
|
LPTSTR lpszCurKey;
|
|
|
|
if (cch >= ARRAYSIZE(szUpLine))
|
|
{
|
|
cch = ARRAYSIZE(szUpLine)-1;
|
|
}
|
|
|
|
memcpy(szUpLine, lpszStr, cch*sizeof(TCHAR));
|
|
|
|
szUpLine[cch] = 0;
|
|
|
|
CharUpper(szUpLine);
|
|
|
|
for (lpszCurKey = lpszKeys; *lpszCurKey; lpszCurKey = SkipStr(lpszCurKey))
|
|
{
|
|
UINT cchKey = lstrlen(lpszCurKey);
|
|
|
|
if ((cchKey < cch) &&
|
|
((szUpLine[cchKey] == TEXT(' ')) || (szUpLine[cchKey] == TEXT('='))) &&
|
|
(memcmp(lpszCurKey, szUpLine, cchKey*sizeof(TCHAR)) == 0))
|
|
{
|
|
return(lpszCurKey);
|
|
}
|
|
}
|
|
return(NULL);
|
|
}
|
|
|
|
|
|
//
|
|
// Copy the current environment into Autoexec.Bat
|
|
//
|
|
|
|
void CopyEnvironment(LPTEXTDATA lpAE)
|
|
{
|
|
TCHAR szKeys[MAX_PATH]; // SIZE?
|
|
TCHAR szSetCmd[20];
|
|
LPTSTR lpszCur = (LPTSTR)GetEnvironmentStrings();
|
|
|
|
LoadString(g_hinst, IDS_SETCMD, szSetCmd, ARRAYSIZE(szSetCmd));
|
|
LoadAndStrip(IDS_NOCOPYENV, szKeys, ARRAYSIZE(szKeys));
|
|
|
|
while (*lpszCur)
|
|
{
|
|
if (!MatchesKey(lpszCur, szKeys))
|
|
{
|
|
AppendStr(lpAE, szSetCmd);
|
|
AppendLine(lpAE, lpszCur);
|
|
}
|
|
|
|
lpszCur = SkipStr(lpszCur);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Add keyboard type option for JKEYB.SYS
|
|
//
|
|
|
|
void SetJkeybOpt(LPTSTR lpszStr)
|
|
{
|
|
UINT cb, cbKey;
|
|
TCHAR szUpLine[64];
|
|
TCHAR lpszKey[] = TEXT("JKEYB.SYS");
|
|
TCHAR *lpszOpts[] = {TEXT(" /101"), TEXT(" /AX"), TEXT(" /106"), TEXT(" /J31DT"), TEXT(" /J31NB"), TEXT(" /J31LT")};
|
|
int KeybOpt;
|
|
int i;
|
|
|
|
ASSERT(lpszStr);
|
|
|
|
cb = lstrlen(lpszStr);
|
|
cbKey = lstrlen(lpszKey);
|
|
|
|
if (cb >= ARRAYSIZE(szUpLine))
|
|
{
|
|
cb = ARRAYSIZE(szUpLine)-1;
|
|
}
|
|
|
|
memcpy(szUpLine, lpszStr, cb*sizeof(TCHAR));
|
|
|
|
szUpLine[cb] = 0;
|
|
|
|
// AnsiUpper(szUpLine);
|
|
CharUpper(szUpLine);
|
|
|
|
for (i = 0; cbKey <= cb; i++, cb--)
|
|
{
|
|
if (memcmp(lpszKey, &szUpLine[i], cbKey*sizeof(TCHAR)) == 0)
|
|
{
|
|
|
|
// if (GetKeyboardType(0) == 7){
|
|
// switch(GetKeyboardType(1)) {
|
|
|
|
if (GetPrivateProfileInt(TEXT("keyboard"), TEXT("type"), 0, TEXT("SYSTEM.INI")) == 7)
|
|
{
|
|
switch(GetPrivateProfileInt(TEXT("keyboard"), TEXT("subtype"), 0, TEXT("SYSTEM.INI")))
|
|
{
|
|
case 0:
|
|
KeybOpt = 0;
|
|
break;
|
|
case 1:
|
|
KeybOpt = 1;
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
KeybOpt = 2;
|
|
break;
|
|
case 13:
|
|
KeybOpt = 3;
|
|
break;
|
|
case 14:
|
|
KeybOpt = 4;
|
|
break;
|
|
case 15:
|
|
KeybOpt = 5;
|
|
break;
|
|
default:
|
|
KeybOpt = 0;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
KeybOpt = 0;
|
|
|
|
lstrcat(lpszStr, lpszOpts[KeybOpt]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Adds an option line from the specified value name to the TEXTDATA structure
|
|
//
|
|
|
|
BOOL AddOption(HKEY hk, LPCTSTR lpszValName, LPTEXTDATA lpTD,
|
|
LPTSTR lpszHighCmds, LPTSTR lpszLowCmd, BOOL bCanLoadHigh)
|
|
{
|
|
TCHAR szOptData[256];
|
|
UINT cb = sizeof(szOptData);
|
|
DWORD dwType;
|
|
LCID lcid = GetThreadLocale();
|
|
|
|
if (RegQueryValueEx(hk, lpszValName, NULL,
|
|
&dwType, (LPBYTE) szOptData, &cb) == ERROR_SUCCESS)
|
|
{
|
|
LPTSTR lpszAddData = szOptData;
|
|
|
|
DoEnvironmentSubst(szOptData, ARRAYSIZE(szOptData));
|
|
|
|
//
|
|
// Now remove LH or LoadHigh or DeviceHigh and replace with the
|
|
// appropriate string if EMM386 has not loaded yet.
|
|
//
|
|
|
|
if (!bCanLoadHigh)
|
|
{
|
|
LPTSTR lpszMatch = MatchesKey(szOptData, lpszHighCmds);
|
|
|
|
if (lpszMatch)
|
|
{
|
|
int cbHigh = lstrlen(lpszMatch);
|
|
if (lpszLowCmd)
|
|
{
|
|
int cbLow = lstrlen(lpszLowCmd);
|
|
|
|
lpszAddData += cbHigh - cbLow;
|
|
|
|
memcpy(lpszAddData, lpszLowCmd, cbLow*sizeof(TCHAR));
|
|
|
|
}
|
|
else
|
|
{
|
|
lpszAddData += cbHigh + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (PRIMARYLANGID(LANGIDFROMLCID(lcid))==LANG_JAPANESE)
|
|
{
|
|
SetJkeybOpt(lpszAddData);
|
|
}
|
|
AppendLine(lpTD, lpszAddData);
|
|
|
|
return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Sets the appropriate configuration options in the PIF proprties
|
|
// If fForceCleanCfg is TRUE then a clean configuration is created. Otherwise
|
|
// the autoexec and config fields are nuked to force the app to use the current
|
|
// configuration.
|
|
//
|
|
|
|
PIFWIZERR SetConfOptions(LPWIZDATA lpwd, HWND hwndOptions, BOOL fForceCleanCfg)
|
|
{
|
|
TEXTDATA AE;
|
|
TEXTDATA CS;
|
|
int i;
|
|
PIFWIZERR err = PIFWIZERR_SUCCESS;
|
|
TCHAR szCSHighCmds[100];
|
|
TCHAR szCSLowCmd[20];
|
|
TCHAR szAEHighCmds[100];
|
|
BOOL bCanLoadHigh = FALSE;
|
|
|
|
//
|
|
// Make sure the real mode flag is set in the program properties.
|
|
//
|
|
|
|
PifMgr_GetProperties(lpwd->hProps, (LPSTR)GROUP_PRG, &(lpwd->PropPrg),
|
|
sizeof(lpwd->PropPrg), GETPROPS_NONE);
|
|
|
|
lpwd->PropPrg.flPrgInit |= PRGINIT_REALMODE;
|
|
|
|
PifMgr_SetProperties(lpwd->hProps, (LPSTR)GROUP_PRG, &(lpwd->PropPrg),
|
|
sizeof(lpwd->PropPrg), SETPROPS_NONE);
|
|
|
|
if (!fForceCleanCfg)
|
|
{
|
|
TCHAR NullStr = 0;
|
|
|
|
PifMgr_SetProperties(lpwd->hProps, AUTOEXECHDRSIG40, &NullStr, 0, SETPROPS_NONE);
|
|
PifMgr_SetProperties(lpwd->hProps, CONFIGHDRSIG40, &NullStr, 0, SETPROPS_NONE);
|
|
return(err);
|
|
}
|
|
|
|
//
|
|
// Load strings used to force drivers to load low if no EMM386.
|
|
//
|
|
|
|
LoadString(g_hinst, IDS_CSLOWSTR, szCSLowCmd, ARRAYSIZE(szCSLowCmd));
|
|
LoadAndStrip(IDS_CSHIGHSTRS, szCSHighCmds, ARRAYSIZE(szCSHighCmds));
|
|
LoadAndStrip(IDS_AEHIGHSTRS, szAEHighCmds, ARRAYSIZE(szAEHighCmds));
|
|
|
|
//
|
|
// Allocate memory for autoexec/config.sys buffers.
|
|
//
|
|
|
|
AE.lpszData = (LPTSTR)LocalAlloc(LPTR, MAX_CFG_FILE_SIZE*sizeof(TCHAR));
|
|
|
|
if (AE.lpszData == NULL)
|
|
{
|
|
return(PIFWIZERR_OUTOFMEM);
|
|
}
|
|
|
|
CS.lpszData = (LPTSTR)LocalAlloc(LPTR, MAX_CFG_FILE_SIZE*sizeof(TCHAR));
|
|
|
|
if (CS.lpszData == NULL)
|
|
{
|
|
LocalFree(AE.lpszData);
|
|
return(PIFWIZERR_OUTOFMEM);
|
|
}
|
|
|
|
AE.cb = CS.cb = 0;
|
|
|
|
//
|
|
// Copy the appropriate goop out of config.sys and autoexec.bat
|
|
//
|
|
|
|
CopyEnvironment(&AE);
|
|
|
|
for (i = 0; i < lpwd->NumOpts; i++)
|
|
{
|
|
int OptSel = OptSelected(lpwd, i, hwndOptions);
|
|
|
|
if (OptSel == OPTSEL_YES)
|
|
{
|
|
bCanLoadHigh |= (lpwd->DosOpt[i].dwFlags & DOSOPTF_PROVIDESUMB);
|
|
|
|
AddOption(lpwd->DosOpt[i].hk, c_szRegValAutoexec, &AE,
|
|
szAEHighCmds, NULL, bCanLoadHigh);
|
|
|
|
AddOption(lpwd->DosOpt[i].hk, c_szRegValConfigSys, &CS,
|
|
szCSHighCmds, szCSLowCmd, bCanLoadHigh);
|
|
|
|
//
|
|
// DOSOPTF_MULTIPLE will load multiple configuration from
|
|
// Config.Sys1 - Config.Sys9 and Autoexec.Bat1 - Autoexec.Bat9
|
|
//
|
|
|
|
if (lpwd->DosOpt[i].dwFlags & DOSOPTF_MULTIPLE)
|
|
{
|
|
BOOL ret;
|
|
TCHAR multicount[2];
|
|
TCHAR multiAutoexec[64];
|
|
TCHAR multiConfig[64];
|
|
|
|
lstrcpy(multicount,TEXT("1"));
|
|
|
|
while (1)
|
|
{
|
|
lstrcpy(multiAutoexec, c_szRegValAutoexec);
|
|
lstrcat(multiAutoexec, multicount);
|
|
lstrcpy(multiConfig, c_szRegValConfigSys);
|
|
lstrcat(multiConfig, multicount);
|
|
|
|
ret = AddOption(lpwd->DosOpt[i].hk, multiAutoexec, &AE,
|
|
szAEHighCmds, NULL, bCanLoadHigh);
|
|
|
|
ret |= AddOption(lpwd->DosOpt[i].hk, multiConfig, &CS,
|
|
szCSHighCmds, szCSLowCmd, bCanLoadHigh);
|
|
|
|
if (!ret)
|
|
break;
|
|
|
|
multicount[0] += 1;
|
|
|
|
if (multicount[0] > TEXT('9'))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (OptSel == OPTSEL_NOTSUPP)
|
|
{
|
|
err = PIFWIZERR_UNSUPPORTEDOPT;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set the properties in the PIF file
|
|
//
|
|
|
|
PifMgr_SetProperties(lpwd->hProps, AUTOEXECHDRSIG40, AE.lpszData, AE.cb, SETPROPS_NONE);
|
|
PifMgr_SetProperties(lpwd->hProps, CONFIGHDRSIG40, CS.lpszData, CS.cb, SETPROPS_NONE);
|
|
|
|
//
|
|
// Clean up allocated memory
|
|
//
|
|
|
|
LocalFree(AE.lpszData);
|
|
LocalFree(CS.lpszData);
|
|
|
|
return(err);
|
|
}
|
|
|
|
|
|
//
|
|
// The user hit the finish button. Set the proper configuration.
|
|
//
|
|
|
|
PIFWIZERR ConfigRealModeOptions(LPWIZDATA lpwd, HWND hwndOptList,
|
|
UINT uAction)
|
|
{
|
|
PIFWIZERR err = PIFWIZERR_GENERALFAILURE;
|
|
BOOL fCleanCfg;
|
|
|
|
switch(uAction)
|
|
{
|
|
case CRMOACTION_DEFAULT:
|
|
fCleanCfg = GetMSDOSOptGlobalFlags(lpwd) & DOSOPTGF_DEFCLEAN;
|
|
break;
|
|
|
|
case CRMOACTION_CLEAN:
|
|
fCleanCfg = TRUE;
|
|
break;
|
|
|
|
case CRMOACTION_CURRENT:
|
|
fCleanCfg = FALSE;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// OK to call twice -- Returns true
|
|
//
|
|
|
|
if (ReadRegInfo(lpwd))
|
|
{
|
|
if (lpwd->hProps == 0)
|
|
{
|
|
if (CreateLink(lpwd))
|
|
{
|
|
TCHAR szLinkName[MAX_PATH];
|
|
|
|
GetLinkName(szLinkName, lpwd);
|
|
|
|
lpwd->hProps = PifMgr_OpenProperties(szLinkName, NULL, 0, OPENPROPS_NONE);
|
|
|
|
if (lpwd->hProps)
|
|
{
|
|
err = SetConfOptions(lpwd, hwndOptList, fCleanCfg);
|
|
|
|
PifMgr_CloseProperties(lpwd->hProps, CLOSEPROPS_NONE);
|
|
|
|
lpwd->hProps = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
err = SetConfOptions(lpwd, hwndOptList, fCleanCfg);
|
|
}
|
|
|
|
FreeRegInfo(lpwd);
|
|
}
|
|
return(err);
|
|
}
|
|
|
|
|
|
BOOL_PTR CALLBACK ConfigOptionsDlgProc(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPNMHDR lpnm = NULL;
|
|
LPPROPSHEETPAGE lpp = (LPPROPSHEETPAGE)(GetWindowLongPtr(hDlg, DWLP_USER));
|
|
LPWIZDATA lpwd = lpp ? (LPWIZDATA)lpp->lParam : NULL;
|
|
|
|
switch(message)
|
|
{
|
|
case WM_NOTIFY:
|
|
lpnm = (LPNMHDR)lParam;
|
|
|
|
if(lpnm)
|
|
{
|
|
switch(lpnm->code)
|
|
{
|
|
case LVN_ITEMCHANGED:
|
|
if(lpwd)
|
|
{
|
|
ItemChanged(lpwd, (LPNM_LISTVIEW)lParam);
|
|
}
|
|
break;
|
|
|
|
case NM_CLICK:
|
|
case NM_DBLCLK:
|
|
ConfOptClick(hDlg, lpnm);
|
|
break;
|
|
|
|
case LVN_KEYDOWN:
|
|
SetDlgMsgResult(hDlg, WM_NOTIFY,
|
|
ConfOptKeyDown(hDlg, (LV_KEYDOWN *)lParam));
|
|
break;
|
|
|
|
|
|
case PSN_SETACTIVE:
|
|
if(lpwd)
|
|
{
|
|
lpwd->hwnd = hDlg;
|
|
|
|
if (lpwd->dwFlags & WDFLAG_PIFPROP)
|
|
{
|
|
TCHAR szOK[20];
|
|
|
|
LoadString(g_hinst, IDS_OK, szOK, ARRAYSIZE(szOK));
|
|
PropSheet_SetFinishText(GetParent(hDlg), szOK);
|
|
}
|
|
else
|
|
{
|
|
PropSheet_SetWizButtons(GetParent(hDlg),
|
|
PSWIZB_FINISH | PSWIZB_BACK);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PSN_WIZFINISH:
|
|
if(lpwd)
|
|
{
|
|
ConfigRealModeOptions(lpwd, GetDlgItem(hDlg, IDC_OPTIONLIST),
|
|
CRMOACTION_CLEAN);
|
|
}
|
|
break;
|
|
|
|
case PSN_RESET:
|
|
if(lpwd)
|
|
{
|
|
CleanUpWizData(lpwd);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
case WM_INITDIALOG:
|
|
ConfOptInit(hDlg, (LPPROPSHEETPAGE)lParam);
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
|
|
} // end of switch on message
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
void WhichConfInit(HWND hDlg, LPPROPSHEETPAGE lpp)
|
|
{
|
|
LPWIZDATA lpwd = InitWizSheet(hDlg, (LPARAM)lpp, 0);
|
|
|
|
CheckRadioButton(hDlg, IDB_CURCFG, IDB_CLEANCFG,
|
|
GetMSDOSOptGlobalFlags(lpwd) & DOSOPTGF_DEFCLEAN ?
|
|
IDB_CLEANCFG : IDB_CURCFG);
|
|
}
|
|
|
|
|
|
void SetChoiceWizBtns(LPWIZDATA lpwd)
|
|
{
|
|
PropSheet_SetWizButtons(GetParent(lpwd->hwnd),
|
|
IsDlgButtonChecked(lpwd->hwnd, IDB_CLEANCFG) ?
|
|
PSWIZB_NEXT | PSWIZB_BACK :
|
|
PSWIZB_FINISH | PSWIZB_BACK);
|
|
}
|
|
|
|
|
|
BOOL_PTR CALLBACK PickConfigDlgProc(HWND hDlg, UINT message , WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LPNMHDR lpnm = NULL;
|
|
LPPROPSHEETPAGE lpp = (LPPROPSHEETPAGE)(GetWindowLongPtr(hDlg, DWLP_USER));
|
|
LPWIZDATA lpwd = lpp ? (LPWIZDATA)lpp->lParam : NULL;
|
|
|
|
switch(message)
|
|
{
|
|
case WM_NOTIFY:
|
|
lpnm = (LPNMHDR)lParam;
|
|
|
|
if(lpnm)
|
|
{
|
|
switch(lpnm->code)
|
|
{
|
|
case PSN_SETACTIVE:
|
|
if(lpwd)
|
|
{
|
|
lpwd->hwnd = hDlg;
|
|
if (MustRebootSystem())
|
|
{
|
|
SetDlgMsgResult(hDlg, WM_NOTIFY, -1);
|
|
}
|
|
else
|
|
{
|
|
SetChoiceWizBtns(lpwd);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PSN_WIZFINISH:
|
|
if(lpwd)
|
|
{
|
|
ConfigRealModeOptions(lpwd, GetDlgItem(hDlg, IDC_OPTIONLIST),
|
|
CRMOACTION_CURRENT);
|
|
}
|
|
break;
|
|
|
|
case PSN_RESET:
|
|
if(lpwd)
|
|
{
|
|
CleanUpWizData(lpwd);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDB_CURCFG:
|
|
case IDB_CLEANCFG:
|
|
if(lpwd)
|
|
{
|
|
SetChoiceWizBtns(lpwd);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG:
|
|
WhichConfInit(hDlg, (LPPROPSHEETPAGE)lParam);
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
|
|
} // end of switch on message
|
|
|
|
return TRUE;
|
|
}
|